[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [PATCH v5 2/3] x86: add domctl cmd to set/get CDP code/data CBM
CDP extends CAT and provides the capacity to control L3 code & data cache. With CDP, one COS corresponds to two CMBs(code & data). cbm_type is added to distinguish different CBM operations. Besides, new domctl cmds are introdunced to support set/get CDP CBM. Some CAT functions to operation CBMs are extended to support CDP. Signed-off-by: He Chen <he.chen@xxxxxxxxxxxxxxx> Reviewed-by: Andrew Cooper <andrew.cooper3@xxxxxxxxxx> --- Changes in v5: * replace -EINVAL with -ENXIO when setting code/data CBM on CDP disabled. --- xen/arch/x86/domctl.c | 32 +++++++- xen/arch/x86/psr.c | 188 ++++++++++++++++++++++++++++++++++---------- xen/include/asm-x86/psr.h | 12 ++- xen/include/public/domctl.h | 4 + 4 files changed, 191 insertions(+), 45 deletions(-) diff --git a/xen/arch/x86/domctl.c b/xen/arch/x86/domctl.c index bf62a88..734fddb 100644 --- a/xen/arch/x86/domctl.c +++ b/xen/arch/x86/domctl.c @@ -1167,12 +1167,40 @@ long arch_do_domctl( { case XEN_DOMCTL_PSR_CAT_OP_SET_L3_CBM: ret = psr_set_l3_cbm(d, domctl->u.psr_cat_op.target, - domctl->u.psr_cat_op.data); + domctl->u.psr_cat_op.data, + PSR_CBM_TYPE_L3); + break; + + case XEN_DOMCTL_PSR_CAT_OP_SET_L3_CODE: + ret = psr_set_l3_cbm(d, domctl->u.psr_cat_op.target, + domctl->u.psr_cat_op.data, + PSR_CBM_TYPE_L3_CODE); + break; + + case XEN_DOMCTL_PSR_CAT_OP_SET_L3_DATA: + ret = psr_set_l3_cbm(d, domctl->u.psr_cat_op.target, + domctl->u.psr_cat_op.data, + PSR_CBM_TYPE_L3_DATA); break; case XEN_DOMCTL_PSR_CAT_OP_GET_L3_CBM: ret = psr_get_l3_cbm(d, domctl->u.psr_cat_op.target, - &domctl->u.psr_cat_op.data); + &domctl->u.psr_cat_op.data, + PSR_CBM_TYPE_L3); + copyback = 1; + break; + + case XEN_DOMCTL_PSR_CAT_OP_GET_L3_CODE: + ret = psr_get_l3_cbm(d, domctl->u.psr_cat_op.target, + &domctl->u.psr_cat_op.data, + PSR_CBM_TYPE_L3_CODE); + copyback = 1; + break; + + case XEN_DOMCTL_PSR_CAT_OP_GET_L3_DATA: + ret = psr_get_l3_cbm(d, domctl->u.psr_cat_op.target, + &domctl->u.psr_cat_op.data, + PSR_CBM_TYPE_L3_DATA); copyback = 1; break; diff --git a/xen/arch/x86/psr.c b/xen/arch/x86/psr.c index 37e77d1..8bfcccb 100644 --- a/xen/arch/x86/psr.c +++ b/xen/arch/x86/psr.c @@ -294,14 +294,40 @@ int psr_get_cat_l3_info(unsigned int socket, uint32_t *cbm_len, return 0; } -int psr_get_l3_cbm(struct domain *d, unsigned int socket, uint64_t *cbm) +int psr_get_l3_cbm(struct domain *d, unsigned int socket, + uint64_t *cbm, enum cbm_type type) { struct psr_cat_socket_info *info = get_cat_socket_info(socket); + bool_t cdp_enabled = cdp_is_enabled(socket, cdp_socket_enable); if ( IS_ERR(info) ) return PTR_ERR(info); - *cbm = info->cos_to_cbm[d->arch.psr_cos_ids[socket]].cbm; + switch ( type ) + { + case PSR_CBM_TYPE_L3: + if ( type == PSR_CBM_TYPE_L3 && cdp_enabled ) + return -EXDEV; + *cbm = info->cos_to_cbm[d->arch.psr_cos_ids[socket]].cbm; + break; + + case PSR_CBM_TYPE_L3_CODE: + if ( !cdp_enabled ) + *cbm = info->cos_to_cbm[d->arch.psr_cos_ids[socket]].cbm; + else + *cbm = info->cos_to_cbm[d->arch.psr_cos_ids[socket]].code; + break; + + case PSR_CBM_TYPE_L3_DATA: + if ( !cdp_enabled ) + *cbm = info->cos_to_cbm[d->arch.psr_cos_ids[socket]].cbm; + else + *cbm = info->cos_to_cbm[d->arch.psr_cos_ids[socket]].data; + break; + + default: + ASSERT_UNREACHABLE(); + } return 0; } @@ -332,19 +358,34 @@ static bool_t psr_check_cbm(unsigned int cbm_len, uint64_t cbm) struct cos_cbm_info { unsigned int cos; - uint64_t cbm; + uint64_t cbm_code; + uint64_t cbm_data; + bool_t cdp; }; static void do_write_l3_cbm(void *data) { struct cos_cbm_info *info = data; - wrmsrl(MSR_IA32_PSR_L3_MASK(info->cos), info->cbm); + if ( info->cdp ) + { + wrmsrl(MSR_IA32_PSR_L3_MASK_CODE(info->cos), info->cbm_code); + wrmsrl(MSR_IA32_PSR_L3_MASK_DATA(info->cos), info->cbm_data); + } + else + wrmsrl(MSR_IA32_PSR_L3_MASK(info->cos), info->cbm_code); } -static int write_l3_cbm(unsigned int socket, unsigned int cos, uint64_t cbm) +static int write_l3_cbm(unsigned int socket, unsigned int cos, + uint64_t cbm_code, uint64_t cbm_data, bool_t cdp) { - struct cos_cbm_info info = { .cos = cos, .cbm = cbm }; + struct cos_cbm_info info = + { + .cos = cos, + .cbm_code = cbm_code, + .cbm_data = cbm_data, + .cdp = cdp, + }; if ( socket == cpu_to_socket(smp_processor_id()) ) do_write_l3_cbm(&info); @@ -360,10 +401,48 @@ static int write_l3_cbm(unsigned int socket, unsigned int cos, uint64_t cbm) return 0; } -int psr_set_l3_cbm(struct domain *d, unsigned int socket, uint64_t cbm) +static int find_cos(struct psr_cat_cbm *map, int cos_max, + uint64_t cbm_code, uint64_t cbm_data, bool_t cdp_enabled) { - unsigned int old_cos, cos; - struct psr_cat_cbm *map, *found = NULL; + unsigned int cos; + + for ( cos = 0; cos <= cos_max; cos++ ) + { + if( map[cos].ref && + ((!cdp_enabled && map[cos].cbm == cbm_code) || + (cdp_enabled && map[cos].code == cbm_code && + map[cos].data == cbm_data))) + return cos; + } + + return -ENOENT; +} + +static int pick_avail_cos(struct psr_cat_cbm *map, unsigned int cos_max, + unsigned int old_cos) +{ + unsigned int cos; + + /* If old cos is referred only by the domain, then use it. */ + if ( map[old_cos].ref == 1 ) + return old_cos; + + /* Find an unused one other than cos0. */ + for ( cos = 1; cos <= cos_max; cos++ ) + if ( map[cos].ref == 0 ) + return cos; + + return -ENOENT; +} + +int psr_set_l3_cbm(struct domain *d, unsigned int socket, + uint64_t cbm, enum cbm_type type) +{ + unsigned int old_cos, cos_max; + int cos, ret; + uint64_t cbm_data, cbm_code; + bool_t cdp_enabled = cdp_is_enabled(socket, cdp_socket_enable); + struct psr_cat_cbm *map; struct psr_cat_socket_info *info = get_cat_socket_info(socket); if ( IS_ERR(info) ) @@ -372,53 +451,80 @@ int psr_set_l3_cbm(struct domain *d, unsigned int socket, uint64_t cbm) if ( !psr_check_cbm(info->cbm_len, cbm) ) return -EINVAL; + if ( !cdp_enabled && (type == PSR_CBM_TYPE_L3_CODE || + type == PSR_CBM_TYPE_L3_DATA) ) + return -ENXIO; + + cos_max = info->cos_max; old_cos = d->arch.psr_cos_ids[socket]; map = info->cos_to_cbm; - spin_lock(&info->cbm_lock); - - for ( cos = 0; cos <= info->cos_max; cos++ ) + switch( type ) { - /* If still not found, then keep unused one. */ - if ( !found && cos != 0 && map[cos].ref == 0 ) - found = map + cos; - else if ( map[cos].cbm == cbm ) - { - if ( unlikely(cos == old_cos) ) - { - ASSERT(cos == 0 || map[cos].ref != 0); - spin_unlock(&info->cbm_lock); - return 0; - } - found = map + cos; - break; - } - } + case PSR_CBM_TYPE_L3: + cbm_code = cbm; + cbm_data = cbm; + break; - /* If old cos is referred only by the domain, then use it. */ - if ( !found && map[old_cos].ref == 1 ) - found = map + old_cos; + case PSR_CBM_TYPE_L3_CODE: + cbm_code = cbm; + cbm_data = map[old_cos].data; + break; - if ( !found ) - { - spin_unlock(&info->cbm_lock); - return -EOVERFLOW; + case PSR_CBM_TYPE_L3_DATA: + cbm_code = map[old_cos].code; + cbm_data = cbm; + break; + + default: + ASSERT_UNREACHABLE(); } - cos = found - map; - if ( found->cbm != cbm ) + spin_lock(&info->cbm_lock); + cos = find_cos(map, cos_max, cbm_code, cbm_data, cdp_enabled); + if ( cos >= 0 ) { - int ret = write_l3_cbm(socket, cos, cbm); + if ( cos == old_cos ) + { + spin_unlock(&info->cbm_lock); + return 0; + } + } + else + { + bool_t need_write = 1; - if ( ret ) + cos = pick_avail_cos(map, cos_max, old_cos); + if ( cos < 0 ) { spin_unlock(&info->cbm_lock); - return ret; + return cos; + } + + /* We try to avoid writing MSR. */ + if ( cdp_enabled ) + { + if ( map[cos].code == cbm_code && + map[cos].data == cbm_data ) + need_write = 0; + } + else + need_write = !(map[cos].cbm == cbm_code); + + if ( need_write ) + { + ret = write_l3_cbm(socket, cos, cbm_code, cbm_data, cdp_enabled); + if ( ret ) + { + spin_unlock(&info->cbm_lock); + return ret; + } + map[cos].code = cbm_code; + map[cos].data = cbm_data; } - found->cbm = cbm; } - found->ref++; + map[cos].ref++; map[old_cos].ref--; spin_unlock(&info->cbm_lock); diff --git a/xen/include/asm-x86/psr.h b/xen/include/asm-x86/psr.h index 5faeaaf..57f47e9 100644 --- a/xen/include/asm-x86/psr.h +++ b/xen/include/asm-x86/psr.h @@ -46,6 +46,12 @@ struct psr_cmt { struct psr_cmt_l3 l3; }; +enum cbm_type { + PSR_CBM_TYPE_L3, + PSR_CBM_TYPE_L3_CODE, + PSR_CBM_TYPE_L3_DATA, +}; + extern struct psr_cmt *psr_cmt; static inline bool_t psr_cmt_enabled(void) @@ -59,8 +65,10 @@ void psr_ctxt_switch_to(struct domain *d); int psr_get_cat_l3_info(unsigned int socket, uint32_t *cbm_len, uint32_t *cos_max, uint32_t *flags); -int psr_get_l3_cbm(struct domain *d, unsigned int socket, uint64_t *cbm); -int psr_set_l3_cbm(struct domain *d, unsigned int socket, uint64_t cbm); +int psr_get_l3_cbm(struct domain *d, unsigned int socket, + uint64_t *cbm, enum cbm_type type); +int psr_set_l3_cbm(struct domain *d, unsigned int socket, + uint64_t cbm, enum cbm_type type); int psr_domain_init(struct domain *d); void psr_domain_free(struct domain *d); diff --git a/xen/include/public/domctl.h b/xen/include/public/domctl.h index 675f021..f438cae 100644 --- a/xen/include/public/domctl.h +++ b/xen/include/public/domctl.h @@ -1056,6 +1056,10 @@ DEFINE_XEN_GUEST_HANDLE(xen_domctl_monitor_op_t); struct xen_domctl_psr_cat_op { #define XEN_DOMCTL_PSR_CAT_OP_SET_L3_CBM 0 #define XEN_DOMCTL_PSR_CAT_OP_GET_L3_CBM 1 +#define XEN_DOMCTL_PSR_CAT_OP_SET_L3_CODE 2 +#define XEN_DOMCTL_PSR_CAT_OP_SET_L3_DATA 3 +#define XEN_DOMCTL_PSR_CAT_OP_GET_L3_CODE 4 +#define XEN_DOMCTL_PSR_CAT_OP_GET_L3_DATA 5 uint32_t cmd; /* IN: XEN_DOMCTL_PSR_CAT_OP_* */ uint32_t target; /* IN */ uint64_t data; /* IN/OUT */ -- 1.9.1 _______________________________________________ Xen-devel mailing list Xen-devel@xxxxxxxxxxxxx http://lists.xen.org/xen-devel
|
Lists.xenproject.org is hosted with RackSpace, monitoring our |