~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/kernel/cacheinfo.c

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp