Merge branch 'master' of /home/trondmy/kernel/linux-2.6/

Conflicts:

	net/sunrpc/auth_gss/gss_krb5_crypto.c
	net/sunrpc/auth_gss/gss_spkm3_token.c
	net/sunrpc/clnt.c

Merge with mainline and fix conflicts.

8 files changed, 312 insertions, 76 deletions

diff --git a/fs/sysfs/bin.c b/fs/sysfs/bin.c
index e8f540d38d48..d3b9f5f07db1 100644
--- a/fs/sysfs/bin.c
+++ b/fs/sysfs/bin.c
@@ -16,6 +16,7 @@
 #include <linux/slab.h>
 
 #include <asm/uaccess.h>
+#include <asm/semaphore.h>
 
 #include "sysfs.h"
 
@@ -146,7 +147,7 @@ static int open(struct inode * inode, struct file * file)
  Error:
         module_put(attr->attr.owner);
  Done:
-        if (error && kobj)
+        if (error)
                 kobject_put(kobj);
         return error;
 }
@@ -157,8 +158,7 @@ static int release(struct inode * inode, struct file * file)
         struct bin_attribute * attr = to_bin_attr(file->f_path.dentry);
         u8 * buffer = file->private_data;
 
-        if (kobj) 
-                kobject_put(kobj);
+        kobject_put(kobj);
         module_put(attr->attr.owner);
         kfree(buffer);
         return 0;
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 511edef8b321..8813990304fe 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -9,6 +9,7 @@
 #include <linux/module.h>
 #include <linux/kobject.h>
 #include <linux/namei.h>
+#include <asm/semaphore.h>
 #include "sysfs.h"
 
 DECLARE_RWSEM(sysfs_rename_sem);
@@ -32,25 +33,39 @@ static struct dentry_operations sysfs_dentry_ops = {
 /*
  * Allocates a new sysfs_dirent and links it to the parent sysfs_dirent
  */
-static struct sysfs_dirent * sysfs_new_dirent(struct sysfs_dirent * parent_sd,
-                                                void * element)
+static struct sysfs_dirent * __sysfs_new_dirent(void * element)
 {
         struct sysfs_dirent * sd;
 
-        sd = kmem_cache_alloc(sysfs_dir_cachep, GFP_KERNEL);
+        sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
         if (!sd)
                 return NULL;
 
-        memset(sd, 0, sizeof(*sd));
         atomic_set(&sd->s_count, 1);
         atomic_set(&sd->s_event, 1);
         INIT_LIST_HEAD(&sd->s_children);
-        list_add(&sd->s_sibling, &parent_sd->s_children);
+        INIT_LIST_HEAD(&sd->s_sibling);
         sd->s_element = element;
 
         return sd;
 }
 
+static void __sysfs_list_dirent(struct sysfs_dirent *parent_sd,
+                              struct sysfs_dirent *sd)
+{
+        if (sd)
+                list_add(&sd->s_sibling, &parent_sd->s_children);
+}
+
+static struct sysfs_dirent * sysfs_new_dirent(struct sysfs_dirent *parent_sd,
+                                                void * element)
+{
+        struct sysfs_dirent *sd;
+        sd = __sysfs_new_dirent(element);
+        __sysfs_list_dirent(parent_sd, sd);
+        return sd;
+}
+
 /*
  *
  * Return -EEXIST if there is already a sysfs element with the same name for
@@ -77,14 +92,14 @@ int sysfs_dirent_exist(struct sysfs_dirent *parent_sd,
 }
 
 
-int sysfs_make_dirent(struct sysfs_dirent * parent_sd, struct dentry * dentry,
-                        void * element, umode_t mode, int type)
+static struct sysfs_dirent *
+__sysfs_make_dirent(struct dentry *dentry, void *element, mode_t mode, int type)
 {
         struct sysfs_dirent * sd;
 
-        sd = sysfs_new_dirent(parent_sd, element);
+        sd = __sysfs_new_dirent(element);
         if (!sd)
-                return -ENOMEM;
+                goto out;
 
         sd->s_mode = mode;
         sd->s_type = type;
@@ -94,7 +109,19 @@ int sysfs_make_dirent(struct sysfs_dirent * parent_sd, struct dentry * dentry,
                 dentry->d_op = &sysfs_dentry_ops;
         }
 
-        return 0;
+out:
+        return sd;
+}
+
+int sysfs_make_dirent(struct sysfs_dirent * parent_sd, struct dentry * dentry,
+                        void * element, umode_t mode, int type)
+{
+        struct sysfs_dirent *sd;
+
+        sd = __sysfs_make_dirent(dentry, element, mode, type);
+        __sysfs_list_dirent(parent_sd, sd);
+
+        return sd ? 0 : -ENOMEM;
 }
 
 static int init_dir(struct inode * inode)
@@ -165,11 +192,11 @@ int sysfs_create_subdir(struct kobject * k, const char * n, struct dentry ** d)
 
 /**
  *      sysfs_create_dir - create a directory for an object.
- *      @parent:        parent parent object.
  *      @kobj:          object we're creating directory for. 
+ *      @shadow_parent: parent parent object.
  */
 
-int sysfs_create_dir(struct kobject * kobj)
+int sysfs_create_dir(struct kobject * kobj, struct dentry *shadow_parent)
 {
         struct dentry * dentry = NULL;
         struct dentry * parent;
@@ -177,7 +204,9 @@ int sysfs_create_dir(struct kobject * kobj)
 
         BUG_ON(!kobj);
 
-        if (kobj->parent)
+        if (shadow_parent)
+                parent = shadow_parent;
+        else if (kobj->parent)
                 parent = kobj->parent->dentry;
         else if (sysfs_mount && sysfs_mount->mnt_sb)
                 parent = sysfs_mount->mnt_sb->s_root;
@@ -267,7 +296,7 @@ static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
         return ERR_PTR(err);
 }
 
-struct inode_operations sysfs_dir_inode_operations = {
+const struct inode_operations sysfs_dir_inode_operations = {
         .lookup         = sysfs_lookup,
         .setattr        = sysfs_setattr,
 };
@@ -298,21 +327,12 @@ void sysfs_remove_subdir(struct dentry * d)
 }
 
 
-/**
- *      sysfs_remove_dir - remove an object's directory.
- *      @kobj:  object. 
- *
- *      The only thing special about this is that we remove any files in 
- *      the directory before we remove the directory, and we've inlined
- *      what used to be sysfs_rmdir() below, instead of calling separately.
- */
-
-void sysfs_remove_dir(struct kobject * kobj)
+static void __sysfs_remove_dir(struct dentry *dentry)
 {
-        struct dentry * dentry = dget(kobj->dentry);
         struct sysfs_dirent * parent_sd;
         struct sysfs_dirent * sd, * tmp;
 
+        dget(dentry);
         if (!dentry)
                 return;
 
@@ -333,32 +353,60 @@ void sysfs_remove_dir(struct kobject * kobj)
          * Drop reference from dget() on entrance.
          */
         dput(dentry);
+}
+
+/**
+ *      sysfs_remove_dir - remove an object's directory.
+ *      @kobj:  object.
+ *
+ *      The only thing special about this is that we remove any files in
+ *      the directory before we remove the directory, and we've inlined
+ *      what used to be sysfs_rmdir() below, instead of calling separately.
+ */
+
+void sysfs_remove_dir(struct kobject * kobj)
+{
+        __sysfs_remove_dir(kobj->dentry);
         kobj->dentry = NULL;
 }
 
-int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
+int sysfs_rename_dir(struct kobject * kobj, struct dentry *new_parent,
+                     const char *new_name)
 {
         int error = 0;
-        struct dentry * new_dentry, * parent;
-
-        if (!strcmp(kobject_name(kobj), new_name))
-                return -EINVAL;
+        struct dentry * new_dentry;
 
-        if (!kobj->parent)
-                return -EINVAL;
+        if (!new_parent)
+                return -EFAULT;
 
         down_write(&sysfs_rename_sem);
-        parent = kobj->parent->dentry;
-
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&new_parent->d_inode->i_mutex);
 
-        new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
+        new_dentry = lookup_one_len(new_name, new_parent, strlen(new_name));
         if (!IS_ERR(new_dentry)) {
-                if (!new_dentry->d_inode) {
+                /* By allowing two different directories with the
+                 * same d_parent we allow this routine to move
+                 * between different shadows of the same directory
+                 */
+                if (kobj->dentry->d_parent->d_inode != new_parent->d_inode)
+                        return -EINVAL;
+                else if (new_dentry->d_parent->d_inode != new_parent->d_inode)
+                        error = -EINVAL;
+                else if (new_dentry == kobj->dentry)
+                        error = -EINVAL;
+                else if (!new_dentry->d_inode) {
                         error = kobject_set_name(kobj, "%s", new_name);
                         if (!error) {
+                                struct sysfs_dirent *sd, *parent_sd;
+
                                 d_add(new_dentry, NULL);
                                 d_move(kobj->dentry, new_dentry);
+
+                                sd = kobj->dentry->d_fsdata;
+                                parent_sd = new_parent->d_fsdata;
+
+                                list_del_init(&sd->s_sibling);
+                                list_add(&sd->s_sibling, &parent_sd->s_children);
                         }
                         else
                                 d_drop(new_dentry);
@@ -366,7 +414,7 @@ int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
                         error = -EEXIST;
                 dput(new_dentry);
         }
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&new_parent->d_inode->i_mutex);
         up_write(&sysfs_rename_sem);
 
         return error;
@@ -378,12 +426,10 @@ int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent)
         struct sysfs_dirent *new_parent_sd, *sd;
         int error;
 
-        if (!new_parent)
-                return -EINVAL;
-
         old_parent_dentry = kobj->parent ?
                 kobj->parent->dentry : sysfs_mount->mnt_sb->s_root;
-        new_parent_dentry = new_parent->dentry;
+        new_parent_dentry = new_parent ?
+                new_parent->dentry : sysfs_mount->mnt_sb->s_root;
 
 again:
         mutex_lock(&old_parent_dentry->d_inode->i_mutex);
@@ -547,6 +593,95 @@ static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
         return offset;
 }
 
+
+/**
+ *      sysfs_make_shadowed_dir - Setup so a directory can be shadowed
+ *      @kobj:  object we're creating shadow of.
+ */
+
+int sysfs_make_shadowed_dir(struct kobject *kobj,
+        void * (*follow_link)(struct dentry *, struct nameidata *))
+{
+        struct inode *inode;
+        struct inode_operations *i_op;
+
+        inode = kobj->dentry->d_inode;
+        if (inode->i_op != &sysfs_dir_inode_operations)
+                return -EINVAL;
+
+        i_op = kmalloc(sizeof(*i_op), GFP_KERNEL);
+        if (!i_op)
+                return -ENOMEM;
+
+        memcpy(i_op, &sysfs_dir_inode_operations, sizeof(*i_op));
+        i_op->follow_link = follow_link;
+
+        /* Locking of inode->i_op?
+         * Since setting i_op is a single word write and they
+         * are atomic we should be ok here.
+         */
+        inode->i_op = i_op;
+        return 0;
+}
+
+/**
+ *      sysfs_create_shadow_dir - create a shadow directory for an object.
+ *      @kobj:  object we're creating directory for.
+ *
+ *      sysfs_make_shadowed_dir must already have been called on this
+ *      directory.
+ */
+
+struct dentry *sysfs_create_shadow_dir(struct kobject *kobj)
+{
+        struct sysfs_dirent *sd;
+        struct dentry *parent, *dir, *shadow;
+        struct inode *inode;
+
+        dir = kobj->dentry;
+        inode = dir->d_inode;
+        parent = dir->d_parent;
+        shadow = ERR_PTR(-EINVAL);
+        if (!sysfs_is_shadowed_inode(inode))
+                goto out;
+
+        shadow = d_alloc(parent, &dir->d_name);
+        if (!shadow)
+                goto nomem;
+
+        sd = __sysfs_make_dirent(shadow, kobj, inode->i_mode, SYSFS_DIR);
+        if (!sd)
+                goto nomem;
+
+        d_instantiate(shadow, igrab(inode));
+        inc_nlink(inode);
+        inc_nlink(parent->d_inode);
+        shadow->d_op = &sysfs_dentry_ops;
+
+        dget(shadow);           /* Extra count - pin the dentry in core */
+
+out:
+        return shadow;
+nomem:
+        dput(shadow);
+        shadow = ERR_PTR(-ENOMEM);
+        goto out;
+}
+
+/**
+ *      sysfs_remove_shadow_dir - remove an object's directory.
+ *      @shadow: dentry of shadow directory
+ *
+ *      The only thing special about this is that we remove any files in
+ *      the directory before we remove the directory, and we've inlined
+ *      what used to be sysfs_rmdir() below, instead of calling separately.
+ */
+
+void sysfs_remove_shadow_dir(struct dentry *shadow)
+{
+        __sysfs_remove_dir(shadow);
+}
+
 const struct file_operations sysfs_dir_operations = {
         .open           = sysfs_dir_open,
         .release        = sysfs_dir_close,
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index 9cfe53e1e00d..c0e117649a4d 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -7,6 +7,7 @@
 #include <linux/kobject.h>
 #include <linux/namei.h>
 #include <linux/poll.h>
+#include <linux/list.h>
 #include <asm/uaccess.h>
 #include <asm/semaphore.h>
 
@@ -50,17 +51,29 @@ static struct sysfs_ops subsys_sysfs_ops = {
         .store  = subsys_attr_store,
 };
 
+/**
+ *      add_to_collection - add buffer to a collection
+ *      @buffer:        buffer to be added
+ *      @node           inode of set to add to
+ */
 
-struct sysfs_buffer {
-        size_t                  count;
-        loff_t                  pos;
-        char                    * page;
-        struct sysfs_ops        * ops;
-        struct semaphore        sem;
-        int                     needs_read_fill;
-        int                     event;
-};
+static inline void
+add_to_collection(struct sysfs_buffer *buffer, struct inode *node)
+{
+        struct sysfs_buffer_collection *set = node->i_private;
 
+        mutex_lock(&node->i_mutex);
+        list_add(&buffer->associates, &set->associates);
+        mutex_unlock(&node->i_mutex);
+}
+
+static inline void
+remove_from_collection(struct sysfs_buffer *buffer, struct inode *node)
+{
+        mutex_lock(&node->i_mutex);
+        list_del(&buffer->associates);
+        mutex_unlock(&node->i_mutex);
+}
 
 /**
  *      fill_read_buffer - allocate and fill buffer from object.
@@ -70,7 +83,8 @@ struct sysfs_buffer {
  *      Allocate @buffer->page, if it hasn't been already, then call the
  *      kobject's show() method to fill the buffer with this attribute's 
  *      data. 
- *      This is called only once, on the file's first read. 
+ *      This is called only once, on the file's first read unless an error
+ *      is returned.
  */
 static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
 {
@@ -88,12 +102,13 @@ static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer
 
         buffer->event = atomic_read(&sd->s_event);
         count = ops->show(kobj,attr,buffer->page);
-        buffer->needs_read_fill = 0;
         BUG_ON(count > (ssize_t)PAGE_SIZE);
-        if (count >= 0)
+        if (count >= 0) {
+                buffer->needs_read_fill = 0;
                 buffer->count = count;
-        else
+        } else {
                 ret = count;
+        }
         return ret;
 }
 
@@ -153,6 +168,10 @@ sysfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
         ssize_t retval = 0;
 
         down(&buffer->sem);
+        if (buffer->orphaned) {
+                retval = -ENODEV;
+                goto out;
+        }
         if (buffer->needs_read_fill) {
                 if ((retval = fill_read_buffer(file->f_path.dentry,buffer)))
                         goto out;
@@ -165,7 +184,6 @@ out:
         return retval;
 }
 
-
 /**
  *      fill_write_buffer - copy buffer from userspace.
  *      @buffer:        data buffer for file.
@@ -243,19 +261,25 @@ sysfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t
         ssize_t len;
 
         down(&buffer->sem);
+        if (buffer->orphaned) {
+                len = -ENODEV;
+                goto out;
+        }
         len = fill_write_buffer(buffer, buf, count);
         if (len > 0)
                 len = flush_write_buffer(file->f_path.dentry, buffer, len);
         if (len > 0)
                 *ppos += len;
+out:
         up(&buffer->sem);
         return len;
 }
 
-static int check_perm(struct inode * inode, struct file * file)
+static int sysfs_open_file(struct inode *inode, struct file *file)
 {
         struct kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent);
         struct attribute * attr = to_attr(file->f_path.dentry);
+        struct sysfs_buffer_collection *set;
         struct sysfs_buffer * buffer;
         struct sysfs_ops * ops = NULL;
         int error = 0;
@@ -285,6 +309,18 @@ static int check_perm(struct inode * inode, struct file * file)
         if (!ops)
                 goto Eaccess;
 
+        /* make sure we have a collection to add our buffers to */
+        mutex_lock(&inode->i_mutex);
+        if (!(set = inode->i_private)) {
+                if (!(set = inode->i_private = kmalloc(sizeof(struct sysfs_buffer_collection), GFP_KERNEL))) {
+                        error = -ENOMEM;
+                        goto Done;
+                } else {
+                        INIT_LIST_HEAD(&set->associates);
+                }
+        }
+        mutex_unlock(&inode->i_mutex);
+
         /* File needs write support.
          * The inode's perms must say it's ok, 
          * and we must have a store method.
@@ -310,9 +346,11 @@ static int check_perm(struct inode * inode, struct file * file)
          */
         buffer = kzalloc(sizeof(struct sysfs_buffer), GFP_KERNEL);
         if (buffer) {
+                INIT_LIST_HEAD(&buffer->associates);
                 init_MUTEX(&buffer->sem);
                 buffer->needs_read_fill = 1;
                 buffer->ops = ops;
+                add_to_collection(buffer, inode);
                 file->private_data = buffer;
         } else
                 error = -ENOMEM;
@@ -325,16 +363,11 @@ static int check_perm(struct inode * inode, struct file * file)
         error = -EACCES;
         module_put(attr->owner);
  Done:
-        if (error && kobj)
+        if (error)
                 kobject_put(kobj);
         return error;
 }
 
-static int sysfs_open_file(struct inode * inode, struct file * filp)
-{
-        return check_perm(inode,filp);
-}
-
 static int sysfs_release(struct inode * inode, struct file * filp)
 {
         struct kobject * kobj = to_kobj(filp->f_path.dentry->d_parent);
@@ -342,8 +375,9 @@ static int sysfs_release(struct inode * inode, struct file * filp)
         struct module * owner = attr->owner;
         struct sysfs_buffer * buffer = filp->private_data;
 
-        if (kobj) 
-                kobject_put(kobj);
+        if (buffer)
+                remove_from_collection(buffer, inode);
+        kobject_put(kobj);
         /* After this point, attr should not be accessed. */
         module_put(owner);
 
@@ -548,7 +582,7 @@ EXPORT_SYMBOL_GPL(sysfs_chmod_file);
 
 void sysfs_remove_file(struct kobject * kobj, const struct attribute * attr)
 {
-        sysfs_hash_and_remove(kobj->dentry,attr->name);
+        sysfs_hash_and_remove(kobj->dentry, attr->name);
 }
 
 
diff --git a/fs/sysfs/group.c b/fs/sysfs/group.c
index 122145b0895c..b20951c93761 100644
--- a/fs/sysfs/group.c
+++ b/fs/sysfs/group.c
@@ -13,6 +13,8 @@
 #include <linux/dcache.h>
 #include <linux/namei.h>
 #include <linux/err.h>
+#include <linux/fs.h>
+#include <asm/semaphore.h>
 #include "sysfs.h"
 
 
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index e79e38d52c00..dd1344b007f5 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -13,6 +13,7 @@
 #include <linux/backing-dev.h>
 #include <linux/capability.h>
 #include <linux/errno.h>
+#include <asm/semaphore.h>
 #include "sysfs.h"
 
 extern struct super_block * sysfs_sb;
@@ -28,10 +29,20 @@ static struct backing_dev_info sysfs_backing_dev_info = {
         .capabilities   = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
 };
 
-static struct inode_operations sysfs_inode_operations ={
+static const struct inode_operations sysfs_inode_operations ={
         .setattr        = sysfs_setattr,
 };
 
+void sysfs_delete_inode(struct inode *inode)
+{
+        /* Free the shadowed directory inode operations */
+        if (sysfs_is_shadowed_inode(inode)) {
+                kfree(inode->i_op);
+                inode->i_op = NULL;
+        }
+        return generic_delete_inode(inode);
+}
+
 int sysfs_setattr(struct dentry * dentry, struct iattr * iattr)
 {
         struct inode * inode = dentry->d_inode;
@@ -209,6 +220,22 @@ const unsigned char * sysfs_get_name(struct sysfs_dirent *sd)
         return NULL;
 }
 
+static inline void orphan_all_buffers(struct inode *node)
+{
+        struct sysfs_buffer_collection *set = node->i_private;
+        struct sysfs_buffer *buf;
+
+        mutex_lock_nested(&node->i_mutex, I_MUTEX_CHILD);
+        if (node->i_private) {
+                list_for_each_entry(buf, &set->associates, associates) {
+                        down(&buf->sem);
+                        buf->orphaned = 1;
+                        up(&buf->sem);
+                }
+        }
+        mutex_unlock(&node->i_mutex);
+}
+
 
 /*
  * Unhashes the dentry corresponding to given sysfs_dirent
@@ -217,16 +244,23 @@ const unsigned char * sysfs_get_name(struct sysfs_dirent *sd)
 void sysfs_drop_dentry(struct sysfs_dirent * sd, struct dentry * parent)
 {
         struct dentry * dentry = sd->s_dentry;
+        struct inode *inode;
 
         if (dentry) {
                 spin_lock(&dcache_lock);
                 spin_lock(&dentry->d_lock);
                 if (!(d_unhashed(dentry) && dentry->d_inode)) {
+                        inode = dentry->d_inode;
+                        spin_lock(&inode->i_lock);
+                        __iget(inode);
+                        spin_unlock(&inode->i_lock);
                         dget_locked(dentry);
                         __d_drop(dentry);
                         spin_unlock(&dentry->d_lock);
                         spin_unlock(&dcache_lock);
                         simple_unlink(parent->d_inode, dentry);
+                        orphan_all_buffers(inode);
+                        iput(inode);
                 } else {
                         spin_unlock(&dentry->d_lock);
                         spin_unlock(&dcache_lock);
@@ -248,7 +282,7 @@ int sysfs_hash_and_remove(struct dentry * dir, const char * name)
                 return -ENOENT;
 
         parent_sd = dir->d_fsdata;
-        mutex_lock(&dir->d_inode->i_mutex);
+        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
         list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
                 if (!sd->s_element)
                         continue;
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index e503f858fba8..23a48a38e6af 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -8,6 +8,7 @@
 #include <linux/mount.h>
 #include <linux/pagemap.h>
 #include <linux/init.h>
+#include <asm/semaphore.h>
 
 #include "sysfs.h"
 
@@ -18,9 +19,12 @@ struct vfsmount *sysfs_mount;
 struct super_block * sysfs_sb = NULL;
 struct kmem_cache *sysfs_dir_cachep;
 
-static struct super_operations sysfs_ops = {
+static void sysfs_clear_inode(struct inode *inode);
+
+static const struct super_operations sysfs_ops = {
         .statfs         = simple_statfs,
-        .drop_inode     = generic_delete_inode,
+        .drop_inode     = sysfs_delete_inode,
+        .clear_inode    = sysfs_clear_inode,
 };
 
 static struct sysfs_dirent sysfs_root = {
@@ -31,6 +35,11 @@ static struct sysfs_dirent sysfs_root = {
         .s_iattr        = NULL,
 };
 
+static void sysfs_clear_inode(struct inode *inode)
+{
+        kfree(inode->i_private);
+}
+
 static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
 {
         struct inode *inode;
diff --git a/fs/sysfs/symlink.c b/fs/sysfs/symlink.c
index f50e3cc2ded8..7b9c5bfde920 100644
--- a/fs/sysfs/symlink.c
+++ b/fs/sysfs/symlink.c
@@ -7,6 +7,7 @@
 #include <linux/module.h>
 #include <linux/kobject.h>
 #include <linux/namei.h>
+#include <asm/semaphore.h>
 
 #include "sysfs.h"
 
@@ -180,7 +181,7 @@ static void sysfs_put_link(struct dentry *dentry, struct nameidata *nd, void *co
                 free_page((unsigned long)page);
 }
 
-struct inode_operations sysfs_symlink_inode_operations = {
+const struct inode_operations sysfs_symlink_inode_operations = {
         .readlink = generic_readlink,
         .follow_link = sysfs_follow_link,
         .put_link = sysfs_put_link,
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index bd7cec295dab..d976b0005549 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -2,6 +2,7 @@
 extern struct vfsmount * sysfs_mount;
 extern struct kmem_cache *sysfs_dir_cachep;
 
+extern void sysfs_delete_inode(struct inode *inode);
 extern struct inode * sysfs_new_inode(mode_t mode, struct sysfs_dirent *);
 extern int sysfs_create(struct dentry *, int mode, int (*init)(struct inode *));
 
@@ -25,14 +26,30 @@ extern struct super_block * sysfs_sb;
 extern const struct file_operations sysfs_dir_operations;
 extern const struct file_operations sysfs_file_operations;
 extern const struct file_operations bin_fops;
-extern struct inode_operations sysfs_dir_inode_operations;
-extern struct inode_operations sysfs_symlink_inode_operations;
+extern const struct inode_operations sysfs_dir_inode_operations;
+extern const struct inode_operations sysfs_symlink_inode_operations;
 
 struct sysfs_symlink {
         char * link_name;
         struct kobject * target_kobj;
 };
 
+struct sysfs_buffer {
+        struct list_head                associates;
+        size_t                          count;
+        loff_t                          pos;
+        char                            * page;
+        struct sysfs_ops                * ops;
+        struct semaphore                sem;
+        int                             orphaned;
+        int                             needs_read_fill;
+        int                             event;
+};
+
+struct sysfs_buffer_collection {
+        struct list_head        associates;
+};
+
 static inline struct kobject * to_kobj(struct dentry * dentry)
 {
         struct sysfs_dirent * sd = dentry->d_fsdata;
@@ -96,3 +113,7 @@ static inline void sysfs_put(struct sysfs_dirent * sd)
                 release_sysfs_dirent(sd);
 }
 
+static inline int sysfs_is_shadowed_inode(struct inode *inode)
+{
+        return S_ISDIR(inode->i_mode) && inode->i_op->follow_link;
+}