5 files changed, 282 insertions, 121 deletions

diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index 956d5ddddf6e..b80bc846a15a 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -23,9 +23,13 @@
 #include <linux/debugfs.h>
 #include <linux/fsnotify.h>
 #include <linux/string.h>
+#include <linux/seq_file.h>
+#include <linux/parser.h>
 #include <linux/magic.h>
 #include <linux/slab.h>
 
+#define DEBUGFS_DEFAULT_MODE    0755
+
 static struct vfsmount *debugfs_mount;
 static int debugfs_mount_count;
 static bool debugfs_registered;
@@ -125,11 +129,154 @@ static inline int debugfs_positive(struct dentry *dentry)
         return dentry->d_inode && !d_unhashed(dentry);
 }
 
+struct debugfs_mount_opts {
+        uid_t uid;
+        gid_t gid;
+        umode_t mode;
+};
+
+enum {
+        Opt_uid,
+        Opt_gid,
+        Opt_mode,
+        Opt_err
+};
+
+static const match_table_t tokens = {
+        {Opt_uid, "uid=%u"},
+        {Opt_gid, "gid=%u"},
+        {Opt_mode, "mode=%o"},
+        {Opt_err, NULL}
+};
+
+struct debugfs_fs_info {
+        struct debugfs_mount_opts mount_opts;
+};
+
+static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
+{
+        substring_t args[MAX_OPT_ARGS];
+        int option;
+        int token;
+        char *p;
+
+        opts->mode = DEBUGFS_DEFAULT_MODE;
+
+        while ((p = strsep(&data, ",")) != NULL) {
+                if (!*p)
+                        continue;
+
+                token = match_token(p, tokens, args);
+                switch (token) {
+                case Opt_uid:
+                        if (match_int(&args[0], &option))
+                                return -EINVAL;
+                        opts->uid = option;
+                        break;
+                case Opt_gid:
+                        if (match_octal(&args[0], &option))
+                                return -EINVAL;
+                        opts->gid = option;
+                        break;
+                case Opt_mode:
+                        if (match_octal(&args[0], &option))
+                                return -EINVAL;
+                        opts->mode = option & S_IALLUGO;
+                        break;
+                /*
+                 * We might like to report bad mount options here;
+                 * but traditionally debugfs has ignored all mount options
+                 */
+                }
+        }
+
+        return 0;
+}
+
+static int debugfs_apply_options(struct super_block *sb)
+{
+        struct debugfs_fs_info *fsi = sb->s_fs_info;
+        struct inode *inode = sb->s_root->d_inode;
+        struct debugfs_mount_opts *opts = &fsi->mount_opts;
+
+        inode->i_mode &= ~S_IALLUGO;
+        inode->i_mode |= opts->mode;
+
+        inode->i_uid = opts->uid;
+        inode->i_gid = opts->gid;
+
+        return 0;
+}
+
+static int debugfs_remount(struct super_block *sb, int *flags, char *data)
+{
+        int err;
+        struct debugfs_fs_info *fsi = sb->s_fs_info;
+
+        err = debugfs_parse_options(data, &fsi->mount_opts);
+        if (err)
+                goto fail;
+
+        debugfs_apply_options(sb);
+
+fail:
+        return err;
+}
+
+static int debugfs_show_options(struct seq_file *m, struct dentry *root)
+{
+        struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
+        struct debugfs_mount_opts *opts = &fsi->mount_opts;
+
+        if (opts->uid != 0)
+                seq_printf(m, ",uid=%u", opts->uid);
+        if (opts->gid != 0)
+                seq_printf(m, ",gid=%u", opts->gid);
+        if (opts->mode != DEBUGFS_DEFAULT_MODE)
+                seq_printf(m, ",mode=%o", opts->mode);
+
+        return 0;
+}
+
+static const struct super_operations debugfs_super_operations = {
+        .statfs         = simple_statfs,
+        .remount_fs     = debugfs_remount,
+        .show_options   = debugfs_show_options,
+};
+
 static int debug_fill_super(struct super_block *sb, void *data, int silent)
 {
         static struct tree_descr debug_files[] = {{""}};
+        struct debugfs_fs_info *fsi;
+        int err;
+
+        save_mount_options(sb, data);
+
+        fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
+        sb->s_fs_info = fsi;
+        if (!fsi) {
+                err = -ENOMEM;
+                goto fail;
+        }
+
+        err = debugfs_parse_options(data, &fsi->mount_opts);
+        if (err)
+                goto fail;
+
+        err  =  simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
+        if (err)
+                goto fail;
+
+        sb->s_op = &debugfs_super_operations;
+
+        debugfs_apply_options(sb);
+
+        return 0;
 
-        return simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
+fail:
+        kfree(fsi);
+        sb->s_fs_info = NULL;
+        return err;
 }
 
 static struct dentry *debug_mount(struct file_system_type *fs_type,
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 7fdf6a7b7436..2a7a3f5d1ca6 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -22,76 +22,103 @@
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <linux/security.h>
+#include <linux/hash.h>
 #include "sysfs.h"
 
 DEFINE_MUTEX(sysfs_mutex);
 DEFINE_SPINLOCK(sysfs_assoc_lock);
 
+#define to_sysfs_dirent(X) rb_entry((X), struct sysfs_dirent, s_rb);
+
 static DEFINE_SPINLOCK(sysfs_ino_lock);
 static DEFINE_IDA(sysfs_ino_ida);
 
 /**
- *      sysfs_link_sibling - link sysfs_dirent into sibling list
+ *      sysfs_name_hash
+ *      @ns:   Namespace tag to hash
+ *      @name: Null terminated string to hash
+ *
+ *      Returns 31 bit hash of ns + name (so it fits in an off_t )
+ */
+static unsigned int sysfs_name_hash(const void *ns, const char *name)
+{
+        unsigned long hash = init_name_hash();
+        unsigned int len = strlen(name);
+        while (len--)
+                hash = partial_name_hash(*name++, hash);
+        hash = ( end_name_hash(hash) ^ hash_ptr( (void *)ns, 31 ) );
+        hash &= 0x7fffffffU;
+        /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
+        if (hash < 1)
+                hash += 2;
+        if (hash >= INT_MAX)
+                hash = INT_MAX - 1;
+        return hash;
+}
+
+static int sysfs_name_compare(unsigned int hash, const void *ns,
+        const char *name, const struct sysfs_dirent *sd)
+{
+        if (hash != sd->s_hash)
+                return hash - sd->s_hash;
+        if (ns != sd->s_ns)
+                return ns - sd->s_ns;
+        return strcmp(name, sd->s_name);
+}
+
+static int sysfs_sd_compare(const struct sysfs_dirent *left,
+                            const struct sysfs_dirent *right)
+{
+        return sysfs_name_compare(left->s_hash, left->s_ns, left->s_name,
+                                  right);
+}
+
+/**
+ *      sysfs_link_subling - link sysfs_dirent into sibling rbtree
  *      @sd: sysfs_dirent of interest
  *
- *      Link @sd into its sibling list which starts from
+ *      Link @sd into its sibling rbtree which starts from
  *      sd->s_parent->s_dir.children.
  *
  *      Locking:
  *      mutex_lock(sysfs_mutex)
+ *
+ *      RETURNS:
+ *      0 on susccess -EEXIST on failure.
  */
-static void sysfs_link_sibling(struct sysfs_dirent *sd)
+static int sysfs_link_sibling(struct sysfs_dirent *sd)
 {
-        struct sysfs_dirent *parent_sd = sd->s_parent;
-
-        struct rb_node **p;
-        struct rb_node *parent;
+        struct rb_node **node = &sd->s_parent->s_dir.children.rb_node;
+        struct rb_node *parent = NULL;
 
         if (sysfs_type(sd) == SYSFS_DIR)
-                parent_sd->s_dir.subdirs++;
-
-        p = &parent_sd->s_dir.inode_tree.rb_node;
-        parent = NULL;
-        while (*p) {
-                parent = *p;
-#define node    rb_entry(parent, struct sysfs_dirent, inode_node)
-                if (sd->s_ino < node->s_ino) {
-                        p = &node->inode_node.rb_left;
-                } else if (sd->s_ino > node->s_ino) {
-                        p = &node->inode_node.rb_right;
-                } else {
-                        printk(KERN_CRIT "sysfs: inserting duplicate inode '%lx'\n",
-                               (unsigned long) sd->s_ino);
-                        BUG();
-                }
-#undef node
-        }
-        rb_link_node(&sd->inode_node, parent, p);
-        rb_insert_color(&sd->inode_node, &parent_sd->s_dir.inode_tree);
-
-        p = &parent_sd->s_dir.name_tree.rb_node;
-        parent = NULL;
-        while (*p) {
-                int c;
-                parent = *p;
-#define node    rb_entry(parent, struct sysfs_dirent, name_node)
-                c = strcmp(sd->s_name, node->s_name);
-                if (c < 0) {
-                        p = &node->name_node.rb_left;
-                } else {
-                        p = &node->name_node.rb_right;
-                }
-#undef node
+                sd->s_parent->s_dir.subdirs++;
+
+        while (*node) {
+                struct sysfs_dirent *pos;
+                int result;
+
+                pos = to_sysfs_dirent(*node);
+                parent = *node;
+                result = sysfs_sd_compare(sd, pos);
+                if (result < 0)
+                        node = &pos->s_rb.rb_left;
+                else if (result > 0)
+                        node = &pos->s_rb.rb_right;
+                else
+                        return -EEXIST;
         }
-        rb_link_node(&sd->name_node, parent, p);
-        rb_insert_color(&sd->name_node, &parent_sd->s_dir.name_tree);
+        /* add new node and rebalance the tree */
+        rb_link_node(&sd->s_rb, parent, node);
+        rb_insert_color(&sd->s_rb, &sd->s_parent->s_dir.children);
+        return 0;
 }
 
 /**
- *      sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
+ *      sysfs_unlink_sibling - unlink sysfs_dirent from sibling rbtree
  *      @sd: sysfs_dirent of interest
  *
- *      Unlink @sd from its sibling list which starts from
+ *      Unlink @sd from its sibling rbtree which starts from
  *      sd->s_parent->s_dir.children.
  *
  *      Locking:
@@ -102,8 +129,7 @@ static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
         if (sysfs_type(sd) == SYSFS_DIR)
                 sd->s_parent->s_dir.subdirs--;
 
-        rb_erase(&sd->inode_node, &sd->s_parent->s_dir.inode_tree);
-        rb_erase(&sd->name_node, &sd->s_parent->s_dir.name_tree);
+        rb_erase(&sd->s_rb, &sd->s_parent->s_dir.children);
 }
 
 /**
@@ -198,7 +224,7 @@ static void sysfs_deactivate(struct sysfs_dirent *sd)
         rwsem_release(&sd->dep_map, 1, _RET_IP_);
 }
 
-static int sysfs_alloc_ino(ino_t *pino)
+static int sysfs_alloc_ino(unsigned int *pino)
 {
         int ino, rc;
 
@@ -217,7 +243,7 @@ static int sysfs_alloc_ino(ino_t *pino)
         return rc;
 }
 
-static void sysfs_free_ino(ino_t ino)
+static void sysfs_free_ino(unsigned int ino)
 {
         spin_lock(&sysfs_ino_lock);
         ida_remove(&sysfs_ino_ida, ino);
@@ -402,6 +428,7 @@ void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
 int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
 {
         struct sysfs_inode_attrs *ps_iattr;
+        int ret;
 
         if (!!sysfs_ns_type(acxt->parent_sd) != !!sd->s_ns) {
                 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
@@ -410,12 +437,12 @@ int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
                 return -EINVAL;
         }
 
-        if (sysfs_find_dirent(acxt->parent_sd, sd->s_ns, sd->s_name))
-                return -EEXIST;
-
+        sd->s_hash = sysfs_name_hash(sd->s_ns, sd->s_name);
         sd->s_parent = sysfs_get(acxt->parent_sd);
 
-        sysfs_link_sibling(sd);
+        ret = sysfs_link_sibling(sd);
+        if (ret)
+                return ret;
 
         /* Update timestamps on the parent */
         ps_iattr = acxt->parent_sd->s_iattr;
@@ -565,8 +592,8 @@ struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
                                        const void *ns,
                                        const unsigned char *name)
 {
-        struct rb_node *p = parent_sd->s_dir.name_tree.rb_node;
-        struct sysfs_dirent *found = NULL;
+        struct rb_node *node = parent_sd->s_dir.children.rb_node;
+        unsigned int hash;
 
         if (!!sysfs_ns_type(parent_sd) != !!ns) {
                 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
@@ -575,33 +602,21 @@ struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
                 return NULL;
         }
 
-        while (p) {
-                int c;
-#define node    rb_entry(p, struct sysfs_dirent, name_node)
-                c = strcmp(name, node->s_name);
-                if (c < 0) {
-                        p = node->name_node.rb_left;
-                } else if (c > 0) {
-                        p = node->name_node.rb_right;
-                } else {
-                        found = node;
-                        p = node->name_node.rb_left;
-                }
-#undef node
-        }
-
-        if (found) {
-                while (found->s_ns != ns) {
-                        p = rb_next(&found->name_node);
-                        if (!p)
-                                return NULL;
-                        found = rb_entry(p, struct sysfs_dirent, name_node);
-                        if (strcmp(name, found->s_name))
-                                return NULL;
-                }
+        hash = sysfs_name_hash(ns, name);
+        while (node) {
+                struct sysfs_dirent *sd;
+                int result;
+
+                sd = to_sysfs_dirent(node);
+                result = sysfs_name_compare(hash, ns, name, sd);
+                if (result < 0)
+                        node = node->rb_left;
+                else if (result > 0)
+                        node = node->rb_right;
+                else
+                        return sd;
         }
-
-        return found;
+        return NULL;
 }
 
 /**
@@ -804,9 +819,9 @@ static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
 
         pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
         sysfs_addrm_start(&acxt, dir_sd);
-        pos = rb_first(&dir_sd->s_dir.inode_tree);
+        pos = rb_first(&dir_sd->s_dir.children);
         while (pos) {
-                struct sysfs_dirent *sd = rb_entry(pos, struct sysfs_dirent, inode_node);
+                struct sysfs_dirent *sd = to_sysfs_dirent(pos);
                 pos = rb_next(pos);
                 if (sysfs_type(sd) != SYSFS_DIR)
                         sysfs_remove_one(&acxt, sd);
@@ -863,6 +878,7 @@ int sysfs_rename(struct sysfs_dirent *sd,
 
                 dup_name = sd->s_name;
                 sd->s_name = new_name;
+                sd->s_hash = sysfs_name_hash(sd->s_ns, sd->s_name);
         }
 
         /* Move to the appropriate place in the appropriate directories rbtree. */
@@ -919,38 +935,36 @@ static int sysfs_dir_release(struct inode *inode, struct file *filp)
 }
 
 static struct sysfs_dirent *sysfs_dir_pos(const void *ns,
-        struct sysfs_dirent *parent_sd, ino_t ino, struct sysfs_dirent *pos)
+        struct sysfs_dirent *parent_sd, loff_t hash, struct sysfs_dirent *pos)
 {
         if (pos) {
                 int valid = !(pos->s_flags & SYSFS_FLAG_REMOVED) &&
                         pos->s_parent == parent_sd &&
-                        ino == pos->s_ino;
+                        hash == pos->s_hash;
                 sysfs_put(pos);
                 if (!valid)
                         pos = NULL;
         }
-        if (!pos && (ino > 1) && (ino < INT_MAX)) {
-                struct rb_node *p = parent_sd->s_dir.inode_tree.rb_node;
-                while (p) {
-#define node    rb_entry(p, struct sysfs_dirent, inode_node)
-                        if (ino < node->s_ino) {
-                                pos = node;
-                                p = node->inode_node.rb_left;
-                        } else if (ino > node->s_ino) {
-                                p = node->inode_node.rb_right;
-                        } else {
-                                pos = node;
+        if (!pos && (hash > 1) && (hash < INT_MAX)) {
+                struct rb_node *node = parent_sd->s_dir.children.rb_node;
+                while (node) {
+                        pos = to_sysfs_dirent(node);
+
+                        if (hash < pos->s_hash)
+                                node = node->rb_left;
+                        else if (hash > pos->s_hash)
+                                node = node->rb_right;
+                        else
                                 break;
-                        }
-#undef node
                 }
         }
+        /* Skip over entries in the wrong namespace */
         while (pos && pos->s_ns != ns) {
-                struct rb_node *p = rb_next(&pos->inode_node);
-                if (!p)
+                struct rb_node *node = rb_next(&pos->s_rb);
+                if (!node)
                         pos = NULL;
                 else
-                        pos = rb_entry(p, struct sysfs_dirent, inode_node);
+                        pos = to_sysfs_dirent(node);
         }
         return pos;
 }
@@ -960,11 +974,11 @@ static struct sysfs_dirent *sysfs_dir_next_pos(const void *ns,
 {
         pos = sysfs_dir_pos(ns, parent_sd, ino, pos);
         if (pos) do {
-                struct rb_node *p = rb_next(&pos->inode_node);
-                if (!p)
+                struct rb_node *node = rb_next(&pos->s_rb);
+                if (!node)
                         pos = NULL;
                 else
-                        pos = rb_entry(p, struct sysfs_dirent, inode_node);
+                        pos = to_sysfs_dirent(node);
         } while (pos && pos->s_ns != ns);
         return pos;
 }
@@ -1006,7 +1020,7 @@ static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
                 len = strlen(name);
                 ino = pos->s_ino;
                 type = dt_type(pos);
-                filp->f_pos = ino;
+                filp->f_pos = pos->s_hash;
                 filp->private_data = sysfs_get(pos);
 
                 mutex_unlock(&sysfs_mutex);
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index 85eb81683a29..feb2d69396cf 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -136,12 +136,13 @@ static int sysfs_sd_setsecdata(struct sysfs_dirent *sd, void **secdata, u32 *sec
         void *old_secdata;
         size_t old_secdata_len;
 
-        iattrs = sd->s_iattr;
-        if (!iattrs)
-                iattrs = sysfs_init_inode_attrs(sd);
-        if (!iattrs)
-                return -ENOMEM;
+        if (!sd->s_iattr) {
+                sd->s_iattr = sysfs_init_inode_attrs(sd);
+                if (!sd->s_iattr)
+                        return -ENOMEM;
+        }
 
+        iattrs = sd->s_iattr;
         old_secdata = iattrs->ia_secdata;
         old_secdata_len = iattrs->ia_secdata_len;
 
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index e34f0d99ea4e..140f26a34288 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -36,7 +36,7 @@ struct sysfs_dirent sysfs_root = {
         .s_name         = "",
         .s_count        = ATOMIC_INIT(1),
         .s_flags        = SYSFS_DIR | (KOBJ_NS_TYPE_NONE << SYSFS_NS_TYPE_SHIFT),
-        .s_mode         = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
+        .s_mode         = S_IFDIR | S_IRUGO | S_IXUGO,
         .s_ino          = 1,
 };
 
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index 7484a36ee678..661a9639570b 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -20,9 +20,8 @@ struct sysfs_elem_dir {
         struct kobject          *kobj;
 
         unsigned long           subdirs;
-
-        struct rb_root          inode_tree;
-        struct rb_root          name_tree;
+        /* children rbtree starts here and goes through sd->s_rb */
+        struct rb_root          children;
 };
 
 struct sysfs_elem_symlink {
@@ -62,8 +61,7 @@ struct sysfs_dirent {
         struct sysfs_dirent     *s_parent;
         const char              *s_name;
 
-        struct rb_node          inode_node;
-        struct rb_node          name_node;
+        struct rb_node          s_rb;
 
         union {
                 struct completion       *completion;
@@ -71,6 +69,7 @@ struct sysfs_dirent {
         } u;
 
         const void              *s_ns; /* namespace tag */
+        unsigned int            s_hash; /* ns + name hash */
         union {
                 struct sysfs_elem_dir           s_dir;
                 struct sysfs_elem_symlink       s_symlink;
@@ -78,9 +77,9 @@ struct sysfs_dirent {
                 struct sysfs_elem_bin_attr      s_bin_attr;
         };
 
-        unsigned int            s_flags;
+        unsigned short          s_flags;
         umode_t                 s_mode;
-        ino_t                   s_ino;
+        unsigned int            s_ino;
         struct sysfs_inode_attrs *s_iattr;
 };
 
@@ -95,11 +94,11 @@ struct sysfs_dirent {
 #define SYSFS_ACTIVE_REF                (SYSFS_KOBJ_ATTR | SYSFS_KOBJ_BIN_ATTR)
 
 /* identify any namespace tag on sysfs_dirents */
-#define SYSFS_NS_TYPE_MASK              0xff00
+#define SYSFS_NS_TYPE_MASK              0xf00
 #define SYSFS_NS_TYPE_SHIFT             8
 
 #define SYSFS_FLAG_MASK                 ~(SYSFS_NS_TYPE_MASK|SYSFS_TYPE_MASK)
-#define SYSFS_FLAG_REMOVED              0x020000
+#define SYSFS_FLAG_REMOVED              0x02000
 
 static inline unsigned int sysfs_type(struct sysfs_dirent *sd)
 {