Merge branch 'linus' into release

Conflicts:
	drivers/acpi/debug.c

Signed-off-by: Len Brown <len.brown@intel.com>

5 files changed, 155 insertions, 47 deletions

diff --git a/fs/proc/Makefile b/fs/proc/Makefile
index 11a7b5c68153..2758e2afc518 100644
--- a/fs/proc/Makefile
+++ b/fs/proc/Makefile
@@ -2,7 +2,7 @@
 # Makefile for the Linux proc filesystem routines.
 #
 
-obj-$(CONFIG_PROC_FS) += proc.o
+obj-y   += proc.o
 
 proc-y                  := nommu.o task_nommu.o
 proc-$(CONFIG_MMU)      := mmu.o task_mmu.o
diff --git a/fs/proc/base.c b/fs/proc/base.c
index acb7ef80ea4f..a1c43e7c8a7b 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -63,6 +63,7 @@
 #include <linux/namei.h>
 #include <linux/mnt_namespace.h>
 #include <linux/mm.h>
+#include <linux/swap.h>
 #include <linux/rcupdate.h>
 #include <linux/kallsyms.h>
 #include <linux/stacktrace.h>
@@ -148,18 +149,13 @@ static unsigned int pid_entry_count_dirs(const struct pid_entry *entries,
         return count;
 }
 
-static int get_fs_path(struct task_struct *task, struct path *path, bool root)
+static int get_task_root(struct task_struct *task, struct path *root)
 {
-        struct fs_struct *fs;
         int result = -ENOENT;
 
         task_lock(task);
-        fs = task->fs;
-        if (fs) {
-                read_lock(&fs->lock);
-                *path = root ? fs->root : fs->pwd;
-                path_get(path);
-                read_unlock(&fs->lock);
+        if (task->fs) {
+                get_fs_root(task->fs, root);
                 result = 0;
         }
         task_unlock(task);
@@ -172,7 +168,12 @@ static int proc_cwd_link(struct inode *inode, struct path *path)
         int result = -ENOENT;
 
         if (task) {
-                result = get_fs_path(task, path, 0);
+                task_lock(task);
+                if (task->fs) {
+                        get_fs_pwd(task->fs, path);
+                        result = 0;
+                }
+                task_unlock(task);
                 put_task_struct(task);
         }
         return result;
@@ -184,7 +185,7 @@ static int proc_root_link(struct inode *inode, struct path *path)
         int result = -ENOENT;
 
         if (task) {
-                result = get_fs_path(task, path, 1);
+                result = get_task_root(task, path);
                 put_task_struct(task);
         }
         return result;
@@ -427,17 +428,14 @@ static const struct file_operations proc_lstats_operations = {
 
 #endif
 
-/* The badness from the OOM killer */
-unsigned long badness(struct task_struct *p, unsigned long uptime);
 static int proc_oom_score(struct task_struct *task, char *buffer)
 {
         unsigned long points = 0;
-        struct timespec uptime;
 
-        do_posix_clock_monotonic_gettime(&uptime);
         read_lock(&tasklist_lock);
         if (pid_alive(task))
-                points = badness(task, uptime.tv_sec);
+                points = oom_badness(task, NULL, NULL,
+                                        totalram_pages + total_swap_pages);
         read_unlock(&tasklist_lock);
         return sprintf(buffer, "%lu\n", points);
 }
@@ -561,9 +559,19 @@ static int proc_setattr(struct dentry *dentry, struct iattr *attr)
                 return -EPERM;
 
         error = inode_change_ok(inode, attr);
-        if (!error)
-                error = inode_setattr(inode, attr);
-        return error;
+        if (error)
+                return error;
+
+        if ((attr->ia_valid & ATTR_SIZE) &&
+            attr->ia_size != i_size_read(inode)) {
+                error = vmtruncate(inode, attr->ia_size);
+                if (error)
+                        return error;
+        }
+
+        setattr_copy(inode, attr);
+        mark_inode_dirty(inode);
+        return 0;
 }
 
 static const struct inode_operations proc_def_inode_operations = {
@@ -589,7 +597,7 @@ static int mounts_open_common(struct inode *inode, struct file *file,
                                 get_mnt_ns(ns);
                 }
                 rcu_read_unlock();
-                if (ns && get_fs_path(task, &root, 1) == 0)
+                if (ns && get_task_root(task, &root) == 0)
                         ret = 0;
                 put_task_struct(task);
         }
@@ -1039,8 +1047,24 @@ static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
                 return -EACCES;
         }
 
+        /*
+         * Warn that /proc/pid/oom_adj is deprecated, see
+         * Documentation/feature-removal-schedule.txt.
+         */
+        printk_once(KERN_WARNING "%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));
         task->signal->oom_adj = oom_adjust;
-
+        /*
+         * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum
+         * value is always attainable.
+         */
+        if (task->signal->oom_adj == OOM_ADJUST_MAX)
+                task->signal->oom_score_adj = OOM_SCORE_ADJ_MAX;
+        else
+                task->signal->oom_score_adj = (oom_adjust * OOM_SCORE_ADJ_MAX) /
+                                                                -OOM_DISABLE;
         unlock_task_sighand(task, &flags);
         put_task_struct(task);
 
@@ -1053,6 +1077,82 @@ static const struct file_operations proc_oom_adjust_operations = {
         .llseek         = generic_file_llseek,
 };
 
+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);
+        char buffer[PROC_NUMBUF];
+        int oom_score_adj = OOM_SCORE_ADJ_MIN;
+        unsigned long flags;
+        size_t len;
+
+        if (!task)
+                return -ESRCH;
+        if (lock_task_sighand(task, &flags)) {
+                oom_score_adj = task->signal->oom_score_adj;
+                unlock_task_sighand(task, &flags);
+        }
+        put_task_struct(task);
+        len = snprintf(buffer, sizeof(buffer), "%d\n", oom_score_adj);
+        return simple_read_from_buffer(buf, count, ppos, buffer, len);
+}
+
+static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
+                                        size_t count, loff_t *ppos)
+{
+        struct task_struct *task;
+        char buffer[PROC_NUMBUF];
+        unsigned long flags;
+        long oom_score_adj;
+        int err;
+
+        memset(buffer, 0, sizeof(buffer));
+        if (count > sizeof(buffer) - 1)
+                count = sizeof(buffer) - 1;
+        if (copy_from_user(buffer, buf, count))
+                return -EFAULT;
+
+        err = strict_strtol(strstrip(buffer), 0, &oom_score_adj);
+        if (err)
+                return -EINVAL;
+        if (oom_score_adj < OOM_SCORE_ADJ_MIN ||
+                        oom_score_adj > OOM_SCORE_ADJ_MAX)
+                return -EINVAL;
+
+        task = get_proc_task(file->f_path.dentry->d_inode);
+        if (!task)
+                return -ESRCH;
+        if (!lock_task_sighand(task, &flags)) {
+                put_task_struct(task);
+                return -ESRCH;
+        }
+        if (oom_score_adj < task->signal->oom_score_adj &&
+                        !capable(CAP_SYS_RESOURCE)) {
+                unlock_task_sighand(task, &flags);
+                put_task_struct(task);
+                return -EACCES;
+        }
+
+        task->signal->oom_score_adj = oom_score_adj;
+        /*
+         * Scale /proc/pid/oom_adj appropriately ensuring that OOM_DISABLE is
+         * always attainable.
+         */
+        if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
+                task->signal->oom_adj = OOM_DISABLE;
+        else
+                task->signal->oom_adj = (oom_score_adj * OOM_ADJUST_MAX) /
+                                                        OOM_SCORE_ADJ_MAX;
+        unlock_task_sighand(task, &flags);
+        put_task_struct(task);
+        return count;
+}
+
+static const struct file_operations proc_oom_score_adj_operations = {
+        .read           = oom_score_adj_read,
+        .write          = oom_score_adj_write,
+};
+
 #ifdef CONFIG_AUDITSYSCALL
 #define TMPBUFLEN 21
 static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
@@ -1426,7 +1526,7 @@ static int do_proc_readlink(struct path *path, char __user *buffer, int buflen)
         if (!tmp)
                 return -ENOMEM;
 
-        pathname = d_path(path, tmp, PAGE_SIZE);
+        pathname = d_path_with_unreachable(path, tmp, PAGE_SIZE);
         len = PTR_ERR(pathname);
         if (IS_ERR(pathname))
                 goto out;
@@ -2625,6 +2725,7 @@ static const struct pid_entry tgid_base_stuff[] = {
 #endif
         INF("oom_score",  S_IRUGO, proc_oom_score),
         REG("oom_adj",    S_IRUGO|S_IWUSR, proc_oom_adjust_operations),
+        REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",   S_IWUSR|S_IRUGO, proc_loginuid_operations),
         REG("sessionid",  S_IRUGO, proc_sessionid_operations),
@@ -2959,6 +3060,7 @@ static const struct pid_entry tid_base_stuff[] = {
 #endif
         INF("oom_score", S_IRUGO, proc_oom_score),
         REG("oom_adj",   S_IRUGO|S_IWUSR, proc_oom_adjust_operations),
+        REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",  S_IWUSR|S_IRUGO, proc_loginuid_operations),
         REG("sessionid",  S_IRUSR, proc_sessionid_operations),
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 2791907744ed..dd29f0337661 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -12,6 +12,7 @@
 #include <linux/time.h>
 #include <linux/proc_fs.h>
 #include <linux/stat.h>
+#include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/mount.h>
@@ -258,17 +259,22 @@ static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
 
         error = inode_change_ok(inode, iattr);
         if (error)
-                goto out;
+                return error;
 
-        error = inode_setattr(inode, iattr);
-        if (error)
-                goto out;
+        if ((iattr->ia_valid & ATTR_SIZE) &&
+            iattr->ia_size != i_size_read(inode)) {
+                error = vmtruncate(inode, iattr->ia_size);
+                if (error)
+                        return error;
+        }
+
+        setattr_copy(inode, iattr);
+        mark_inode_dirty(inode);
         
         de->uid = inode->i_uid;
         de->gid = inode->i_gid;
         de->mode = inode->i_mode;
-out:
-        return error;
+        return 0;
 }
 
 static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry,
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index aea8502e58a3..9c2b5f484879 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -25,11 +25,12 @@
 
 #include "internal.h"
 
-static void proc_delete_inode(struct inode *inode)
+static void proc_evict_inode(struct inode *inode)
 {
         struct proc_dir_entry *de;
 
         truncate_inode_pages(&inode->i_data, 0);
+        end_writeback(inode);
 
         /* Stop tracking associated processes */
         put_pid(PROC_I(inode)->pid);
@@ -40,7 +41,6 @@ static void proc_delete_inode(struct inode *inode)
                 pde_put(de);
         if (PROC_I(inode)->sysctl)
                 sysctl_head_put(PROC_I(inode)->sysctl);
-        clear_inode(inode);
 }
 
 struct vfsmount *proc_mnt;
@@ -91,7 +91,7 @@ static const struct super_operations proc_sops = {
         .alloc_inode    = proc_alloc_inode,
         .destroy_inode  = proc_destroy_inode,
         .drop_inode     = generic_delete_inode,
-        .delete_inode   = proc_delete_inode,
+        .evict_inode    = proc_evict_inode,
         .statfs         = simple_statfs,
 };
 
@@ -214,8 +214,7 @@ static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigne
 {
         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
         long rv = -ENOTTY;
-        long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
-        int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);
+        long (*ioctl)(struct file *, unsigned int, unsigned long);
 
         spin_lock(&pde->pde_unload_lock);
         if (!pde->proc_fops) {
@@ -223,19 +222,11 @@ static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigne
                 return rv;
         }
         pde->pde_users++;
-        unlocked_ioctl = pde->proc_fops->unlocked_ioctl;
-        ioctl = pde->proc_fops->ioctl;
+        ioctl = pde->proc_fops->unlocked_ioctl;
         spin_unlock(&pde->pde_unload_lock);
 
-        if (unlocked_ioctl) {
-                rv = unlocked_ioctl(file, cmd, arg);
-                if (rv == -ENOIOCTLCMD)
-                        rv = -EINVAL;
-        } else if (ioctl) {
-                WARN_ONCE(1, "Procfs ioctl handlers must use unlocked_ioctl, "
-                          "%pf will be called without the Bkl held\n", ioctl);
-                rv = ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
-        }
+        if (ioctl)
+                rv = ioctl(file, cmd, arg);
 
         pde_users_dec(pde);
         return rv;
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 6ff9981f0a18..5be436ea088e 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -329,10 +329,19 @@ static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
                 return -EPERM;
 
         error = inode_change_ok(inode, attr);
-        if (!error)
-                error = inode_setattr(inode, attr);
+        if (error)
+                return error;
+
+        if ((attr->ia_valid & ATTR_SIZE) &&
+            attr->ia_size != i_size_read(inode)) {
+                error = vmtruncate(inode, attr->ia_size);
+                if (error)
+                        return error;
+        }
 
-        return error;
+        setattr_copy(inode, attr);
+        mark_inode_dirty(inode);
+        return 0;
 }
 
 static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)