cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

cache.c (4348B)

      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * Extract CPU cache information and expose them via sysfs.
      4 *
      5 *    Copyright IBM Corp. 2012
      6 */
      7
      8#include <linux/seq_file.h>
      9#include <linux/cpu.h>
     10#include <linux/cacheinfo.h>
     11#include <asm/facility.h>
     12
     13enum {
     14	CACHE_SCOPE_NOTEXISTS,
     15	CACHE_SCOPE_PRIVATE,
     16	CACHE_SCOPE_SHARED,
     17	CACHE_SCOPE_RESERVED,
     18};
     19
     20enum {
     21	CTYPE_SEPARATE,
     22	CTYPE_DATA,
     23	CTYPE_INSTRUCTION,
     24	CTYPE_UNIFIED,
     25};
     26
     27enum {
     28	EXTRACT_TOPOLOGY,
     29	EXTRACT_LINE_SIZE,
     30	EXTRACT_SIZE,
     31	EXTRACT_ASSOCIATIVITY,
     32};
     33
     34enum {
     35	CACHE_TI_UNIFIED = 0,
     36	CACHE_TI_DATA = 0,
     37	CACHE_TI_INSTRUCTION,
     38};
     39
     40struct cache_info {
     41	unsigned char	    : 4;
     42	unsigned char scope : 2;
     43	unsigned char type  : 2;
     44};
     45
     46#define CACHE_MAX_LEVEL 8
     47union cache_topology {
     48	struct cache_info ci[CACHE_MAX_LEVEL];
     49	unsigned long long raw;
     50};
     51
     52static const char * const cache_type_string[] = {
     53	"",
     54	"Instruction",
     55	"Data",
     56	"",
     57	"Unified",
     58};
     59
     60static const enum cache_type cache_type_map[] = {
     61	[CTYPE_SEPARATE] = CACHE_TYPE_SEPARATE,
     62	[CTYPE_DATA] = CACHE_TYPE_DATA,
     63	[CTYPE_INSTRUCTION] = CACHE_TYPE_INST,
     64	[CTYPE_UNIFIED] = CACHE_TYPE_UNIFIED,
     65};
     66
     67void show_cacheinfo(struct seq_file *m)
     68{
     69	struct cpu_cacheinfo *this_cpu_ci;
     70	struct cacheinfo *cache;
     71	int idx;
     72
     73	this_cpu_ci = get_cpu_cacheinfo(cpumask_any(cpu_online_mask));
     74	for (idx = 0; idx < this_cpu_ci->num_leaves; idx++) {
     75		cache = this_cpu_ci->info_list + idx;
     76		seq_printf(m, "cache%-11d: ", idx);
     77		seq_printf(m, "level=%d ", cache->level);
     78		seq_printf(m, "type=%s ", cache_type_string[cache->type]);
     79		seq_printf(m, "scope=%s ",
     80			   cache->disable_sysfs ? "Shared" : "Private");
     81		seq_printf(m, "size=%dK ", cache->size >> 10);
     82		seq_printf(m, "line_size=%u ", cache->coherency_line_size);
     83		seq_printf(m, "associativity=%d", cache->ways_of_associativity);
     84		seq_puts(m, "\n");
     85	}
     86}
     87
     88static inline enum cache_type get_cache_type(struct cache_info *ci, int level)
     89{
     90	if (level >= CACHE_MAX_LEVEL)
     91		return CACHE_TYPE_NOCACHE;
     92	ci += level;
     93	if (ci->scope != CACHE_SCOPE_SHARED && ci->scope != CACHE_SCOPE_PRIVATE)
     94		return CACHE_TYPE_NOCACHE;
     95	return cache_type_map[ci->type];
     96}
     97
     98static inline unsigned long ecag(int ai, int li, int ti)
     99{
    100	return __ecag(ECAG_CACHE_ATTRIBUTE, ai << 4 | li << 1 | ti);
    101}
    102
    103static void ci_leaf_init(struct cacheinfo *this_leaf, int private,
    104			 enum cache_type type, unsigned int level, int cpu)
    105{
    106	int ti, num_sets;
    107
    108	if (type == CACHE_TYPE_INST)
    109		ti = CACHE_TI_INSTRUCTION;
    110	else
    111		ti = CACHE_TI_UNIFIED;
    112	this_leaf->level = level + 1;
    113	this_leaf->type = type;
    114	this_leaf->coherency_line_size = ecag(EXTRACT_LINE_SIZE, level, ti);
    115	this_leaf->ways_of_associativity = ecag(EXTRACT_ASSOCIATIVITY, level, ti);
    116	this_leaf->size = ecag(EXTRACT_SIZE, level, ti);
    117	num_sets = this_leaf->size / this_leaf->coherency_line_size;
    118	num_sets /= this_leaf->ways_of_associativity;
    119	this_leaf->number_of_sets = num_sets;
    120	cpumask_set_cpu(cpu, &this_leaf->shared_cpu_map);
    121	if (!private)
    122		this_leaf->disable_sysfs = true;
    123}
    124
    125int init_cache_level(unsigned int cpu)
    126{
    127	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
    128	unsigned int level = 0, leaves = 0;
    129	union cache_topology ct;
    130	enum cache_type ctype;
    131
    132	if (!this_cpu_ci)
    133		return -EINVAL;
    134	ct.raw = ecag(EXTRACT_TOPOLOGY, 0, 0);
    135	do {
    136		ctype = get_cache_type(&ct.ci[0], level);
    137		if (ctype == CACHE_TYPE_NOCACHE)
    138			break;
    139		/* Separate instruction and data caches */
    140		leaves += (ctype == CACHE_TYPE_SEPARATE) ? 2 : 1;
    141	} while (++level < CACHE_MAX_LEVEL);
    142	this_cpu_ci->num_levels = level;
    143	this_cpu_ci->num_leaves = leaves;
    144	return 0;
    145}
    146
    147int populate_cache_leaves(unsigned int cpu)
    148{
    149	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
    150	struct cacheinfo *this_leaf = this_cpu_ci->info_list;
    151	unsigned int level, idx, pvt;
    152	union cache_topology ct;
    153	enum cache_type ctype;
    154
    155	ct.raw = ecag(EXTRACT_TOPOLOGY, 0, 0);
    156	for (idx = 0, level = 0; level < this_cpu_ci->num_levels &&
    157	     idx < this_cpu_ci->num_leaves; idx++, level++) {
    158		if (!this_leaf)
    159			return -EINVAL;
    160		pvt = (ct.ci[level].scope == CACHE_SCOPE_PRIVATE) ? 1 : 0;
    161		ctype = get_cache_type(&ct.ci[0], level);
    162		if (ctype == CACHE_TYPE_SEPARATE) {
    163			ci_leaf_init(this_leaf++, pvt, CACHE_TYPE_DATA, level, cpu);
    164			ci_leaf_init(this_leaf++, pvt, CACHE_TYPE_INST, level, cpu);
    165		} else {
    166			ci_leaf_init(this_leaf++, pvt, ctype, level, cpu);
    167		}
    168	}
    169	return 0;
    170}