Re: [PATCH v3 1/7] ACPI/PPTT: Add Processor Properties Topology Table parsing
From: Jeremy Linton
Date: Fri Oct 13 2017 - 18:41:16 EST
Hi,
Thanks for spending the time to take a look at this.
On 10/13/2017 04:56 AM, Julien Thierry wrote:
Hi Jeremy,
Please see below some suggestions.
On 12/10/17 20:48, Jeremy Linton wrote:
ACPI 6.2 adds a new table, which describes how processing units
are related to each other in tree like fashion. Caches are
also sprinkled throughout the tree and describe the properties
of the caches in relation to other caches and processing units.
Add the code to parse the cache hierarchy and report the total
number of levels of cache for a given core using
acpi_find_last_cache_level() as well as fill out the individual
cores cache information with cache_setup_acpi() once the
cpu_cacheinfo structure has been populated by the arch specific
code.
Further, report peers in the topology using setup_acpi_cpu_topology()
to report a unique ID for each processing unit at a given level
in the tree. These unique id's can then be used to match related
processing units which exist as threads, COD (clusters
on die), within a given package, etc.
Signed-off-by: Jeremy Linton <jeremy.linton@xxxxxxx>
---
 drivers/acpi/pptt.c | 485
++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 485 insertions(+)
 create mode 100644 drivers/acpi/pptt.c
diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
new file mode 100644
index 000000000000..c86715fed4a7
--- /dev/null
+++ b/drivers/acpi/pptt.c
@@ -0,1 +1,485 @@
+/*
+ * Copyright (C) 2017, ARM
+ *
+ * This program is free software; you can redistribute it and/or
modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but
WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for
+ * more details.
+ *
+ * This file implements parsing of Processor Properties Topology
Table (PPTT)
+ * which is optionally used to describe the processor and cache
topology.
+ * Due to the relative pointers used throughout the table, this doesn't
+ * leverage the existing subtable parsing in the kernel.
+ */
+#define pr_fmt(fmt) "ACPI PPTT: " fmt
+
+#include <linux/acpi.h>
+#include <linux/cacheinfo.h>
+#include <acpi/processor.h>
+
+/*
+ * Given the PPTT table, find and verify that the subtable entry
+ * is located within the table
+ */
+static struct acpi_subtable_header *fetch_pptt_subtable(
+ÂÂÂ struct acpi_table_header *table_hdr, u32 pptt_ref)
+{
+ÂÂÂ struct acpi_subtable_header *entry;
+
+ÂÂÂ /* there isn't a subtable at reference 0 */
+ÂÂÂ if (!pptt_ref)
+ÂÂÂÂÂÂÂ return NULL;
Seeing the usage of pptt_ref to retrieve the subtable, would the
following be a more accurate check?
ÂÂÂÂif (pptt_ref < sizeof(struct acpi_table_header))
ÂÂÂÂÂÂÂ return NULL;
Yes, that makes it better match the comment, and I guess tightens up the
sanity checking. The original intention was just to catch null
references that were encoded as parent/etc fields.
+
+ÂÂÂ if (pptt_ref + sizeof(struct acpi_subtable_header) >
table_hdr->length)
+ÂÂÂÂÂÂÂ return NULL;
+
+ÂÂÂ entry = (struct acpi_subtable_header *)((u8 *)table_hdr + pptt_ref);
+
+ÂÂÂ if (pptt_ref + entry->length > table_hdr->length)
+ÂÂÂÂÂÂÂ return NULL;
+
+ÂÂÂ return entry;
+}
+
+static struct acpi_pptt_processor *fetch_pptt_node(
+ÂÂÂ struct acpi_table_header *table_hdr, u32 pptt_ref)
+{
+ÂÂÂ return (struct acpi_pptt_processor
*)fetch_pptt_subtable(table_hdr, pptt_ref);
+}
+
+static struct acpi_pptt_cache *fetch_pptt_cache(
+ÂÂÂ struct acpi_table_header *table_hdr, u32 pptt_ref)
+{
+ÂÂÂ return (struct acpi_pptt_cache *)fetch_pptt_subtable(table_hdr,
pptt_ref);
+}
+
+static struct acpi_subtable_header *acpi_get_pptt_resource(
+ÂÂÂ struct acpi_table_header *table_hdr,
+ÂÂÂ struct acpi_pptt_processor *node, int resource)
+{
+ÂÂÂ u32 ref;
+
+ÂÂÂ if (resource >= node->number_of_priv_resources)
+ÂÂÂÂÂÂÂ return NULL;
+
+ÂÂÂ ref = *(u32 *)((u8 *)node + sizeof(struct acpi_pptt_processor) +
+ÂÂÂÂÂÂÂÂÂÂÂÂÂ sizeof(u32) * resource);
+
I think this can be simplified as:
ÂÂÂÂref = *((u32 *)(node + 1) + resource);
I think Thomasz had a better suggestion with regard to ACPI_ADD_PTR()
for avoiding the explicit pointer math, although it may not be that
clean either because it doesn't fit 1:1 with the macro at the moment,
maybe i'm doing it wrong...
+ÂÂÂ return fetch_pptt_subtable(table_hdr, ref);
+}
+
+/*
+ * given a pptt resource, verify that it is a cache node, then walk
+ * down each level of caches, counting how many levels are found
+ * as well as checking the cache type (icache, dcache, unified). If a
+ * level & type match, then we set found, and continue the search.
+ * Once the entire cache branch has been walked return its max
+ * depth.
+ */
+static int acpi_pptt_walk_cache(struct acpi_table_header *table_hdr,
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ int local_level,
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ struct acpi_subtable_header *res,
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ struct acpi_pptt_cache **found,
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ int level, int type)
+{
+ÂÂÂ struct acpi_pptt_cache *cache;
+
+ÂÂÂ if (res->type != ACPI_PPTT_TYPE_CACHE)
+ÂÂÂÂÂÂÂ return 0;
+
+ÂÂÂ cache = (struct acpi_pptt_cache *) res;
+ÂÂÂ while (cache) {
+ÂÂÂÂÂÂÂ local_level++;
+
+ÂÂÂÂÂÂÂ if ((local_level == level) &&
+ÂÂÂÂÂÂÂÂÂÂÂ (cache->flags & ACPI_PPTT_CACHE_TYPE_VALID) &&
+ÂÂÂÂÂÂÂÂÂÂÂ ((cache->attributes & ACPI_PPTT_MASK_CACHE_TYPE) == type)) {
+ÂÂÂÂÂÂÂÂÂÂÂ if (*found != NULL)
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ pr_err("Found duplicate cache level/type unable to
determine uniqueness\n");
+
+ÂÂÂÂÂÂÂÂÂÂÂ pr_debug("Found cache @ level %d\n", level);
+ÂÂÂÂÂÂÂÂÂÂÂ *found = cache;
+ÂÂÂÂÂÂÂÂÂÂÂ /*
+ÂÂÂÂÂÂÂÂÂÂÂÂ * continue looking at this node's resource list
+ÂÂÂÂÂÂÂÂÂÂÂÂ * to verify that we don't find a duplicate
+ÂÂÂÂÂÂÂÂÂÂÂÂ * cache node.
+ÂÂÂÂÂÂÂÂÂÂÂÂ */
+ÂÂÂÂÂÂÂ }
+ÂÂÂÂÂÂÂ cache = fetch_pptt_cache(table_hdr, cache->next_level_of_cache);
+ÂÂÂ }
+ÂÂÂ return local_level;
+}
+
+/*
+ * Given a CPU node look for cache levels that exist at this level,
and then
+ * for each cache node, count how many levels exist below (logically
above) it.
+ * If a level and type are specified, and we find that level/type, abort
+ * processing and return the acpi_pptt_cache structure.
+ */
+static struct acpi_pptt_cache *acpi_find_cache_level(
+ÂÂÂ struct acpi_table_header *table_hdr,
+ÂÂÂ struct acpi_pptt_processor *cpu_node,
+ÂÂÂ int *starting_level, int level, int type)
+{
+ÂÂÂ struct acpi_subtable_header *res;
+ÂÂÂ int number_of_levels = *starting_level;
+ÂÂÂ int resource = 0;
+ÂÂÂ struct acpi_pptt_cache *ret = NULL;
+ÂÂÂ int local_level;
+
+ÂÂÂ /* walk down from the processor node */
+ÂÂÂ while ((res = acpi_get_pptt_resource(table_hdr, cpu_node,
resource))) {
+ÂÂÂÂÂÂÂ resource++;
+
+ÂÂÂÂÂÂÂ local_level = acpi_pptt_walk_cache(table_hdr, *starting_level,
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ res, &ret, level, type);
+ÂÂÂÂÂÂÂ /*
+ÂÂÂÂÂÂÂÂ * we are looking for the max depth. Since its potentially
+ÂÂÂÂÂÂÂÂ * possible for a given node to have resources with differing
+ÂÂÂÂÂÂÂÂ * depths verify that the depth we have found is the largest.
+ÂÂÂÂÂÂÂÂ */
+ÂÂÂÂÂÂÂ if (number_of_levels < local_level)
+ÂÂÂÂÂÂÂÂÂÂÂ number_of_levels = local_level;
+ÂÂÂ }
+ÂÂÂ if (number_of_levels > *starting_level)
+ÂÂÂÂÂÂÂ *starting_level = number_of_levels;
+
+ÂÂÂ return ret;
+}
+
+/*
+ * given a processor node containing a processing unit, walk into it
and count
+ * how many levels exist solely for it, and then walk up each level
until we hit
+ * the root node (ignore the package level because it may be possible
to have
+ * caches that exist across packages). Count the number of cache
levels that
+ * exist at each level on the way up.
+ */
+static int acpi_process_node(struct acpi_table_header *table_hdr,
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ struct acpi_pptt_processor *cpu_node)
+{
+ÂÂÂ int total_levels = 0;
+
+ÂÂÂ do {
+ÂÂÂÂÂÂÂ acpi_find_cache_level(table_hdr, cpu_node, &total_levels, 0, 0);
+ÂÂÂÂÂÂÂ cpu_node = fetch_pptt_node(table_hdr, cpu_node->parent);
+ÂÂÂ } while (cpu_node);
+
+ÂÂÂ return total_levels;
+}
+
+/* determine if the given node is a leaf node */
+static int acpi_pptt_leaf_node(struct acpi_table_header *table_hdr,
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ struct acpi_pptt_processor *node)
+{
+ÂÂÂ struct acpi_subtable_header *entry;
+ÂÂÂ unsigned long table_end;
+ÂÂÂ u32 node_entry;
+ÂÂÂ struct acpi_pptt_processor *cpu_node;
Can cpu_node be defined inside the loop? It isn't used outside.
Yes, but i'm not sure that is the style of the acpi code, if you look at
scan.c, acpi_ipmi.c maybe others, they seem to be following the "all
definitions at the top of the block" form despite having a few loops
with variables that are only used in the block.
+
+ÂÂÂ table_end = (unsigned long)table_hdr + table_hdr->length;
+ÂÂÂ node_entry = (u32)((u8 *)node - (u8 *)table_hdr);
+ÂÂÂ entry = (struct acpi_subtable_header *)((u8 *)table_hdr +
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ sizeof(struct acpi_table_pptt));
+
+ÂÂÂ while (((unsigned long)entry) + sizeof(struct
acpi_subtable_header) < table_end) {
ÂÂÂÂwhile ((unsigned long) (entry + 1) < table_end) {
+ÂÂÂÂÂÂÂ cpu_node = (struct acpi_pptt_processor *)entry;
+ÂÂÂÂÂÂÂ if ((entry->type == ACPI_PPTT_TYPE_PROCESSOR) &&
+ÂÂÂÂÂÂÂÂÂÂÂ (cpu_node->parent == node_entry))
+ÂÂÂÂÂÂÂÂÂÂÂ return 0;
+ÂÂÂÂÂÂÂ entry = (struct acpi_subtable_header *)((u8 *)entry +
entry->length);
+ÂÂÂ }
+ÂÂÂ return 1;
+}
+
+/*
+ * Find the subtable entry describing the provided processor
+ */
+static struct acpi_pptt_processor *acpi_find_processor_node(
+ÂÂÂ struct acpi_table_header *table_hdr,
+ÂÂÂ u32 acpi_cpu_id)
+{
+ÂÂÂ struct acpi_subtable_header *entry;
+ÂÂÂ unsigned long table_end;
+ÂÂÂ struct acpi_pptt_processor *cpu_node;
+
+ÂÂÂ table_end = (unsigned long)table_hdr + table_hdr->length;
+ÂÂÂ entry = (struct acpi_subtable_header *)((u8 *)table_hdr +
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ sizeof(struct acpi_table_pptt));
Can I suggest having two inline functions for this and the above function?
static inline unsigned long acpi_get_table_end(const struct
acpi_table_header *);
Which is a bit overkill for an add, let me think about this one.
static inline struct acpi_subtable_header *acpi_get_first_entry(const
struct acpi_table_header *);
This one and the below are really just degenerate cases of
fetch_pptt_subtable().
(Feel free to adapt the names of course)
+
+ÂÂÂ /* find the processor structure associated with this cpuid */
+ÂÂÂ while (((unsigned long)entry) + sizeof(struct
acpi_subtable_header) < table_end) {
Same as above -> (unsigned long) (entry + 1).
+ÂÂÂÂÂÂÂ cpu_node = (struct acpi_pptt_processor *)entry;
+
+ÂÂÂÂÂÂÂ if ((entry->type == ACPI_PPTT_TYPE_PROCESSOR) &&
+ÂÂÂÂÂÂÂÂÂÂÂ acpi_pptt_leaf_node(table_hdr, cpu_node)) {
+ÂÂÂÂÂÂÂÂÂÂÂ pr_debug("checking phy_cpu_id %d against acpi id %d\n",
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ acpi_cpu_id, cpu_node->acpi_processor_id);
+ÂÂÂÂÂÂÂÂÂÂÂ if (acpi_cpu_id == cpu_node->acpi_processor_id) {
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ /* found the correct entry */
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ pr_debug("match found!\n");
+ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ return (struct acpi_pptt_processor *)entry;
+ÂÂÂÂÂÂÂÂÂÂÂ }
+ÂÂÂÂÂÂÂ }
+
+ÂÂÂÂÂÂÂ if (entry->length == 0) {
+ÂÂÂÂÂÂÂÂÂÂÂ pr_err("Invalid zero length subtable\n");
+ÂÂÂÂÂÂÂÂÂÂÂ break;
+ÂÂÂÂÂÂÂ }
+ÂÂÂÂÂÂÂ entry = (struct acpi_subtable_header *)
+ÂÂÂÂÂÂÂÂÂÂÂ ((u8 *)entry + entry->length);
I also think it would be nicer to have an inline function for this:
static struct acpi_subtable_header *acpi_get_next_entry(const struct
acpi_subtable_header *);
Which is just a degenerate case of fetch_pptt_subtable() in both cases
after having had the macro in actypes.h pointed out, I think most of
this manipulation is going to just get buried behind those macros.
+ÂÂÂ }
+
+ÂÂÂ return NULL;
+}
+
+/*
+ * Given a acpi_pptt_processor node, walk up until we identify the
+ * package that the node is associated with or we run out of levels
+ * to request.
+ */
+static struct acpi_pptt_processor *acpi_find_processor_package_id(
+ÂÂÂ struct acpi_table_header *table_hdr,
+ÂÂÂ struct acpi_pptt_processor *cpu,
+ÂÂÂ int level)
+{
+ÂÂÂ struct acpi_pptt_processor *prev_node;
+
+ÂÂÂ while (cpu && level && !(cpu->flags & ACPI_PPTT_PHYSICAL_PACKAGE)) {
+ÂÂÂÂÂÂÂ pr_debug("level %d\n", level);
+ÂÂÂÂÂÂÂ prev_node = fetch_pptt_node(table_hdr, cpu->parent);
+ÂÂÂÂÂÂÂ if (prev_node == NULL)
+ÂÂÂÂÂÂÂÂÂÂÂ break;
+ÂÂÂÂÂÂÂ cpu = prev_node;
+ÂÂÂÂÂÂÂ level--;
+ÂÂÂ }
+ÂÂÂ return cpu;
+}
+
+static int acpi_parse_pptt(struct acpi_table_header *table_hdr, u32
acpi_cpu_id)
+{
+ÂÂÂ int number_of_levels = 0;
+ÂÂÂ struct acpi_pptt_processor *cpu;
+
+ÂÂÂ cpu = acpi_find_processor_node(table_hdr, acpi_cpu_id);
+ÂÂÂ if (cpu)
+ÂÂÂÂÂÂÂ number_of_levels = acpi_process_node(table_hdr, cpu);
+
+ÂÂÂ return number_of_levels;
+}
+
+#define ACPI_6_2_CACHE_TYPE_DATAÂÂÂÂÂÂÂÂÂÂÂÂÂ (0x0)
+#define ACPI_6_2_CACHE_TYPE_INSTRÂÂÂÂÂÂÂÂÂÂÂÂÂ (1<<2)
+#define ACPI_6_2_CACHE_TYPE_UNIFIEDÂÂÂÂÂÂÂÂÂÂÂÂÂ (1<<3)
+#define ACPI_6_2_CACHE_POLICY_WBÂÂÂÂÂÂÂÂÂÂÂÂÂ (0x0)
+#define ACPI_6_2_CACHE_POLICY_WTÂÂÂÂÂÂÂÂÂÂÂÂÂ (1<<4)
+#define ACPI_6_2_CACHE_READ_ALLOCATEÂÂÂÂÂÂÂÂÂÂÂÂÂ (0x0)
+#define ACPI_6_2_CACHE_WRITE_ALLOCATEÂÂÂÂÂÂÂÂÂÂÂÂÂ (0x01)
+#define ACPI_6_2_CACHE_RW_ALLOCATEÂÂÂÂÂÂÂÂÂÂÂÂÂ (0x02)
+
+static u8 acpi_cache_type(enum cache_type type)
+{
+ÂÂÂ switch (type) {
+ÂÂÂ case CACHE_TYPE_DATA:
+ÂÂÂÂÂÂÂ pr_debug("Looking for data cache\n");
+ÂÂÂÂÂÂÂ return ACPI_6_2_CACHE_TYPE_DATA;
+ÂÂÂ case CACHE_TYPE_INST:
+ÂÂÂÂÂÂÂ pr_debug("Looking for instruction cache\n");
+ÂÂÂÂÂÂÂ return ACPI_6_2_CACHE_TYPE_INSTR;
+ÂÂÂ default:
+ÂÂÂÂÂÂÂ pr_debug("Unknown cache type, assume unified\n");
+ÂÂÂ case CACHE_TYPE_UNIFIED:
+ÂÂÂÂÂÂÂ pr_debug("Looking for unified cache\n");
+ÂÂÂÂÂÂÂ return ACPI_6_2_CACHE_TYPE_UNIFIED;
+ÂÂÂ }
+}
+
+/* find the ACPI node describing the cache type/level for the given
CPU */
+static struct acpi_pptt_cache *acpi_find_cache_node(
+ÂÂÂ struct acpi_table_header *table_hdr, u32 acpi_cpu_id,
+ÂÂÂ enum cache_type type, unsigned int level,
+ÂÂÂ struct acpi_pptt_processor **node)
+{
+ÂÂÂ int total_levels = 0;
+ÂÂÂ struct acpi_pptt_cache *found = NULL;
+ÂÂÂ struct acpi_pptt_processor *cpu_node;
+ÂÂÂ u8 acpi_type = acpi_cache_type(type);
+
+ÂÂÂ pr_debug("Looking for CPU %d's level %d cache type %d\n",
+ÂÂÂÂÂÂÂÂ acpi_cpu_id, level, acpi_type);
+
+ÂÂÂ cpu_node = acpi_find_processor_node(table_hdr, acpi_cpu_id);
+ÂÂÂ if (!cpu_node)
+ÂÂÂÂÂÂÂ return NULL;
+
+ÂÂÂ do {
+ÂÂÂÂÂÂÂ found = acpi_find_cache_level(table_hdr, cpu_node,
&total_levels, level, acpi_type);
+ÂÂÂÂÂÂÂ *node = cpu_node;
+ÂÂÂÂÂÂÂ cpu_node = fetch_pptt_node(table_hdr, cpu_node->parent);
+ÂÂÂ } while ((cpu_node) && (!found));
Why not combine the do...while loop and the pevious check in a simple
while loop? The same condion should work as such for a while loop.
Ok, sure...