5 files changed, 85 insertions, 20 deletions

diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index ade9a7e6a757..e7735f643cd1 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -135,7 +135,7 @@ sysfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
                         goto out;
         }
         pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
-                 __FUNCTION__, count, *ppos, buffer->page);
+                 __func__, count, *ppos, buffer->page);
         retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
                                          buffer->count);
 out:
@@ -477,11 +477,10 @@ const struct file_operations sysfs_file_operations = {
         .poll           = sysfs_poll,
 };
 
-
-int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
-                   int type)
+int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
+                        const struct attribute *attr, int type, mode_t amode)
 {
-        umode_t mode = (attr->mode & S_IALLUGO) | S_IFREG;
+        umode_t mode = (amode & S_IALLUGO) | S_IFREG;
         struct sysfs_addrm_cxt acxt;
         struct sysfs_dirent *sd;
         int rc;
@@ -502,6 +501,13 @@ int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
 }
 
 
+int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
+                   int type)
+{
+        return sysfs_add_file_mode(dir_sd, attr, type, attr->mode);
+}
+
+
 /**
  *      sysfs_create_file - create an attribute file for an object.
  *      @kobj:  object we're creating for. 
diff --git a/fs/sysfs/group.c b/fs/sysfs/group.c
index 477904915032..eeba38417b1d 100644
--- a/fs/sysfs/group.c
+++ b/fs/sysfs/group.c
@@ -23,35 +23,50 @@ static void remove_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
         int i;
 
         for (i = 0, attr = grp->attrs; *attr; i++, attr++)
-                if (!grp->is_visible ||
-                    grp->is_visible(kobj, *attr, i))
-                        sysfs_hash_and_remove(dir_sd, (*attr)->name);
+                sysfs_hash_and_remove(dir_sd, (*attr)->name);
 }
 
 static int create_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
-                        const struct attribute_group *grp)
+                        const struct attribute_group *grp, int update)
 {
         struct attribute *const* attr;
         int error = 0, i;
 
-        for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++)
-                if (!grp->is_visible ||
-                    grp->is_visible(kobj, *attr, i))
-                        error |=
-                                sysfs_add_file(dir_sd, *attr, SYSFS_KOBJ_ATTR);
+        for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++) {
+                mode_t mode = 0;
+
+                /* in update mode, we're changing the permissions or
+                 * visibility.  Do this by first removing then
+                 * re-adding (if required) the file */
+                if (update)
+                        sysfs_hash_and_remove(dir_sd, (*attr)->name);
+                if (grp->is_visible) {
+                        mode = grp->is_visible(kobj, *attr, i);
+                        if (!mode)
+                                continue;
+                }
+                error = sysfs_add_file_mode(dir_sd, *attr, SYSFS_KOBJ_ATTR,
+                                            (*attr)->mode | mode);
+                if (unlikely(error))
+                        break;
+        }
         if (error)
                 remove_files(dir_sd, kobj, grp);
         return error;
 }
 
 
-int sysfs_create_group(struct kobject * kobj, 
-                       const struct attribute_group * grp)
+static int internal_create_group(struct kobject *kobj, int update,
+                                 const struct attribute_group *grp)
 {
         struct sysfs_dirent *sd;
         int error;
 
-        BUG_ON(!kobj || !kobj->sd);
+        BUG_ON(!kobj || (!update && !kobj->sd));
+
+        /* Updates may happen before the object has been instantiated */
+        if (unlikely(update && !kobj->sd))
+                return -EINVAL;
 
         if (grp->name) {
                 error = sysfs_create_subdir(kobj, grp->name, &sd);
@@ -60,7 +75,7 @@ int sysfs_create_group(struct kobject * kobj,
         } else
                 sd = kobj->sd;
         sysfs_get(sd);
-        error = create_files(sd, kobj, grp);
+        error = create_files(sd, kobj, grp, update);
         if (error) {
                 if (grp->name)
                         sysfs_remove_subdir(sd);
@@ -69,6 +84,47 @@ int sysfs_create_group(struct kobject * kobj,
         return error;
 }
 
+/**
+ * sysfs_create_group - given a directory kobject, create an attribute group
+ * @kobj:       The kobject to create the group on
+ * @grp:        The attribute group to create
+ *
+ * This function creates a group for the first time.  It will explicitly
+ * warn and error if any of the attribute files being created already exist.
+ *
+ * Returns 0 on success or error.
+ */
+int sysfs_create_group(struct kobject *kobj,
+                       const struct attribute_group *grp)
+{
+        return internal_create_group(kobj, 0, grp);
+}
+
+/**
+ * sysfs_update_group - given a directory kobject, create an attribute group
+ * @kobj:       The kobject to create the group on
+ * @grp:        The attribute group to create
+ *
+ * This function updates an attribute group.  Unlike
+ * sysfs_create_group(), it will explicitly not warn or error if any
+ * of the attribute files being created already exist.  Furthermore,
+ * if the visibility of the files has changed through the is_visible()
+ * callback, it will update the permissions and add or remove the
+ * relevant files.
+ *
+ * The primary use for this function is to call it after making a change
+ * that affects group visibility.
+ *
+ * Returns 0 on success or error.
+ */
+int sysfs_update_group(struct kobject *kobj,
+                       const struct attribute_group *grp)
+{
+        return internal_create_group(kobj, 1, grp);
+}
+
+
+
 void sysfs_remove_group(struct kobject * kobj, 
                         const struct attribute_group * grp)
 {
@@ -95,4 +151,5 @@ void sysfs_remove_group(struct kobject * kobj,
 
 
 EXPORT_SYMBOL_GPL(sysfs_create_group);
+EXPORT_SYMBOL_GPL(sysfs_update_group);
 EXPORT_SYMBOL_GPL(sysfs_remove_group);
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index d9262f74f94e..f8b82e73b3bf 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -30,7 +30,7 @@ static const struct address_space_operations sysfs_aops = {
 
 static struct backing_dev_info sysfs_backing_dev_info = {
         .ra_pages       = 0,    /* No readahead */
-        .capabilities   = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
+        .capabilities   = BDI_CAP_NO_ACCT_AND_WRITEBACK,
 };
 
 static const struct inode_operations sysfs_inode_operations ={
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index 74168266cd59..14f0023984d7 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -61,7 +61,7 @@ static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
         /* instantiate and link root dentry */
         root = d_alloc_root(inode);
         if (!root) {
-                pr_debug("%s: could not get root dentry!\n",__FUNCTION__);
+                pr_debug("%s: could not get root dentry!\n",__func__);
                 iput(inode);
                 return -ENOMEM;
         }
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index ff17f8da9b43..ce4e15f8aaeb 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -154,6 +154,8 @@ extern const struct file_operations sysfs_file_operations;
 int sysfs_add_file(struct sysfs_dirent *dir_sd,
                    const struct attribute *attr, int type);
 
+int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
+                        const struct attribute *attr, int type, mode_t amode);
 /*
  * bin.c
  */