8 files changed, 177 insertions, 200 deletions

diff --git a/arch/powerpc/kernel/sysfs.c b/arch/powerpc/kernel/sysfs.c
index f396ef27916b..5e7c1655f13a 100644
--- a/arch/powerpc/kernel/sysfs.c
+++ b/arch/powerpc/kernel/sysfs.c
@@ -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);
 
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 8272d92d22c0..f17e3ea041c0 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -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;
 
diff --git a/drivers/base/node.c b/drivers/base/node.c
index 6ce1501c7de5..996d2189689b 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -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>
@@ -19,18 +18,16 @@
 #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);
diff --git a/include/linux/memory.h b/include/linux/memory.h
index 935699b30b7c..1ac7f6e405f9 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -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);
diff --git a/include/linux/node.h b/include/linux/node.h
index 92370e22343c..624e53cecc02 100644
--- a/include/linux/node.h
+++ b/include/linux/node.h
@@ -14,12 +14,12 @@
 #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_ */
diff --git a/mm/compaction.c b/mm/compaction.c
index 899d95638586..1253d7ac332b 100644
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -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 */
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index dae27ba3be2c..ad713e2d61bc 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -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,
diff --git a/mm/vmscan.c b/mm/vmscan.c
index a1893c050795..2b4189d759e4 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -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