Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

6 files changed, 201 insertions, 79 deletions

diff --git a/fs/proc/base.c b/fs/proc/base.c
index 88f8edf18258..81d7d145292a 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -314,9 +314,12 @@ static int proc_pid_schedstat(struct task_struct *task, char *buffer)
 static int lstats_show_proc(struct seq_file *m, void *v)
 {
         int i;
-        struct task_struct *task = m->private;
-        seq_puts(m, "Latency Top version : v0.1\n");
+        struct inode *inode = m->private;
+        struct task_struct *task = get_proc_task(inode);
 
+        if (!task)
+                return -ESRCH;
+        seq_puts(m, "Latency Top version : v0.1\n");
         for (i = 0; i < 32; i++) {
                 if (task->latency_record[i].backtrace[0]) {
                         int q;
@@ -341,32 +344,24 @@ static int lstats_show_proc(struct seq_file *m, void *v)
                 }
 
         }
+        put_task_struct(task);
         return 0;
 }
 
 static int lstats_open(struct inode *inode, struct file *file)
 {
-        int ret;
-        struct seq_file *m;
-        struct task_struct *task = get_proc_task(inode);
-
-        ret = single_open(file, lstats_show_proc, NULL);
-        if (!ret) {
-                m = file->private_data;
-                m->private = task;
-        }
-        return ret;
+        return single_open(file, lstats_show_proc, inode);
 }
 
 static ssize_t lstats_write(struct file *file, const char __user *buf,
                             size_t count, loff_t *offs)
 {
-        struct seq_file *m;
-        struct task_struct *task;
+        struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
 
-        m = file->private_data;
-        task = m->private;
+        if (!task)
+                return -ESRCH;
         clear_all_latency_tracing(task);
+        put_task_struct(task);
 
         return count;
 }
@@ -416,6 +411,7 @@ static const struct limit_names lnames[RLIM_NLIMITS] = {
         [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
         [RLIMIT_NICE] = {"Max nice priority", NULL},
         [RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
+        [RLIMIT_RTTIME] = {"Max realtime timeout", "us"},
 };
 
 /* Display limits for a process */
@@ -1040,6 +1036,26 @@ static const struct file_operations proc_loginuid_operations = {
         .read           = proc_loginuid_read,
         .write          = proc_loginuid_write,
 };
+
+static ssize_t proc_sessionid_read(struct file * file, char __user * buf,
+                                  size_t count, loff_t *ppos)
+{
+        struct inode * inode = file->f_path.dentry->d_inode;
+        struct task_struct *task = get_proc_task(inode);
+        ssize_t length;
+        char tmpbuf[TMPBUFLEN];
+
+        if (!task)
+                return -ESRCH;
+        length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
+                                audit_get_sessionid(task));
+        put_task_struct(task);
+        return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
+}
+
+static const struct file_operations proc_sessionid_operations = {
+        .read           = proc_sessionid_read,
+};
 #endif
 
 #ifdef CONFIG_FAULT_INJECTION
@@ -2273,6 +2289,9 @@ static const struct pid_entry tgid_base_stuff[] = {
         DIR("task",       S_IRUGO|S_IXUGO, task),
         DIR("fd",         S_IRUSR|S_IXUSR, fd),
         DIR("fdinfo",     S_IRUSR|S_IXUSR, fdinfo),
+#ifdef CONFIG_NET
+        DIR("net",        S_IRUGO|S_IXUGO, net),
+#endif
         REG("environ",    S_IRUSR, environ),
         INF("auxv",       S_IRUSR, pid_auxv),
         ONE("status",     S_IRUGO, pid_status),
@@ -2320,6 +2339,7 @@ static const struct pid_entry tgid_base_stuff[] = {
         REG("oom_adj",    S_IRUGO|S_IWUSR, oom_adjust),
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",   S_IWUSR|S_IRUGO, loginuid),
+        REG("sessionid",  S_IRUSR, sessionid),
 #endif
 #ifdef CONFIG_FAULT_INJECTION
         REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
@@ -2650,6 +2670,7 @@ static const struct pid_entry tid_base_stuff[] = {
         REG("oom_adj",   S_IRUGO|S_IWUSR, oom_adjust),
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",  S_IWUSR|S_IRUGO, loginuid),
+        REG("sessionid",  S_IRUSR, sessionid),
 #endif
 #ifdef CONFIG_FAULT_INJECTION
         REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 68971e66cd41..a36ad3c75cf4 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -377,15 +377,14 @@ static struct dentry_operations proc_dentry_operations =
  * Don't create negative dentries here, return -ENOENT by hand
  * instead.
  */
-struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
+struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
+                struct dentry *dentry)
 {
         struct inode *inode = NULL;
-        struct proc_dir_entry * de;
         int error = -ENOENT;
 
         lock_kernel();
         spin_lock(&proc_subdir_lock);
-        de = PDE(dir);
         if (de) {
                 for (de = de->subdir; de ; de = de->next) {
                         if (de->namelen != dentry->d_name.len)
@@ -393,8 +392,6 @@ 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;
 
-                                if (de->shadow_proc)
-                                        de = de->shadow_proc(current, de);
                                 ino = de->low_ino;
                                 de_get(de);
                                 spin_unlock(&proc_subdir_lock);
@@ -417,6 +414,12 @@ out_unlock:
         return ERR_PTR(error);
 }
 
+struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
+                struct nameidata *nd)
+{
+        return proc_lookup_de(PDE(dir), dir, dentry);
+}
+
 /*
  * This returns non-zero if at EOF, so that the /proc
  * root directory can use this and check if it should
@@ -426,10 +429,9 @@ out_unlock:
  * value of the readdir() call, as long as it's non-negative
  * for success..
  */
-int proc_readdir(struct file * filp,
-        void * dirent, filldir_t filldir)
+int proc_readdir_de(struct proc_dir_entry *de, struct file *filp, void *dirent,
+                filldir_t filldir)
 {
-        struct proc_dir_entry * de;
         unsigned int ino;
         int i;
         struct inode *inode = filp->f_path.dentry->d_inode;
@@ -438,7 +440,6 @@ int proc_readdir(struct file * filp,
         lock_kernel();
 
         ino = inode->i_ino;
-        de = PDE(inode);
         if (!de) {
                 ret = -EINVAL;
                 goto out;
@@ -499,6 +500,13 @@ out:	unlock_kernel();
         return ret;     
 }
 
+int proc_readdir(struct file *filp, void *dirent, filldir_t filldir)
+{
+        struct inode *inode = filp->f_path.dentry->d_inode;
+
+        return proc_readdir_de(PDE(inode), filp, dirent, filldir);
+}
+
 /*
  * These are the generic /proc directory operations. They
  * use the in-memory "struct proc_dir_entry" tree to parse
diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index 1c81c8f1aeed..bc72f5c8c47d 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -64,6 +64,8 @@ extern const struct file_operations proc_numa_maps_operations;
 extern const struct file_operations proc_smaps_operations;
 extern const struct file_operations proc_clear_refs_operations;
 extern const struct file_operations proc_pagemap_operations;
+extern const struct file_operations proc_net_operations;
+extern const struct inode_operations proc_net_inode_operations;
 
 void free_proc_entry(struct proc_dir_entry *de);
 
@@ -83,3 +85,8 @@ static inline int proc_fd(struct inode *inode)
 {
         return PROC_I(inode)->fd;
 }
+
+struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *ino,
+                struct dentry *dentry);
+int proc_readdir_de(struct proc_dir_entry *de, struct file *filp, void *dirent,
+                filldir_t filldir);
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 468805d40e2b..2d563979cb02 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -32,6 +32,7 @@
 #include <linux/interrupt.h>
 #include <linux/swap.h>
 #include <linux/slab.h>
+#include <linux/genhd.h>
 #include <linux/smp.h>
 #include <linux/signal.h>
 #include <linux/module.h>
@@ -377,7 +378,6 @@ static int stram_read_proc(char *page, char **start, off_t off,
 #endif
 
 #ifdef CONFIG_BLOCK
-extern const struct seq_operations partitions_op;
 static int partitions_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &partitions_op);
@@ -389,7 +389,6 @@ static const struct file_operations proc_partitions_operations = {
         .release        = seq_release,
 };
 
-extern const struct seq_operations diskstats_op;
 static int diskstats_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &diskstats_op);
diff --git a/fs/proc/proc_net.c b/fs/proc/proc_net.c
index 14e9b5aaf863..13cd7835d0df 100644
--- a/fs/proc/proc_net.c
+++ b/fs/proc/proc_net.c
@@ -44,7 +44,9 @@ int seq_open_net(struct inode *ino, struct file *f,
                 put_net(net);
                 return -ENOMEM;
         }
+#ifdef CONFIG_NET_NS
         p->net = net;
+#endif
         return 0;
 }
 EXPORT_SYMBOL_GPL(seq_open_net);
@@ -52,17 +54,91 @@ EXPORT_SYMBOL_GPL(seq_open_net);
 int seq_release_net(struct inode *ino, struct file *f)
 {
         struct seq_file *seq;
-        struct seq_net_private *p;
 
         seq = f->private_data;
-        p = seq->private;
 
-        put_net(p->net);
+        put_net(seq_file_net(seq));
         seq_release_private(ino, f);
         return 0;
 }
 EXPORT_SYMBOL_GPL(seq_release_net);
 
+static struct net *get_proc_task_net(struct inode *dir)
+{
+        struct task_struct *task;
+        struct nsproxy *ns;
+        struct net *net = NULL;
+
+        rcu_read_lock();
+        task = pid_task(proc_pid(dir), PIDTYPE_PID);
+        if (task != NULL) {
+                ns = task_nsproxy(task);
+                if (ns != NULL)
+                        net = get_net(ns->net_ns);
+        }
+        rcu_read_unlock();
+
+        return net;
+}
+
+static struct dentry *proc_tgid_net_lookup(struct inode *dir,
+                struct dentry *dentry, struct nameidata *nd)
+{
+        struct dentry *de;
+        struct net *net;
+
+        de = ERR_PTR(-ENOENT);
+        net = get_proc_task_net(dir);
+        if (net != NULL) {
+                de = proc_lookup_de(net->proc_net, dir, dentry);
+                put_net(net);
+        }
+        return de;
+}
+
+static int proc_tgid_net_getattr(struct vfsmount *mnt, struct dentry *dentry,
+                struct kstat *stat)
+{
+        struct inode *inode = dentry->d_inode;
+        struct net *net;
+
+        net = get_proc_task_net(inode);
+
+        generic_fillattr(inode, stat);
+
+        if (net != NULL) {
+                stat->nlink = net->proc_net->nlink;
+                put_net(net);
+        }
+
+        return 0;
+}
+
+const struct inode_operations proc_net_inode_operations = {
+        .lookup         = proc_tgid_net_lookup,
+        .getattr        = proc_tgid_net_getattr,
+};
+
+static int proc_tgid_net_readdir(struct file *filp, void *dirent,
+                filldir_t filldir)
+{
+        int ret;
+        struct net *net;
+
+        ret = -EINVAL;
+        net = get_proc_task_net(filp->f_path.dentry->d_inode);
+        if (net != NULL) {
+                ret = proc_readdir_de(net->proc_net, filp, dirent, filldir);
+                put_net(net);
+        }
+        return ret;
+}
+
+const struct file_operations proc_net_operations = {
+        .read           = generic_read_dir,
+        .readdir        = proc_tgid_net_readdir,
+};
+
 
 struct proc_dir_entry *proc_net_fops_create(struct net *net,
         const char *name, mode_t mode, const struct file_operations *fops)
@@ -83,14 +159,6 @@ struct net *get_proc_net(const struct inode *inode)
 }
 EXPORT_SYMBOL_GPL(get_proc_net);
 
-static struct proc_dir_entry *shadow_pde;
-
-static struct proc_dir_entry *proc_net_shadow(struct task_struct *task,
-                                                struct proc_dir_entry *de)
-{
-        return task->nsproxy->net_ns->proc_net;
-}
-
 struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name,
                 struct proc_dir_entry *parent)
 {
@@ -104,45 +172,39 @@ EXPORT_SYMBOL_GPL(proc_net_mkdir);
 
 static __net_init int proc_net_ns_init(struct net *net)
 {
-        struct proc_dir_entry *root, *netd, *net_statd;
+        struct proc_dir_entry *netd, *net_statd;
         int err;
 
         err = -ENOMEM;
-        root = kzalloc(sizeof(*root), GFP_KERNEL);
-        if (!root)
+        netd = kzalloc(sizeof(*netd), GFP_KERNEL);
+        if (!netd)
                 goto out;
 
-        err = -EEXIST;
-        netd = proc_net_mkdir(net, "net", root);
-        if (!netd)
-                goto free_root;
+        netd->data = net;
+        netd->nlink = 2;
+        netd->name = "net";
+        netd->namelen = 3;
+        netd->parent = &proc_root;
 
         err = -EEXIST;
         net_statd = proc_net_mkdir(net, "stat", netd);
         if (!net_statd)
                 goto free_net;
 
-        root->data = net;
-
-        net->proc_net_root = root;
         net->proc_net = netd;
         net->proc_net_stat = net_statd;
-        err = 0;
+        return 0;
 
+free_net:
+        kfree(netd);
 out:
         return err;
-free_net:
-        remove_proc_entry("net", root);
-free_root:
-        kfree(root);
-        goto out;
 }
 
 static __net_exit void proc_net_ns_exit(struct net *net)
 {
         remove_proc_entry("stat", net->proc_net);
-        remove_proc_entry("net", net->proc_net_root);
-        kfree(net->proc_net_root);
+        kfree(net->proc_net);
 }
 
 static struct pernet_operations __net_initdata proc_net_ns_ops = {
@@ -152,8 +214,7 @@ static struct pernet_operations __net_initdata proc_net_ns_ops = {
 
 int __init proc_net_init(void)
 {
-        shadow_pde = proc_mkdir("net", NULL);
-        shadow_pde->shadow_proc = proc_net_shadow;
+        proc_symlink("net", NULL, "self/net");
 
         return register_pernet_subsys(&proc_net_ns_ops);
 }
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 49958cffbd8d..9dfb5ff24209 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -527,13 +527,21 @@ struct pagemapread {
         char __user *out, *end;
 };
 
-#define PM_ENTRY_BYTES sizeof(u64)
-#define PM_RESERVED_BITS    3
-#define PM_RESERVED_OFFSET  (64 - PM_RESERVED_BITS)
-#define PM_RESERVED_MASK    (((1LL<<PM_RESERVED_BITS)-1) << PM_RESERVED_OFFSET)
-#define PM_SPECIAL(nr)      (((nr) << PM_RESERVED_OFFSET) | PM_RESERVED_MASK)
-#define PM_NOT_PRESENT      PM_SPECIAL(1LL)
-#define PM_SWAP             PM_SPECIAL(2LL)
+#define PM_ENTRY_BYTES      sizeof(u64)
+#define PM_STATUS_BITS      3
+#define PM_STATUS_OFFSET    (64 - PM_STATUS_BITS)
+#define PM_STATUS_MASK      (((1LL << PM_STATUS_BITS) - 1) << PM_STATUS_OFFSET)
+#define PM_STATUS(nr)       (((nr) << PM_STATUS_OFFSET) & PM_STATUS_MASK)
+#define PM_PSHIFT_BITS      6
+#define PM_PSHIFT_OFFSET    (PM_STATUS_OFFSET - PM_PSHIFT_BITS)
+#define PM_PSHIFT_MASK      (((1LL << PM_PSHIFT_BITS) - 1) << PM_PSHIFT_OFFSET)
+#define PM_PSHIFT(x)        (((u64) (x) << PM_PSHIFT_OFFSET) & PM_PSHIFT_MASK)
+#define PM_PFRAME_MASK      ((1LL << PM_PSHIFT_OFFSET) - 1)
+#define PM_PFRAME(x)        ((x) & PM_PFRAME_MASK)
+
+#define PM_PRESENT          PM_STATUS(4LL)
+#define PM_SWAP             PM_STATUS(2LL)
+#define PM_NOT_PRESENT      PM_PSHIFT(PAGE_SHIFT)
 #define PM_END_OF_BUFFER    1
 
 static int add_to_pagemap(unsigned long addr, u64 pfn,
@@ -574,7 +582,7 @@ static int pagemap_pte_hole(unsigned long start, unsigned long end,
 u64 swap_pte_to_pagemap_entry(pte_t pte)
 {
         swp_entry_t e = pte_to_swp_entry(pte);
-        return PM_SWAP | swp_type(e) | (swp_offset(e) << MAX_SWAPFILES_SHIFT);
+        return swp_type(e) | (swp_offset(e) << MAX_SWAPFILES_SHIFT);
 }
 
 static int pagemap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
@@ -588,9 +596,11 @@ static int pagemap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
                 u64 pfn = PM_NOT_PRESENT;
                 pte = pte_offset_map(pmd, addr);
                 if (is_swap_pte(*pte))
-                        pfn = swap_pte_to_pagemap_entry(*pte);
+                        pfn = PM_PFRAME(swap_pte_to_pagemap_entry(*pte))
+                                | PM_PSHIFT(PAGE_SHIFT) | PM_SWAP;
                 else if (pte_present(*pte))
-                        pfn = pte_pfn(*pte);
+                        pfn = PM_PFRAME(pte_pfn(*pte))
+                                | PM_PSHIFT(PAGE_SHIFT) | PM_PRESENT;
                 /* unmap so we're not in atomic when we copy to userspace */
                 pte_unmap(pte);
                 err = add_to_pagemap(addr, pfn, pm);
@@ -611,12 +621,20 @@ static struct mm_walk pagemap_walk = {
 /*
  * /proc/pid/pagemap - an array mapping virtual pages to pfns
  *
- * For each page in the address space, this file contains one 64-bit
- * entry representing the corresponding physical page frame number
- * (PFN) if the page is present. If there is a swap entry for the
- * physical page, then an encoding of the swap file number and the
- * page's offset into the swap file are returned. If no page is
- * present at all, PM_NOT_PRESENT is returned. This allows determining
+ * For each page in the address space, this file contains one 64-bit entry
+ * consisting of the following:
+ *
+ * Bits 0-55  page frame number (PFN) if present
+ * Bits 0-4   swap type if swapped
+ * Bits 5-55  swap offset if swapped
+ * Bits 55-60 page shift (page size = 1<<page shift)
+ * Bit  61    reserved for future use
+ * Bit  62    page swapped
+ * Bit  63    page present
+ *
+ * If the page is not present but in swap, then the PFN contains an
+ * encoding of the swap file number and the page's offset into the
+ * swap. Unmapped pages return a null PFN. This allows determining
  * precisely which pages are mapped (or in swap) and comparing mapped
  * pages between processes.
  *
@@ -640,17 +658,17 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
 
         ret = -EACCES;
         if (!ptrace_may_attach(task))
-                goto out;
+                goto out_task;
 
         ret = -EINVAL;
         /* file position must be aligned */
         if (*ppos % PM_ENTRY_BYTES)
-                goto out;
+                goto out_task;
 
         ret = 0;
         mm = get_task_mm(task);
         if (!mm)
-                goto out;
+                goto out_task;
 
         ret = -ENOMEM;
         uaddr = (unsigned long)buf & PAGE_MASK;
@@ -658,7 +676,7 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
         pagecount = (PAGE_ALIGN(uend) - uaddr) / PAGE_SIZE;
         pages = kmalloc(pagecount * sizeof(struct page *), GFP_KERNEL);
         if (!pages)
-                goto out_task;
+                goto out_mm;
 
         down_read(&current->mm->mmap_sem);
         ret = get_user_pages(current, current->mm, uaddr, pagecount,
@@ -668,6 +686,12 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
         if (ret < 0)
                 goto out_free;
 
+        if (ret != pagecount) {
+                pagecount = ret;
+                ret = -EFAULT;
+                goto out_pages;
+        }
+
         pm.out = buf;
         pm.end = buf + count;
 
@@ -699,15 +723,17 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
                         ret = pm.out - buf;
         }
 
+out_pages:
         for (; pagecount; pagecount--) {
                 page = pages[pagecount-1];
                 if (!PageReserved(page))
                         SetPageDirty(page);
                 page_cache_release(page);
         }
-        mmput(mm);
 out_free:
         kfree(pages);
+out_mm:
+        mmput(mm);
 out_task:
         put_task_struct(task);
 out: