2 * drivers/base/node.c - basic Node class support
5 #include <linux/sysdev.h>
6 #include <linux/module.h>
7 #include <linux/init.h>
9 #include <linux/node.h>
10 #include <linux/hugetlb.h>
11 #include <linux/cpumask.h>
12 #include <linux/topology.h>
13 #include <linux/nodemask.h>
14 #include <linux/cpu.h>
15 #include <linux/device.h>
16 #include <linux/swap.h>
18 static struct sysdev_class node_class
= {
23 static ssize_t
node_read_cpumap(struct sys_device
*dev
, int type
, char *buf
)
25 struct node
*node_dev
= to_node(dev
);
26 node_to_cpumask_ptr(mask
, node_dev
->sysdev
.id
);
29 /* 2008/04/07: buf currently PAGE_SIZE, need 9 chars per 32 bits. */
30 BUILD_BUG_ON((NR_CPUS
/32 * 9) > (PAGE_SIZE
-1));
33 cpulist_scnprintf(buf
, PAGE_SIZE
-2, mask
) :
34 cpumask_scnprintf(buf
, PAGE_SIZE
-2, mask
);
40 static inline ssize_t
node_read_cpumask(struct sys_device
*dev
,
41 struct sysdev_attribute
*attr
, char *buf
)
43 return node_read_cpumap(dev
, 0, buf
);
45 static inline ssize_t
node_read_cpulist(struct sys_device
*dev
,
46 struct sysdev_attribute
*attr
, char *buf
)
48 return node_read_cpumap(dev
, 1, buf
);
51 static SYSDEV_ATTR(cpumap
, S_IRUGO
, node_read_cpumask
, NULL
);
52 static SYSDEV_ATTR(cpulist
, S_IRUGO
, node_read_cpulist
, NULL
);
54 #define K(x) ((x) << (PAGE_SHIFT - 10))
55 static ssize_t
node_read_meminfo(struct sys_device
* dev
,
56 struct sysdev_attribute
*attr
, char * buf
)
62 si_meminfo_node(&i
, nid
);
65 "Node %d MemTotal: %8lu kB\n"
66 "Node %d MemFree: %8lu kB\n"
67 "Node %d MemUsed: %8lu kB\n"
68 "Node %d Active: %8lu kB\n"
69 "Node %d Inactive: %8lu kB\n"
70 "Node %d Active(anon): %8lu kB\n"
71 "Node %d Inactive(anon): %8lu kB\n"
72 "Node %d Active(file): %8lu kB\n"
73 "Node %d Inactive(file): %8lu kB\n"
74 #ifdef CONFIG_UNEVICTABLE_LRU
75 "Node %d Unevictable: %8lu kB\n"
76 "Node %d Mlocked: %8lu kB\n"
79 "Node %d HighTotal: %8lu kB\n"
80 "Node %d HighFree: %8lu kB\n"
81 "Node %d LowTotal: %8lu kB\n"
82 "Node %d LowFree: %8lu kB\n"
84 "Node %d Dirty: %8lu kB\n"
85 "Node %d Writeback: %8lu kB\n"
86 "Node %d FilePages: %8lu kB\n"
87 "Node %d Mapped: %8lu kB\n"
88 "Node %d AnonPages: %8lu kB\n"
89 "Node %d PageTables: %8lu kB\n"
90 "Node %d NFS_Unstable: %8lu kB\n"
91 "Node %d Bounce: %8lu kB\n"
92 "Node %d WritebackTmp: %8lu kB\n"
93 "Node %d Slab: %8lu kB\n"
94 "Node %d SReclaimable: %8lu kB\n"
95 "Node %d SUnreclaim: %8lu kB\n",
98 nid
, K(i
.totalram
- i
.freeram
),
99 nid
, K(node_page_state(nid
, NR_ACTIVE_ANON
) +
100 node_page_state(nid
, NR_ACTIVE_FILE
)),
101 nid
, K(node_page_state(nid
, NR_INACTIVE_ANON
) +
102 node_page_state(nid
, NR_INACTIVE_FILE
)),
103 nid
, K(node_page_state(nid
, NR_ACTIVE_ANON
)),
104 nid
, K(node_page_state(nid
, NR_INACTIVE_ANON
)),
105 nid
, K(node_page_state(nid
, NR_ACTIVE_FILE
)),
106 nid
, K(node_page_state(nid
, NR_INACTIVE_FILE
)),
107 #ifdef CONFIG_UNEVICTABLE_LRU
108 nid
, K(node_page_state(nid
, NR_UNEVICTABLE
)),
109 nid
, K(node_page_state(nid
, NR_MLOCK
)),
111 #ifdef CONFIG_HIGHMEM
114 nid
, K(i
.totalram
- i
.totalhigh
),
115 nid
, K(i
.freeram
- i
.freehigh
),
117 nid
, K(node_page_state(nid
, NR_FILE_DIRTY
)),
118 nid
, K(node_page_state(nid
, NR_WRITEBACK
)),
119 nid
, K(node_page_state(nid
, NR_FILE_PAGES
)),
120 nid
, K(node_page_state(nid
, NR_FILE_MAPPED
)),
121 nid
, K(node_page_state(nid
, NR_ANON_PAGES
)),
122 nid
, K(node_page_state(nid
, NR_PAGETABLE
)),
123 nid
, K(node_page_state(nid
, NR_UNSTABLE_NFS
)),
124 nid
, K(node_page_state(nid
, NR_BOUNCE
)),
125 nid
, K(node_page_state(nid
, NR_WRITEBACK_TEMP
)),
126 nid
, K(node_page_state(nid
, NR_SLAB_RECLAIMABLE
) +
127 node_page_state(nid
, NR_SLAB_UNRECLAIMABLE
)),
128 nid
, K(node_page_state(nid
, NR_SLAB_RECLAIMABLE
)),
129 nid
, K(node_page_state(nid
, NR_SLAB_UNRECLAIMABLE
)));
130 n
+= hugetlb_report_node_meminfo(nid
, buf
+ n
);
135 static SYSDEV_ATTR(meminfo
, S_IRUGO
, node_read_meminfo
, NULL
);
137 static ssize_t
node_read_numastat(struct sys_device
* dev
,
138 struct sysdev_attribute
*attr
, char * buf
)
144 "interleave_hit %lu\n"
147 node_page_state(dev
->id
, NUMA_HIT
),
148 node_page_state(dev
->id
, NUMA_MISS
),
149 node_page_state(dev
->id
, NUMA_FOREIGN
),
150 node_page_state(dev
->id
, NUMA_INTERLEAVE_HIT
),
151 node_page_state(dev
->id
, NUMA_LOCAL
),
152 node_page_state(dev
->id
, NUMA_OTHER
));
154 static SYSDEV_ATTR(numastat
, S_IRUGO
, node_read_numastat
, NULL
);
156 static ssize_t
node_read_distance(struct sys_device
* dev
,
157 struct sysdev_attribute
*attr
, char * buf
)
163 /* buf currently PAGE_SIZE, need ~4 chars per node */
164 BUILD_BUG_ON(MAX_NUMNODES
*4 > PAGE_SIZE
/2);
166 for_each_online_node(i
)
167 len
+= sprintf(buf
+ len
, "%s%d", i
? " " : "", node_distance(nid
, i
));
169 len
+= sprintf(buf
+ len
, "\n");
172 static SYSDEV_ATTR(distance
, S_IRUGO
, node_read_distance
, NULL
);
176 * register_node - Setup a sysfs device for a node.
177 * @num - Node number to use when creating the device.
179 * Initialize and register the node device.
181 int register_node(struct node
*node
, int num
, struct node
*parent
)
185 node
->sysdev
.id
= num
;
186 node
->sysdev
.cls
= &node_class
;
187 error
= sysdev_register(&node
->sysdev
);
190 sysdev_create_file(&node
->sysdev
, &attr_cpumap
);
191 sysdev_create_file(&node
->sysdev
, &attr_cpulist
);
192 sysdev_create_file(&node
->sysdev
, &attr_meminfo
);
193 sysdev_create_file(&node
->sysdev
, &attr_numastat
);
194 sysdev_create_file(&node
->sysdev
, &attr_distance
);
196 scan_unevictable_register_node(node
);
202 * unregister_node - unregister a node device
203 * @node: node going away
205 * Unregisters a node device @node. All the devices on the node must be
206 * unregistered before calling this function.
208 void unregister_node(struct node
*node
)
210 sysdev_remove_file(&node
->sysdev
, &attr_cpumap
);
211 sysdev_remove_file(&node
->sysdev
, &attr_cpulist
);
212 sysdev_remove_file(&node
->sysdev
, &attr_meminfo
);
213 sysdev_remove_file(&node
->sysdev
, &attr_numastat
);
214 sysdev_remove_file(&node
->sysdev
, &attr_distance
);
216 scan_unevictable_unregister_node(node
);
218 sysdev_unregister(&node
->sysdev
);
221 struct node node_devices
[MAX_NUMNODES
];
224 * register cpu under node
226 int register_cpu_under_node(unsigned int cpu
, unsigned int nid
)
228 if (node_online(nid
)) {
229 struct sys_device
*obj
= get_cpu_sysdev(cpu
);
232 return sysfs_create_link(&node_devices
[nid
].sysdev
.kobj
,
234 kobject_name(&obj
->kobj
));
240 int unregister_cpu_under_node(unsigned int cpu
, unsigned int nid
)
242 if (node_online(nid
)) {
243 struct sys_device
*obj
= get_cpu_sysdev(cpu
);
245 sysfs_remove_link(&node_devices
[nid
].sysdev
.kobj
,
246 kobject_name(&obj
->kobj
));
251 int register_one_node(int nid
)
256 if (node_online(nid
)) {
257 int p_node
= parent_node(nid
);
258 struct node
*parent
= NULL
;
261 parent
= &node_devices
[p_node
];
263 error
= register_node(&node_devices
[nid
], nid
, parent
);
265 /* link cpu under this node */
266 for_each_present_cpu(cpu
) {
267 if (cpu_to_node(cpu
) == nid
)
268 register_cpu_under_node(cpu
, nid
);
276 void unregister_one_node(int nid
)
278 unregister_node(&node_devices
[nid
]);
282 * node states attributes
285 static ssize_t
print_nodes_state(enum node_states state
, char *buf
)
289 n
= nodelist_scnprintf(buf
, PAGE_SIZE
, node_states
[state
]);
290 if (n
> 0 && PAGE_SIZE
> n
+ 1) {
297 static ssize_t
print_nodes_possible(struct sysdev_class
*class, char *buf
)
299 return print_nodes_state(N_POSSIBLE
, buf
);
302 static ssize_t
print_nodes_online(struct sysdev_class
*class, char *buf
)
304 return print_nodes_state(N_ONLINE
, buf
);
307 static ssize_t
print_nodes_has_normal_memory(struct sysdev_class
*class,
310 return print_nodes_state(N_NORMAL_MEMORY
, buf
);
313 static ssize_t
print_nodes_has_cpu(struct sysdev_class
*class, char *buf
)
315 return print_nodes_state(N_CPU
, buf
);
318 static SYSDEV_CLASS_ATTR(possible
, 0444, print_nodes_possible
, NULL
);
319 static SYSDEV_CLASS_ATTR(online
, 0444, print_nodes_online
, NULL
);
320 static SYSDEV_CLASS_ATTR(has_normal_memory
, 0444, print_nodes_has_normal_memory
,
322 static SYSDEV_CLASS_ATTR(has_cpu
, 0444, print_nodes_has_cpu
, NULL
);
324 #ifdef CONFIG_HIGHMEM
325 static ssize_t
print_nodes_has_high_memory(struct sysdev_class
*class,
328 return print_nodes_state(N_HIGH_MEMORY
, buf
);
331 static SYSDEV_CLASS_ATTR(has_high_memory
, 0444, print_nodes_has_high_memory
,
335 struct sysdev_class_attribute
*node_state_attr
[] = {
338 &attr_has_normal_memory
,
339 #ifdef CONFIG_HIGHMEM
340 &attr_has_high_memory
,
345 static int node_states_init(void)
350 for (i
= 0; i
< NR_NODE_STATES
; i
++) {
352 ret
= sysdev_class_create_file(&node_class
, node_state_attr
[i
]);
359 static int __init
register_node_type(void)
363 ret
= sysdev_class_register(&node_class
);
365 ret
= node_states_init();
368 * Note: we're not going to unregister the node class if we fail
369 * to register the node state class attribute files.
373 postcore_initcall(register_node_type
);