2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
6 * This file contains NUMA specific variables and functions which can
7 * be split away from DISCONTIGMEM and are used on NUMA machines with
9 * 2002/08/07 Erich Focht <efocht@ess.nec.de>
10 * Populate cpu entries in sysfs for non-numa systems as well
11 * Intel Corporation - Ashok Raj
12 * 02/27/2006 Zhang, Yanmin
13 * Populate cpu cache entries in sysfs for cpu cache info
16 #include <linux/cpu.h>
17 #include <linux/kernel.h>
19 #include <linux/node.h>
20 #include <linux/init.h>
21 #include <linux/bootmem.h>
22 #include <linux/nodemask.h>
23 #include <linux/notifier.h>
24 #include <asm/mmzone.h>
28 static struct ia64_cpu
*sysfs_cpus
;
30 void arch_fix_phys_package_id(int num
, u32 slot
)
33 if (cpu_data(num
)->socket_id
== -1)
34 cpu_data(num
)->socket_id
= slot
;
37 EXPORT_SYMBOL_GPL(arch_fix_phys_package_id
);
40 #ifdef CONFIG_HOTPLUG_CPU
41 int __ref
arch_register_cpu(int num
)
45 * If CPEI can be re-targetted or if this is not
46 * CPEI target, then it is hotpluggable
48 if (can_cpei_retarget() || !is_cpu_cpei_target(num
))
49 sysfs_cpus
[num
].cpu
.hotpluggable
= 1;
50 map_cpu_to_node(num
, node_cpuid
[num
].nid
);
52 return register_cpu(&sysfs_cpus
[num
].cpu
, num
);
54 EXPORT_SYMBOL(arch_register_cpu
);
56 void arch_unregister_cpu(int num
)
58 unregister_cpu(&sysfs_cpus
[num
].cpu
);
59 unmap_cpu_from_node(num
, cpu_to_node(num
));
61 EXPORT_SYMBOL(arch_unregister_cpu
);
63 static int __init
arch_register_cpu(int num
)
65 return register_cpu(&sysfs_cpus
[num
].cpu
, num
);
67 #endif /*CONFIG_HOTPLUG_CPU*/
70 static int __init
topology_init(void)
76 * MCD - Do we want to register all ONLINE nodes, or all POSSIBLE nodes?
78 for_each_online_node(i
) {
79 if ((err
= register_one_node(i
)))
84 sysfs_cpus
= kzalloc(sizeof(struct ia64_cpu
) * NR_CPUS
, GFP_KERNEL
);
86 panic("kzalloc in topology_init failed - NR_CPUS too big?");
88 for_each_present_cpu(i
) {
89 if((err
= arch_register_cpu(i
)))
96 subsys_initcall(topology_init
);
100 * Export cpu cache information through sysfs
104 * A bunch of string array to get pretty printing
106 static const char *cache_types
[] = {
110 "Unified" /* unified */
113 static const char *cache_mattrib
[]={
121 pal_cache_config_info_t cci
;
122 cpumask_t shared_cpu_map
;
128 struct cpu_cache_info
{
129 struct cache_info
*cache_leaves
;
130 int num_cache_leaves
;
134 static struct cpu_cache_info all_cpu_cache_info
[NR_CPUS
] __cpuinitdata
;
135 #define LEAF_KOBJECT_PTR(x,y) (&all_cpu_cache_info[x].cache_leaves[y])
138 static void __cpuinit
cache_shared_cpu_map_setup( unsigned int cpu
,
139 struct cache_info
* this_leaf
)
141 pal_cache_shared_info_t csi
;
142 int num_shared
, i
= 0;
145 if (cpu_data(cpu
)->threads_per_core
<= 1 &&
146 cpu_data(cpu
)->cores_per_socket
<= 1) {
147 cpu_set(cpu
, this_leaf
->shared_cpu_map
);
151 if (ia64_pal_cache_shared_info(this_leaf
->level
,
154 &csi
) != PAL_STATUS_SUCCESS
)
157 num_shared
= (int) csi
.num_shared
;
159 for_each_possible_cpu(j
)
160 if (cpu_data(cpu
)->socket_id
== cpu_data(j
)->socket_id
161 && cpu_data(j
)->core_id
== csi
.log1_cid
162 && cpu_data(j
)->thread_id
== csi
.log1_tid
)
163 cpu_set(j
, this_leaf
->shared_cpu_map
);
166 } while (i
< num_shared
&&
167 ia64_pal_cache_shared_info(this_leaf
->level
,
170 &csi
) == PAL_STATUS_SUCCESS
);
173 static void __cpuinit
cache_shared_cpu_map_setup(unsigned int cpu
,
174 struct cache_info
* this_leaf
)
176 cpu_set(cpu
, this_leaf
->shared_cpu_map
);
181 static ssize_t
show_coherency_line_size(struct cache_info
*this_leaf
,
184 return sprintf(buf
, "%u\n", 1 << this_leaf
->cci
.pcci_line_size
);
187 static ssize_t
show_ways_of_associativity(struct cache_info
*this_leaf
,
190 return sprintf(buf
, "%u\n", this_leaf
->cci
.pcci_assoc
);
193 static ssize_t
show_attributes(struct cache_info
*this_leaf
, char *buf
)
197 cache_mattrib
[this_leaf
->cci
.pcci_cache_attr
]);
200 static ssize_t
show_size(struct cache_info
*this_leaf
, char *buf
)
202 return sprintf(buf
, "%uK\n", this_leaf
->cci
.pcci_cache_size
/ 1024);
205 static ssize_t
show_number_of_sets(struct cache_info
*this_leaf
, char *buf
)
207 unsigned number_of_sets
= this_leaf
->cci
.pcci_cache_size
;
208 number_of_sets
/= this_leaf
->cci
.pcci_assoc
;
209 number_of_sets
/= 1 << this_leaf
->cci
.pcci_line_size
;
211 return sprintf(buf
, "%u\n", number_of_sets
);
214 static ssize_t
show_shared_cpu_map(struct cache_info
*this_leaf
, char *buf
)
217 cpumask_t shared_cpu_map
;
219 cpus_and(shared_cpu_map
, this_leaf
->shared_cpu_map
, cpu_online_map
);
220 len
= cpumask_scnprintf(buf
, NR_CPUS
+1, shared_cpu_map
);
221 len
+= sprintf(buf
+len
, "\n");
225 static ssize_t
show_type(struct cache_info
*this_leaf
, char *buf
)
227 int type
= this_leaf
->type
+ this_leaf
->cci
.pcci_unified
;
228 return sprintf(buf
, "%s\n", cache_types
[type
]);
231 static ssize_t
show_level(struct cache_info
*this_leaf
, char *buf
)
233 return sprintf(buf
, "%u\n", this_leaf
->level
);
237 struct attribute attr
;
238 ssize_t (*show
)(struct cache_info
*, char *);
239 ssize_t (*store
)(struct cache_info
*, const char *, size_t count
);
245 #define define_one_ro(_name) \
246 static struct cache_attr _name = \
247 __ATTR(_name, 0444, show_##_name, NULL)
249 define_one_ro(level
);
251 define_one_ro(coherency_line_size
);
252 define_one_ro(ways_of_associativity
);
254 define_one_ro(number_of_sets
);
255 define_one_ro(shared_cpu_map
);
256 define_one_ro(attributes
);
258 static struct attribute
* cache_default_attrs
[] = {
261 &coherency_line_size
.attr
,
262 &ways_of_associativity
.attr
,
265 &number_of_sets
.attr
,
266 &shared_cpu_map
.attr
,
270 #define to_object(k) container_of(k, struct cache_info, kobj)
271 #define to_attr(a) container_of(a, struct cache_attr, attr)
273 static ssize_t
cache_show(struct kobject
* kobj
, struct attribute
* attr
, char * buf
)
275 struct cache_attr
*fattr
= to_attr(attr
);
276 struct cache_info
*this_leaf
= to_object(kobj
);
279 ret
= fattr
->show
? fattr
->show(this_leaf
, buf
) : 0;
283 static struct sysfs_ops cache_sysfs_ops
= {
287 static struct kobj_type cache_ktype
= {
288 .sysfs_ops
= &cache_sysfs_ops
,
289 .default_attrs
= cache_default_attrs
,
292 static struct kobj_type cache_ktype_percpu_entry
= {
293 .sysfs_ops
= &cache_sysfs_ops
,
296 static void __cpuinit
cpu_cache_sysfs_exit(unsigned int cpu
)
298 kfree(all_cpu_cache_info
[cpu
].cache_leaves
);
299 all_cpu_cache_info
[cpu
].cache_leaves
= NULL
;
300 all_cpu_cache_info
[cpu
].num_cache_leaves
= 0;
301 memset(&all_cpu_cache_info
[cpu
].kobj
, 0, sizeof(struct kobject
));
305 static int __cpuinit
cpu_cache_sysfs_init(unsigned int cpu
)
307 u64 i
, levels
, unique_caches
;
308 pal_cache_config_info_t cci
;
311 struct cache_info
*this_cache
;
312 int num_cache_leaves
= 0;
314 if ((status
= ia64_pal_cache_summary(&levels
, &unique_caches
)) != 0) {
315 printk(KERN_ERR
"ia64_pal_cache_summary=%ld\n", status
);
319 this_cache
=kzalloc(sizeof(struct cache_info
)*unique_caches
,
321 if (this_cache
== NULL
)
324 for (i
=0; i
< levels
; i
++) {
325 for (j
=2; j
>0 ; j
--) {
326 if ((status
=ia64_pal_cache_config_info(i
,j
, &cci
)) !=
330 this_cache
[num_cache_leaves
].cci
= cci
;
331 this_cache
[num_cache_leaves
].level
= i
+ 1;
332 this_cache
[num_cache_leaves
].type
= j
;
334 cache_shared_cpu_map_setup(cpu
,
335 &this_cache
[num_cache_leaves
]);
340 all_cpu_cache_info
[cpu
].cache_leaves
= this_cache
;
341 all_cpu_cache_info
[cpu
].num_cache_leaves
= num_cache_leaves
;
343 memset(&all_cpu_cache_info
[cpu
].kobj
, 0, sizeof(struct kobject
));
348 /* Add cache interface for CPU device */
349 static int __cpuinit
cache_add_dev(struct sys_device
* sys_dev
)
351 unsigned int cpu
= sys_dev
->id
;
353 struct cache_info
*this_object
;
357 if (all_cpu_cache_info
[cpu
].kobj
.parent
)
360 oldmask
= current
->cpus_allowed
;
361 retval
= set_cpus_allowed(current
, cpumask_of_cpu(cpu
));
362 if (unlikely(retval
))
365 retval
= cpu_cache_sysfs_init(cpu
);
366 set_cpus_allowed(current
, oldmask
);
367 if (unlikely(retval
< 0))
370 retval
= kobject_init_and_add(&all_cpu_cache_info
[cpu
].kobj
,
371 &cache_ktype_percpu_entry
, &sys_dev
->kobj
,
374 for (i
= 0; i
< all_cpu_cache_info
[cpu
].num_cache_leaves
; i
++) {
375 this_object
= LEAF_KOBJECT_PTR(cpu
,i
);
376 retval
= kobject_init_and_add(&(this_object
->kobj
),
378 &all_cpu_cache_info
[cpu
].kobj
,
380 if (unlikely(retval
)) {
381 for (j
= 0; j
< i
; j
++) {
382 kobject_put(&(LEAF_KOBJECT_PTR(cpu
,j
)->kobj
));
384 kobject_put(&all_cpu_cache_info
[cpu
].kobj
);
385 cpu_cache_sysfs_exit(cpu
);
388 kobject_uevent(&(this_object
->kobj
), KOBJ_ADD
);
390 kobject_uevent(&all_cpu_cache_info
[cpu
].kobj
, KOBJ_ADD
);
394 /* Remove cache interface for CPU device */
395 static int __cpuinit
cache_remove_dev(struct sys_device
* sys_dev
)
397 unsigned int cpu
= sys_dev
->id
;
400 for (i
= 0; i
< all_cpu_cache_info
[cpu
].num_cache_leaves
; i
++)
401 kobject_put(&(LEAF_KOBJECT_PTR(cpu
,i
)->kobj
));
403 if (all_cpu_cache_info
[cpu
].kobj
.parent
) {
404 kobject_put(&all_cpu_cache_info
[cpu
].kobj
);
405 memset(&all_cpu_cache_info
[cpu
].kobj
,
407 sizeof(struct kobject
));
410 cpu_cache_sysfs_exit(cpu
);
416 * When a cpu is hot-plugged, do a check and initiate
417 * cache kobject if necessary
419 static int __cpuinit
cache_cpu_callback(struct notifier_block
*nfb
,
420 unsigned long action
, void *hcpu
)
422 unsigned int cpu
= (unsigned long)hcpu
;
423 struct sys_device
*sys_dev
;
425 sys_dev
= get_cpu_sysdev(cpu
);
428 case CPU_ONLINE_FROZEN
:
429 cache_add_dev(sys_dev
);
432 case CPU_DEAD_FROZEN
:
433 cache_remove_dev(sys_dev
);
439 static struct notifier_block __cpuinitdata cache_cpu_notifier
=
441 .notifier_call
= cache_cpu_callback
444 static int __init
cache_sysfs_init(void)
448 for_each_online_cpu(i
) {
449 struct sys_device
*sys_dev
= get_cpu_sysdev((unsigned int)i
);
450 cache_add_dev(sys_dev
);
453 register_hotcpu_notifier(&cache_cpu_notifier
);
458 device_initcall(cache_sysfs_init
);