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