1 /*
2 * Basic Node interface support
3 */
4
5 #include <linux/module.h>
6 #include <linux/init.h>
7 #include <linux/mm.h>
8 #include <linux/memory.h>
9 #include <linux/vmstat.h>
10 #include <linux/notifier.h>
11 #include <linux/node.h>
12 #include <linux/hugetlb.h>
13 #include <linux/compaction.h>
14 #include <linux/cpumask.h>
15 #include <linux/topology.h>
16 #include <linux/nodemask.h>
17 #include <linux/cpu.h>
18 #include <linux/device.h>
19 #include <linux/swap.h>
20 #include <linux/slab.h>
21
22 static struct bus_type node_subsys = {
23 .name = "node",
24 .dev_name = "node",
25 };
26
27
node_read_cpumap(struct device * dev,int type,char * buf)28 static ssize_t node_read_cpumap(struct device *dev, int type, char *buf)
29 {
30 struct node *node_dev = to_node(dev);
31 const struct cpumask *mask = cpumask_of_node(node_dev->dev.id);
32 int len;
33
34 /* 2008/04/07: buf currently PAGE_SIZE, need 9 chars per 32 bits. */
35 BUILD_BUG_ON((NR_CPUS/32 * 9) > (PAGE_SIZE-1));
36
37 len = type?
38 cpulist_scnprintf(buf, PAGE_SIZE-2, mask) :
39 cpumask_scnprintf(buf, PAGE_SIZE-2, mask);
40 buf[len++] = '\n';
41 buf[len] = '\0';
42 return len;
43 }
44
node_read_cpumask(struct device * dev,struct device_attribute * attr,char * buf)45 static inline ssize_t node_read_cpumask(struct device *dev,
46 struct device_attribute *attr, char *buf)
47 {
48 return node_read_cpumap(dev, 0, buf);
49 }
node_read_cpulist(struct device * dev,struct device_attribute * attr,char * buf)50 static inline ssize_t node_read_cpulist(struct device *dev,
51 struct device_attribute *attr, char *buf)
52 {
53 return node_read_cpumap(dev, 1, buf);
54 }
55
56 static DEVICE_ATTR(cpumap, S_IRUGO, node_read_cpumask, NULL);
57 static DEVICE_ATTR(cpulist, S_IRUGO, node_read_cpulist, NULL);
58
59 #define K(x) ((x) << (PAGE_SHIFT - 10))
node_read_meminfo(struct device * dev,struct device_attribute * attr,char * buf)60 static ssize_t node_read_meminfo(struct device *dev,
61 struct device_attribute *attr, char *buf)
62 {
63 int n;
64 int nid = dev->id;
65 struct sysinfo i;
66
67 si_meminfo_node(&i, nid);
68 n = sprintf(buf,
69 "Node %d MemTotal: %8lu kB\n"
70 "Node %d MemFree: %8lu kB\n"
71 "Node %d MemUsed: %8lu kB\n"
72 "Node %d Active: %8lu kB\n"
73 "Node %d Inactive: %8lu kB\n"
74 "Node %d Active(anon): %8lu kB\n"
75 "Node %d Inactive(anon): %8lu kB\n"
76 "Node %d Active(file): %8lu kB\n"
77 "Node %d Inactive(file): %8lu kB\n"
78 "Node %d Unevictable: %8lu kB\n"
79 "Node %d Mlocked: %8lu kB\n",
80 nid, K(i.totalram),
81 nid, K(i.freeram),
82 nid, K(i.totalram - i.freeram),
83 nid, K(node_page_state(nid, NR_ACTIVE_ANON) +
84 node_page_state(nid, NR_ACTIVE_FILE)),
85 nid, K(node_page_state(nid, NR_INACTIVE_ANON) +
86 node_page_state(nid, NR_INACTIVE_FILE)),
87 nid, K(node_page_state(nid, NR_ACTIVE_ANON)),
88 nid, K(node_page_state(nid, NR_INACTIVE_ANON)),
89 nid, K(node_page_state(nid, NR_ACTIVE_FILE)),
90 nid, K(node_page_state(nid, NR_INACTIVE_FILE)),
91 nid, K(node_page_state(nid, NR_UNEVICTABLE)),
92 nid, K(node_page_state(nid, NR_MLOCK)));
93
94 #ifdef CONFIG_HIGHMEM
95 n += sprintf(buf + n,
96 "Node %d HighTotal: %8lu kB\n"
97 "Node %d HighFree: %8lu kB\n"
98 "Node %d LowTotal: %8lu kB\n"
99 "Node %d LowFree: %8lu kB\n",
100 nid, K(i.totalhigh),
101 nid, K(i.freehigh),
102 nid, K(i.totalram - i.totalhigh),
103 nid, K(i.freeram - i.freehigh));
104 #endif
105 n += sprintf(buf + n,
106 "Node %d Dirty: %8lu kB\n"
107 "Node %d Writeback: %8lu kB\n"
108 "Node %d FilePages: %8lu kB\n"
109 "Node %d Mapped: %8lu kB\n"
110 "Node %d AnonPages: %8lu kB\n"
111 "Node %d Shmem: %8lu kB\n"
112 "Node %d KernelStack: %8lu kB\n"
113 "Node %d PageTables: %8lu kB\n"
114 "Node %d NFS_Unstable: %8lu kB\n"
115 "Node %d Bounce: %8lu kB\n"
116 "Node %d WritebackTmp: %8lu kB\n"
117 "Node %d Slab: %8lu kB\n"
118 "Node %d SReclaimable: %8lu kB\n"
119 "Node %d SUnreclaim: %8lu kB\n"
120 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
121 "Node %d AnonHugePages: %8lu kB\n"
122 #endif
123 ,
124 nid, K(node_page_state(nid, NR_FILE_DIRTY)),
125 nid, K(node_page_state(nid, NR_WRITEBACK)),
126 nid, K(node_page_state(nid, NR_FILE_PAGES)),
127 nid, K(node_page_state(nid, NR_FILE_MAPPED)),
128 nid, K(node_page_state(nid, NR_ANON_PAGES)),
129 nid, K(i.sharedram),
130 nid, node_page_state(nid, NR_KERNEL_STACK) *
131 THREAD_SIZE / 1024,
132 nid, K(node_page_state(nid, NR_PAGETABLE)),
133 nid, K(node_page_state(nid, NR_UNSTABLE_NFS)),
134 nid, K(node_page_state(nid, NR_BOUNCE)),
135 nid, K(node_page_state(nid, NR_WRITEBACK_TEMP)),
136 nid, K(node_page_state(nid, NR_SLAB_RECLAIMABLE) +
137 node_page_state(nid, NR_SLAB_UNRECLAIMABLE)),
138 nid, K(node_page_state(nid, NR_SLAB_RECLAIMABLE)),
139 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
140 nid, K(node_page_state(nid, NR_SLAB_UNRECLAIMABLE))
141 , nid,
142 K(node_page_state(nid, NR_ANON_TRANSPARENT_HUGEPAGES) *
143 HPAGE_PMD_NR));
144 #else
145 nid, K(node_page_state(nid, NR_SLAB_UNRECLAIMABLE)));
146 #endif
147 n += hugetlb_report_node_meminfo(nid, buf + n);
148 return n;
149 }
150
151 #undef K
152 static DEVICE_ATTR(meminfo, S_IRUGO, node_read_meminfo, NULL);
153
node_read_numastat(struct device * dev,struct device_attribute * attr,char * buf)154 static ssize_t node_read_numastat(struct device *dev,
155 struct device_attribute *attr, char *buf)
156 {
157 return sprintf(buf,
158 "numa_hit %lu\n"
159 "numa_miss %lu\n"
160 "numa_foreign %lu\n"
161 "interleave_hit %lu\n"
162 "local_node %lu\n"
163 "other_node %lu\n",
164 node_page_state(dev->id, NUMA_HIT),
165 node_page_state(dev->id, NUMA_MISS),
166 node_page_state(dev->id, NUMA_FOREIGN),
167 node_page_state(dev->id, NUMA_INTERLEAVE_HIT),
168 node_page_state(dev->id, NUMA_LOCAL),
169 node_page_state(dev->id, NUMA_OTHER));
170 }
171 static DEVICE_ATTR(numastat, S_IRUGO, node_read_numastat, NULL);
172
node_read_vmstat(struct device * dev,struct device_attribute * attr,char * buf)173 static ssize_t node_read_vmstat(struct device *dev,
174 struct device_attribute *attr, char *buf)
175 {
176 int nid = dev->id;
177 int i;
178 int n = 0;
179
180 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
181 n += sprintf(buf+n, "%s %lu\n", vmstat_text[i],
182 node_page_state(nid, i));
183
184 return n;
185 }
186 static DEVICE_ATTR(vmstat, S_IRUGO, node_read_vmstat, NULL);
187
node_read_distance(struct device * dev,struct device_attribute * attr,char * buf)188 static ssize_t node_read_distance(struct device *dev,
189 struct device_attribute *attr, char * buf)
190 {
191 int nid = dev->id;
192 int len = 0;
193 int i;
194
195 /*
196 * buf is currently PAGE_SIZE in length and each node needs 4 chars
197 * at the most (distance + space or newline).
198 */
199 BUILD_BUG_ON(MAX_NUMNODES * 4 > PAGE_SIZE);
200
201 for_each_online_node(i)
202 len += sprintf(buf + len, "%s%d", i ? " " : "", node_distance(nid, i));
203
204 len += sprintf(buf + len, "\n");
205 return len;
206 }
207 static DEVICE_ATTR(distance, S_IRUGO, node_read_distance, NULL);
208
209 #ifdef CONFIG_HUGETLBFS
210 /*
211 * hugetlbfs per node attributes registration interface:
212 * When/if hugetlb[fs] subsystem initializes [sometime after this module],
213 * it will register its per node attributes for all online nodes with
214 * memory. It will also call register_hugetlbfs_with_node(), below, to
215 * register its attribute registration functions with this node driver.
216 * Once these hooks have been initialized, the node driver will call into
217 * the hugetlb module to [un]register attributes for hot-plugged nodes.
218 */
219 static node_registration_func_t __hugetlb_register_node;
220 static node_registration_func_t __hugetlb_unregister_node;
221
hugetlb_register_node(struct node * node)222 static inline bool hugetlb_register_node(struct node *node)
223 {
224 if (__hugetlb_register_node &&
225 node_state(node->dev.id, N_MEMORY)) {
226 __hugetlb_register_node(node);
227 return true;
228 }
229 return false;
230 }
231
hugetlb_unregister_node(struct node * node)232 static inline void hugetlb_unregister_node(struct node *node)
233 {
234 if (__hugetlb_unregister_node)
235 __hugetlb_unregister_node(node);
236 }
237
register_hugetlbfs_with_node(node_registration_func_t doregister,node_registration_func_t unregister)238 void register_hugetlbfs_with_node(node_registration_func_t doregister,
239 node_registration_func_t unregister)
240 {
241 __hugetlb_register_node = doregister;
242 __hugetlb_unregister_node = unregister;
243 }
244 #else
hugetlb_register_node(struct node * node)245 static inline void hugetlb_register_node(struct node *node) {}
246
hugetlb_unregister_node(struct node * node)247 static inline void hugetlb_unregister_node(struct node *node) {}
248 #endif
249
node_device_release(struct device * dev)250 static void node_device_release(struct device *dev)
251 {
252 struct node *node = to_node(dev);
253
254 #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) && defined(CONFIG_HUGETLBFS)
255 /*
256 * We schedule the work only when a memory section is
257 * onlined/offlined on this node. When we come here,
258 * all the memory on this node has been offlined,
259 * so we won't enqueue new work to this work.
260 *
261 * The work is using node->node_work, so we should
262 * flush work before freeing the memory.
263 */
264 flush_work(&node->node_work);
265 #endif
266 kfree(node);
267 }
268
269 /*
270 * register_node - Setup a sysfs device for a node.
271 * @num - Node number to use when creating the device.
272 *
273 * Initialize and register the node device.
274 */
register_node(struct node * node,int num,struct node * parent)275 static int register_node(struct node *node, int num, struct node *parent)
276 {
277 int error;
278
279 node->dev.id = num;
280 node->dev.bus = &node_subsys;
281 node->dev.release = node_device_release;
282 error = device_register(&node->dev);
283
284 if (!error){
285 device_create_file(&node->dev, &dev_attr_cpumap);
286 device_create_file(&node->dev, &dev_attr_cpulist);
287 device_create_file(&node->dev, &dev_attr_meminfo);
288 device_create_file(&node->dev, &dev_attr_numastat);
289 device_create_file(&node->dev, &dev_attr_distance);
290 device_create_file(&node->dev, &dev_attr_vmstat);
291
292 hugetlb_register_node(node);
293
294 compaction_register_node(node);
295 }
296 return error;
297 }
298
299 /**
300 * unregister_node - unregister a node device
301 * @node: node going away
302 *
303 * Unregisters a node device @node. All the devices on the node must be
304 * unregistered before calling this function.
305 */
unregister_node(struct node * node)306 void unregister_node(struct node *node)
307 {
308 device_remove_file(&node->dev, &dev_attr_cpumap);
309 device_remove_file(&node->dev, &dev_attr_cpulist);
310 device_remove_file(&node->dev, &dev_attr_meminfo);
311 device_remove_file(&node->dev, &dev_attr_numastat);
312 device_remove_file(&node->dev, &dev_attr_distance);
313 device_remove_file(&node->dev, &dev_attr_vmstat);
314
315 hugetlb_unregister_node(node); /* no-op, if memoryless node */
316
317 device_unregister(&node->dev);
318 }
319
320 struct node *node_devices[MAX_NUMNODES];
321
322 /*
323 * register cpu under node
324 */
register_cpu_under_node(unsigned int cpu,unsigned int nid)325 int register_cpu_under_node(unsigned int cpu, unsigned int nid)
326 {
327 int ret;
328 struct device *obj;
329
330 if (!node_online(nid))
331 return 0;
332
333 obj = get_cpu_device(cpu);
334 if (!obj)
335 return 0;
336
337 ret = sysfs_create_link(&node_devices[nid]->dev.kobj,
338 &obj->kobj,
339 kobject_name(&obj->kobj));
340 if (ret)
341 return ret;
342
343 return sysfs_create_link(&obj->kobj,
344 &node_devices[nid]->dev.kobj,
345 kobject_name(&node_devices[nid]->dev.kobj));
346 }
347
unregister_cpu_under_node(unsigned int cpu,unsigned int nid)348 int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
349 {
350 struct device *obj;
351
352 if (!node_online(nid))
353 return 0;
354
355 obj = get_cpu_device(cpu);
356 if (!obj)
357 return 0;
358
359 sysfs_remove_link(&node_devices[nid]->dev.kobj,
360 kobject_name(&obj->kobj));
361 sysfs_remove_link(&obj->kobj,
362 kobject_name(&node_devices[nid]->dev.kobj));
363
364 return 0;
365 }
366
367 #ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
368 #define page_initialized(page) (page->lru.next)
369
get_nid_for_pfn(unsigned long pfn)370 static int get_nid_for_pfn(unsigned long pfn)
371 {
372 struct page *page;
373
374 if (!pfn_valid_within(pfn))
375 return -1;
376 page = pfn_to_page(pfn);
377 if (!page_initialized(page))
378 return -1;
379 return pfn_to_nid(pfn);
380 }
381
382 /* register memory section under specified node if it spans that node */
register_mem_sect_under_node(struct memory_block * mem_blk,int nid)383 int register_mem_sect_under_node(struct memory_block *mem_blk, int nid)
384 {
385 int ret;
386 unsigned long pfn, sect_start_pfn, sect_end_pfn;
387
388 if (!mem_blk)
389 return -EFAULT;
390 if (!node_online(nid))
391 return 0;
392
393 sect_start_pfn = section_nr_to_pfn(mem_blk->start_section_nr);
394 sect_end_pfn = section_nr_to_pfn(mem_blk->end_section_nr);
395 sect_end_pfn += PAGES_PER_SECTION - 1;
396 for (pfn = sect_start_pfn; pfn <= sect_end_pfn; pfn++) {
397 int page_nid;
398
399 /*
400 * memory block could have several absent sections from start.
401 * skip pfn range from absent section
402 */
403 if (!pfn_present(pfn)) {
404 pfn = round_down(pfn + PAGES_PER_SECTION,
405 PAGES_PER_SECTION) - 1;
406 continue;
407 }
408
409 page_nid = get_nid_for_pfn(pfn);
410 if (page_nid < 0)
411 continue;
412 if (page_nid != nid)
413 continue;
414 ret = sysfs_create_link_nowarn(&node_devices[nid]->dev.kobj,
415 &mem_blk->dev.kobj,
416 kobject_name(&mem_blk->dev.kobj));
417 if (ret)
418 return ret;
419
420 return sysfs_create_link_nowarn(&mem_blk->dev.kobj,
421 &node_devices[nid]->dev.kobj,
422 kobject_name(&node_devices[nid]->dev.kobj));
423 }
424 /* mem section does not span the specified node */
425 return 0;
426 }
427
428 /* unregister memory section under all nodes that it spans */
unregister_mem_sect_under_nodes(struct memory_block * mem_blk,unsigned long phys_index)429 int unregister_mem_sect_under_nodes(struct memory_block *mem_blk,
430 unsigned long phys_index)
431 {
432 NODEMASK_ALLOC(nodemask_t, unlinked_nodes, GFP_KERNEL);
433 unsigned long pfn, sect_start_pfn, sect_end_pfn;
434
435 if (!mem_blk) {
436 NODEMASK_FREE(unlinked_nodes);
437 return -EFAULT;
438 }
439 if (!unlinked_nodes)
440 return -ENOMEM;
441 nodes_clear(*unlinked_nodes);
442
443 sect_start_pfn = section_nr_to_pfn(phys_index);
444 sect_end_pfn = sect_start_pfn + PAGES_PER_SECTION - 1;
445 for (pfn = sect_start_pfn; pfn <= sect_end_pfn; pfn++) {
446 int nid;
447
448 nid = get_nid_for_pfn(pfn);
449 if (nid < 0)
450 continue;
451 if (!node_online(nid))
452 continue;
453 if (node_test_and_set(nid, *unlinked_nodes))
454 continue;
455 sysfs_remove_link(&node_devices[nid]->dev.kobj,
456 kobject_name(&mem_blk->dev.kobj));
457 sysfs_remove_link(&mem_blk->dev.kobj,
458 kobject_name(&node_devices[nid]->dev.kobj));
459 }
460 NODEMASK_FREE(unlinked_nodes);
461 return 0;
462 }
463
link_mem_sections(int nid)464 static int link_mem_sections(int nid)
465 {
466 unsigned long start_pfn = NODE_DATA(nid)->node_start_pfn;
467 unsigned long end_pfn = start_pfn + NODE_DATA(nid)->node_spanned_pages;
468 unsigned long pfn;
469 struct memory_block *mem_blk = NULL;
470 int err = 0;
471
472 for (pfn = start_pfn; pfn < end_pfn; pfn += PAGES_PER_SECTION) {
473 unsigned long section_nr = pfn_to_section_nr(pfn);
474 struct mem_section *mem_sect;
475 int ret;
476
477 if (!present_section_nr(section_nr))
478 continue;
479 mem_sect = __nr_to_section(section_nr);
480
481 /* same memblock ? */
482 if (mem_blk)
483 if ((section_nr >= mem_blk->start_section_nr) &&
484 (section_nr <= mem_blk->end_section_nr))
485 continue;
486
487 mem_blk = find_memory_block_hinted(mem_sect, mem_blk);
488
489 ret = register_mem_sect_under_node(mem_blk, nid);
490 if (!err)
491 err = ret;
492
493 /* discard ref obtained in find_memory_block() */
494 }
495
496 if (mem_blk)
497 kobject_put(&mem_blk->dev.kobj);
498 return err;
499 }
500
501 #ifdef CONFIG_HUGETLBFS
502 /*
503 * Handle per node hstate attribute [un]registration on transistions
504 * to/from memoryless state.
505 */
node_hugetlb_work(struct work_struct * work)506 static void node_hugetlb_work(struct work_struct *work)
507 {
508 struct node *node = container_of(work, struct node, node_work);
509
510 /*
511 * We only get here when a node transitions to/from memoryless state.
512 * We can detect which transition occurred by examining whether the
513 * node has memory now. hugetlb_register_node() already check this
514 * so we try to register the attributes. If that fails, then the
515 * node has transitioned to memoryless, try to unregister the
516 * attributes.
517 */
518 if (!hugetlb_register_node(node))
519 hugetlb_unregister_node(node);
520 }
521
init_node_hugetlb_work(int nid)522 static void init_node_hugetlb_work(int nid)
523 {
524 INIT_WORK(&node_devices[nid]->node_work, node_hugetlb_work);
525 }
526
node_memory_callback(struct notifier_block * self,unsigned long action,void * arg)527 static int node_memory_callback(struct notifier_block *self,
528 unsigned long action, void *arg)
529 {
530 struct memory_notify *mnb = arg;
531 int nid = mnb->status_change_nid;
532
533 switch (action) {
534 case MEM_ONLINE:
535 case MEM_OFFLINE:
536 /*
537 * offload per node hstate [un]registration to a work thread
538 * when transitioning to/from memoryless state.
539 */
540 if (nid != NUMA_NO_NODE)
541 schedule_work(&node_devices[nid]->node_work);
542 break;
543
544 case MEM_GOING_ONLINE:
545 case MEM_GOING_OFFLINE:
546 case MEM_CANCEL_ONLINE:
547 case MEM_CANCEL_OFFLINE:
548 default:
549 break;
550 }
551
552 return NOTIFY_OK;
553 }
554 #endif /* CONFIG_HUGETLBFS */
555 #else /* !CONFIG_MEMORY_HOTPLUG_SPARSE */
556
link_mem_sections(int nid)557 static int link_mem_sections(int nid) { return 0; }
558 #endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */
559
560 #if !defined(CONFIG_MEMORY_HOTPLUG_SPARSE) || \
561 !defined(CONFIG_HUGETLBFS)
node_memory_callback(struct notifier_block * self,unsigned long action,void * arg)562 static inline int node_memory_callback(struct notifier_block *self,
563 unsigned long action, void *arg)
564 {
565 return NOTIFY_OK;
566 }
567
init_node_hugetlb_work(int nid)568 static void init_node_hugetlb_work(int nid) { }
569
570 #endif
571
register_one_node(int nid)572 int register_one_node(int nid)
573 {
574 int error = 0;
575 int cpu;
576
577 if (node_online(nid)) {
578 int p_node = parent_node(nid);
579 struct node *parent = NULL;
580
581 if (p_node != nid)
582 parent = node_devices[p_node];
583
584 node_devices[nid] = kzalloc(sizeof(struct node), GFP_KERNEL);
585 if (!node_devices[nid])
586 return -ENOMEM;
587
588 error = register_node(node_devices[nid], nid, parent);
589
590 /* link cpu under this node */
591 for_each_present_cpu(cpu) {
592 if (cpu_to_node(cpu) == nid)
593 register_cpu_under_node(cpu, nid);
594 }
595
596 /* link memory sections under this node */
597 error = link_mem_sections(nid);
598
599 /* initialize work queue for memory hot plug */
600 init_node_hugetlb_work(nid);
601 }
602
603 return error;
604
605 }
606
unregister_one_node(int nid)607 void unregister_one_node(int nid)
608 {
609 if (!node_devices[nid])
610 return;
611
612 unregister_node(node_devices[nid]);
613 node_devices[nid] = NULL;
614 }
615
616 /*
617 * node states attributes
618 */
619
print_nodes_state(enum node_states state,char * buf)620 static ssize_t print_nodes_state(enum node_states state, char *buf)
621 {
622 int n;
623
624 n = nodelist_scnprintf(buf, PAGE_SIZE-2, node_states[state]);
625 buf[n++] = '\n';
626 buf[n] = '\0';
627 return n;
628 }
629
630 struct node_attr {
631 struct device_attribute attr;
632 enum node_states state;
633 };
634
show_node_state(struct device * dev,struct device_attribute * attr,char * buf)635 static ssize_t show_node_state(struct device *dev,
636 struct device_attribute *attr, char *buf)
637 {
638 struct node_attr *na = container_of(attr, struct node_attr, attr);
639 return print_nodes_state(na->state, buf);
640 }
641
642 #define _NODE_ATTR(name, state) \
643 { __ATTR(name, 0444, show_node_state, NULL), state }
644
645 static struct node_attr node_state_attr[] = {
646 [N_POSSIBLE] = _NODE_ATTR(possible, N_POSSIBLE),
647 [N_ONLINE] = _NODE_ATTR(online, N_ONLINE),
648 [N_NORMAL_MEMORY] = _NODE_ATTR(has_normal_memory, N_NORMAL_MEMORY),
649 #ifdef CONFIG_HIGHMEM
650 [N_HIGH_MEMORY] = _NODE_ATTR(has_high_memory, N_HIGH_MEMORY),
651 #endif
652 #ifdef CONFIG_MOVABLE_NODE
653 [N_MEMORY] = _NODE_ATTR(has_memory, N_MEMORY),
654 #endif
655 [N_CPU] = _NODE_ATTR(has_cpu, N_CPU),
656 };
657
658 static struct attribute *node_state_attrs[] = {
659 &node_state_attr[N_POSSIBLE].attr.attr,
660 &node_state_attr[N_ONLINE].attr.attr,
661 &node_state_attr[N_NORMAL_MEMORY].attr.attr,
662 #ifdef CONFIG_HIGHMEM
663 &node_state_attr[N_HIGH_MEMORY].attr.attr,
664 #endif
665 #ifdef CONFIG_MOVABLE_NODE
666 &node_state_attr[N_MEMORY].attr.attr,
667 #endif
668 &node_state_attr[N_CPU].attr.attr,
669 NULL
670 };
671
672 static struct attribute_group memory_root_attr_group = {
673 .attrs = node_state_attrs,
674 };
675
676 static const struct attribute_group *cpu_root_attr_groups[] = {
677 &memory_root_attr_group,
678 NULL,
679 };
680
681 #define NODE_CALLBACK_PRI 2 /* lower than SLAB */
register_node_type(void)682 static int __init register_node_type(void)
683 {
684 int ret;
685
686 BUILD_BUG_ON(ARRAY_SIZE(node_state_attr) != NR_NODE_STATES);
687 BUILD_BUG_ON(ARRAY_SIZE(node_state_attrs)-1 != NR_NODE_STATES);
688
689 ret = subsys_system_register(&node_subsys, cpu_root_attr_groups);
690 if (!ret) {
691 static struct notifier_block node_memory_callback_nb = {
692 .notifier_call = node_memory_callback,
693 .priority = NODE_CALLBACK_PRI,
694 };
695 register_hotmemory_notifier(&node_memory_callback_nb);
696 }
697
698 /*
699 * Note: we're not going to unregister the node class if we fail
700 * to register the node state class attribute files.
701 */
702 return ret;
703 }
704 postcore_initcall(register_node_type);
705