]>
Commit | Line | Data |
---|---|---|
93197a36 NL |
1 | /* |
2 | * Processor cache information made available to userspace via sysfs; | |
3 | * intended to be compatible with x86 intel_cacheinfo implementation. | |
4 | * | |
5 | * Copyright 2008 IBM Corporation | |
6 | * Author: Nathan Lynch | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License version | |
10 | * 2 as published by the Free Software Foundation. | |
11 | */ | |
12 | ||
13 | #include <linux/cpu.h> | |
14 | #include <linux/cpumask.h> | |
93197a36 NL |
15 | #include <linux/kernel.h> |
16 | #include <linux/kobject.h> | |
17 | #include <linux/list.h> | |
18 | #include <linux/notifier.h> | |
19 | #include <linux/of.h> | |
20 | #include <linux/percpu.h> | |
5a0e3ad6 | 21 | #include <linux/slab.h> |
93197a36 NL |
22 | #include <asm/prom.h> |
23 | ||
24 | #include "cacheinfo.h" | |
25 | ||
26 | /* per-cpu object for tracking: | |
27 | * - a "cache" kobject for the top-level directory | |
28 | * - a list of "index" objects representing the cpu's local cache hierarchy | |
29 | */ | |
30 | struct cache_dir { | |
31 | struct kobject *kobj; /* bare (not embedded) kobject for cache | |
32 | * directory */ | |
33 | struct cache_index_dir *index; /* list of index objects */ | |
34 | }; | |
35 | ||
36 | /* "index" object: each cpu's cache directory has an index | |
37 | * subdirectory corresponding to a cache object associated with the | |
38 | * cpu. This object's lifetime is managed via the embedded kobject. | |
39 | */ | |
40 | struct cache_index_dir { | |
41 | struct kobject kobj; | |
42 | struct cache_index_dir *next; /* next index in parent directory */ | |
43 | struct cache *cache; | |
44 | }; | |
45 | ||
46 | /* Template for determining which OF properties to query for a given | |
47 | * cache type */ | |
48 | struct cache_type_info { | |
49 | const char *name; | |
50 | const char *size_prop; | |
51 | ||
52 | /* Allow for both [di]-cache-line-size and | |
53 | * [di]-cache-block-size properties. According to the PowerPC | |
54 | * Processor binding, -line-size should be provided if it | |
55 | * differs from the cache block size (that which is operated | |
56 | * on by cache instructions), so we look for -line-size first. | |
57 | * See cache_get_line_size(). */ | |
58 | ||
59 | const char *line_size_props[2]; | |
60 | const char *nr_sets_prop; | |
61 | }; | |
62 | ||
63 | /* These are used to index the cache_type_info array. */ | |
f7e9e358 DO |
64 | #define CACHE_TYPE_UNIFIED 0 /* cache-size, cache-block-size, etc. */ |
65 | #define CACHE_TYPE_UNIFIED_D 1 /* d-cache-size, d-cache-block-size, etc */ | |
66 | #define CACHE_TYPE_INSTRUCTION 2 | |
67 | #define CACHE_TYPE_DATA 3 | |
93197a36 NL |
68 | |
69 | static const struct cache_type_info cache_type_info[] = { | |
f7e9e358 DO |
70 | { |
71 | /* Embedded systems that use cache-size, cache-block-size, | |
72 | * etc. for the Unified (typically L2) cache. */ | |
73 | .name = "Unified", | |
74 | .size_prop = "cache-size", | |
75 | .line_size_props = { "cache-line-size", | |
76 | "cache-block-size", }, | |
77 | .nr_sets_prop = "cache-sets", | |
78 | }, | |
93197a36 NL |
79 | { |
80 | /* PowerPC Processor binding says the [di]-cache-* | |
81 | * must be equal on unified caches, so just use | |
82 | * d-cache properties. */ | |
83 | .name = "Unified", | |
84 | .size_prop = "d-cache-size", | |
85 | .line_size_props = { "d-cache-line-size", | |
86 | "d-cache-block-size", }, | |
87 | .nr_sets_prop = "d-cache-sets", | |
88 | }, | |
89 | { | |
90 | .name = "Instruction", | |
91 | .size_prop = "i-cache-size", | |
92 | .line_size_props = { "i-cache-line-size", | |
93 | "i-cache-block-size", }, | |
94 | .nr_sets_prop = "i-cache-sets", | |
95 | }, | |
96 | { | |
97 | .name = "Data", | |
98 | .size_prop = "d-cache-size", | |
99 | .line_size_props = { "d-cache-line-size", | |
100 | "d-cache-block-size", }, | |
101 | .nr_sets_prop = "d-cache-sets", | |
102 | }, | |
103 | }; | |
104 | ||
105 | /* Cache object: each instance of this corresponds to a distinct cache | |
106 | * in the system. There are separate objects for Harvard caches: one | |
107 | * each for instruction and data, and each refers to the same OF node. | |
108 | * The refcount of the OF node is elevated for the lifetime of the | |
109 | * cache object. A cache object is released when its shared_cpu_map | |
110 | * is cleared (see cache_cpu_clear). | |
111 | * | |
112 | * A cache object is on two lists: an unsorted global list | |
113 | * (cache_list) of cache objects; and a singly-linked list | |
114 | * representing the local cache hierarchy, which is ordered by level | |
115 | * (e.g. L1d -> L1i -> L2 -> L3). | |
116 | */ | |
117 | struct cache { | |
118 | struct device_node *ofnode; /* OF node for this cache, may be cpu */ | |
119 | struct cpumask shared_cpu_map; /* online CPUs using this cache */ | |
120 | int type; /* split cache disambiguation */ | |
121 | int level; /* level not explicit in device tree */ | |
122 | struct list_head list; /* global list of cache objects */ | |
123 | struct cache *next_local; /* next cache of >= level */ | |
124 | }; | |
125 | ||
fc7a9feb | 126 | static DEFINE_PER_CPU(struct cache_dir *, cache_dir_pcpu); |
93197a36 NL |
127 | |
128 | /* traversal/modification of this list occurs only at cpu hotplug time; | |
129 | * access is serialized by cpu hotplug locking | |
130 | */ | |
131 | static LIST_HEAD(cache_list); | |
132 | ||
133 | static struct cache_index_dir *kobj_to_cache_index_dir(struct kobject *k) | |
134 | { | |
135 | return container_of(k, struct cache_index_dir, kobj); | |
136 | } | |
137 | ||
138 | static const char *cache_type_string(const struct cache *cache) | |
139 | { | |
140 | return cache_type_info[cache->type].name; | |
141 | } | |
142 | ||
061d19f2 PG |
143 | static void cache_init(struct cache *cache, int type, int level, |
144 | struct device_node *ofnode) | |
93197a36 NL |
145 | { |
146 | cache->type = type; | |
147 | cache->level = level; | |
148 | cache->ofnode = of_node_get(ofnode); | |
149 | INIT_LIST_HEAD(&cache->list); | |
150 | list_add(&cache->list, &cache_list); | |
151 | } | |
152 | ||
061d19f2 | 153 | static struct cache *new_cache(int type, int level, struct device_node *ofnode) |
93197a36 NL |
154 | { |
155 | struct cache *cache; | |
156 | ||
157 | cache = kzalloc(sizeof(*cache), GFP_KERNEL); | |
158 | if (cache) | |
159 | cache_init(cache, type, level, ofnode); | |
160 | ||
161 | return cache; | |
162 | } | |
163 | ||
164 | static void release_cache_debugcheck(struct cache *cache) | |
165 | { | |
166 | struct cache *iter; | |
167 | ||
168 | list_for_each_entry(iter, &cache_list, list) | |
169 | WARN_ONCE(iter->next_local == cache, | |
b7c670d6 RH |
170 | "cache for %pOF(%s) refers to cache for %pOF(%s)\n", |
171 | iter->ofnode, | |
93197a36 | 172 | cache_type_string(iter), |
b7c670d6 | 173 | cache->ofnode, |
93197a36 NL |
174 | cache_type_string(cache)); |
175 | } | |
176 | ||
177 | static void release_cache(struct cache *cache) | |
178 | { | |
179 | if (!cache) | |
180 | return; | |
181 | ||
b7c670d6 RH |
182 | pr_debug("freeing L%d %s cache for %pOF\n", cache->level, |
183 | cache_type_string(cache), cache->ofnode); | |
93197a36 NL |
184 | |
185 | release_cache_debugcheck(cache); | |
186 | list_del(&cache->list); | |
187 | of_node_put(cache->ofnode); | |
188 | kfree(cache); | |
189 | } | |
190 | ||
191 | static void cache_cpu_set(struct cache *cache, int cpu) | |
192 | { | |
193 | struct cache *next = cache; | |
194 | ||
195 | while (next) { | |
196 | WARN_ONCE(cpumask_test_cpu(cpu, &next->shared_cpu_map), | |
b7c670d6 RH |
197 | "CPU %i already accounted in %pOF(%s)\n", |
198 | cpu, next->ofnode, | |
93197a36 NL |
199 | cache_type_string(next)); |
200 | cpumask_set_cpu(cpu, &next->shared_cpu_map); | |
201 | next = next->next_local; | |
202 | } | |
203 | } | |
204 | ||
205 | static int cache_size(const struct cache *cache, unsigned int *ret) | |
206 | { | |
207 | const char *propname; | |
d10bd84f | 208 | const __be32 *cache_size; |
93197a36 NL |
209 | |
210 | propname = cache_type_info[cache->type].size_prop; | |
211 | ||
212 | cache_size = of_get_property(cache->ofnode, propname, NULL); | |
213 | if (!cache_size) | |
214 | return -ENODEV; | |
215 | ||
d10bd84f | 216 | *ret = of_read_number(cache_size, 1); |
93197a36 NL |
217 | return 0; |
218 | } | |
219 | ||
220 | static int cache_size_kb(const struct cache *cache, unsigned int *ret) | |
221 | { | |
222 | unsigned int size; | |
223 | ||
224 | if (cache_size(cache, &size)) | |
225 | return -ENODEV; | |
226 | ||
227 | *ret = size / 1024; | |
228 | return 0; | |
229 | } | |
230 | ||
231 | /* not cache_line_size() because that's a macro in include/linux/cache.h */ | |
232 | static int cache_get_line_size(const struct cache *cache, unsigned int *ret) | |
233 | { | |
d10bd84f | 234 | const __be32 *line_size; |
93197a36 NL |
235 | int i, lim; |
236 | ||
237 | lim = ARRAY_SIZE(cache_type_info[cache->type].line_size_props); | |
238 | ||
239 | for (i = 0; i < lim; i++) { | |
240 | const char *propname; | |
241 | ||
242 | propname = cache_type_info[cache->type].line_size_props[i]; | |
243 | line_size = of_get_property(cache->ofnode, propname, NULL); | |
244 | if (line_size) | |
245 | break; | |
246 | } | |
247 | ||
248 | if (!line_size) | |
249 | return -ENODEV; | |
250 | ||
d10bd84f | 251 | *ret = of_read_number(line_size, 1); |
93197a36 NL |
252 | return 0; |
253 | } | |
254 | ||
255 | static int cache_nr_sets(const struct cache *cache, unsigned int *ret) | |
256 | { | |
257 | const char *propname; | |
d10bd84f | 258 | const __be32 *nr_sets; |
93197a36 NL |
259 | |
260 | propname = cache_type_info[cache->type].nr_sets_prop; | |
261 | ||
262 | nr_sets = of_get_property(cache->ofnode, propname, NULL); | |
263 | if (!nr_sets) | |
264 | return -ENODEV; | |
265 | ||
d10bd84f | 266 | *ret = of_read_number(nr_sets, 1); |
93197a36 NL |
267 | return 0; |
268 | } | |
269 | ||
270 | static int cache_associativity(const struct cache *cache, unsigned int *ret) | |
271 | { | |
272 | unsigned int line_size; | |
273 | unsigned int nr_sets; | |
274 | unsigned int size; | |
275 | ||
276 | if (cache_nr_sets(cache, &nr_sets)) | |
277 | goto err; | |
278 | ||
279 | /* If the cache is fully associative, there is no need to | |
280 | * check the other properties. | |
281 | */ | |
282 | if (nr_sets == 1) { | |
283 | *ret = 0; | |
284 | return 0; | |
285 | } | |
286 | ||
287 | if (cache_get_line_size(cache, &line_size)) | |
288 | goto err; | |
289 | if (cache_size(cache, &size)) | |
290 | goto err; | |
291 | ||
292 | if (!(nr_sets > 0 && size > 0 && line_size > 0)) | |
293 | goto err; | |
294 | ||
295 | *ret = (size / nr_sets) / line_size; | |
296 | return 0; | |
297 | err: | |
298 | return -ENODEV; | |
299 | } | |
300 | ||
301 | /* helper for dealing with split caches */ | |
302 | static struct cache *cache_find_first_sibling(struct cache *cache) | |
303 | { | |
304 | struct cache *iter; | |
305 | ||
f7e9e358 DO |
306 | if (cache->type == CACHE_TYPE_UNIFIED || |
307 | cache->type == CACHE_TYPE_UNIFIED_D) | |
93197a36 NL |
308 | return cache; |
309 | ||
310 | list_for_each_entry(iter, &cache_list, list) | |
311 | if (iter->ofnode == cache->ofnode && iter->next_local == cache) | |
312 | return iter; | |
313 | ||
314 | return cache; | |
315 | } | |
316 | ||
317 | /* return the first cache on a local list matching node */ | |
318 | static struct cache *cache_lookup_by_node(const struct device_node *node) | |
319 | { | |
320 | struct cache *cache = NULL; | |
321 | struct cache *iter; | |
322 | ||
323 | list_for_each_entry(iter, &cache_list, list) { | |
324 | if (iter->ofnode != node) | |
325 | continue; | |
326 | cache = cache_find_first_sibling(iter); | |
327 | break; | |
328 | } | |
329 | ||
330 | return cache; | |
331 | } | |
332 | ||
333 | static bool cache_node_is_unified(const struct device_node *np) | |
334 | { | |
335 | return of_get_property(np, "cache-unified", NULL); | |
336 | } | |
337 | ||
f7e9e358 DO |
338 | /* |
339 | * Unified caches can have two different sets of tags. Most embedded | |
340 | * use cache-size, etc. for the unified cache size, but open firmware systems | |
341 | * use d-cache-size, etc. Check on initialization for which type we have, and | |
342 | * return the appropriate structure type. Assume it's embedded if it isn't | |
343 | * open firmware. If it's yet a 3rd type, then there will be missing entries | |
344 | * in /sys/devices/system/cpu/cpu0/cache/index2/, and this code will need | |
345 | * to be extended further. | |
346 | */ | |
347 | static int cache_is_unified_d(const struct device_node *np) | |
93197a36 | 348 | { |
f7e9e358 DO |
349 | return of_get_property(np, |
350 | cache_type_info[CACHE_TYPE_UNIFIED_D].size_prop, NULL) ? | |
351 | CACHE_TYPE_UNIFIED_D : CACHE_TYPE_UNIFIED; | |
352 | } | |
93197a36 | 353 | |
f7e9e358 DO |
354 | /* |
355 | */ | |
356 | static struct cache *cache_do_one_devnode_unified(struct device_node *node, int level) | |
357 | { | |
b7c670d6 | 358 | pr_debug("creating L%d ucache for %pOF\n", level, node); |
93197a36 | 359 | |
f7e9e358 | 360 | return new_cache(cache_is_unified_d(node), level, node); |
93197a36 NL |
361 | } |
362 | ||
061d19f2 PG |
363 | static struct cache *cache_do_one_devnode_split(struct device_node *node, |
364 | int level) | |
93197a36 NL |
365 | { |
366 | struct cache *dcache, *icache; | |
367 | ||
b7c670d6 RH |
368 | pr_debug("creating L%d dcache and icache for %pOF\n", level, |
369 | node); | |
93197a36 NL |
370 | |
371 | dcache = new_cache(CACHE_TYPE_DATA, level, node); | |
372 | icache = new_cache(CACHE_TYPE_INSTRUCTION, level, node); | |
373 | ||
374 | if (!dcache || !icache) | |
375 | goto err; | |
376 | ||
377 | dcache->next_local = icache; | |
378 | ||
379 | return dcache; | |
380 | err: | |
381 | release_cache(dcache); | |
382 | release_cache(icache); | |
383 | return NULL; | |
384 | } | |
385 | ||
061d19f2 | 386 | static struct cache *cache_do_one_devnode(struct device_node *node, int level) |
93197a36 NL |
387 | { |
388 | struct cache *cache; | |
389 | ||
390 | if (cache_node_is_unified(node)) | |
391 | cache = cache_do_one_devnode_unified(node, level); | |
392 | else | |
393 | cache = cache_do_one_devnode_split(node, level); | |
394 | ||
395 | return cache; | |
396 | } | |
397 | ||
061d19f2 PG |
398 | static struct cache *cache_lookup_or_instantiate(struct device_node *node, |
399 | int level) | |
93197a36 NL |
400 | { |
401 | struct cache *cache; | |
402 | ||
403 | cache = cache_lookup_by_node(node); | |
404 | ||
405 | WARN_ONCE(cache && cache->level != level, | |
406 | "cache level mismatch on lookup (got %d, expected %d)\n", | |
407 | cache->level, level); | |
408 | ||
409 | if (!cache) | |
410 | cache = cache_do_one_devnode(node, level); | |
411 | ||
412 | return cache; | |
413 | } | |
414 | ||
061d19f2 | 415 | static void link_cache_lists(struct cache *smaller, struct cache *bigger) |
93197a36 NL |
416 | { |
417 | while (smaller->next_local) { | |
418 | if (smaller->next_local == bigger) | |
419 | return; /* already linked */ | |
420 | smaller = smaller->next_local; | |
421 | } | |
422 | ||
423 | smaller->next_local = bigger; | |
424 | } | |
425 | ||
061d19f2 | 426 | static void do_subsidiary_caches_debugcheck(struct cache *cache) |
93197a36 NL |
427 | { |
428 | WARN_ON_ONCE(cache->level != 1); | |
429 | WARN_ON_ONCE(strcmp(cache->ofnode->type, "cpu")); | |
430 | } | |
431 | ||
061d19f2 | 432 | static void do_subsidiary_caches(struct cache *cache) |
93197a36 NL |
433 | { |
434 | struct device_node *subcache_node; | |
435 | int level = cache->level; | |
436 | ||
437 | do_subsidiary_caches_debugcheck(cache); | |
438 | ||
439 | while ((subcache_node = of_find_next_cache_node(cache->ofnode))) { | |
440 | struct cache *subcache; | |
441 | ||
442 | level++; | |
443 | subcache = cache_lookup_or_instantiate(subcache_node, level); | |
444 | of_node_put(subcache_node); | |
445 | if (!subcache) | |
446 | break; | |
447 | ||
448 | link_cache_lists(cache, subcache); | |
449 | cache = subcache; | |
450 | } | |
451 | } | |
452 | ||
061d19f2 | 453 | static struct cache *cache_chain_instantiate(unsigned int cpu_id) |
93197a36 NL |
454 | { |
455 | struct device_node *cpu_node; | |
456 | struct cache *cpu_cache = NULL; | |
457 | ||
458 | pr_debug("creating cache object(s) for CPU %i\n", cpu_id); | |
459 | ||
460 | cpu_node = of_get_cpu_node(cpu_id, NULL); | |
461 | WARN_ONCE(!cpu_node, "no OF node found for CPU %i\n", cpu_id); | |
462 | if (!cpu_node) | |
463 | goto out; | |
464 | ||
465 | cpu_cache = cache_lookup_or_instantiate(cpu_node, 1); | |
466 | if (!cpu_cache) | |
467 | goto out; | |
468 | ||
469 | do_subsidiary_caches(cpu_cache); | |
470 | ||
471 | cache_cpu_set(cpu_cache, cpu_id); | |
472 | out: | |
473 | of_node_put(cpu_node); | |
474 | ||
475 | return cpu_cache; | |
476 | } | |
477 | ||
061d19f2 | 478 | static struct cache_dir *cacheinfo_create_cache_dir(unsigned int cpu_id) |
93197a36 NL |
479 | { |
480 | struct cache_dir *cache_dir; | |
8a25a2fd | 481 | struct device *dev; |
93197a36 NL |
482 | struct kobject *kobj = NULL; |
483 | ||
8a25a2fd KS |
484 | dev = get_cpu_device(cpu_id); |
485 | WARN_ONCE(!dev, "no dev for CPU %i\n", cpu_id); | |
486 | if (!dev) | |
93197a36 NL |
487 | goto err; |
488 | ||
8a25a2fd | 489 | kobj = kobject_create_and_add("cache", &dev->kobj); |
93197a36 NL |
490 | if (!kobj) |
491 | goto err; | |
492 | ||
493 | cache_dir = kzalloc(sizeof(*cache_dir), GFP_KERNEL); | |
494 | if (!cache_dir) | |
495 | goto err; | |
496 | ||
497 | cache_dir->kobj = kobj; | |
498 | ||
fc7a9feb | 499 | WARN_ON_ONCE(per_cpu(cache_dir_pcpu, cpu_id) != NULL); |
93197a36 | 500 | |
fc7a9feb | 501 | per_cpu(cache_dir_pcpu, cpu_id) = cache_dir; |
93197a36 NL |
502 | |
503 | return cache_dir; | |
504 | err: | |
505 | kobject_put(kobj); | |
506 | return NULL; | |
507 | } | |
508 | ||
509 | static void cache_index_release(struct kobject *kobj) | |
510 | { | |
511 | struct cache_index_dir *index; | |
512 | ||
513 | index = kobj_to_cache_index_dir(kobj); | |
514 | ||
515 | pr_debug("freeing index directory for L%d %s cache\n", | |
516 | index->cache->level, cache_type_string(index->cache)); | |
517 | ||
518 | kfree(index); | |
519 | } | |
520 | ||
521 | static ssize_t cache_index_show(struct kobject *k, struct attribute *attr, char *buf) | |
522 | { | |
523 | struct kobj_attribute *kobj_attr; | |
524 | ||
525 | kobj_attr = container_of(attr, struct kobj_attribute, attr); | |
526 | ||
527 | return kobj_attr->show(k, kobj_attr, buf); | |
528 | } | |
529 | ||
530 | static struct cache *index_kobj_to_cache(struct kobject *k) | |
531 | { | |
532 | struct cache_index_dir *index; | |
533 | ||
534 | index = kobj_to_cache_index_dir(k); | |
535 | ||
536 | return index->cache; | |
537 | } | |
538 | ||
539 | static ssize_t size_show(struct kobject *k, struct kobj_attribute *attr, char *buf) | |
540 | { | |
541 | unsigned int size_kb; | |
542 | struct cache *cache; | |
543 | ||
544 | cache = index_kobj_to_cache(k); | |
545 | ||
546 | if (cache_size_kb(cache, &size_kb)) | |
547 | return -ENODEV; | |
548 | ||
549 | return sprintf(buf, "%uK\n", size_kb); | |
550 | } | |
551 | ||
552 | static struct kobj_attribute cache_size_attr = | |
553 | __ATTR(size, 0444, size_show, NULL); | |
554 | ||
555 | ||
556 | static ssize_t line_size_show(struct kobject *k, struct kobj_attribute *attr, char *buf) | |
557 | { | |
558 | unsigned int line_size; | |
559 | struct cache *cache; | |
560 | ||
561 | cache = index_kobj_to_cache(k); | |
562 | ||
563 | if (cache_get_line_size(cache, &line_size)) | |
564 | return -ENODEV; | |
565 | ||
566 | return sprintf(buf, "%u\n", line_size); | |
567 | } | |
568 | ||
569 | static struct kobj_attribute cache_line_size_attr = | |
570 | __ATTR(coherency_line_size, 0444, line_size_show, NULL); | |
571 | ||
572 | static ssize_t nr_sets_show(struct kobject *k, struct kobj_attribute *attr, char *buf) | |
573 | { | |
574 | unsigned int nr_sets; | |
575 | struct cache *cache; | |
576 | ||
577 | cache = index_kobj_to_cache(k); | |
578 | ||
579 | if (cache_nr_sets(cache, &nr_sets)) | |
580 | return -ENODEV; | |
581 | ||
582 | return sprintf(buf, "%u\n", nr_sets); | |
583 | } | |
584 | ||
585 | static struct kobj_attribute cache_nr_sets_attr = | |
586 | __ATTR(number_of_sets, 0444, nr_sets_show, NULL); | |
587 | ||
588 | static ssize_t associativity_show(struct kobject *k, struct kobj_attribute *attr, char *buf) | |
589 | { | |
590 | unsigned int associativity; | |
591 | struct cache *cache; | |
592 | ||
593 | cache = index_kobj_to_cache(k); | |
594 | ||
595 | if (cache_associativity(cache, &associativity)) | |
596 | return -ENODEV; | |
597 | ||
598 | return sprintf(buf, "%u\n", associativity); | |
599 | } | |
600 | ||
601 | static struct kobj_attribute cache_assoc_attr = | |
602 | __ATTR(ways_of_associativity, 0444, associativity_show, NULL); | |
603 | ||
604 | static ssize_t type_show(struct kobject *k, struct kobj_attribute *attr, char *buf) | |
605 | { | |
606 | struct cache *cache; | |
607 | ||
608 | cache = index_kobj_to_cache(k); | |
609 | ||
610 | return sprintf(buf, "%s\n", cache_type_string(cache)); | |
611 | } | |
612 | ||
613 | static struct kobj_attribute cache_type_attr = | |
614 | __ATTR(type, 0444, type_show, NULL); | |
615 | ||
616 | static ssize_t level_show(struct kobject *k, struct kobj_attribute *attr, char *buf) | |
617 | { | |
618 | struct cache_index_dir *index; | |
619 | struct cache *cache; | |
620 | ||
621 | index = kobj_to_cache_index_dir(k); | |
622 | cache = index->cache; | |
623 | ||
624 | return sprintf(buf, "%d\n", cache->level); | |
625 | } | |
626 | ||
627 | static struct kobj_attribute cache_level_attr = | |
628 | __ATTR(level, 0444, level_show, NULL); | |
629 | ||
630 | static ssize_t shared_cpu_map_show(struct kobject *k, struct kobj_attribute *attr, char *buf) | |
631 | { | |
632 | struct cache_index_dir *index; | |
633 | struct cache *cache; | |
0c118b7b | 634 | int ret; |
93197a36 NL |
635 | |
636 | index = kobj_to_cache_index_dir(k); | |
637 | cache = index->cache; | |
93197a36 | 638 | |
0c118b7b TH |
639 | ret = scnprintf(buf, PAGE_SIZE - 1, "%*pb\n", |
640 | cpumask_pr_args(&cache->shared_cpu_map)); | |
641 | buf[ret++] = '\n'; | |
642 | buf[ret] = '\0'; | |
643 | return ret; | |
93197a36 NL |
644 | } |
645 | ||
646 | static struct kobj_attribute cache_shared_cpu_map_attr = | |
647 | __ATTR(shared_cpu_map, 0444, shared_cpu_map_show, NULL); | |
648 | ||
649 | /* Attributes which should always be created -- the kobject/sysfs core | |
650 | * does this automatically via kobj_type->default_attrs. This is the | |
651 | * minimum data required to uniquely identify a cache. | |
652 | */ | |
653 | static struct attribute *cache_index_default_attrs[] = { | |
654 | &cache_type_attr.attr, | |
655 | &cache_level_attr.attr, | |
656 | &cache_shared_cpu_map_attr.attr, | |
657 | NULL, | |
658 | }; | |
659 | ||
660 | /* Attributes which should be created if the cache device node has the | |
661 | * right properties -- see cacheinfo_create_index_opt_attrs | |
662 | */ | |
663 | static struct kobj_attribute *cache_index_opt_attrs[] = { | |
664 | &cache_size_attr, | |
665 | &cache_line_size_attr, | |
666 | &cache_nr_sets_attr, | |
667 | &cache_assoc_attr, | |
668 | }; | |
669 | ||
52cf25d0 | 670 | static const struct sysfs_ops cache_index_ops = { |
93197a36 NL |
671 | .show = cache_index_show, |
672 | }; | |
673 | ||
674 | static struct kobj_type cache_index_type = { | |
675 | .release = cache_index_release, | |
676 | .sysfs_ops = &cache_index_ops, | |
677 | .default_attrs = cache_index_default_attrs, | |
678 | }; | |
679 | ||
061d19f2 | 680 | static void cacheinfo_create_index_opt_attrs(struct cache_index_dir *dir) |
93197a36 | 681 | { |
93197a36 NL |
682 | const char *cache_type; |
683 | struct cache *cache; | |
684 | char *buf; | |
685 | int i; | |
686 | ||
687 | buf = kmalloc(PAGE_SIZE, GFP_KERNEL); | |
688 | if (!buf) | |
689 | return; | |
690 | ||
691 | cache = dir->cache; | |
93197a36 NL |
692 | cache_type = cache_type_string(cache); |
693 | ||
694 | /* We don't want to create an attribute that can't provide a | |
695 | * meaningful value. Check the return value of each optional | |
696 | * attribute's ->show method before registering the | |
697 | * attribute. | |
698 | */ | |
699 | for (i = 0; i < ARRAY_SIZE(cache_index_opt_attrs); i++) { | |
700 | struct kobj_attribute *attr; | |
701 | ssize_t rc; | |
702 | ||
703 | attr = cache_index_opt_attrs[i]; | |
704 | ||
705 | rc = attr->show(&dir->kobj, attr, buf); | |
706 | if (rc <= 0) { | |
707 | pr_debug("not creating %s attribute for " | |
b7c670d6 RH |
708 | "%pOF(%s) (rc = %zd)\n", |
709 | attr->attr.name, cache->ofnode, | |
93197a36 NL |
710 | cache_type, rc); |
711 | continue; | |
712 | } | |
713 | if (sysfs_create_file(&dir->kobj, &attr->attr)) | |
b7c670d6 RH |
714 | pr_debug("could not create %s attribute for %pOF(%s)\n", |
715 | attr->attr.name, cache->ofnode, cache_type); | |
93197a36 NL |
716 | } |
717 | ||
718 | kfree(buf); | |
719 | } | |
720 | ||
061d19f2 PG |
721 | static void cacheinfo_create_index_dir(struct cache *cache, int index, |
722 | struct cache_dir *cache_dir) | |
93197a36 NL |
723 | { |
724 | struct cache_index_dir *index_dir; | |
725 | int rc; | |
726 | ||
727 | index_dir = kzalloc(sizeof(*index_dir), GFP_KERNEL); | |
728 | if (!index_dir) | |
729 | goto err; | |
730 | ||
731 | index_dir->cache = cache; | |
732 | ||
733 | rc = kobject_init_and_add(&index_dir->kobj, &cache_index_type, | |
734 | cache_dir->kobj, "index%d", index); | |
735 | if (rc) | |
736 | goto err; | |
737 | ||
738 | index_dir->next = cache_dir->index; | |
739 | cache_dir->index = index_dir; | |
740 | ||
741 | cacheinfo_create_index_opt_attrs(index_dir); | |
742 | ||
743 | return; | |
744 | err: | |
745 | kfree(index_dir); | |
746 | } | |
747 | ||
061d19f2 PG |
748 | static void cacheinfo_sysfs_populate(unsigned int cpu_id, |
749 | struct cache *cache_list) | |
93197a36 NL |
750 | { |
751 | struct cache_dir *cache_dir; | |
752 | struct cache *cache; | |
753 | int index = 0; | |
754 | ||
755 | cache_dir = cacheinfo_create_cache_dir(cpu_id); | |
756 | if (!cache_dir) | |
757 | return; | |
758 | ||
759 | cache = cache_list; | |
760 | while (cache) { | |
761 | cacheinfo_create_index_dir(cache, index, cache_dir); | |
762 | index++; | |
763 | cache = cache->next_local; | |
764 | } | |
765 | } | |
766 | ||
061d19f2 | 767 | void cacheinfo_cpu_online(unsigned int cpu_id) |
93197a36 NL |
768 | { |
769 | struct cache *cache; | |
770 | ||
771 | cache = cache_chain_instantiate(cpu_id); | |
772 | if (!cache) | |
773 | return; | |
774 | ||
775 | cacheinfo_sysfs_populate(cpu_id, cache); | |
776 | } | |
777 | ||
6b36ba84 HM |
778 | /* functions needed to remove cache entry for cpu offline or suspend/resume */ |
779 | ||
780 | #if (defined(CONFIG_PPC_PSERIES) && defined(CONFIG_SUSPEND)) || \ | |
781 | defined(CONFIG_HOTPLUG_CPU) | |
93197a36 NL |
782 | |
783 | static struct cache *cache_lookup_by_cpu(unsigned int cpu_id) | |
784 | { | |
785 | struct device_node *cpu_node; | |
786 | struct cache *cache; | |
787 | ||
788 | cpu_node = of_get_cpu_node(cpu_id, NULL); | |
789 | WARN_ONCE(!cpu_node, "no OF node found for CPU %i\n", cpu_id); | |
790 | if (!cpu_node) | |
791 | return NULL; | |
792 | ||
793 | cache = cache_lookup_by_node(cpu_node); | |
794 | of_node_put(cpu_node); | |
795 | ||
796 | return cache; | |
797 | } | |
798 | ||
799 | static void remove_index_dirs(struct cache_dir *cache_dir) | |
800 | { | |
801 | struct cache_index_dir *index; | |
802 | ||
803 | index = cache_dir->index; | |
804 | ||
805 | while (index) { | |
806 | struct cache_index_dir *next; | |
807 | ||
808 | next = index->next; | |
809 | kobject_put(&index->kobj); | |
810 | index = next; | |
811 | } | |
812 | } | |
813 | ||
814 | static void remove_cache_dir(struct cache_dir *cache_dir) | |
815 | { | |
816 | remove_index_dirs(cache_dir); | |
817 | ||
91b973f9 PM |
818 | /* Remove cache dir from sysfs */ |
819 | kobject_del(cache_dir->kobj); | |
820 | ||
93197a36 NL |
821 | kobject_put(cache_dir->kobj); |
822 | ||
823 | kfree(cache_dir); | |
824 | } | |
825 | ||
826 | static void cache_cpu_clear(struct cache *cache, int cpu) | |
827 | { | |
828 | while (cache) { | |
829 | struct cache *next = cache->next_local; | |
830 | ||
831 | WARN_ONCE(!cpumask_test_cpu(cpu, &cache->shared_cpu_map), | |
b7c670d6 RH |
832 | "CPU %i not accounted in %pOF(%s)\n", |
833 | cpu, cache->ofnode, | |
93197a36 NL |
834 | cache_type_string(cache)); |
835 | ||
836 | cpumask_clear_cpu(cpu, &cache->shared_cpu_map); | |
837 | ||
838 | /* Release the cache object if all the cpus using it | |
839 | * are offline */ | |
840 | if (cpumask_empty(&cache->shared_cpu_map)) | |
841 | release_cache(cache); | |
842 | ||
843 | cache = next; | |
844 | } | |
845 | } | |
846 | ||
847 | void cacheinfo_cpu_offline(unsigned int cpu_id) | |
848 | { | |
849 | struct cache_dir *cache_dir; | |
850 | struct cache *cache; | |
851 | ||
852 | /* Prevent userspace from seeing inconsistent state - remove | |
853 | * the sysfs hierarchy first */ | |
fc7a9feb | 854 | cache_dir = per_cpu(cache_dir_pcpu, cpu_id); |
93197a36 NL |
855 | |
856 | /* careful, sysfs population may have failed */ | |
857 | if (cache_dir) | |
858 | remove_cache_dir(cache_dir); | |
859 | ||
fc7a9feb | 860 | per_cpu(cache_dir_pcpu, cpu_id) = NULL; |
93197a36 NL |
861 | |
862 | /* clear the CPU's bit in its cache chain, possibly freeing | |
863 | * cache objects */ | |
864 | cache = cache_lookup_by_cpu(cpu_id); | |
865 | if (cache) | |
866 | cache_cpu_clear(cache, cpu_id); | |
867 | } | |
6dfd1d5f NL |
868 | |
869 | void cacheinfo_teardown(void) | |
870 | { | |
871 | unsigned int cpu; | |
872 | ||
873 | lockdep_assert_cpus_held(); | |
874 | ||
875 | for_each_online_cpu(cpu) | |
876 | cacheinfo_cpu_offline(cpu); | |
877 | } | |
878 | ||
879 | void cacheinfo_rebuild(void) | |
880 | { | |
881 | unsigned int cpu; | |
882 | ||
883 | lockdep_assert_cpus_held(); | |
884 | ||
885 | for_each_online_cpu(cpu) | |
886 | cacheinfo_cpu_online(cpu); | |
887 | } | |
888 | ||
6b36ba84 | 889 | #endif /* (CONFIG_PPC_PSERIES && CONFIG_SUSPEND) || CONFIG_HOTPLUG_CPU */ |