lkml.org 
[lkml]   [2015]   [Sep]   [9]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 06/11] x86/intel_rdt: Add L3 cache capacity bitmask management
    Date
    This patch adds different APIs to manage the L3 cache capacity bitmask.
    The capacity bit mask(CBM) needs to have only contiguous bits set. The
    current implementation has a global CBM for each class of service id.
    There are APIs added to update the CBM via MSR write to IA32_L3_MASK_n
    on all packages. Other APIs are to read and write entries to the
    clos_cbm_table.

    Signed-off-by: Vikas Shivappa <vikas.shivappa@linux.intel.com>
    ---
    arch/x86/include/asm/intel_rdt.h | 4 ++
    arch/x86/kernel/cpu/intel_rdt.c | 122 +++++++++++++++++++++++++++++++++++++++
    2 files changed, 126 insertions(+)

    diff --git a/arch/x86/include/asm/intel_rdt.h b/arch/x86/include/asm/intel_rdt.h
    index 88b7643..4f45dc8 100644
    --- a/arch/x86/include/asm/intel_rdt.h
    +++ b/arch/x86/include/asm/intel_rdt.h
    @@ -3,6 +3,10 @@

    #ifdef CONFIG_INTEL_RDT

    +#define MAX_CBM_LENGTH 32
    +#define IA32_L3_CBM_BASE 0xc90
    +#define CBM_FROM_INDEX(x) (IA32_L3_CBM_BASE + x)
    +
    struct clos_cbm_table {
    unsigned long l3_cbm;
    unsigned int clos_refcnt;
    diff --git a/arch/x86/kernel/cpu/intel_rdt.c b/arch/x86/kernel/cpu/intel_rdt.c
    index cc988b1..c9db0ed 100644
    --- a/arch/x86/kernel/cpu/intel_rdt.c
    +++ b/arch/x86/kernel/cpu/intel_rdt.c
    @@ -34,6 +34,15 @@ static struct clos_cbm_table *cctable;
    * closid availability bit map.
    */
    unsigned long *closmap;
    +/*
    + * Mask of CPUs for writing CBM values. We only need one CPU per-socket.
    + */
    +static cpumask_t rdt_cpumask;
    +/*
    + * Temporary cpumask used during hot cpu notificaiton handling. The usage
    + * is serialized by hot cpu locks.
    + */
    +static cpumask_t tmp_cpumask;
    static DEFINE_MUTEX(rdt_group_mutex);

    static inline void closid_get(u32 closid)
    @@ -82,6 +91,117 @@ static void closid_put(u32 closid)
    closid_free(closid);
    }

    +static bool cbm_validate(unsigned long var)
    +{
    + u32 max_cbm_len = boot_cpu_data.x86_cache_max_cbm_len;
    + unsigned long first_bit, zero_bit;
    + u64 max_cbm;
    +
    + if (bitmap_weight(&var, max_cbm_len) < 1)
    + return false;
    +
    + max_cbm = (1ULL << max_cbm_len) - 1;
    + if (var & ~max_cbm)
    + return false;
    +
    + first_bit = find_first_bit(&var, max_cbm_len);
    + zero_bit = find_next_zero_bit(&var, max_cbm_len, first_bit);
    +
    + if (find_next_bit(&var, max_cbm_len, zero_bit) < max_cbm_len)
    + return false;
    +
    + return true;
    +}
    +
    +static int clos_cbm_table_read(u32 closid, unsigned long *l3_cbm)
    +{
    + u32 maxid = boot_cpu_data.x86_cache_max_closid;
    +
    + lockdep_assert_held(&rdt_group_mutex);
    +
    + if (closid >= maxid)
    + return -EINVAL;
    +
    + *l3_cbm = cctable[closid].l3_cbm;
    +
    + return 0;
    +}
    +
    +/*
    + * clos_cbm_table_update() - Update a clos cbm table entry.
    + * @closid: the closid whose cbm needs to be updated
    + * @cbm: the new cbm value that has to be updated
    + *
    + * This assumes the cbm is validated as per the interface requirements
    + * and the cache allocation requirements(through the cbm_validate).
    + */
    +static int clos_cbm_table_update(u32 closid, unsigned long cbm)
    +{
    + u32 maxid = boot_cpu_data.x86_cache_max_closid;
    +
    + lockdep_assert_held(&rdt_group_mutex);
    +
    + if (closid >= maxid)
    + return -EINVAL;
    +
    + cctable[closid].l3_cbm = cbm;
    +
    + return 0;
    +}
    +
    +static bool cbm_search(unsigned long cbm, u32 *closid)
    +{
    + u32 maxid = boot_cpu_data.x86_cache_max_closid;
    + u32 i;
    +
    + for (i = 0; i < maxid; i++) {
    + if (cctable[i].clos_refcnt &&
    + bitmap_equal(&cbm, &cctable[i].l3_cbm, MAX_CBM_LENGTH)) {
    + *closid = i;
    + return true;
    + }
    + }
    +
    + return false;
    +}
    +
    +static void closcbm_map_dump(void)
    +{
    + u32 i;
    +
    + pr_debug("CBMMAP\n");
    + for (i = 0; i < boot_cpu_data.x86_cache_max_closid; i++) {
    + pr_debug("l3_cbm: 0x%x,clos_refcnt: %u\n",
    + (unsigned int)cctable[i].l3_cbm, cctable[i].clos_refcnt);
    + }
    +}
    +
    +static void cbm_cpu_update(void *info)
    +{
    + u32 closid = (u32) info;
    +
    + wrmsrl(CBM_FROM_INDEX(closid), cctable[closid].l3_cbm);
    +}
    +
    +/*
    + * cbm_update_all() - Update the cache bit mask for all packages.
    + */
    +static void cbm_update_all(u32 closid)
    +{
    + on_each_cpu_mask(&rdt_cpumask, cbm_cpu_update, (void *)closid, 1);
    +}
    +
    +static inline bool rdt_cpumask_update(int cpu)
    +{
    + cpumask_and(&tmp_cpumask, &rdt_cpumask, topology_core_cpumask(cpu));
    + if (cpumask_empty(&tmp_cpumask)) {
    + cpumask_set_cpu(cpu, &rdt_cpumask);
    + return true;
    + }
    +
    + return false;
    +}
    +
    static int __init intel_rdt_late_init(void)
    {
    struct cpuinfo_x86 *c = &boot_cpu_data;
    @@ -112,6 +232,8 @@ static int __init intel_rdt_late_init(void)
    goto out_err;
    }

    + for_each_online_cpu(i)
    + rdt_cpumask_update(i);
    pr_info("Intel cache allocation enabled\n");
    out_err:

    --
    1.9.1


    \
     
     \ /
      Last update: 2015-09-09 21:41    [W:3.152 / U:0.188 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site