10 files changed, 196 insertions, 37 deletions

diff --git a/fs/proc/array.c b/fs/proc/array.c
index 7eb1bd7f800c..7a76ad570230 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -330,7 +330,6 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
         unsigned long  min_flt = 0,  maj_flt = 0;
         cputime_t cutime, cstime, utime, stime;
         unsigned long rsslim = 0;
-        DEFINE_KTIME(it_real_value);
         struct task_struct *t;
         char tcomm[sizeof(task->comm)];
 
@@ -386,7 +385,6 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
                         utime = cputime_add(utime, task->signal->utime);
                         stime = cputime_add(stime, task->signal->stime);
                 }
-                it_real_value = task->signal->real_timer.expires;
         }
         ppid = pid_alive(task) ? task->group_leader->real_parent->tgid : 0;
         read_unlock(&tasklist_lock);
@@ -413,7 +411,7 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
         start_time = nsec_to_clock_t(start_time);
 
         res = sprintf(buffer,"%d (%s) %c %d %d %d %d %d %lu %lu \
-%lu %lu %lu %lu %lu %ld %ld %ld %ld %d %ld %llu %lu %ld %lu %lu %lu %lu %lu \
+%lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
 %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %lu\n",
                 task->pid,
                 tcomm,
@@ -435,7 +433,6 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
                 priority,
                 nice,
                 num_threads,
-                (long) ktime_to_clock_t(it_real_value),
                 start_time,
                 vsize,
                 mm ? get_mm_rss(mm) : 0,
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 20feb7568deb..8f1f49ceebec 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -104,6 +104,7 @@ enum pid_directory_inos {
         PROC_TGID_MAPS,
         PROC_TGID_NUMA_MAPS,
         PROC_TGID_MOUNTS,
+        PROC_TGID_MOUNTSTATS,
         PROC_TGID_WCHAN,
 #ifdef CONFIG_MMU
         PROC_TGID_SMAPS,
@@ -144,6 +145,7 @@ enum pid_directory_inos {
         PROC_TID_MAPS,
         PROC_TID_NUMA_MAPS,
         PROC_TID_MOUNTS,
+        PROC_TID_MOUNTSTATS,
         PROC_TID_WCHAN,
 #ifdef CONFIG_MMU
         PROC_TID_SMAPS,
@@ -201,6 +203,7 @@ static struct pid_entry tgid_base_stuff[] = {
         E(PROC_TGID_ROOT,      "root",    S_IFLNK|S_IRWXUGO),
         E(PROC_TGID_EXE,       "exe",     S_IFLNK|S_IRWXUGO),
         E(PROC_TGID_MOUNTS,    "mounts",  S_IFREG|S_IRUGO),
+        E(PROC_TGID_MOUNTSTATS, "mountstats", S_IFREG|S_IRUSR),
 #ifdef CONFIG_MMU
         E(PROC_TGID_SMAPS,     "smaps",   S_IFREG|S_IRUGO),
 #endif
@@ -732,6 +735,38 @@ static struct file_operations proc_mounts_operations = {
         .poll           = mounts_poll,
 };
 
+extern struct seq_operations mountstats_op;
+static int mountstats_open(struct inode *inode, struct file *file)
+{
+        struct task_struct *task = proc_task(inode);
+        int ret = seq_open(file, &mountstats_op);
+
+        if (!ret) {
+                struct seq_file *m = file->private_data;
+                struct namespace *namespace;
+                task_lock(task);
+                namespace = task->namespace;
+                if (namespace)
+                        get_namespace(namespace);
+                task_unlock(task);
+
+                if (namespace)
+                        m->private = namespace;
+                else {
+                        seq_release(inode, file);
+                        ret = -EINVAL;
+                }
+        }
+        return ret;
+}
+
+static struct file_operations proc_mountstats_operations = {
+        .open           = mountstats_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = mounts_release,
+};
+
 #define PROC_BLOCK_SIZE (3*1024)                /* 4K page size but our output routines use some slack for overruns */
 
 static ssize_t proc_info_read(struct file * file, char __user * buf,
@@ -1730,6 +1765,10 @@ static struct dentry *proc_pident_lookup(struct inode *dir,
                         inode->i_fop = &proc_smaps_operations;
                         break;
 #endif
+                case PROC_TID_MOUNTSTATS:
+                case PROC_TGID_MOUNTSTATS:
+                        inode->i_fop = &proc_mountstats_operations;
+                        break;
 #ifdef CONFIG_SECURITY
                 case PROC_TID_ATTR:
                         inode->i_nlink = 2;
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 20e5c4509a43..4ba03009cf72 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -19,6 +19,7 @@
 #include <linux/idr.h>
 #include <linux/namei.h>
 #include <linux/bitops.h>
+#include <linux/spinlock.h>
 #include <asm/uaccess.h>
 
 #include "internal.h"
@@ -29,6 +30,8 @@ static ssize_t proc_file_write(struct file *file, const char __user *buffer,
                                size_t count, loff_t *ppos);
 static loff_t proc_file_lseek(struct file *, loff_t, int);
 
+DEFINE_SPINLOCK(proc_subdir_lock);
+
 int proc_match(int len, const char *name, struct proc_dir_entry *de)
 {
         if (de->namelen != len)
@@ -277,7 +280,9 @@ static int xlate_proc_name(const char *name,
         const char              *cp = name, *next;
         struct proc_dir_entry   *de;
         int                     len;
+        int                     rtn = 0;
 
+        spin_lock(&proc_subdir_lock);
         de = &proc_root;
         while (1) {
                 next = strchr(cp, '/');
@@ -289,13 +294,17 @@ static int xlate_proc_name(const char *name,
                         if (proc_match(len, cp, de))
                                 break;
                 }
-                if (!de)
-                        return -ENOENT;
+                if (!de) {
+                        rtn = -ENOENT;
+                        goto out;
+                }
                 cp += len + 1;
         }
         *residual = cp;
         *ret = de;
-        return 0;
+out:
+        spin_unlock(&proc_subdir_lock);
+        return rtn;
 }
 
 static DEFINE_IDR(proc_inum_idr);
@@ -380,6 +389,7 @@ struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nam
         int error = -ENOENT;
 
         lock_kernel();
+        spin_lock(&proc_subdir_lock);
         de = PDE(dir);
         if (de) {
                 for (de = de->subdir; de ; de = de->next) {
@@ -388,12 +398,15 @@ struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nam
                         if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
                                 unsigned int ino = de->low_ino;
 
+                                spin_unlock(&proc_subdir_lock);
                                 error = -EINVAL;
                                 inode = proc_get_inode(dir->i_sb, ino, de);
+                                spin_lock(&proc_subdir_lock);
                                 break;
                         }
                 }
         }
+        spin_unlock(&proc_subdir_lock);
         unlock_kernel();
 
         if (inode) {
@@ -447,11 +460,13 @@ int proc_readdir(struct file * filp,
                         filp->f_pos++;
                         /* fall through */
                 default:
+                        spin_lock(&proc_subdir_lock);
                         de = de->subdir;
                         i -= 2;
                         for (;;) {
                                 if (!de) {
                                         ret = 1;
+                                        spin_unlock(&proc_subdir_lock);
                                         goto out;
                                 }
                                 if (!i)
@@ -461,12 +476,16 @@ int proc_readdir(struct file * filp,
                         }
 
                         do {
+                                /* filldir passes info to user space */
+                                spin_unlock(&proc_subdir_lock);
                                 if (filldir(dirent, de->name, de->namelen, filp->f_pos,
                                             de->low_ino, de->mode >> 12) < 0)
                                         goto out;
+                                spin_lock(&proc_subdir_lock);
                                 filp->f_pos++;
                                 de = de->next;
                         } while (de);
+                        spin_unlock(&proc_subdir_lock);
         }
         ret = 1;
 out:    unlock_kernel();
@@ -500,9 +519,13 @@ static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp
         if (i == 0)
                 return -EAGAIN;
         dp->low_ino = i;
+
+        spin_lock(&proc_subdir_lock);
         dp->next = dir->subdir;
         dp->parent = dir;
         dir->subdir = dp;
+        spin_unlock(&proc_subdir_lock);
+
         if (S_ISDIR(dp->mode)) {
                 if (dp->proc_iops == NULL) {
                         dp->proc_fops = &proc_dir_operations;
@@ -537,7 +560,7 @@ static void proc_kill_inodes(struct proc_dir_entry *de)
                 struct file * filp = list_entry(p, struct file, f_u.fu_list);
                 struct dentry * dentry = filp->f_dentry;
                 struct inode * inode;
-                struct file_operations *fops;
+                const struct file_operations *fops;
 
                 if (dentry->d_op != &proc_dentry_operations)
                         continue;
@@ -694,6 +717,8 @@ void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
         if (!parent && xlate_proc_name(name, &parent, &fn) != 0)
                 goto out;
         len = strlen(fn);
+
+        spin_lock(&proc_subdir_lock);
         for (p = &parent->subdir; *p; p=&(*p)->next ) {
                 if (!proc_match(len, fn, *p))
                         continue;
@@ -714,6 +739,7 @@ void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
                 }
                 break;
         }
+        spin_unlock(&proc_subdir_lock);
 out:
         return;
 }
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 075d3e945602..722b9c463111 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -121,7 +121,8 @@ int __init proc_init_inodecache(void)
 {
         proc_inode_cachep = kmem_cache_create("proc_inode_cache",
                                              sizeof(struct proc_inode),
-                                             0, SLAB_RECLAIM_ACCOUNT,
+                                             0, (SLAB_RECLAIM_ACCOUNT|
+                                                SLAB_MEM_SPREAD),
                                              init_once, NULL);
         if (proc_inode_cachep == NULL)
                 return -ENOMEM;
diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index 95a1cf32b838..0502f17b860d 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -30,7 +30,7 @@ do {						\
 
 #endif
 
-extern void create_seq_entry(char *name, mode_t mode, struct file_operations *f);
+extern void create_seq_entry(char *name, mode_t mode, const struct file_operations *f);
 extern int proc_exe_link(struct inode *, struct dentry **, struct vfsmount **);
 extern int proc_tid_stat(struct task_struct *,  char *);
 extern int proc_tgid_stat(struct task_struct *, char *);
diff --git a/fs/proc/kcore.c b/fs/proc/kcore.c
index adc2cd95169a..17f6e8fa1397 100644
--- a/fs/proc/kcore.c
+++ b/fs/proc/kcore.c
@@ -31,7 +31,7 @@ static int open_kcore(struct inode * inode, struct file * filp)
 
 static ssize_t read_kcore(struct file *, char __user *, size_t, loff_t *);
 
-struct file_operations proc_kcore_operations = {
+const struct file_operations proc_kcore_operations = {
         .read           = read_kcore,
         .open           = open_kcore,
 };
diff --git a/fs/proc/kmsg.c b/fs/proc/kmsg.c
index 10d37bf25206..ff3b90b56e9d 100644
--- a/fs/proc/kmsg.c
+++ b/fs/proc/kmsg.c
@@ -47,7 +47,7 @@ static unsigned int kmsg_poll(struct file *file, poll_table *wait)
 }
 
 
-struct file_operations proc_kmsg_operations = {
+const struct file_operations proc_kmsg_operations = {
         .read           = kmsg_read,
         .poll           = kmsg_poll,
         .open           = kmsg_open,
diff --git a/fs/proc/proc_devtree.c b/fs/proc/proc_devtree.c
index 9bdd077d6f55..abdf068bc27f 100644
--- a/fs/proc/proc_devtree.c
+++ b/fs/proc/proc_devtree.c
@@ -52,7 +52,8 @@ static int property_read_proc(char *page, char **start, off_t off,
  * Add a property to a node
  */
 static struct proc_dir_entry *
-__proc_device_tree_add_prop(struct proc_dir_entry *de, struct property *pp)
+__proc_device_tree_add_prop(struct proc_dir_entry *de, struct property *pp,
+                const char *name)
 {
         struct proc_dir_entry *ent;
 
@@ -60,14 +61,14 @@ __proc_device_tree_add_prop(struct proc_dir_entry *de, struct property *pp)
          * Unfortunately proc_register puts each new entry
          * at the beginning of the list.  So we rearrange them.
          */
-        ent = create_proc_read_entry(pp->name,
-                                     strncmp(pp->name, "security-", 9)
+        ent = create_proc_read_entry(name,
+                                     strncmp(name, "security-", 9)
                                      ? S_IRUGO : S_IRUSR, de,
                                      property_read_proc, pp);
         if (ent == NULL)
                 return NULL;
 
-        if (!strncmp(pp->name, "security-", 9))
+        if (!strncmp(name, "security-", 9))
                 ent->size = 0; /* don't leak number of password chars */
         else
                 ent->size = pp->length;
@@ -78,7 +79,7 @@ __proc_device_tree_add_prop(struct proc_dir_entry *de, struct property *pp)
 
 void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop)
 {
-        __proc_device_tree_add_prop(pde, prop);
+        __proc_device_tree_add_prop(pde, prop, prop->name);
 }
 
 void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
@@ -106,6 +107,69 @@ void proc_device_tree_update_prop(struct proc_dir_entry *pde,
 }
 
 /*
+ * Various dodgy firmware might give us nodes and/or properties with
+ * conflicting names. That's generally ok, except for exporting via /proc,
+ * so munge names here to ensure they're unique.
+ */
+
+static int duplicate_name(struct proc_dir_entry *de, const char *name)
+{
+        struct proc_dir_entry *ent;
+        int found = 0;
+
+        spin_lock(&proc_subdir_lock);
+
+        for (ent = de->subdir; ent != NULL; ent = ent->next) {
+                if (strcmp(ent->name, name) == 0) {
+                        found = 1;
+                        break;
+                }
+        }
+
+        spin_unlock(&proc_subdir_lock);
+
+        return found;
+}
+
+static const char *fixup_name(struct device_node *np, struct proc_dir_entry *de,
+                const char *name)
+{
+        char *fixed_name;
+        int fixup_len = strlen(name) + 2 + 1; /* name + #x + \0 */
+        int i = 1, size;
+
+realloc:
+        fixed_name = kmalloc(fixup_len, GFP_KERNEL);
+        if (fixed_name == NULL) {
+                printk(KERN_ERR "device-tree: Out of memory trying to fixup "
+                                "name \"%s\"\n", name);
+                return name;
+        }
+
+retry:
+        size = snprintf(fixed_name, fixup_len, "%s#%d", name, i);
+        size++; /* account for NULL */
+
+        if (size > fixup_len) {
+                /* We ran out of space, free and reallocate. */
+                kfree(fixed_name);
+                fixup_len = size;
+                goto realloc;
+        }
+
+        if (duplicate_name(de, fixed_name)) {
+                /* Multiple duplicates. Retry with a different offset. */
+                i++;
+                goto retry;
+        }
+
+        printk(KERN_WARNING "device-tree: Duplicate name in %s, "
+                        "renamed to \"%s\"\n", np->full_name, fixed_name);
+
+        return fixed_name;
+}
+
+/*
  * Process a node, adding entries for its children and its properties.
  */
 void proc_device_tree_add_node(struct device_node *np,
@@ -118,35 +182,30 @@ void proc_device_tree_add_node(struct device_node *np,
 
         set_node_proc_entry(np, de);
         for (child = NULL; (child = of_get_next_child(np, child));) {
+                /* Use everything after the last slash, or the full name */
                 p = strrchr(child->full_name, '/');
                 if (!p)
                         p = child->full_name;
                 else
                         ++p;
+
+                if (duplicate_name(de, p))
+                        p = fixup_name(np, de, p);
+
                 ent = proc_mkdir(p, de);
                 if (ent == 0)
                         break;
                 proc_device_tree_add_node(child, ent);
         }
         of_node_put(child);
+
         for (pp = np->properties; pp != 0; pp = pp->next) {
-                /*
-                 * Yet another Apple device-tree bogosity: on some machines,
-                 * they have properties & nodes with the same name. Those
-                 * properties are quite unimportant for us though, thus we
-                 * simply "skip" them here, but we do have to check.
-                 */
-                for (ent = de->subdir; ent != NULL; ent = ent->next)
-                        if (!strcmp(ent->name, pp->name))
-                                break;
-                if (ent != NULL) {
-                        printk(KERN_WARNING "device-tree: property \"%s\" name"
-                               " conflicts with node in %s\n", pp->name,
-                               np->full_name);
-                        continue;
-                }
+                p = pp->name;
+
+                if (duplicate_name(de, p))
+                        p = fixup_name(np, de, p);
 
-                ent = __proc_device_tree_add_prop(de, pp);
+                ent = __proc_device_tree_add_prop(de, pp, p);
                 if (ent == 0)
                         break;
         }
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 1d24fead51a6..ef5a3323f4b5 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -312,7 +312,7 @@ static void *devinfo_next(struct seq_file *f, void *v, loff_t *pos)
                 case BLK_HDR:
                         info->state = BLK_LIST;
                         (*pos)++;
-                        break;
+                        /*fallthrough*/
                 case BLK_LIST:
                         if (get_blkdev_info(info->blkdev,&idummy,&ndummy)) {
                                 /*
@@ -485,6 +485,40 @@ static struct file_operations proc_slabinfo_operations = {
         .llseek         = seq_lseek,
         .release        = seq_release,
 };
+
+#ifdef CONFIG_DEBUG_SLAB_LEAK
+extern struct seq_operations slabstats_op;
+static int slabstats_open(struct inode *inode, struct file *file)
+{
+        unsigned long *n = kzalloc(PAGE_SIZE, GFP_KERNEL);
+        int ret = -ENOMEM;
+        if (n) {
+                ret = seq_open(file, &slabstats_op);
+                if (!ret) {
+                        struct seq_file *m = file->private_data;
+                        *n = PAGE_SIZE / (2 * sizeof(unsigned long));
+                        m->private = n;
+                        n = NULL;
+                }
+                kfree(n);
+        }
+        return ret;
+}
+
+static int slabstats_release(struct inode *inode, struct file *file)
+{
+        struct seq_file *m = file->private_data;
+        kfree(m->private);
+        return seq_release(inode, file);
+}
+
+static struct file_operations proc_slabstats_operations = {
+        .open           = slabstats_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = slabstats_release,
+};
+#endif
 #endif
 
 static int show_stat(struct seq_file *p, void *v)
@@ -500,7 +534,7 @@ static int show_stat(struct seq_file *p, void *v)
         if (wall_to_monotonic.tv_nsec)
                 --jif;
 
-        for_each_cpu(i) {
+        for_each_possible_cpu(i) {
                 int j;
 
                 user = cputime64_add(user, kstat_cpu(i).cpustat.user);
@@ -697,7 +731,7 @@ static struct file_operations proc_sysrq_trigger_operations = {
 
 struct proc_dir_entry *proc_root_kcore;
 
-void create_seq_entry(char *name, mode_t mode, struct file_operations *f)
+void create_seq_entry(char *name, mode_t mode, const struct file_operations *f)
 {
         struct proc_dir_entry *entry;
         entry = create_proc_entry(name, mode, NULL);
@@ -744,6 +778,9 @@ void __init proc_misc_init(void)
         create_seq_entry("interrupts", 0, &proc_interrupts_operations);
 #ifdef CONFIG_SLAB
         create_seq_entry("slabinfo",S_IWUSR|S_IRUGO,&proc_slabinfo_operations);
+#ifdef CONFIG_DEBUG_SLAB_LEAK
+        create_seq_entry("slab_allocators", 0 ,&proc_slabstats_operations);
+#endif
 #endif
         create_seq_entry("buddyinfo",S_IRUGO, &fragmentation_file_operations);
         create_seq_entry("vmstat",S_IRUGO, &proc_vmstat_file_operations);
diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index 4063fb32f78c..7efa73d44c9a 100644
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
@@ -172,7 +172,7 @@ static int open_vmcore(struct inode *inode, struct file *filp)
         return 0;
 }
 
-struct file_operations proc_vmcore_operations = {
+const struct file_operations proc_vmcore_operations = {
         .read           = read_vmcore,
         .open           = open_vmcore,
 };