16 files changed, 127 insertions, 153 deletions

diff --git a/fs/proc/Makefile b/fs/proc/Makefile
index 981b05601931..712f24db9600 100644
--- a/fs/proc/Makefile
+++ b/fs/proc/Makefile
@@ -8,7 +8,8 @@ proc-y			:= nommu.o task_nommu.o
 proc-$(CONFIG_MMU)      := mmu.o task_mmu.o
 
 proc-y       += inode.o root.o base.o generic.o array.o \
-                proc_tty.o fd.o
+                fd.o
+proc-$(CONFIG_TTY)      += proc_tty.o
 proc-y  += cmdline.o
 proc-y  += consoles.o
 proc-y  += cpuinfo.o
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 6a91e6ffbcbd..f7ed9ee46eb9 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -449,7 +449,7 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
                         do {
                                 min_flt += t->min_flt;
                                 maj_flt += t->maj_flt;
-                                gtime += t->gtime;
+                                gtime += task_gtime(t);
                                 t = next_thread(t);
                         } while (t != task);
 
@@ -472,7 +472,7 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
                 min_flt = task->min_flt;
                 maj_flt = task->maj_flt;
                 task_cputime_adjusted(task, &utime, &stime);
-                gtime = task->gtime;
+                gtime = task_gtime(task);
         }
 
         /* scale priority and nice values from timeslices to -20..20 */
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 9b43ff77a51e..69078c7cef1f 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -73,6 +73,7 @@
 #include <linux/security.h>
 #include <linux/ptrace.h>
 #include <linux/tracehook.h>
+#include <linux/printk.h>
 #include <linux/cgroup.h>
 #include <linux/cpuset.h>
 #include <linux/audit.h>
@@ -383,7 +384,7 @@ static int lstats_open(struct inode *inode, struct file *file)
 static ssize_t lstats_write(struct file *file, const char __user *buf,
                             size_t count, loff_t *offs)
 {
-        struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
 
         if (!task)
                 return -ESRCH;
@@ -602,7 +603,7 @@ static const struct inode_operations proc_def_inode_operations = {
 static ssize_t proc_info_read(struct file * file, char __user * buf,
                           size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         unsigned long page;
         ssize_t length;
         struct task_struct *task = get_proc_task(inode);
@@ -668,7 +669,7 @@ static const struct file_operations proc_single_file_operations = {
 
 static int __mem_open(struct inode *inode, struct file *file, unsigned int mode)
 {
-        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         struct mm_struct *mm;
 
         if (!task)
@@ -869,7 +870,7 @@ static const struct file_operations proc_environ_operations = {
 static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count,
                             loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         char buffer[PROC_NUMBUF];
         int oom_adj = OOM_ADJUST_MIN;
         size_t len;
@@ -916,7 +917,7 @@ static ssize_t oom_adj_write(struct file *file, const char __user *buf,
                 goto out;
         }
 
-        task = get_proc_task(file->f_path.dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task) {
                 err = -ESRCH;
                 goto out;
@@ -952,7 +953,7 @@ static ssize_t oom_adj_write(struct file *file, const char __user *buf,
          * /proc/pid/oom_adj is provided for legacy purposes, ask users to use
          * /proc/pid/oom_score_adj instead.
          */
-        printk_once(KERN_WARNING "%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
+        pr_warn_once("%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
                   current->comm, task_pid_nr(current), task_pid_nr(task),
                   task_pid_nr(task));
 
@@ -976,7 +977,7 @@ static const struct file_operations proc_oom_adj_operations = {
 static ssize_t oom_score_adj_read(struct file *file, char __user *buf,
                                         size_t count, loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         char buffer[PROC_NUMBUF];
         short oom_score_adj = OOM_SCORE_ADJ_MIN;
         unsigned long flags;
@@ -1019,7 +1020,7 @@ static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
                 goto out;
         }
 
-        task = get_proc_task(file->f_path.dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task) {
                 err = -ESRCH;
                 goto out;
@@ -1067,7 +1068,7 @@ static const struct file_operations proc_oom_score_adj_operations = {
 static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
                                   size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         struct task_struct *task = get_proc_task(inode);
         ssize_t length;
         char tmpbuf[TMPBUFLEN];
@@ -1084,7 +1085,7 @@ static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
 static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
                                    size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         char *page, *tmp;
         ssize_t length;
         uid_t loginuid;
@@ -1142,7 +1143,7 @@ static const struct file_operations proc_loginuid_operations = {
 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 inode * inode = file_inode(file);
         struct task_struct *task = get_proc_task(inode);
         ssize_t length;
         char tmpbuf[TMPBUFLEN];
@@ -1165,7 +1166,7 @@ static const struct file_operations proc_sessionid_operations = {
 static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
                                       size_t count, loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         char buffer[PROC_NUMBUF];
         size_t len;
         int make_it_fail;
@@ -1197,7 +1198,7 @@ static ssize_t proc_fault_inject_write(struct file * file,
         make_it_fail = simple_strtol(strstrip(buffer), &end, 0);
         if (*end)
                 return -EINVAL;
-        task = get_proc_task(file->f_dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task)
                 return -ESRCH;
         task->make_it_fail = make_it_fail;
@@ -1237,7 +1238,7 @@ static ssize_t
 sched_write(struct file *file, const char __user *buf,
             size_t count, loff_t *offset)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct task_struct *p;
 
         p = get_proc_task(inode);
@@ -1288,7 +1289,7 @@ static ssize_t
 sched_autogroup_write(struct file *file, const char __user *buf,
             size_t count, loff_t *offset)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct task_struct *p;
         char buffer[PROC_NUMBUF];
         int nice;
@@ -1343,7 +1344,7 @@ static const struct file_operations proc_pid_sched_autogroup_operations = {
 static ssize_t comm_write(struct file *file, const char __user *buf,
                                 size_t count, loff_t *offset)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct task_struct *p;
         char buffer[TASK_COMM_LEN];
 
@@ -1711,7 +1712,7 @@ static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
                 return -ECHILD;
 
         if (!capable(CAP_SYS_ADMIN)) {
-                status = -EACCES;
+                status = -EPERM;
                 goto out_notask;
         }
 
@@ -1844,7 +1845,7 @@ static struct dentry *proc_map_files_lookup(struct inode *dir,
         struct dentry *result;
         struct mm_struct *mm;
 
-        result = ERR_PTR(-EACCES);
+        result = ERR_PTR(-EPERM);
         if (!capable(CAP_SYS_ADMIN))
                 goto out;
 
@@ -1900,7 +1901,7 @@ proc_map_files_readdir(struct file *filp, void *dirent, filldir_t filldir)
         ino_t ino;
         int ret;
 
-        ret = -EACCES;
+        ret = -EPERM;
         if (!capable(CAP_SYS_ADMIN))
                 goto out;
 
@@ -2146,7 +2147,7 @@ out_no_task:
 static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
                                   size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         char *p = NULL;
         ssize_t length;
         struct task_struct *task = get_proc_task(inode);
@@ -2167,7 +2168,7 @@ static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
 static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
                                    size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         char *page;
         ssize_t length;
         struct task_struct *task = get_proc_task(inode);
@@ -2256,7 +2257,7 @@ static const struct inode_operations proc_attr_dir_inode_operations = {
 static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
                                          size_t count, loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         struct mm_struct *mm;
         char buffer[PROC_NUMBUF];
         size_t len;
@@ -2308,7 +2309,7 @@ static ssize_t proc_coredump_filter_write(struct file *file,
                 goto out_no_task;
 
         ret = -ESRCH;
-        task = get_proc_task(file->f_dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task)
                 goto out_no_task;
 
@@ -2618,6 +2619,7 @@ static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
 
         name.name = buf;
         name.len = snprintf(buf, sizeof(buf), "%d", pid);
+        /* no ->d_hash() rejects on procfs */
         dentry = d_hash_and_lookup(mnt->mnt_root, &name);
         if (dentry) {
                 shrink_dcache_parent(dentry);
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 76ddae83daa5..4b3b3ffb52f1 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -15,6 +15,7 @@
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/slab.h>
+#include <linux/printk.h>
 #include <linux/mount.h>
 #include <linux/init.h>
 #include <linux/idr.h>
@@ -42,7 +43,7 @@ static ssize_t
 __proc_file_read(struct file *file, char __user *buf, size_t nbytes,
                loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         char    *page;
         ssize_t retval=0;
         int     eof=0;
@@ -132,11 +133,8 @@ __proc_file_read(struct file *file, char __user *buf, size_t nbytes,
                 }
 
                 if (start == NULL) {
-                        if (n > PAGE_SIZE) {
-                                printk(KERN_ERR
-                                       "proc_file_read: Apparent buffer overflow!\n");
+                        if (n > PAGE_SIZE)      /* Apparent buffer overflow */
                                 n = PAGE_SIZE;
-                        }
                         n -= *ppos;
                         if (n <= 0)
                                 break;
@@ -144,26 +142,19 @@ __proc_file_read(struct file *file, char __user *buf, size_t nbytes,
                                 n = count;
                         start = page + *ppos;
                 } else if (start < page) {
-                        if (n > PAGE_SIZE) {
-                                printk(KERN_ERR
-                                       "proc_file_read: Apparent buffer overflow!\n");
+                        if (n > PAGE_SIZE)      /* Apparent buffer overflow */
                                 n = PAGE_SIZE;
-                        }
                         if (n > count) {
                                 /*
                                  * Don't reduce n because doing so might
                                  * cut off part of a data block.
                                  */
-                                printk(KERN_WARNING
-                                       "proc_file_read: Read count exceeded\n");
+                                pr_warn("proc_file_read: count exceeded\n");
                         }
                 } else /* start >= page */ {
                         unsigned long startoff = (unsigned long)(start - page);
-                        if (n > (PAGE_SIZE - startoff)) {
-                                printk(KERN_ERR
-                                       "proc_file_read: Apparent buffer overflow!\n");
+                        if (n > (PAGE_SIZE - startoff)) /* buffer overflow? */
                                 n = PAGE_SIZE - startoff;
-                        }
                         if (n > count)
                                 n = count;
                 }
@@ -188,7 +179,7 @@ static ssize_t
 proc_file_read(struct file *file, char __user *buf, size_t nbytes,
                loff_t *ppos)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         ssize_t rv = -EIO;
 
         spin_lock(&pde->pde_unload_lock);
@@ -209,7 +200,7 @@ static ssize_t
 proc_file_write(struct file *file, const char __user *buffer,
                 size_t count, loff_t *ppos)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         ssize_t rv = -EIO;
 
         if (pde->write_proc) {
@@ -412,8 +403,7 @@ static const struct dentry_operations proc_dentry_operations =
 struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
                 struct dentry *dentry)
 {
-        struct inode *inode = NULL;
-        int error = -ENOENT;
+        struct inode *inode;
 
         spin_lock(&proc_subdir_lock);
         for (de = de->subdir; de ; de = de->next) {
@@ -422,22 +412,16 @@ struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
                 if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
                         pde_get(de);
                         spin_unlock(&proc_subdir_lock);
-                        error = -ENOMEM;
                         inode = proc_get_inode(dir->i_sb, de);
-                        goto out_unlock;
+                        if (!inode)
+                                return ERR_PTR(-ENOMEM);
+                        d_set_d_op(dentry, &proc_dentry_operations);
+                        d_add(dentry, inode);
+                        return NULL;
                 }
         }
         spin_unlock(&proc_subdir_lock);
-out_unlock:
-
-        if (inode) {
-                d_set_d_op(dentry, &proc_dentry_operations);
-                d_add(dentry, inode);
-                return NULL;
-        }
-        if (de)
-                pde_put(de);
-        return ERR_PTR(error);
+        return ERR_PTR(-ENOENT);
 }
 
 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
@@ -460,7 +444,7 @@ int proc_readdir_de(struct proc_dir_entry *de, struct file *filp, void *dirent,
 {
         unsigned int ino;
         int i;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int ret = 0;
 
         ino = inode->i_ino;
@@ -522,7 +506,7 @@ out:
 
 int proc_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         return proc_readdir_de(PDE(inode), filp, dirent, filldir);
 }
@@ -576,7 +560,7 @@ static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp
 
         for (tmp = dir->subdir; tmp; tmp = tmp->next)
                 if (strcmp(tmp->name, dp->name) == 0) {
-                        WARN(1, KERN_WARNING "proc_dir_entry '%s/%s' already registered\n",
+                        WARN(1, "proc_dir_entry '%s/%s' already registered\n",
                                 dir->name, dp->name);
                         break;
                 }
@@ -837,9 +821,9 @@ void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
         if (S_ISDIR(de->mode))
                 parent->nlink--;
         de->nlink = 0;
-        WARN(de->subdir, KERN_WARNING "%s: removing non-empty directory "
-                        "'%s/%s', leaking at least '%s'\n", __func__,
-                        de->parent->name, de->name, de->subdir->name);
+        WARN(de->subdir, "%s: removing non-empty directory "
+                         "'%s/%s', leaking at least '%s'\n", __func__,
+                         de->parent->name, de->name, de->subdir->name);
         pde_put(de);
 }
 EXPORT_SYMBOL(remove_proc_entry);
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 439ae6886507..869116c2afbe 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -13,6 +13,7 @@
 #include <linux/stat.h>
 #include <linux/completion.h>
 #include <linux/poll.h>
+#include <linux/printk.h>
 #include <linux/file.h>
 #include <linux/limits.h>
 #include <linux/init.h>
@@ -144,7 +145,7 @@ void pde_users_dec(struct proc_dir_entry *pde)
 
 static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         loff_t rv = -EINVAL;
         loff_t (*llseek)(struct file *, loff_t, int);
 
@@ -179,7 +180,7 @@ static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
 
 static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         ssize_t rv = -EIO;
         ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
 
@@ -201,7 +202,7 @@ static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count,
 
 static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         ssize_t rv = -EIO;
         ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
 
@@ -223,7 +224,7 @@ static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t
 
 static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         unsigned int rv = DEFAULT_POLLMASK;
         unsigned int (*poll)(struct file *, struct poll_table_struct *);
 
@@ -245,7 +246,7 @@ static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *p
 
 static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         long rv = -ENOTTY;
         long (*ioctl)(struct file *, unsigned int, unsigned long);
 
@@ -268,7 +269,7 @@ static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigne
 #ifdef CONFIG_COMPAT
 static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         long rv = -ENOTTY;
         long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
 
@@ -291,7 +292,7 @@ static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned
 
 static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         int rv = -EIO;
         int (*mmap)(struct file *, struct vm_area_struct *);
 
@@ -445,12 +446,10 @@ static const struct file_operations proc_reg_file_ops_no_compat = {
 
 struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
 {
-        struct inode * inode;
+        struct inode *inode = new_inode_pseudo(sb);
 
-        inode = iget_locked(sb, de->low_ino);
-        if (!inode)
-                return NULL;
-        if (inode->i_state & I_NEW) {
+        if (inode) {
+                inode->i_ino = de->low_ino;
                 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
                 PROC_I(inode)->pde = de;
 
@@ -478,14 +477,15 @@ struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
                                 inode->i_fop = de->proc_fops;
                         }
                 }
-                unlock_new_inode(inode);
         } else
                pde_put(de);
         return inode;
-}                       
+}
 
 int proc_fill_super(struct super_block *s)
 {
+        struct inode *root_inode;
+
         s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
         s->s_blocksize = 1024;
         s->s_blocksize_bits = 10;
@@ -494,11 +494,17 @@ int proc_fill_super(struct super_block *s)
         s->s_time_gran = 1;
         
         pde_get(&proc_root);
-        s->s_root = d_make_root(proc_get_inode(s, &proc_root));
-        if (s->s_root)
-                return 0;
+        root_inode = proc_get_inode(s, &proc_root);
+        if (!root_inode) {
+                pr_err("proc_fill_super: get root inode failed\n");
+                return -ENOMEM;
+        }
 
-        printk("proc_read_super: get root inode failed\n");
-        pde_put(&proc_root);
-        return -ENOMEM;
+        s->s_root = d_make_root(root_inode);
+        if (!s->s_root) {
+                pr_err("proc_fill_super: allocate dentry failed\n");
+                return -ENOMEM;
+        }
+
+        return 0;
 }
diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index 252544c05207..85ff3a4598b3 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -11,6 +11,7 @@
 
 #include <linux/sched.h>
 #include <linux/proc_fs.h>
+#include <linux/binfmts.h>
 struct  ctl_table_header;
 struct  mempolicy;
 
@@ -108,7 +109,7 @@ static inline int task_dumpable(struct task_struct *task)
         if (mm)
                 dumpable = get_dumpable(mm);
         task_unlock(task);
-        if (dumpable == SUID_DUMPABLE_ENABLED)
+        if (dumpable == SUID_DUMP_USER)
                 return 1;
         return 0;
 }
diff --git a/fs/proc/kcore.c b/fs/proc/kcore.c
index e96d4f18ca3a..eda6f017f272 100644
--- a/fs/proc/kcore.c
+++ b/fs/proc/kcore.c
@@ -17,6 +17,7 @@
 #include <linux/elfcore.h>
 #include <linux/vmalloc.h>
 #include <linux/highmem.h>
+#include <linux/printk.h>
 #include <linux/bootmem.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -619,7 +620,7 @@ static int __init proc_kcore_init(void)
         proc_root_kcore = proc_create("kcore", S_IRUSR, NULL,
                                       &proc_kcore_operations);
         if (!proc_root_kcore) {
-                printk(KERN_ERR "couldn't create /proc/kcore\n");
+                pr_err("couldn't create /proc/kcore\n");
                 return 0; /* Always returns 0. */
         }
         /* Store text area if it's special */
diff --git a/fs/proc/meminfo.c b/fs/proc/meminfo.c
index 80e4645f7990..1efaaa19c4f3 100644
--- a/fs/proc/meminfo.c
+++ b/fs/proc/meminfo.c
@@ -40,7 +40,7 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 * sysctl_overcommit_ratio / 100) + total_swap_pages;
 
         cached = global_page_state(NR_FILE_PAGES) -
-                        total_swapcache_pages - i.bufferram;
+                        total_swapcache_pages() - i.bufferram;
         if (cached < 0)
                 cached = 0;
 
@@ -109,7 +109,7 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 K(i.freeram),
                 K(i.bufferram),
                 K(cached),
-                K(total_swapcache_pages),
+                K(total_swapcache_pages()),
                 K(pages[LRU_ACTIVE_ANON]   + pages[LRU_ACTIVE_FILE]),
                 K(pages[LRU_INACTIVE_ANON] + pages[LRU_INACTIVE_FILE]),
                 K(pages[LRU_ACTIVE_ANON]),
@@ -158,7 +158,7 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 vmi.used >> 10,
                 vmi.largest_chunk >> 10
 #ifdef CONFIG_MEMORY_FAILURE
-                ,atomic_long_read(&mce_bad_pages) << (PAGE_SHIFT - 10)
+                ,atomic_long_read(&num_poisoned_pages) << (PAGE_SHIFT - 10)
 #endif
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
                 ,K(global_page_state(NR_ANON_TRANSPARENT_HUGEPAGES) *
diff --git a/fs/proc/namespaces.c b/fs/proc/namespaces.c
index b7a47196c8c3..66b51c0383da 100644
--- a/fs/proc/namespaces.c
+++ b/fs/proc/namespaces.c
@@ -118,7 +118,7 @@ static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd)
         struct super_block *sb = inode->i_sb;
         struct proc_inode *ei = PROC_I(inode);
         struct task_struct *task;
-        struct dentry *ns_dentry;
+        struct path ns_path;
         void *error = ERR_PTR(-EACCES);
 
         task = get_proc_task(inode);
@@ -128,14 +128,14 @@ static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd)
         if (!ptrace_may_access(task, PTRACE_MODE_READ))
                 goto out_put_task;
 
-        ns_dentry = proc_ns_get_dentry(sb, task, ei->ns_ops);
-        if (IS_ERR(ns_dentry)) {
-                error = ERR_CAST(ns_dentry);
+        ns_path.dentry = proc_ns_get_dentry(sb, task, ei->ns_ops);
+        if (IS_ERR(ns_path.dentry)) {
+                error = ERR_CAST(ns_path.dentry);
                 goto out_put_task;
         }
 
-        dput(nd->path.dentry);
-        nd->path.dentry = ns_dentry;
+        ns_path.mnt = mntget(nd->path.mnt);
+        nd_jump_link(nd, &ns_path);
         error = NULL;
 
 out_put_task:
diff --git a/fs/proc/nommu.c b/fs/proc/nommu.c
index b1822dde55c2..ccfd99bd1c5a 100644
--- a/fs/proc/nommu.c
+++ b/fs/proc/nommu.c
@@ -45,7 +45,7 @@ static int nommu_region_show(struct seq_file *m, struct vm_region *region)
         file = region->vm_file;
 
         if (file) {
-                struct inode *inode = region->vm_file->f_path.dentry->d_inode;
+                struct inode *inode = file_inode(region->vm_file);
                 dev = inode->i_sb->s_dev;
                 ino = inode->i_ino;
         }
diff --git a/fs/proc/proc_devtree.c b/fs/proc/proc_devtree.c
index de20ec480fa0..30b590f5bd35 100644
--- a/fs/proc/proc_devtree.c
+++ b/fs/proc/proc_devtree.c
@@ -8,6 +8,7 @@
 #include <linux/time.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/printk.h>
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/of.h>
@@ -110,8 +111,8 @@ void proc_device_tree_update_prop(struct proc_dir_entry *pde,
                 if (ent->data == oldprop)
                         break;
         if (ent == NULL) {
-                printk(KERN_WARNING "device-tree: property \"%s\" "
-                       " does not exist\n", oldprop->name);
+                pr_warn("device-tree: property \"%s\" does not exist\n",
+                        oldprop->name);
         } else {
                 ent->data = newprop;
                 ent->size = newprop->length;
@@ -153,8 +154,8 @@ static const char *fixup_name(struct device_node *np, struct proc_dir_entry *de,
 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);
+                pr_err("device-tree: Out of memory trying to fixup "
+                       "name \"%s\"\n", name);
                 return name;
         }
 
@@ -175,8 +176,8 @@ retry:
                 goto retry;
         }
 
-        printk(KERN_WARNING "device-tree: Duplicate name in %s, "
-                        "renamed to \"%s\"\n", np->full_name, fixed_name);
+        pr_warn("device-tree: Duplicate name in %s, renamed to \"%s\"\n",
+                np->full_name, fixed_name);
 
         return fixed_name;
 }
diff --git a/fs/proc/proc_net.c b/fs/proc/proc_net.c
index fe72cd073dea..b4ac6572474f 100644
--- a/fs/proc/proc_net.c
+++ b/fs/proc/proc_net.c
@@ -163,7 +163,7 @@ static int proc_tgid_net_readdir(struct file *filp, void *dirent,
         struct net *net;
 
         ret = -EINVAL;
-        net = get_proc_task_net(filp->f_path.dentry->d_inode);
+        net = get_proc_task_net(file_inode(filp));
         if (net != NULL) {
                 ret = proc_readdir_de(net->proc_net, filp, dirent, filldir);
                 put_net(net);
@@ -177,20 +177,6 @@ const struct file_operations proc_net_operations = {
         .readdir        = proc_tgid_net_readdir,
 };
 
-
-struct proc_dir_entry *proc_net_fops_create(struct net *net,
-        const char *name, umode_t mode, const struct file_operations *fops)
-{
-        return proc_create(name, mode, net->proc_net, fops);
-}
-EXPORT_SYMBOL_GPL(proc_net_fops_create);
-
-void proc_net_remove(struct net *net, const char *name)
-{
-        remove_proc_entry(name, net->proc_net);
-}
-EXPORT_SYMBOL_GPL(proc_net_remove);
-
 static __net_init int proc_net_ns_init(struct net *net)
 {
         struct proc_dir_entry *netd, *net_statd;
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 1827d88ad58b..ac05f33a0dde 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -5,6 +5,7 @@
 #include <linux/sysctl.h>
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
+#include <linux/printk.h>
 #include <linux/security.h>
 #include <linux/sched.h>
 #include <linux/namei.h>
@@ -57,7 +58,7 @@ static void sysctl_print_dir(struct ctl_dir *dir)
 {
         if (dir->header.parent)
                 sysctl_print_dir(dir->header.parent);
-        printk(KERN_CONT "%s/", dir->header.ctl_table[0].procname);
+        pr_cont("%s/", dir->header.ctl_table[0].procname);
 }
 
 static int namecmp(const char *name1, int len1, const char *name2, int len2)
@@ -134,9 +135,9 @@ static int insert_entry(struct ctl_table_header *head, struct ctl_table *entry)
                 else if (cmp > 0)
                         p = &(*p)->rb_right;
                 else {
-                        printk(KERN_ERR "sysctl duplicate entry: ");
+                        pr_err("sysctl duplicate entry: ");
                         sysctl_print_dir(head->parent);
-                        printk(KERN_CONT "/%s\n", entry->procname);
+                        pr_cont("/%s\n", entry->procname);
                         return -EEXIST;
                 }
         }
@@ -478,7 +479,7 @@ out:
 static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
                 size_t count, loff_t *ppos, int write)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ctl_table_header *head = grab_header(inode);
         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
         ssize_t error;
@@ -542,7 +543,7 @@ static int proc_sys_open(struct inode *inode, struct file *filp)
 
 static unsigned int proc_sys_poll(struct file *filp, poll_table *wait)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ctl_table_header *head = grab_header(inode);
         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
         unsigned int ret = DEFAULT_POLLMASK;
@@ -927,9 +928,9 @@ found:
         subdir->header.nreg++;
 failed:
         if (unlikely(IS_ERR(subdir))) {
-                printk(KERN_ERR "sysctl could not get directory: ");
+                pr_err("sysctl could not get directory: ");
                 sysctl_print_dir(dir);
-                printk(KERN_CONT "/%*.*s %ld\n",
+                pr_cont("/%*.*s %ld\n",
                         namelen, namelen, name, PTR_ERR(subdir));
         }
         drop_sysctl_table(&dir->header);
@@ -995,8 +996,8 @@ static int sysctl_err(const char *path, struct ctl_table *table, char *fmt, ...)
         vaf.fmt = fmt;
         vaf.va = &args;
 
-        printk(KERN_ERR "sysctl table check failed: %s/%s %pV\n",
-                path, table->procname, &vaf);
+        pr_err("sysctl table check failed: %s/%s %pV\n",
+               path, table->procname, &vaf);
 
         va_end(args);
         return -EINVAL;
@@ -1510,9 +1511,9 @@ static void put_links(struct ctl_table_header *header)
                         drop_sysctl_table(link_head);
                 }
                 else {
-                        printk(KERN_ERR "sysctl link missing during unregister: ");
+                        pr_err("sysctl link missing during unregister: ");
                         sysctl_print_dir(parent);
-                        printk(KERN_CONT "/%s\n", name);
+                        pr_cont("/%s\n", name);
                 }
         }
 }
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index ca5ce7f9f800..3e636d864d56 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -271,7 +271,7 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma, int is_pid)
         const char *name = NULL;
 
         if (file) {
-                struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+                struct inode *inode = file_inode(vma->vm_file);
                 dev = inode->i_sb->s_dev;
                 ino = inode->i_ino;
                 pgoff = ((loff_t)vma->vm_pgoff) << PAGE_SHIFT;
@@ -743,7 +743,7 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                 return rv;
         if (type < CLEAR_REFS_ALL || type > CLEAR_REFS_MAPPED)
                 return -EINVAL;
-        task = get_proc_task(file->f_path.dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task)
                 return -ESRCH;
         mm = get_task_mm(task);
@@ -1015,7 +1015,7 @@ static int pagemap_hugetlb_range(pte_t *pte, unsigned long hmask,
 static ssize_t pagemap_read(struct file *file, char __user *buf,
                             size_t count, loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         struct mm_struct *mm;
         struct pagemapread pm;
         int ret = -ESRCH;
diff --git a/fs/proc/task_nommu.c b/fs/proc/task_nommu.c
index 1ccfa537f5f5..56123a6f462e 100644
--- a/fs/proc/task_nommu.c
+++ b/fs/proc/task_nommu.c
@@ -149,7 +149,7 @@ static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma,
         file = vma->vm_file;
 
         if (file) {
-                struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+                struct inode *inode = file_inode(vma->vm_file);
                 dev = inode->i_sb->s_dev;
                 ino = inode->i_ino;
                 pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT;
diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index 0d5071d29985..b870f740ab5a 100644
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
@@ -15,6 +15,7 @@
 #include <linux/export.h>
 #include <linux/slab.h>
 #include <linux/highmem.h>
+#include <linux/printk.h>
 #include <linux/bootmem.h>
 #include <linux/init.h>
 #include <linux/crash_dump.h>
@@ -175,15 +176,15 @@ static ssize_t read_vmcore(struct file *file, char __user *buffer,
         start = map_offset_to_paddr(*fpos, &vmcore_list, &curr_m);
         if (!curr_m)
                 return -EINVAL;
-        if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen)
-                tsz = buflen;
-
-        /* Calculate left bytes in current memory segment. */
-        nr_bytes = (curr_m->size - (start - curr_m->paddr));
-        if (tsz > nr_bytes)
-                tsz = nr_bytes;
 
         while (buflen) {
+                tsz = min_t(size_t, buflen, PAGE_SIZE - (start & ~PAGE_MASK));
+
+                /* Calculate left bytes in current memory segment. */
+                nr_bytes = (curr_m->size - (start - curr_m->paddr));
+                if (tsz > nr_bytes)
+                        tsz = nr_bytes;
+
                 tmp = read_from_oldmem(buffer, tsz, &start, 1);
                 if (tmp < 0)
                         return tmp;
@@ -198,12 +199,6 @@ static ssize_t read_vmcore(struct file *file, char __user *buffer,
                                                 struct vmcore, list);
                         start = curr_m->paddr;
                 }
-                if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen)
-                        tsz = buflen;
-                /* Calculate left bytes in current memory segment. */
-                nr_bytes = (curr_m->size - (start - curr_m->paddr));
-                if (tsz > nr_bytes)
-                        tsz = nr_bytes;
         }
         return acc;
 }
@@ -553,8 +548,7 @@ static int __init parse_crash_elf64_headers(void)
                 ehdr.e_ehsize != sizeof(Elf64_Ehdr) ||
                 ehdr.e_phentsize != sizeof(Elf64_Phdr) ||
                 ehdr.e_phnum == 0) {
-                printk(KERN_WARNING "Warning: Core image elf header is not"
-                                        "sane\n");
+                pr_warn("Warning: Core image elf header is not sane\n");
                 return -EINVAL;
         }
 
@@ -609,8 +603,7 @@ static int __init parse_crash_elf32_headers(void)
                 ehdr.e_ehsize != sizeof(Elf32_Ehdr) ||
                 ehdr.e_phentsize != sizeof(Elf32_Phdr) ||
                 ehdr.e_phnum == 0) {
-                printk(KERN_WARNING "Warning: Core image elf header is not"
-                                        "sane\n");
+                pr_warn("Warning: Core image elf header is not sane\n");
                 return -EINVAL;
         }
 
@@ -653,8 +646,7 @@ static int __init parse_crash_elf_headers(void)
         if (rc < 0)
                 return rc;
         if (memcmp(e_ident, ELFMAG, SELFMAG) != 0) {
-                printk(KERN_WARNING "Warning: Core image elf header"
-                                        " not found\n");
+                pr_warn("Warning: Core image elf header not found\n");
                 return -EINVAL;
         }
 
@@ -673,8 +665,7 @@ static int __init parse_crash_elf_headers(void)
                 /* Determine vmcore size. */
                 vmcore_size = get_vmcore_size_elf32(elfcorebuf);
         } else {
-                printk(KERN_WARNING "Warning: Core image elf header is not"
-                                        " sane\n");
+                pr_warn("Warning: Core image elf header is not sane\n");
                 return -EINVAL;
         }
         return 0;
@@ -690,7 +681,7 @@ static int __init vmcore_init(void)
                 return rc;
         rc = parse_crash_elf_headers();
         if (rc) {
-                printk(KERN_WARNING "Kdump: vmcore not initialized\n");
+                pr_warn("Kdump: vmcore not initialized\n");
                 return rc;
         }