Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753412AbbBXXTx (ORCPT ); Tue, 24 Feb 2015 18:19:53 -0500 Received: from mga01.intel.com ([192.55.52.88]:5505 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753167AbbBXXSb (ORCPT ); Tue, 24 Feb 2015 18:18:31 -0500 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.09,641,1418112000"; d="scan'208";a="532359988" From: Vikas Shivappa To: linux-kernel@vger.kernel.org Cc: vikas.shivappa@intel.com, vikas.shivappa@linux.intel.com, matt.fleming@intel.com, hpa@zytor.com, tglx@linutronix.de, mingo@kernel.org, tj@kernel.org, peterz@infradead.org, will.auld@intel.com, dave.hansen@intel.com, andi.kleen@intel.com, tony.luck@intel.com, kanaka.d.juvva@intel.com Subject: [PATCH 2/7] x86/intel_rdt: Adds support for Class of service management Date: Tue, 24 Feb 2015 15:16:39 -0800 Message-Id: <1424819804-4082-3-git-send-email-vikas.shivappa@linux.intel.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1424819804-4082-1-git-send-email-vikas.shivappa@linux.intel.com> References: <1424819804-4082-1-git-send-email-vikas.shivappa@linux.intel.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 6230 Lines: 227 This patch adds a cgroup subsystem to support Intel Resource Director Technology(RDT) or Platform Shared resources Control. The resources that are currently supported for sharing is Last level cache (Cache Allocation Technology or CAT). When a RDT cgroup is created it has a CLOSid and CBM associated with it which are inherited from its parent. A Class of service(CLOS) in Cache Allocation is represented by a CLOSid. CLOSid is internal to the kernel and not exposed to user. Cache bitmask(CBM) represents one cache 'subset'. Root cgroup would have all available bits set for its CBM and would be assigned the CLOSid 0. CLOSid allocation is tracked using a separate bitmap. The maximum number of CLOSids is specified by the h/w during CPUID enumeration and the kernel simply throws an -ENOSPC when it runs out of CLOSids. Each CBM has an associated CLOSid. If multiple cgroups have the same CBM they would also have the same CLOSid. The reference count parameter in CLOSid-CBM map keeps track of how many cgroups are using each CLOSid<->CBM mapping. Signed-off-by: Vikas Shivappa --- arch/x86/include/asm/intel_rdt.h | 40 +++++++++++++++ arch/x86/kernel/cpu/intel_rdt.c | 103 ++++++++++++++++++++++++++++++++++++--- include/linux/cgroup_subsys.h | 4 ++ 3 files changed, 141 insertions(+), 6 deletions(-) create mode 100644 arch/x86/include/asm/intel_rdt.h diff --git a/arch/x86/include/asm/intel_rdt.h b/arch/x86/include/asm/intel_rdt.h new file mode 100644 index 0000000..ecd9664 --- /dev/null +++ b/arch/x86/include/asm/intel_rdt.h @@ -0,0 +1,40 @@ +#ifndef _RDT_H_ +#define _RDT_H_ + +#ifdef CONFIG_CGROUP_RDT + +#include + +struct rdt_subsys_info { + /* Clos Bitmap to keep track of available CLOSids.*/ + unsigned long *closmap; +}; + +struct intel_rdt { + struct cgroup_subsys_state css; + /* Class of service for the cgroup.*/ + unsigned int clos; + /* Corresponding cache bit mask.*/ + unsigned long *cbm; +}; + +struct clos_cbm_map { + unsigned long cbm; + unsigned int cgrp_count; +}; + +/* + * Return rdt group corresponding to this container. + */ +static inline struct intel_rdt *css_rdt(struct cgroup_subsys_state *css) +{ + return css ? container_of(css, struct intel_rdt, css) : NULL; +} + +static inline struct intel_rdt *parent_rdt(struct intel_rdt *ir) +{ + return css_rdt(ir->css.parent); +} + +#endif +#endif diff --git a/arch/x86/kernel/cpu/intel_rdt.c b/arch/x86/kernel/cpu/intel_rdt.c index 46ce449..6cf1a16 100644 --- a/arch/x86/kernel/cpu/intel_rdt.c +++ b/arch/x86/kernel/cpu/intel_rdt.c @@ -23,10 +23,19 @@ #include #include #include +#include -static inline bool rdt_supported(struct cpuinfo_x86 *c) +/* + * ccmap maintains 1:1 mapping between CLOSid and cbm. + */ +static struct clos_cbm_map *ccmap; +static struct rdt_subsys_info rdtss_info; +static DEFINE_MUTEX(rdt_group_mutex); +struct intel_rdt rdt_root_group; + +static inline bool cat_supported(struct cpuinfo_x86 *c) { - if (cpu_has(c, X86_FEATURE_RDT)) + if (cpu_has(c, X86_FEATURE_CAT_L3)) return true; return false; @@ -35,17 +44,99 @@ static inline bool rdt_supported(struct cpuinfo_x86 *c) static int __init rdt_late_init(void) { struct cpuinfo_x86 *c = &boot_cpu_data; + static struct clos_cbm_map *ccm; + size_t sizeb; int maxid, cbm_len; - if (!rdt_supported(c)) + if (!cat_supported(c)) { + rdt_root_group.css.ss->disabled = 1; return -ENODEV; + } else { + maxid = c->x86_cat_closs; + cbm_len = c->x86_cat_cbmlength; + sizeb = BITS_TO_LONGS(maxid) * sizeof(long); + + rdtss_info.closmap = kzalloc(sizeb, GFP_KERNEL); + if (!rdtss_info.closmap) + return -ENOMEM; - maxid = c->x86_cat_closs; - cbm_len = c->x86_cat_cbmlength; + sizeb = maxid * sizeof(struct clos_cbm_map); + ccmap = kzalloc(sizeb, GFP_KERNEL); + if (!ccmap) { + kfree(rdtss_info.closmap); + return -ENOMEM; + } - pr_info("cbmlength:%u,Closs: %u\n", cbm_len, maxid); + set_bit(0, rdtss_info.closmap); + rdt_root_group.clos = 0; + + ccm = &ccmap[0]; + ccm->cbm = (u32)((u64)(1 << cbm_len) - 1); + rdt_root_group.cbm = &(ccm->cbm); + ccm->cgrp_count++; + + pr_info("cbmlength:%u,Closs: %u\n", cbm_len, maxid); + } return 0; } late_initcall(rdt_late_init); + +/* +* Called with the rdt_group_mutex held. +*/ +static int rdt_free_closid(struct intel_rdt *ir) +{ + + lockdep_assert_held(&rdt_group_mutex); + + WARN_ON(!ccmap[ir->clos].cgrp_count); + ccmap[ir->clos].cgrp_count--; + if (!ccmap[ir->clos].cgrp_count) + clear_bit(ir->clos, rdtss_info.closmap); + + return 0; +} + +static struct cgroup_subsys_state * +rdt_css_alloc(struct cgroup_subsys_state *parent_css) +{ + struct intel_rdt *parent = css_rdt(parent_css); + struct intel_rdt *ir; + + /* + * Cannot return failure on systems with no Cache Allocation + * as the cgroup_init does not handle failures gracefully. + */ + if (!parent) + return &rdt_root_group.css; + + ir = kzalloc(sizeof(struct intel_rdt), GFP_KERNEL); + if (!ir) + return ERR_PTR(-ENOMEM); + + mutex_lock(&rdt_group_mutex); + ir->clos = parent->clos; + ccmap[parent->clos].cgrp_count++; + mutex_unlock(&rdt_group_mutex); + + ir->cbm = parent->cbm; + return &ir->css; +} + +static void rdt_css_free(struct cgroup_subsys_state *css) +{ + struct intel_rdt *ir = css_rdt(css); + + mutex_lock(&rdt_group_mutex); + rdt_free_closid(ir); + kfree(ir); + mutex_unlock(&rdt_group_mutex); +} + +struct cgroup_subsys rdt_cgrp_subsys = { + .css_alloc = rdt_css_alloc, + .css_free = rdt_css_free, + .early_init = 0, +}; diff --git a/include/linux/cgroup_subsys.h b/include/linux/cgroup_subsys.h index 98c4f9b..925c370 100644 --- a/include/linux/cgroup_subsys.h +++ b/include/linux/cgroup_subsys.h @@ -47,6 +47,10 @@ SUBSYS(net_prio) SUBSYS(hugetlb) #endif +#if IS_ENABLED(CONFIG_CGROUP_RDT) +SUBSYS(rdt) +#endif + /* * The following subsystems are not supported on the default hierarchy. */ -- 1.9.1 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/