/* * Basic Node interface support */ #include <linux/module.h>#include <linux/init.h>#include <linux/mm.h>#include <linux/memory.h>#include <linux/vmstat.h>#include <linux/notifier.h>#include <linux/node.h>#include <linux/hugetlb.h>#include <linux/compaction.h>#include <linux/cpumask.h>#include <linux/topology.h>#include <linux/nodemask.h>#include <linux/cpu.h>#include <linux/device.h>#include <linux/swap.h>#include <linux/slab.h> static struct bus_type node_subsys = {	.name = "node",	.dev_name = "node",};  static ssize_t node_read_cpumap(struct device *dev, bool list, char *buf){	struct node *node_dev = to_node(dev);	const struct cpumask *mask = cpumask_of_node(node_dev->dev.id); 	/* 2008/04/07: buf currently PAGE_SIZE, need 9 chars per 32 bits. */	BUILD_BUG_ON((NR_CPUS/32 * 9) > (PAGE_SIZE-1)); 	return cpumap_print_to_pagebuf(list, buf, mask);} static inline ssize_t node_read_cpumask(struct device *dev,				struct device_attribute *attr, char *buf){	return node_read_cpumap(dev, false, buf);}static inline ssize_t node_read_cpulist(struct device *dev,				struct device_attribute *attr, char *buf){	return node_read_cpumap(dev, true, buf);} static DEVICE_ATTR(cpumap,  S_IRUGO, node_read_cpumask, NULL);static DEVICE_ATTR(cpulist, S_IRUGO, node_read_cpulist, NULL); #define K(x) ((x) << (PAGE_SHIFT - 10))static ssize_t node_read_meminfo(struct device *dev,			struct device_attribute *attr, char *buf){	int n;	int nid = dev->id;	struct sysinfo i; 	si_meminfo_node(&i, nid);	n = sprintf(buf,		       "Node %d MemTotal:       %8lu kB\n"		       "Node %d MemFree:        %8lu kB\n"		       "Node %d MemUsed:        %8lu kB\n"		       "Node %d Active:         %8lu kB\n"		       "Node %d Inactive:       %8lu kB\n"		       "Node %d Active(anon):   %8lu kB\n"		       "Node %d Inactive(anon): %8lu kB\n"		       "Node %d Active(file):   %8lu kB\n"		       "Node %d Inactive(file): %8lu kB\n"		       "Node %d Unevictable:    %8lu kB\n"		       "Node %d Mlocked:        %8lu kB\n",		       nid, K(i.totalram),		       nid, K(i.freeram),		       nid, K(i.totalram - i.freeram),		       nid, K(node_page_state(nid, NR_ACTIVE_ANON) +				node_page_state(nid, NR_ACTIVE_FILE)),		       nid, K(node_page_state(nid, NR_INACTIVE_ANON) +				node_page_state(nid, NR_INACTIVE_FILE)),		       nid, K(node_page_state(nid, NR_ACTIVE_ANON)),		       nid, K(node_page_state(nid, NR_INACTIVE_ANON)),		       nid, K(node_page_state(nid, NR_ACTIVE_FILE)),		       nid, K(node_page_state(nid, NR_INACTIVE_FILE)),		       nid, K(node_page_state(nid, NR_UNEVICTABLE)),		       nid, K(node_page_state(nid, NR_MLOCK))); #ifdef CONFIG_HIGHMEM	n += sprintf(buf + n,		       "Node %d HighTotal:      %8lu kB\n"		       "Node %d HighFree:       %8lu kB\n"		       "Node %d LowTotal:       %8lu kB\n"		       "Node %d LowFree:        %8lu kB\n",		       nid, K(i.totalhigh),		       nid, K(i.freehigh),		       nid, K(i.totalram - i.totalhigh),		       nid, K(i.freeram - i.freehigh));#endif	n += sprintf(buf + n,		       "Node %d Dirty:          %8lu kB\n"		       "Node %d Writeback:      %8lu kB\n"		       "Node %d FilePages:      %8lu kB\n"		       "Node %d Mapped:         %8lu kB\n"		       "Node %d AnonPages:      %8lu kB\n"		       "Node %d Shmem:          %8lu kB\n"		       "Node %d KernelStack:    %8lu kB\n"		       "Node %d PageTables:     %8lu kB\n"		       "Node %d NFS_Unstable:   %8lu kB\n"		       "Node %d Bounce:         %8lu kB\n"		       "Node %d WritebackTmp:   %8lu kB\n"		       "Node %d Slab:           %8lu kB\n"		       "Node %d SReclaimable:   %8lu kB\n"		       "Node %d SUnreclaim:     %8lu kB\n"#ifdef CONFIG_TRANSPARENT_HUGEPAGE		       "Node %d AnonHugePages:  %8lu kB\n"#endif			,		       nid, K(node_page_state(nid, NR_FILE_DIRTY)),		       nid, K(node_page_state(nid, NR_WRITEBACK)),		       nid, K(node_page_state(nid, NR_FILE_PAGES)),		       nid, K(node_page_state(nid, NR_FILE_MAPPED)),		       nid, K(node_page_state(nid, NR_ANON_PAGES)),		       nid, K(i.sharedram),		       nid, node_page_state(nid, NR_KERNEL_STACK) *				THREAD_SIZE / 1024,		       nid, K(node_page_state(nid, NR_PAGETABLE)),		       nid, K(node_page_state(nid, NR_UNSTABLE_NFS)),		       nid, K(node_page_state(nid, NR_BOUNCE)),		       nid, K(node_page_state(nid, NR_WRITEBACK_TEMP)),		       nid, K(node_page_state(nid, NR_SLAB_RECLAIMABLE) +				node_page_state(nid, NR_SLAB_UNRECLAIMABLE)),		       nid, K(node_page_state(nid, NR_SLAB_RECLAIMABLE)),#ifdef CONFIG_TRANSPARENT_HUGEPAGE		       nid, K(node_page_state(nid, NR_SLAB_UNRECLAIMABLE))			, nid,			K(node_page_state(nid, NR_ANON_TRANSPARENT_HUGEPAGES) *			HPAGE_PMD_NR));#else		       nid, K(node_page_state(nid, NR_SLAB_UNRECLAIMABLE)));#endif	n += hugetlb_report_node_meminfo(nid, buf + n);	return n;} #undef Kstatic DEVICE_ATTR(meminfo, S_IRUGO, node_read_meminfo, NULL); static ssize_t node_read_numastat(struct device *dev,				struct device_attribute *attr, char *buf){	return sprintf(buf,		       "numa_hit %lu\n"		       "numa_miss %lu\n"		       "numa_foreign %lu\n"		       "interleave_hit %lu\n"		       "local_node %lu\n"		       "other_node %lu\n",		       node_page_state(dev->id, NUMA_HIT),		       node_page_state(dev->id, NUMA_MISS),		       node_page_state(dev->id, NUMA_FOREIGN),		       node_page_state(dev->id, NUMA_INTERLEAVE_HIT),		       node_page_state(dev->id, NUMA_LOCAL),		       node_page_state(dev->id, NUMA_OTHER));}static DEVICE_ATTR(numastat, S_IRUGO, node_read_numastat, NULL); static ssize_t node_read_vmstat(struct device *dev,				struct device_attribute *attr, char *buf){	int nid = dev->id;	int i;	int n = 0; 	for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)		n += sprintf(buf+n, "%s %lu\n", vmstat_text[i],			     node_page_state(nid, i)); 	return n;}static DEVICE_ATTR(vmstat, S_IRUGO, node_read_vmstat, NULL); static ssize_t node_read_distance(struct device *dev,			struct device_attribute *attr, char *buf){	int nid = dev->id;	int len = 0;	int i; 	/*	 * buf is currently PAGE_SIZE in length and each node needs 4 chars	 * at the most (distance + space or newline).	 */	BUILD_BUG_ON(MAX_NUMNODES * 4 > PAGE_SIZE); 	for_each_online_node(i)		len += sprintf(buf + len, "%s%d", i ? " " : "", node_distance(nid, i)); 	len += sprintf(buf + len, "\n");	return len;}static DEVICE_ATTR(distance, S_IRUGO, node_read_distance, NULL); static struct attribute *node_dev_attrs[] = {	&dev_attr_cpumap.attr,	&dev_attr_cpulist.attr,	&dev_attr_meminfo.attr,	&dev_attr_numastat.attr,	&dev_attr_distance.attr,	&dev_attr_vmstat.attr,	NULL};ATTRIBUTE_GROUPS(node_dev); #ifdef CONFIG_HUGETLBFS/* * hugetlbfs per node attributes registration interface: * When/if hugetlb[fs] subsystem initializes [sometime after this module], * it will register its per node attributes for all online nodes with * memory.  It will also call register_hugetlbfs_with_node(), below, to * register its attribute registration functions with this node driver. * Once these hooks have been initialized, the node driver will call into * the hugetlb module to [un]register attributes for hot-plugged nodes. */static node_registration_func_t __hugetlb_register_node;static node_registration_func_t __hugetlb_unregister_node; static inline bool hugetlb_register_node(struct node *node){	if (__hugetlb_register_node &&			node_state(node->dev.id, N_MEMORY)) {		__hugetlb_register_node(node);		return true;	}	return false;} static inline void hugetlb_unregister_node(struct node *node){	if (__hugetlb_unregister_node)		__hugetlb_unregister_node(node);} void register_hugetlbfs_with_node(node_registration_func_t doregister,				  node_registration_func_t unregister){	__hugetlb_register_node   = doregister;	__hugetlb_unregister_node = unregister;}#elsestatic inline void hugetlb_register_node(struct node *node) {} static inline void hugetlb_unregister_node(struct node *node) {}#endif static void node_device_release(struct device *dev){	struct node *node = to_node(dev); #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) && defined(CONFIG_HUGETLBFS)	/*	 * We schedule the work only when a memory section is	 * onlined/offlined on this node. When we come here,	 * all the memory on this node has been offlined,	 * so we won't enqueue new work to this work.	 *	 * The work is using node->node_work, so we should	 * flush work before freeing the memory.	 */	flush_work(&node->node_work);#endif	kfree(node);} /* * register_node - Setup a sysfs device for a node. * @num - Node number to use when creating the device. * * Initialize and register the node device. */static int register_node(struct node *node, int num, struct node *parent){	int error; 	node->dev.id = num;	node->dev.bus = &node_subsys;	node->dev.release = node_device_release;	node->dev.groups = node_dev_groups;	error = device_register(&node->dev); 	if (!error){		hugetlb_register_node(node); 		compaction_register_node(node);	}	return error;} /** * unregister_node - unregister a node device * @node: node going away * * Unregisters a node device @node.  All the devices on the node must be * unregistered before calling this function. */void unregister_node(struct node *node){	hugetlb_unregister_node(node);		/* no-op, if memoryless node */ 	device_unregister(&node->dev);} struct node *node_devices[MAX_NUMNODES]; /* * register cpu under node */int register_cpu_under_node(unsigned int cpu, unsigned int nid){	int ret;	struct device *obj; 	if (!node_online(nid))		return 0; 	obj = get_cpu_device(cpu);	if (!obj)		return 0; 	ret = sysfs_create_link(&node_devices[nid]->dev.kobj,				&obj->kobj,				kobject_name(&obj->kobj));	if (ret)		return ret; 	return sysfs_create_link(&obj->kobj,				 &node_devices[nid]->dev.kobj,				 kobject_name(&node_devices[nid]->dev.kobj));} int unregister_cpu_under_node(unsigned int cpu, unsigned int nid){	struct device *obj; 	if (!node_online(nid))		return 0; 	obj = get_cpu_device(cpu);	if (!obj)		return 0; 	sysfs_remove_link(&node_devices[nid]->dev.kobj,			  kobject_name(&obj->kobj));	sysfs_remove_link(&obj->kobj,			  kobject_name(&node_devices[nid]->dev.kobj)); 	return 0;} #ifdef CONFIG_MEMORY_HOTPLUG_SPARSE#define page_initialized(page)  (page->lru.next) static int __init_refok get_nid_for_pfn(unsigned long pfn){	struct page *page; 	if (!pfn_valid_within(pfn))		return -1;#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT	if (system_state == SYSTEM_BOOTING)		return early_pfn_to_nid(pfn);#endif	page = pfn_to_page(pfn);	if (!page_initialized(page))		return -1;	return pfn_to_nid(pfn);} /* register memory section under specified node if it spans that node */int register_mem_sect_under_node(struct memory_block *mem_blk, int nid){	int ret;	unsigned long pfn, sect_start_pfn, sect_end_pfn; 	if (!mem_blk)		return -EFAULT;	if (!node_online(nid))		return 0; 	sect_start_pfn = section_nr_to_pfn(mem_blk->start_section_nr);	sect_end_pfn = section_nr_to_pfn(mem_blk->end_section_nr);	sect_end_pfn += PAGES_PER_SECTION - 1;	for (pfn = sect_start_pfn; pfn <= sect_end_pfn; pfn++) {		int page_nid; 		/*		 * memory block could have several absent sections from start.		 * skip pfn range from absent section		 */		if (!pfn_present(pfn)) {			pfn = round_down(pfn + PAGES_PER_SECTION,					 PAGES_PER_SECTION) - 1;			continue;		} 		page_nid = get_nid_for_pfn(pfn);		if (page_nid < 0)			continue;		if (page_nid != nid)			continue;		ret = sysfs_create_link_nowarn(&node_devices[nid]->dev.kobj,					&mem_blk->dev.kobj,					kobject_name(&mem_blk->dev.kobj));		if (ret)			return ret; 		return sysfs_create_link_nowarn(&mem_blk->dev.kobj,				&node_devices[nid]->dev.kobj,				kobject_name(&node_devices[nid]->dev.kobj));	}	/* mem section does not span the specified node */	return 0;} /* unregister memory section under all nodes that it spans */int unregister_mem_sect_under_nodes(struct memory_block *mem_blk,				    unsigned long phys_index){	NODEMASK_ALLOC(nodemask_t, unlinked_nodes, GFP_KERNEL);	unsigned long pfn, sect_start_pfn, sect_end_pfn; 	if (!mem_blk) {		NODEMASK_FREE(unlinked_nodes);		return -EFAULT;	}	if (!unlinked_nodes)		return -ENOMEM;	nodes_clear(*unlinked_nodes); 	sect_start_pfn = section_nr_to_pfn(phys_index);	sect_end_pfn = sect_start_pfn + PAGES_PER_SECTION - 1;	for (pfn = sect_start_pfn; pfn <= sect_end_pfn; pfn++) {		int nid; 		nid = get_nid_for_pfn(pfn);		if (nid < 0)			continue;		if (!node_online(nid))			continue;		if (node_test_and_set(nid, *unlinked_nodes))			continue;		sysfs_remove_link(&node_devices[nid]->dev.kobj,			 kobject_name(&mem_blk->dev.kobj));		sysfs_remove_link(&mem_blk->dev.kobj,			 kobject_name(&node_devices[nid]->dev.kobj));	}	NODEMASK_FREE(unlinked_nodes);	return 0;} static int link_mem_sections(int nid){	unsigned long start_pfn = NODE_DATA(nid)->node_start_pfn;	unsigned long end_pfn = start_pfn + NODE_DATA(nid)->node_spanned_pages;	unsigned long pfn;	struct memory_block *mem_blk = NULL;	int err = 0; 	for (pfn = start_pfn; pfn < end_pfn; pfn += PAGES_PER_SECTION) {		unsigned long section_nr = pfn_to_section_nr(pfn);		struct mem_section *mem_sect;		int ret; 		if (!present_section_nr(section_nr))			continue;		mem_sect = __nr_to_section(section_nr); 		/* same memblock ? */		if (mem_blk)			if ((section_nr >= mem_blk->start_section_nr) &&			    (section_nr <= mem_blk->end_section_nr))				continue; 		mem_blk = find_memory_block_hinted(mem_sect, mem_blk); 		ret = register_mem_sect_under_node(mem_blk, nid);		if (!err)			err = ret; 		/* discard ref obtained in find_memory_block() */	} 	if (mem_blk)		kobject_put(&mem_blk->dev.kobj);	return err;} #ifdef CONFIG_HUGETLBFS/* * Handle per node hstate attribute [un]registration on transistions * to/from memoryless state.

Lines 1–500 of 701. Load more