convert 'memory' sysdev_class to a regular subsystem
Kay Sievers [Wed, 21 Dec 2011 22:48:43 +0000 (14:48 -0800)]
This moves the 'memory sysdev_class' over to a regular 'memory' subsystem
and converts the devices to regular devices. The sysdev drivers are
implemented as subsystem interfaces now.

After all sysdev classes are ported to regular driver core entities, the
sysdev implementation will be entirely removed from the kernel.

Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

arch/powerpc/kernel/sysfs.c
drivers/base/memory.c
drivers/base/node.c
include/linux/memory.h
include/linux/node.h
mm/compaction.c
mm/hugetlb.c
mm/vmscan.c

index f396ef2..5e7c165 100644 (file)
@@ -592,7 +592,7 @@ static void register_nodes(void)
 int sysfs_add_device_to_node(struct device *dev, int nid)
 {
        struct node *node = &node_devices[nid];
-       return sysfs_create_link(&node->sysdev.kobj, &dev->kobj,
+       return sysfs_create_link(&node->dev.kobj, &dev->kobj,
                        kobject_name(&dev->kobj));
 }
 EXPORT_SYMBOL_GPL(sysfs_add_device_to_node);
@@ -600,7 +600,7 @@ EXPORT_SYMBOL_GPL(sysfs_add_device_to_node);
 void sysfs_remove_device_from_node(struct device *dev, int nid)
 {
        struct node *node = &node_devices[nid];
-       sysfs_remove_link(&node->sysdev.kobj, kobject_name(&dev->kobj));
+       sysfs_remove_link(&node->dev.kobj, kobject_name(&dev->kobj));
 }
 EXPORT_SYMBOL_GPL(sysfs_remove_device_from_node);
 
index 8272d92..f17e3ea 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * drivers/base/memory.c - basic Memory class support
+ * Memory subsystem support
  *
  * Written by Matt Tolentino <matthew.e.tolentino@intel.com>
  *            Dave Hansen <haveblue@us.ibm.com>
@@ -10,7 +10,6 @@
  * SPARSEMEM should be contained here, or in mm/memory_hotplug.c.
  */
 
-#include <linux/sysdev.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/topology.h>
@@ -38,26 +37,9 @@ static inline int base_memory_block_id(int section_nr)
        return section_nr / sections_per_block;
 }
 
-static struct sysdev_class memory_sysdev_class = {
+static struct bus_type memory_subsys = {
        .name = MEMORY_CLASS_NAME,
-};
-
-static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj)
-{
-       return MEMORY_CLASS_NAME;
-}
-
-static int memory_uevent(struct kset *kset, struct kobject *obj,
-                       struct kobj_uevent_env *env)
-{
-       int retval = 0;
-
-       return retval;
-}
-
-static const struct kset_uevent_ops memory_uevent_ops = {
-       .name           = memory_uevent_name,
-       .uevent         = memory_uevent,
+       .dev_name = MEMORY_CLASS_NAME,
 };
 
 static BLOCKING_NOTIFIER_HEAD(memory_chain);
@@ -96,21 +78,21 @@ int register_memory(struct memory_block *memory)
 {
        int error;
 
-       memory->sysdev.cls = &memory_sysdev_class;
-       memory->sysdev.id = memory->start_section_nr / sections_per_block;
+       memory->dev.bus = &memory_subsys;
+       memory->dev.id = memory->start_section_nr / sections_per_block;
 
-       error = sysdev_register(&memory->sysdev);
+       error = device_register(&memory->dev);
        return error;
 }
 
 static void
 unregister_memory(struct memory_block *memory)
 {
-       BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
+       BUG_ON(memory->dev.bus != &memory_subsys);
 
        /* drop the ref. we got in remove_memory_block() */
-       kobject_put(&memory->sysdev.kobj);
-       sysdev_unregister(&memory->sysdev);
+       kobject_put(&memory->dev.kobj);
+       device_unregister(&memory->dev);
 }
 
 unsigned long __weak memory_block_size_bytes(void)
@@ -138,22 +120,22 @@ static unsigned long get_memory_block_size(void)
  * uses.
  */
 
-static ssize_t show_mem_start_phys_index(struct sys_device *dev,
-                       struct sysdev_attribute *attr, char *buf)
+static ssize_t show_mem_start_phys_index(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
        struct memory_block *mem =
-               container_of(dev, struct memory_block, sysdev);
+               container_of(dev, struct memory_block, dev);
        unsigned long phys_index;
 
        phys_index = mem->start_section_nr / sections_per_block;
        return sprintf(buf, "%08lx\n", phys_index);
 }
 
-static ssize_t show_mem_end_phys_index(struct sys_device *dev,
-                       struct sysdev_attribute *attr, char *buf)
+static ssize_t show_mem_end_phys_index(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
        struct memory_block *mem =
-               container_of(dev, struct memory_block, sysdev);
+               container_of(dev, struct memory_block, dev);
        unsigned long phys_index;
 
        phys_index = mem->end_section_nr / sections_per_block;
@@ -163,13 +145,13 @@ static ssize_t show_mem_end_phys_index(struct sys_device *dev,
 /*
  * Show whether the section of memory is likely to be hot-removable
  */
-static ssize_t show_mem_removable(struct sys_device *dev,
-                       struct sysdev_attribute *attr, char *buf)
+static ssize_t show_mem_removable(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
        unsigned long i, pfn;
        int ret = 1;
        struct memory_block *mem =
-               container_of(dev, struct memory_block, sysdev);
+               container_of(dev, struct memory_block, dev);
 
        for (i = 0; i < sections_per_block; i++) {
                pfn = section_nr_to_pfn(mem->start_section_nr + i);
@@ -182,11 +164,11 @@ static ssize_t show_mem_removable(struct sys_device *dev,
 /*
  * online, offline, going offline, etc.
  */
-static ssize_t show_mem_state(struct sys_device *dev,
-                       struct sysdev_attribute *attr, char *buf)
+static ssize_t show_mem_state(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
        struct memory_block *mem =
-               container_of(dev, struct memory_block, sysdev);
+               container_of(dev, struct memory_block, dev);
        ssize_t len = 0;
 
        /*
@@ -324,13 +306,13 @@ out:
 }
 
 static ssize_t
-store_mem_state(struct sys_device *dev,
-               struct sysdev_attribute *attr, const char *buf, size_t count)
+store_mem_state(struct device *dev,
+               struct device_attribute *attr, const char *buf, size_t count)
 {
        struct memory_block *mem;
        int ret = -EINVAL;
 
-       mem = container_of(dev, struct memory_block, sysdev);
+       mem = container_of(dev, struct memory_block, dev);
 
        if (!strncmp(buf, "online", min((int)count, 6)))
                ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
@@ -351,41 +333,41 @@ store_mem_state(struct sys_device *dev,
  * s.t. if I offline all of these sections I can then
  * remove the physical device?
  */
-static ssize_t show_phys_device(struct sys_device *dev,
-                               struct sysdev_attribute *attr, char *buf)
+static ssize_t show_phys_device(struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
        struct memory_block *mem =
-               container_of(dev, struct memory_block, sysdev);
+               container_of(dev, struct memory_block, dev);
        return sprintf(buf, "%d\n", mem->phys_device);
 }
 
-static SYSDEV_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL);
-static SYSDEV_ATTR(end_phys_index, 0444, show_mem_end_phys_index, NULL);
-static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state);
-static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL);
-static SYSDEV_ATTR(removable, 0444, show_mem_removable, NULL);
+static DEVICE_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL);
+static DEVICE_ATTR(end_phys_index, 0444, show_mem_end_phys_index, NULL);
+static DEVICE_ATTR(state, 0644, show_mem_state, store_mem_state);
+static DEVICE_ATTR(phys_device, 0444, show_phys_device, NULL);
+static DEVICE_ATTR(removable, 0444, show_mem_removable, NULL);
 
 #define mem_create_simple_file(mem, attr_name) \
-       sysdev_create_file(&mem->sysdev, &attr_##attr_name)
+       device_create_file(&mem->dev, &dev_attr_##attr_name)
 #define mem_remove_simple_file(mem, attr_name) \
-       sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
+       device_remove_file(&mem->dev, &dev_attr_##attr_name)
 
 /*
  * Block size attribute stuff
  */
 static ssize_t
-print_block_size(struct sysdev_class *class, struct sysdev_class_attribute *attr,
+print_block_size(struct device *dev, struct device_attribute *attr,
                 char *buf)
 {
        return sprintf(buf, "%lx\n", get_memory_block_size());
 }
 
-static SYSDEV_CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
+static DEVICE_ATTR(block_size_bytes, 0444, print_block_size, NULL);
 
 static int block_size_init(void)
 {
-       return sysfs_create_file(&memory_sysdev_class.kset.kobj,
-                               &attr_block_size_bytes.attr);
+       return device_create_file(memory_subsys.dev_root,
+                                 &dev_attr_block_size_bytes);
 }
 
 /*
@@ -396,7 +378,7 @@ static int block_size_init(void)
  */
 #ifdef CONFIG_ARCH_MEMORY_PROBE
 static ssize_t
-memory_probe_store(struct class *class, struct class_attribute *attr,
+memory_probe_store(struct device *dev, struct device_attribute *attr,
                   const char *buf, size_t count)
 {
        u64 phys_addr;
@@ -423,12 +405,11 @@ memory_probe_store(struct class *class, struct class_attribute *attr,
 out:
        return ret;
 }
-static CLASS_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
+static DEVICE_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
 
 static int memory_probe_init(void)
 {
-       return sysfs_create_file(&memory_sysdev_class.kset.kobj,
-                               &class_attr_probe.attr);
+       return device_create_file(memory_subsys.dev_root, &dev_attr_probe);
 }
 #else
 static inline int memory_probe_init(void)
@@ -444,8 +425,8 @@ static inline int memory_probe_init(void)
 
 /* Soft offline a page */
 static ssize_t
-store_soft_offline_page(struct class *class,
-                       struct class_attribute *attr,
+store_soft_offline_page(struct device *dev,
+                       struct device_attribute *attr,
                        const char *buf, size_t count)
 {
        int ret;
@@ -463,8 +444,8 @@ store_soft_offline_page(struct class *class,
 
 /* Forcibly offline a page, including killing processes. */
 static ssize_t
-store_hard_offline_page(struct class *class,
-                       struct class_attribute *attr,
+store_hard_offline_page(struct device *dev,
+                       struct device_attribute *attr,
                        const char *buf, size_t count)
 {
        int ret;
@@ -478,18 +459,18 @@ store_hard_offline_page(struct class *class,
        return ret ? ret : count;
 }
 
-static CLASS_ATTR(soft_offline_page, 0644, NULL, store_soft_offline_page);
-static CLASS_ATTR(hard_offline_page, 0644, NULL, store_hard_offline_page);
+static DEVICE_ATTR(soft_offline_page, 0644, NULL, store_soft_offline_page);
+static DEVICE_ATTR(hard_offline_page, 0644, NULL, store_hard_offline_page);
 
 static __init int memory_fail_init(void)
 {
        int err;
 
-       err = sysfs_create_file(&memory_sysdev_class.kset.kobj,
-                               &class_attr_soft_offline_page.attr);
+       err = device_create_file(memory_subsys.dev_root,
+                               &dev_attr_soft_offline_page);
        if (!err)
-               err = sysfs_create_file(&memory_sysdev_class.kset.kobj,
-                               &class_attr_hard_offline_page.attr);
+               err = device_create_file(memory_subsys.dev_root,
+                               &dev_attr_hard_offline_page);
        return err;
 }
 #else
@@ -509,31 +490,23 @@ int __weak arch_get_memory_phys_device(unsigned long start_pfn)
        return 0;
 }
 
+/*
+ * A reference for the returned object is held and the reference for the
+ * hinted object is released.
+ */
 struct memory_block *find_memory_block_hinted(struct mem_section *section,
                                              struct memory_block *hint)
 {
-       struct kobject *kobj;
-       struct sys_device *sysdev;
-       struct memory_block *mem;
-       char name[sizeof(MEMORY_CLASS_NAME) + 9 + 1];
        int block_id = base_memory_block_id(__section_nr(section));
+       struct device *hintdev = hint ? &hint->dev : NULL;
+       struct device *dev;
 
-       kobj = hint ? &hint->sysdev.kobj : NULL;
-
-       /*
-        * This only works because we know that section == sysdev->id
-        * slightly redundant with sysdev_register()
-        */
-       sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, block_id);
-
-       kobj = kset_find_obj_hinted(&memory_sysdev_class.kset, name, kobj);
-       if (!kobj)
+       dev = subsys_find_device_by_id(&memory_subsys, block_id, hintdev);
+       if (hint)
+               put_device(&hint->dev);
+       if (!dev)
                return NULL;
-
-       sysdev = container_of(kobj, struct sys_device, kobj);
-       mem = container_of(sysdev, struct memory_block, sysdev);
-
-       return mem;
+       return container_of(dev, struct memory_block, dev);
 }
 
 /*
@@ -542,7 +515,7 @@ struct memory_block *find_memory_block_hinted(struct mem_section *section,
  * this gets to be a real problem, we can always use a radix
  * tree or something here.
  *
- * This could be made generic for all sysdev classes.
+ * This could be made generic for all device subsystems.
  */
 struct memory_block *find_memory_block(struct mem_section *section)
 {
@@ -598,7 +571,7 @@ static int add_memory_section(int nid, struct mem_section *section,
        mem = find_memory_block(section);
        if (mem) {
                mem->section_count++;
-               kobject_put(&mem->sysdev.kobj);
+               kobject_put(&mem->dev.kobj);
        } else
                ret = init_memory_block(&mem, section, state);
 
@@ -631,7 +604,7 @@ int remove_memory_block(unsigned long node_id, struct mem_section *section,
                unregister_memory(mem);
                kfree(mem);
        } else
-               kobject_put(&mem->sysdev.kobj);
+               kobject_put(&mem->dev.kobj);
 
        mutex_unlock(&mem_sysfs_mutex);
        return 0;
@@ -664,8 +637,7 @@ int __init memory_dev_init(void)
        int err;
        unsigned long block_sz;
 
-       memory_sysdev_class.kset.uevent_ops = &memory_uevent_ops;
-       ret = sysdev_class_register(&memory_sysdev_class);
+       ret = subsys_system_register(&memory_subsys, NULL);
        if (ret)
                goto out;
 
index 6ce1501..996d218 100644 (file)
@@ -1,8 +1,7 @@
 /*
- * drivers/base/node.c - basic Node class support
+ * Basic Node interface support
  */
 
-#include <linux/sysdev.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/slab.h>
 
-static struct sysdev_class_attribute *node_state_attrs[];
-
-static struct sysdev_class node_class = {
+static struct bus_type node_subsys = {
        .name = "node",
-       .attrs = node_state_attrs,
+       .dev_name = "node",
 };
 
 
-static ssize_t node_read_cpumap(struct sys_device *dev, int type, char *buf)
+static ssize_t node_read_cpumap(struct device *dev, int type, char *buf)
 {
        struct node *node_dev = to_node(dev);
-       const struct cpumask *mask = cpumask_of_node(node_dev->sysdev.id);
+       const struct cpumask *mask = cpumask_of_node(node_dev->dev.id);
        int len;
 
        /* 2008/04/07: buf currently PAGE_SIZE, need 9 chars per 32 bits. */
@@ -44,23 +41,23 @@ static ssize_t node_read_cpumap(struct sys_device *dev, int type, char *buf)
        return len;
 }
 
-static inline ssize_t node_read_cpumask(struct sys_device *dev,
-                               struct sysdev_attribute *attr, char *buf)
+static inline ssize_t node_read_cpumask(struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
        return node_read_cpumap(dev, 0, buf);
 }
-static inline ssize_t node_read_cpulist(struct sys_device *dev,
-                               struct sysdev_attribute *attr, char *buf)
+static inline ssize_t node_read_cpulist(struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
        return node_read_cpumap(dev, 1, buf);
 }
 
-static SYSDEV_ATTR(cpumap,  S_IRUGO, node_read_cpumask, NULL);
-static SYSDEV_ATTR(cpulist, S_IRUGO, node_read_cpulist, NULL);
+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 sys_device * dev,
-                       struct sysdev_attribute *attr, char * buf)
+static ssize_t node_read_meminfo(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
        int n;
        int nid = dev->id;
@@ -155,10 +152,10 @@ static ssize_t node_read_meminfo(struct sys_device * dev,
 }
 
 #undef K
-static SYSDEV_ATTR(meminfo, S_IRUGO, node_read_meminfo, NULL);
+static DEVICE_ATTR(meminfo, S_IRUGO, node_read_meminfo, NULL);
 
-static ssize_t node_read_numastat(struct sys_device * dev,
-                               struct sysdev_attribute *attr, char * buf)
+static ssize_t node_read_numastat(struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
        return sprintf(buf,
                       "numa_hit %lu\n"
@@ -174,10 +171,10 @@ static ssize_t node_read_numastat(struct sys_device * dev,
                       node_page_state(dev->id, NUMA_LOCAL),
                       node_page_state(dev->id, NUMA_OTHER));
 }
-static SYSDEV_ATTR(numastat, S_IRUGO, node_read_numastat, NULL);
+static DEVICE_ATTR(numastat, S_IRUGO, node_read_numastat, NULL);
 
-static ssize_t node_read_vmstat(struct sys_device *dev,
-                               struct sysdev_attribute *attr, char *buf)
+static ssize_t node_read_vmstat(struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
        int nid = dev->id;
        int i;
@@ -189,10 +186,10 @@ static ssize_t node_read_vmstat(struct sys_device *dev,
 
        return n;
 }
-static SYSDEV_ATTR(vmstat, S_IRUGO, node_read_vmstat, NULL);
+static DEVICE_ATTR(vmstat, S_IRUGO, node_read_vmstat, NULL);
 
-static ssize_t node_read_distance(struct sys_device * dev,
-                       struct sysdev_attribute *attr, char * buf)
+static ssize_t node_read_distance(struct device *dev,
+                       struct device_attribute *attr, char * buf)
 {
        int nid = dev->id;
        int len = 0;
@@ -210,7 +207,7 @@ static ssize_t node_read_distance(struct sys_device * dev,
        len += sprintf(buf + len, "\n");
        return len;
 }
-static SYSDEV_ATTR(distance, S_IRUGO, node_read_distance, NULL);
+static DEVICE_ATTR(distance, S_IRUGO, node_read_distance, NULL);
 
 #ifdef CONFIG_HUGETLBFS
 /*
@@ -228,7 +225,7 @@ static node_registration_func_t __hugetlb_unregister_node;
 static inline bool hugetlb_register_node(struct node *node)
 {
        if (__hugetlb_register_node &&
-                       node_state(node->sysdev.id, N_HIGH_MEMORY)) {
+                       node_state(node->dev.id, N_HIGH_MEMORY)) {
                __hugetlb_register_node(node);
                return true;
        }
@@ -264,17 +261,17 @@ int register_node(struct node *node, int num, struct node *parent)
 {
        int error;
 
-       node->sysdev.id = num;
-       node->sysdev.cls = &node_class;
-       error = sysdev_register(&node->sysdev);
+       node->dev.id = num;
+       node->dev.bus = &node_subsys;
+       error = device_register(&node->dev);
 
        if (!error){
-               sysdev_create_file(&node->sysdev, &attr_cpumap);
-               sysdev_create_file(&node->sysdev, &attr_cpulist);
-               sysdev_create_file(&node->sysdev, &attr_meminfo);
-               sysdev_create_file(&node->sysdev, &attr_numastat);
-               sysdev_create_file(&node->sysdev, &attr_distance);
-               sysdev_create_file(&node->sysdev, &attr_vmstat);
+               device_create_file(&node->dev, &dev_attr_cpumap);
+               device_create_file(&node->dev, &dev_attr_cpulist);
+               device_create_file(&node->dev, &dev_attr_meminfo);
+               device_create_file(&node->dev, &dev_attr_numastat);
+               device_create_file(&node->dev, &dev_attr_distance);
+               device_create_file(&node->dev, &dev_attr_vmstat);
 
                scan_unevictable_register_node(node);
 
@@ -294,17 +291,17 @@ int register_node(struct node *node, int num, struct node *parent)
  */
 void unregister_node(struct node *node)
 {
-       sysdev_remove_file(&node->sysdev, &attr_cpumap);
-       sysdev_remove_file(&node->sysdev, &attr_cpulist);
-       sysdev_remove_file(&node->sysdev, &attr_meminfo);
-       sysdev_remove_file(&node->sysdev, &attr_numastat);
-       sysdev_remove_file(&node->sysdev, &attr_distance);
-       sysdev_remove_file(&node->sysdev, &attr_vmstat);
+       device_remove_file(&node->dev, &dev_attr_cpumap);
+       device_remove_file(&node->dev, &dev_attr_cpulist);
+       device_remove_file(&node->dev, &dev_attr_meminfo);
+       device_remove_file(&node->dev, &dev_attr_numastat);
+       device_remove_file(&node->dev, &dev_attr_distance);
+       device_remove_file(&node->dev, &dev_attr_vmstat);
 
        scan_unevictable_unregister_node(node);
        hugetlb_unregister_node(node);          /* no-op, if memoryless node */
 
-       sysdev_unregister(&node->sysdev);
+       device_unregister(&node->dev);
 }
 
 struct node node_devices[MAX_NUMNODES];
@@ -324,15 +321,15 @@ int register_cpu_under_node(unsigned int cpu, unsigned int nid)
        if (!obj)
                return 0;
 
-       ret = sysfs_create_link(&node_devices[nid].sysdev.kobj,
+       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].sysdev.kobj,
-                                kobject_name(&node_devices[nid].sysdev.kobj));
+                                &node_devices[nid].dev.kobj,
+                                kobject_name(&node_devices[nid].dev.kobj));
 }
 
 int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
@@ -346,10 +343,10 @@ int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
        if (!obj)
                return 0;
 
-       sysfs_remove_link(&node_devices[nid].sysdev.kobj,
+       sysfs_remove_link(&node_devices[nid].dev.kobj,
                          kobject_name(&obj->kobj));
        sysfs_remove_link(&obj->kobj,
-                         kobject_name(&node_devices[nid].sysdev.kobj));
+                         kobject_name(&node_devices[nid].dev.kobj));
 
        return 0;
 }
@@ -391,15 +388,15 @@ int register_mem_sect_under_node(struct memory_block *mem_blk, int nid)
                        continue;
                if (page_nid != nid)
                        continue;
-               ret = sysfs_create_link_nowarn(&node_devices[nid].sysdev.kobj,
-                                       &mem_blk->sysdev.kobj,
-                                       kobject_name(&mem_blk->sysdev.kobj));
+               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->sysdev.kobj,
-                               &node_devices[nid].sysdev.kobj,
-                               kobject_name(&node_devices[nid].sysdev.kobj));
+               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;
@@ -432,10 +429,10 @@ int unregister_mem_sect_under_nodes(struct memory_block *mem_blk,
                        continue;
                if (node_test_and_set(nid, *unlinked_nodes))
                        continue;
-               sysfs_remove_link(&node_devices[nid].sysdev.kobj,
-                        kobject_name(&mem_blk->sysdev.kobj));
-               sysfs_remove_link(&mem_blk->sysdev.kobj,
-                        kobject_name(&node_devices[nid].sysdev.kobj));
+               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;
@@ -466,7 +463,7 @@ static int link_mem_sections(int nid)
        }
 
        if (mem_blk)
-               kobject_put(&mem_blk->sysdev.kobj);
+               kobject_put(&mem_blk->dev.kobj);
        return err;
 }
 
@@ -594,19 +591,19 @@ static ssize_t print_nodes_state(enum node_states state, char *buf)
 }
 
 struct node_attr {
-       struct sysdev_class_attribute attr;
+       struct device_attribute attr;
        enum node_states state;
 };
 
-static ssize_t show_node_state(struct sysdev_class *class,
-                              struct sysdev_class_attribute *attr, char *buf)
+static ssize_t show_node_state(struct device *dev,
+                              struct device_attribute *attr, char *buf)
 {
        struct node_attr *na = container_of(attr, struct node_attr, attr);
        return print_nodes_state(na->state, buf);
 }
 
 #define _NODE_ATTR(name, state) \
-       { _SYSDEV_CLASS_ATTR(name, 0444, show_node_state, NULL), state }
+       { __ATTR(name, 0444, show_node_state, NULL), state }
 
 static struct node_attr node_state_attr[] = {
        _NODE_ATTR(possible, N_POSSIBLE),
@@ -618,17 +615,26 @@ static struct node_attr node_state_attr[] = {
 #endif
 };
 
-static struct sysdev_class_attribute *node_state_attrs[] = {
-       &node_state_attr[0].attr,
-       &node_state_attr[1].attr,
-       &node_state_attr[2].attr,
-       &node_state_attr[3].attr,
+static struct attribute *node_state_attrs[] = {
+       &node_state_attr[0].attr.attr,
+       &node_state_attr[1].attr.attr,
+       &node_state_attr[2].attr.attr,
+       &node_state_attr[3].attr.attr,
 #ifdef CONFIG_HIGHMEM
-       &node_state_attr[4].attr,
+       &node_state_attr[4].attr.attr,
 #endif
        NULL
 };
 
+static struct attribute_group memory_root_attr_group = {
+       .attrs = node_state_attrs,
+};
+
+static const struct attribute_group *cpu_root_attr_groups[] = {
+       &memory_root_attr_group,
+       NULL,
+};
+
 #define NODE_CALLBACK_PRI      2       /* lower than SLAB */
 static int __init register_node_type(void)
 {
@@ -637,7 +643,7 @@ static int __init register_node_type(void)
        BUILD_BUG_ON(ARRAY_SIZE(node_state_attr) != NR_NODE_STATES);
        BUILD_BUG_ON(ARRAY_SIZE(node_state_attrs)-1 != NR_NODE_STATES);
 
-       ret = sysdev_class_register(&node_class);
+       ret = subsys_system_register(&node_subsys, cpu_root_attr_groups);
        if (!ret) {
                hotplug_memory_notifier(node_memory_callback,
                                        NODE_CALLBACK_PRI);
index 935699b..1ac7f6e 100644 (file)
@@ -15,7 +15,6 @@
 #ifndef _LINUX_MEMORY_H_
 #define _LINUX_MEMORY_H_
 
-#include <linux/sysdev.h>
 #include <linux/node.h>
 #include <linux/compiler.h>
 #include <linux/mutex.h>
@@ -38,7 +37,7 @@ struct memory_block {
        int phys_device;                /* to which fru does this belong? */
        void *hw;                       /* optional pointer to fw/hw data */
        int (*phys_callback)(struct memory_block *);
-       struct sys_device sysdev;
+       struct device dev;
 };
 
 int arch_get_memory_phys_device(unsigned long start_pfn);
index 92370e2..624e53c 100644 (file)
 #ifndef _LINUX_NODE_H_
 #define _LINUX_NODE_H_
 
-#include <linux/sysdev.h>
+#include <linux/device.h>
 #include <linux/cpumask.h>
 #include <linux/workqueue.h>
 
 struct node {
-       struct sys_device       sysdev;
+       struct device   dev;
 
 #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) && defined(CONFIG_HUGETLBFS)
        struct work_struct      node_work;
@@ -80,6 +80,6 @@ static inline void register_hugetlbfs_with_node(node_registration_func_t reg,
 }
 #endif
 
-#define to_node(sys_device) container_of(sys_device, struct node, sysdev)
+#define to_node(device) container_of(device, struct node, dev)
 
 #endif /* _LINUX_NODE_H_ */
index 899d956..1253d7a 100644 (file)
@@ -721,23 +721,23 @@ int sysctl_extfrag_handler(struct ctl_table *table, int write,
 }
 
 #if defined(CONFIG_SYSFS) && defined(CONFIG_NUMA)
-ssize_t sysfs_compact_node(struct sys_device *dev,
-                       struct sysdev_attribute *attr,
+ssize_t sysfs_compact_node(struct device *dev,
+                       struct device_attribute *attr,
                        const char *buf, size_t count)
 {
        compact_node(dev->id);
 
        return count;
 }
-static SYSDEV_ATTR(compact, S_IWUSR, NULL, sysfs_compact_node);
+static DEVICE_ATTR(compact, S_IWUSR, NULL, sysfs_compact_node);
 
 int compaction_register_node(struct node *node)
 {
-       return sysdev_create_file(&node->sysdev, &attr_compact);
+       return device_create_file(&node->dev, &dev_attr_compact);
 }
 
 void compaction_unregister_node(struct node *node)
 {
-       return sysdev_remove_file(&node->sysdev, &attr_compact);
+       return device_remove_file(&node->dev, &dev_attr_compact);
 }
 #endif /* CONFIG_SYSFS && CONFIG_NUMA */
index dae27ba..ad713e2 100644 (file)
@@ -1591,9 +1591,9 @@ static void __init hugetlb_sysfs_init(void)
 
 /*
  * node_hstate/s - associate per node hstate attributes, via their kobjects,
- * with node sysdevs in node_devices[] using a parallel array.  The array
- * index of a node sysdev or _hstate == node id.
- * This is here to avoid any static dependency of the node sysdev driver, in
+ * with node devices in node_devices[] using a parallel array.  The array
+ * index of a node device or _hstate == node id.
+ * This is here to avoid any static dependency of the node device driver, in
  * the base kernel, on the hugetlb module.
  */
 struct node_hstate {
@@ -1603,7 +1603,7 @@ struct node_hstate {
 struct node_hstate node_hstates[MAX_NUMNODES];
 
 /*
- * A subset of global hstate attributes for node sysdevs
+ * A subset of global hstate attributes for node devices
  */
 static struct attribute *per_node_hstate_attrs[] = {
        &nr_hugepages_attr.attr,
@@ -1617,7 +1617,7 @@ static struct attribute_group per_node_hstate_attr_group = {
 };
 
 /*
- * kobj_to_node_hstate - lookup global hstate for node sysdev hstate attr kobj.
+ * kobj_to_node_hstate - lookup global hstate for node device hstate attr kobj.
  * Returns node id via non-NULL nidp.
  */
 static struct hstate *kobj_to_node_hstate(struct kobject *kobj, int *nidp)
@@ -1640,13 +1640,13 @@ static struct hstate *kobj_to_node_hstate(struct kobject *kobj, int *nidp)
 }
 
 /*
- * Unregister hstate attributes from a single node sysdev.
+ * Unregister hstate attributes from a single node device.
  * No-op if no hstate attributes attached.
  */
 void hugetlb_unregister_node(struct node *node)
 {
        struct hstate *h;
-       struct node_hstate *nhs = &node_hstates[node->sysdev.id];
+       struct node_hstate *nhs = &node_hstates[node->dev.id];
 
        if (!nhs->hugepages_kobj)
                return;         /* no hstate attributes */
@@ -1662,7 +1662,7 @@ void hugetlb_unregister_node(struct node *node)
 }
 
 /*
- * hugetlb module exit:  unregister hstate attributes from node sysdevs
+ * hugetlb module exit:  unregister hstate attributes from node devices
  * that have them.
  */
 static void hugetlb_unregister_all_nodes(void)
@@ -1670,7 +1670,7 @@ static void hugetlb_unregister_all_nodes(void)
        int nid;
 
        /*
-        * disable node sysdev registrations.
+        * disable node device registrations.
         */
        register_hugetlbfs_with_node(NULL, NULL);
 
@@ -1682,20 +1682,20 @@ static void hugetlb_unregister_all_nodes(void)
 }
 
 /*
- * Register hstate attributes for a single node sysdev.
+ * Register hstate attributes for a single node device.
  * No-op if attributes already registered.
  */
 void hugetlb_register_node(struct node *node)
 {
        struct hstate *h;
-       struct node_hstate *nhs = &node_hstates[node->sysdev.id];
+       struct node_hstate *nhs = &node_hstates[node->dev.id];
        int err;
 
        if (nhs->hugepages_kobj)
                return;         /* already allocated */
 
        nhs->hugepages_kobj = kobject_create_and_add("hugepages",
-                                                       &node->sysdev.kobj);
+                                                       &node->dev.kobj);
        if (!nhs->hugepages_kobj)
                return;
 
@@ -1706,7 +1706,7 @@ void hugetlb_register_node(struct node *node)
                if (err) {
                        printk(KERN_ERR "Hugetlb: Unable to add hstate %s"
                                        " for node %d\n",
-                                               h->name, node->sysdev.id);
+                                               h->name, node->dev.id);
                        hugetlb_unregister_node(node);
                        break;
                }
@@ -1715,8 +1715,8 @@ void hugetlb_register_node(struct node *node)
 
 /*
  * hugetlb init time:  register hstate attributes for all registered node
- * sysdevs of nodes that have memory.  All on-line nodes should have
- * registered their associated sysdev by this time.
+ * devices of nodes that have memory.  All on-line nodes should have
+ * registered their associated device by this time.
  */
 static void hugetlb_register_all_nodes(void)
 {
@@ -1724,12 +1724,12 @@ static void hugetlb_register_all_nodes(void)
 
        for_each_node_state(nid, N_HIGH_MEMORY) {
                struct node *node = &node_devices[nid];
-               if (node->sysdev.id == nid)
+               if (node->dev.id == nid)
                        hugetlb_register_node(node);
        }
 
        /*
-        * Let the node sysdev driver know we're here so it can
+        * Let the node device driver know we're here so it can
         * [un]register hstate attributes on node hotplug.
         */
        register_hugetlbfs_with_node(hugetlb_register_node,
index a1893c0..2b4189d 100644 (file)
@@ -3475,16 +3475,16 @@ int scan_unevictable_handler(struct ctl_table *table, int write,
  * a specified node's per zone unevictable lists for evictable pages.
  */
 
-static ssize_t read_scan_unevictable_node(struct sys_device *dev,
-                                         struct sysdev_attribute *attr,
+static ssize_t read_scan_unevictable_node(struct device *dev,
+                                         struct device_attribute *attr,
                                          char *buf)
 {
        warn_scan_unevictable_pages();
        return sprintf(buf, "0\n");     /* always zero; should fit... */
 }
 
-static ssize_t write_scan_unevictable_node(struct sys_device *dev,
-                                          struct sysdev_attribute *attr,
+static ssize_t write_scan_unevictable_node(struct device *dev,
+                                          struct device_attribute *attr,
                                        const char *buf, size_t count)
 {
        warn_scan_unevictable_pages();
@@ -3492,17 +3492,17 @@ static ssize_t write_scan_unevictable_node(struct sys_device *dev,
 }
 
 
-static SYSDEV_ATTR(scan_unevictable_pages, S_IRUGO | S_IWUSR,
+static DEVICE_ATTR(scan_unevictable_pages, S_IRUGO | S_IWUSR,
                        read_scan_unevictable_node,
                        write_scan_unevictable_node);
 
 int scan_unevictable_register_node(struct node *node)
 {
-       return sysdev_create_file(&node->sysdev, &attr_scan_unevictable_pages);
+       return device_create_file(&node->dev, &dev_attr_scan_unevictable_pages);
 }
 
 void scan_unevictable_unregister_node(struct node *node)
 {
-       sysdev_remove_file(&node->sysdev, &attr_scan_unevictable_pages);
+       device_remove_file(&node->dev, &dev_attr_scan_unevictable_pages);
 }
 #endif