1 /* 2 * drivers/base/node.c - basic Node class support 3 */ 4 5 #include <linux/sysdev.h> 6 #include <linux/module.h> 7 #include <linux/init.h> 8 #include <linux/mm.h> 9 #include <linux/memory.h> 10 #include <linux/node.h> 11 #include <linux/hugetlb.h> 12 #include <linux/cpumask.h> 13 #include <linux/topology.h> 14 #include <linux/nodemask.h> 15 #include <linux/cpu.h> 16 #include <linux/device.h> 17 #include <linux/swap.h> 18 19 static struct sysdev_class node_class = { 20 .name = "node", 21 }; 22 23 24 static ssize_t node_read_cpumap(struct sys_device *dev, int type, char *buf) 25 { 26 struct node *node_dev = to_node(dev); 27 const struct cpumask *mask = cpumask_of_node(node_dev->sysdev.id); 28 int len; 29 30 /* 2008/04/07: buf currently PAGE_SIZE, need 9 chars per 32 bits. */ 31 BUILD_BUG_ON((NR_CPUS/32 * 9) > (PAGE_SIZE-1)); 32 33 len = type? 34 cpulist_scnprintf(buf, PAGE_SIZE-2, mask) : 35 cpumask_scnprintf(buf, PAGE_SIZE-2, mask); 36 buf[len++] = '\n'; 37 buf[len] = '\0'; 38 return len; 39 } 40 41 static inline ssize_t node_read_cpumask(struct sys_device *dev, 42 struct sysdev_attribute *attr, char *buf) 43 { 44 return node_read_cpumap(dev, 0, buf); 45 } 46 static inline ssize_t node_read_cpulist(struct sys_device *dev, 47 struct sysdev_attribute *attr, char *buf) 48 { 49 return node_read_cpumap(dev, 1, buf); 50 } 51 52 static SYSDEV_ATTR(cpumap, S_IRUGO, node_read_cpumask, NULL); 53 static SYSDEV_ATTR(cpulist, S_IRUGO, node_read_cpulist, NULL); 54 55 #define K(x) ((x) << (PAGE_SHIFT - 10)) 56 static ssize_t node_read_meminfo(struct sys_device * dev, 57 struct sysdev_attribute *attr, char * buf) 58 { 59 int n; 60 int nid = dev->id; 61 struct sysinfo i; 62 63 si_meminfo_node(&i, nid); 64 65 n = sprintf(buf, "\n" 66 "Node %d MemTotal: %8lu kB\n" 67 "Node %d MemFree: %8lu kB\n" 68 "Node %d MemUsed: %8lu kB\n" 69 "Node %d Active: %8lu kB\n" 70 "Node %d Inactive: %8lu kB\n" 71 "Node %d Active(anon): %8lu kB\n" 72 "Node %d Inactive(anon): %8lu kB\n" 73 "Node %d Active(file): %8lu kB\n" 74 "Node %d Inactive(file): %8lu kB\n" 75 "Node %d Unevictable: %8lu kB\n" 76 "Node %d Mlocked: %8lu kB\n" 77 #ifdef CONFIG_HIGHMEM 78 "Node %d HighTotal: %8lu kB\n" 79 "Node %d HighFree: %8lu kB\n" 80 "Node %d LowTotal: %8lu kB\n" 81 "Node %d LowFree: %8lu kB\n" 82 #endif 83 "Node %d Dirty: %8lu kB\n" 84 "Node %d Writeback: %8lu kB\n" 85 "Node %d FilePages: %8lu kB\n" 86 "Node %d Mapped: %8lu kB\n" 87 "Node %d AnonPages: %8lu kB\n" 88 "Node %d Shmem: %8lu kB\n" 89 "Node %d KernelStack: %8lu kB\n" 90 "Node %d PageTables: %8lu kB\n" 91 "Node %d NFS_Unstable: %8lu kB\n" 92 "Node %d Bounce: %8lu kB\n" 93 "Node %d WritebackTmp: %8lu kB\n" 94 "Node %d Slab: %8lu kB\n" 95 "Node %d SReclaimable: %8lu kB\n" 96 "Node %d SUnreclaim: %8lu kB\n", 97 nid, K(i.totalram), 98 nid, K(i.freeram), 99 nid, K(i.totalram - i.freeram), 100 nid, K(node_page_state(nid, NR_ACTIVE_ANON) + 101 node_page_state(nid, NR_ACTIVE_FILE)), 102 nid, K(node_page_state(nid, NR_INACTIVE_ANON) + 103 node_page_state(nid, NR_INACTIVE_FILE)), 104 nid, K(node_page_state(nid, NR_ACTIVE_ANON)), 105 nid, K(node_page_state(nid, NR_INACTIVE_ANON)), 106 nid, K(node_page_state(nid, NR_ACTIVE_FILE)), 107 nid, K(node_page_state(nid, NR_INACTIVE_FILE)), 108 nid, K(node_page_state(nid, NR_UNEVICTABLE)), 109 nid, K(node_page_state(nid, NR_MLOCK)), 110 #ifdef CONFIG_HIGHMEM 111 nid, K(i.totalhigh), 112 nid, K(i.freehigh), 113 nid, K(i.totalram - i.totalhigh), 114 nid, K(i.freeram - i.freehigh), 115 #endif 116 nid, K(node_page_state(nid, NR_FILE_DIRTY)), 117 nid, K(node_page_state(nid, NR_WRITEBACK)), 118 nid, K(node_page_state(nid, NR_FILE_PAGES)), 119 nid, K(node_page_state(nid, NR_FILE_MAPPED)), 120 nid, K(node_page_state(nid, NR_ANON_PAGES)), 121 nid, K(node_page_state(nid, NR_SHMEM)), 122 nid, node_page_state(nid, NR_KERNEL_STACK) * 123 THREAD_SIZE / 1024, 124 nid, K(node_page_state(nid, NR_PAGETABLE)), 125 nid, K(node_page_state(nid, NR_UNSTABLE_NFS)), 126 nid, K(node_page_state(nid, NR_BOUNCE)), 127 nid, K(node_page_state(nid, NR_WRITEBACK_TEMP)), 128 nid, K(node_page_state(nid, NR_SLAB_RECLAIMABLE) + 129 node_page_state(nid, NR_SLAB_UNRECLAIMABLE)), 130 nid, K(node_page_state(nid, NR_SLAB_RECLAIMABLE)), 131 nid, K(node_page_state(nid, NR_SLAB_UNRECLAIMABLE))); 132 n += hugetlb_report_node_meminfo(nid, buf + n); 133 return n; 134 } 135 136 #undef K 137 static SYSDEV_ATTR(meminfo, S_IRUGO, node_read_meminfo, NULL); 138 139 static ssize_t node_read_numastat(struct sys_device * dev, 140 struct sysdev_attribute *attr, char * buf) 141 { 142 return sprintf(buf, 143 "numa_hit %lu\n" 144 "numa_miss %lu\n" 145 "numa_foreign %lu\n" 146 "interleave_hit %lu\n" 147 "local_node %lu\n" 148 "other_node %lu\n", 149 node_page_state(dev->id, NUMA_HIT), 150 node_page_state(dev->id, NUMA_MISS), 151 node_page_state(dev->id, NUMA_FOREIGN), 152 node_page_state(dev->id, NUMA_INTERLEAVE_HIT), 153 node_page_state(dev->id, NUMA_LOCAL), 154 node_page_state(dev->id, NUMA_OTHER)); 155 } 156 static SYSDEV_ATTR(numastat, S_IRUGO, node_read_numastat, NULL); 157 158 static ssize_t node_read_distance(struct sys_device * dev, 159 struct sysdev_attribute *attr, char * buf) 160 { 161 int nid = dev->id; 162 int len = 0; 163 int i; 164 165 /* buf currently PAGE_SIZE, need ~4 chars per node */ 166 BUILD_BUG_ON(MAX_NUMNODES*4 > PAGE_SIZE/2); 167 168 for_each_online_node(i) 169 len += sprintf(buf + len, "%s%d", i ? " " : "", node_distance(nid, i)); 170 171 len += sprintf(buf + len, "\n"); 172 return len; 173 } 174 static SYSDEV_ATTR(distance, S_IRUGO, node_read_distance, NULL); 175 176 177 /* 178 * register_node - Setup a sysfs device for a node. 179 * @num - Node number to use when creating the device. 180 * 181 * Initialize and register the node device. 182 */ 183 int register_node(struct node *node, int num, struct node *parent) 184 { 185 int error; 186 187 node->sysdev.id = num; 188 node->sysdev.cls = &node_class; 189 error = sysdev_register(&node->sysdev); 190 191 if (!error){ 192 sysdev_create_file(&node->sysdev, &attr_cpumap); 193 sysdev_create_file(&node->sysdev, &attr_cpulist); 194 sysdev_create_file(&node->sysdev, &attr_meminfo); 195 sysdev_create_file(&node->sysdev, &attr_numastat); 196 sysdev_create_file(&node->sysdev, &attr_distance); 197 198 scan_unevictable_register_node(node); 199 } 200 return error; 201 } 202 203 /** 204 * unregister_node - unregister a node device 205 * @node: node going away 206 * 207 * Unregisters a node device @node. All the devices on the node must be 208 * unregistered before calling this function. 209 */ 210 void unregister_node(struct node *node) 211 { 212 sysdev_remove_file(&node->sysdev, &attr_cpumap); 213 sysdev_remove_file(&node->sysdev, &attr_cpulist); 214 sysdev_remove_file(&node->sysdev, &attr_meminfo); 215 sysdev_remove_file(&node->sysdev, &attr_numastat); 216 sysdev_remove_file(&node->sysdev, &attr_distance); 217 218 scan_unevictable_unregister_node(node); 219 220 sysdev_unregister(&node->sysdev); 221 } 222 223 struct node node_devices[MAX_NUMNODES]; 224 225 /* 226 * register cpu under node 227 */ 228 int register_cpu_under_node(unsigned int cpu, unsigned int nid) 229 { 230 if (node_online(nid)) { 231 struct sys_device *obj = get_cpu_sysdev(cpu); 232 if (!obj) 233 return 0; 234 return sysfs_create_link(&node_devices[nid].sysdev.kobj, 235 &obj->kobj, 236 kobject_name(&obj->kobj)); 237 } 238 239 return 0; 240 } 241 242 int unregister_cpu_under_node(unsigned int cpu, unsigned int nid) 243 { 244 if (node_online(nid)) { 245 struct sys_device *obj = get_cpu_sysdev(cpu); 246 if (obj) 247 sysfs_remove_link(&node_devices[nid].sysdev.kobj, 248 kobject_name(&obj->kobj)); 249 } 250 return 0; 251 } 252 253 #ifdef CONFIG_MEMORY_HOTPLUG_SPARSE 254 #define page_initialized(page) (page->lru.next) 255 256 static int get_nid_for_pfn(unsigned long pfn) 257 { 258 struct page *page; 259 260 if (!pfn_valid_within(pfn)) 261 return -1; 262 page = pfn_to_page(pfn); 263 if (!page_initialized(page)) 264 return -1; 265 return pfn_to_nid(pfn); 266 } 267 268 /* register memory section under specified node if it spans that node */ 269 int register_mem_sect_under_node(struct memory_block *mem_blk, int nid) 270 { 271 unsigned long pfn, sect_start_pfn, sect_end_pfn; 272 273 if (!mem_blk) 274 return -EFAULT; 275 if (!node_online(nid)) 276 return 0; 277 sect_start_pfn = section_nr_to_pfn(mem_blk->phys_index); 278 sect_end_pfn = sect_start_pfn + PAGES_PER_SECTION - 1; 279 for (pfn = sect_start_pfn; pfn <= sect_end_pfn; pfn++) { 280 int page_nid; 281 282 page_nid = get_nid_for_pfn(pfn); 283 if (page_nid < 0) 284 continue; 285 if (page_nid != nid) 286 continue; 287 return sysfs_create_link_nowarn(&node_devices[nid].sysdev.kobj, 288 &mem_blk->sysdev.kobj, 289 kobject_name(&mem_blk->sysdev.kobj)); 290 } 291 /* mem section does not span the specified node */ 292 return 0; 293 } 294 295 /* unregister memory section under all nodes that it spans */ 296 int unregister_mem_sect_under_nodes(struct memory_block *mem_blk) 297 { 298 nodemask_t unlinked_nodes; 299 unsigned long pfn, sect_start_pfn, sect_end_pfn; 300 301 if (!mem_blk) 302 return -EFAULT; 303 nodes_clear(unlinked_nodes); 304 sect_start_pfn = section_nr_to_pfn(mem_blk->phys_index); 305 sect_end_pfn = sect_start_pfn + PAGES_PER_SECTION - 1; 306 for (pfn = sect_start_pfn; pfn <= sect_end_pfn; pfn++) { 307 int nid; 308 309 nid = get_nid_for_pfn(pfn); 310 if (nid < 0) 311 continue; 312 if (!node_online(nid)) 313 continue; 314 if (node_test_and_set(nid, unlinked_nodes)) 315 continue; 316 sysfs_remove_link(&node_devices[nid].sysdev.kobj, 317 kobject_name(&mem_blk->sysdev.kobj)); 318 } 319 return 0; 320 } 321 322 static int link_mem_sections(int nid) 323 { 324 unsigned long start_pfn = NODE_DATA(nid)->node_start_pfn; 325 unsigned long end_pfn = start_pfn + NODE_DATA(nid)->node_spanned_pages; 326 unsigned long pfn; 327 int err = 0; 328 329 for (pfn = start_pfn; pfn < end_pfn; pfn += PAGES_PER_SECTION) { 330 unsigned long section_nr = pfn_to_section_nr(pfn); 331 struct mem_section *mem_sect; 332 struct memory_block *mem_blk; 333 int ret; 334 335 if (!present_section_nr(section_nr)) 336 continue; 337 mem_sect = __nr_to_section(section_nr); 338 mem_blk = find_memory_block(mem_sect); 339 ret = register_mem_sect_under_node(mem_blk, nid); 340 if (!err) 341 err = ret; 342 343 /* discard ref obtained in find_memory_block() */ 344 kobject_put(&mem_blk->sysdev.kobj); 345 } 346 return err; 347 } 348 #else 349 static int link_mem_sections(int nid) { return 0; } 350 #endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */ 351 352 int register_one_node(int nid) 353 { 354 int error = 0; 355 int cpu; 356 357 if (node_online(nid)) { 358 int p_node = parent_node(nid); 359 struct node *parent = NULL; 360 361 if (p_node != nid) 362 parent = &node_devices[p_node]; 363 364 error = register_node(&node_devices[nid], nid, parent); 365 366 /* link cpu under this node */ 367 for_each_present_cpu(cpu) { 368 if (cpu_to_node(cpu) == nid) 369 register_cpu_under_node(cpu, nid); 370 } 371 372 /* link memory sections under this node */ 373 error = link_mem_sections(nid); 374 } 375 376 return error; 377 378 } 379 380 void unregister_one_node(int nid) 381 { 382 unregister_node(&node_devices[nid]); 383 } 384 385 /* 386 * node states attributes 387 */ 388 389 static ssize_t print_nodes_state(enum node_states state, char *buf) 390 { 391 int n; 392 393 n = nodelist_scnprintf(buf, PAGE_SIZE, node_states[state]); 394 if (n > 0 && PAGE_SIZE > n + 1) { 395 *(buf + n++) = '\n'; 396 *(buf + n++) = '\0'; 397 } 398 return n; 399 } 400 401 static ssize_t print_nodes_possible(struct sysdev_class *class, char *buf) 402 { 403 return print_nodes_state(N_POSSIBLE, buf); 404 } 405 406 static ssize_t print_nodes_online(struct sysdev_class *class, char *buf) 407 { 408 return print_nodes_state(N_ONLINE, buf); 409 } 410 411 static ssize_t print_nodes_has_normal_memory(struct sysdev_class *class, 412 char *buf) 413 { 414 return print_nodes_state(N_NORMAL_MEMORY, buf); 415 } 416 417 static ssize_t print_nodes_has_cpu(struct sysdev_class *class, char *buf) 418 { 419 return print_nodes_state(N_CPU, buf); 420 } 421 422 static SYSDEV_CLASS_ATTR(possible, 0444, print_nodes_possible, NULL); 423 static SYSDEV_CLASS_ATTR(online, 0444, print_nodes_online, NULL); 424 static SYSDEV_CLASS_ATTR(has_normal_memory, 0444, print_nodes_has_normal_memory, 425 NULL); 426 static SYSDEV_CLASS_ATTR(has_cpu, 0444, print_nodes_has_cpu, NULL); 427 428 #ifdef CONFIG_HIGHMEM 429 static ssize_t print_nodes_has_high_memory(struct sysdev_class *class, 430 char *buf) 431 { 432 return print_nodes_state(N_HIGH_MEMORY, buf); 433 } 434 435 static SYSDEV_CLASS_ATTR(has_high_memory, 0444, print_nodes_has_high_memory, 436 NULL); 437 #endif 438 439 struct sysdev_class_attribute *node_state_attr[] = { 440 &attr_possible, 441 &attr_online, 442 &attr_has_normal_memory, 443 #ifdef CONFIG_HIGHMEM 444 &attr_has_high_memory, 445 #endif 446 &attr_has_cpu, 447 }; 448 449 static int node_states_init(void) 450 { 451 int i; 452 int err = 0; 453 454 for (i = 0; i < NR_NODE_STATES; i++) { 455 int ret; 456 ret = sysdev_class_create_file(&node_class, node_state_attr[i]); 457 if (!err) 458 err = ret; 459 } 460 return err; 461 } 462 463 static int __init register_node_type(void) 464 { 465 int ret; 466 467 ret = sysdev_class_register(&node_class); 468 if (!ret) 469 ret = node_states_init(); 470 471 /* 472 * Note: we're not going to unregister the node class if we fail 473 * to register the node state class attribute files. 474 */ 475 return ret; 476 } 477 postcore_initcall(register_node_type); 478