Merge branch 'akpm' (patches from Andrew)

Merge misc updates from Andrew Morton:

 - kasan updates

 - procfs

 - lib/bitmap updates

 - other lib/ updates

 - checkpatch tweaks

 - rapidio

 - ubsan

 - pipe fixes and cleanups

 - lots of other misc bits

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (114 commits)
  Documentation/sysctl/user.txt: fix typo
  MAINTAINERS: update ARM/QUALCOMM SUPPORT patterns
  MAINTAINERS: update various PALM patterns
  MAINTAINERS: update "ARM/OXNAS platform support" patterns
  MAINTAINERS: update Cortina/Gemini patterns
  MAINTAINERS: remove ARM/CLKDEV SUPPORT file pattern
  MAINTAINERS: remove ANDROID ION pattern
  mm: docs: add blank lines to silence sphinx "Unexpected indentation" errors
  mm: docs: fix parameter names mismatch
  mm: docs: fixup punctuation
  pipe: read buffer limits atomically
  pipe: simplify round_pipe_size()
  pipe: reject F_SETPIPE_SZ with size over UINT_MAX
  pipe: fix off-by-one error when checking buffer limits
  pipe: actually allow root to exceed the pipe buffer limits
  pipe, sysctl: remove pipe_proc_fn()
  pipe, sysctl: drop 'min' parameter from pipe-max-size converter
  kasan: rework Kconfig settings
  crash_dump: is_kdump_kernel can be boolean
  kernel/mutex: mutex_is_locked can be boolean
  ...

1 files changed, 24 insertions, 33 deletions

diff --git a/fs/pipe.c b/fs/pipe.c
index a449ca0ec0c6..0913aed7fd0d 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -35,11 +35,6 @@
  */
 unsigned int pipe_max_size = 1048576;
 
-/*
- * Minimum pipe size, as required by POSIX
- */
-unsigned int pipe_min_size = PAGE_SIZE;
-
 /* Maximum allocatable pages per user. Hard limit is unset by default, soft
  * matches default values.
  */
@@ -610,12 +605,21 @@ static unsigned long account_pipe_buffers(struct user_struct *user,
 
 static bool too_many_pipe_buffers_soft(unsigned long user_bufs)
 {
-        return pipe_user_pages_soft && user_bufs >= pipe_user_pages_soft;
+        unsigned long soft_limit = READ_ONCE(pipe_user_pages_soft);
+
+        return soft_limit && user_bufs > soft_limit;
 }
 
 static bool too_many_pipe_buffers_hard(unsigned long user_bufs)
 {
-        return pipe_user_pages_hard && user_bufs >= pipe_user_pages_hard;
+        unsigned long hard_limit = READ_ONCE(pipe_user_pages_hard);
+
+        return hard_limit && user_bufs > hard_limit;
+}
+
+static bool is_unprivileged_user(void)
+{
+        return !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN);
 }
 
 struct pipe_inode_info *alloc_pipe_info(void)
@@ -624,22 +628,23 @@ struct pipe_inode_info *alloc_pipe_info(void)
         unsigned long pipe_bufs = PIPE_DEF_BUFFERS;
         struct user_struct *user = get_current_user();
         unsigned long user_bufs;
+        unsigned int max_size = READ_ONCE(pipe_max_size);
 
         pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL_ACCOUNT);
         if (pipe == NULL)
                 goto out_free_uid;
 
-        if (pipe_bufs * PAGE_SIZE > pipe_max_size && !capable(CAP_SYS_RESOURCE))
-                pipe_bufs = pipe_max_size >> PAGE_SHIFT;
+        if (pipe_bufs * PAGE_SIZE > max_size && !capable(CAP_SYS_RESOURCE))
+                pipe_bufs = max_size >> PAGE_SHIFT;
 
         user_bufs = account_pipe_buffers(user, 0, pipe_bufs);
 
-        if (too_many_pipe_buffers_soft(user_bufs)) {
+        if (too_many_pipe_buffers_soft(user_bufs) && is_unprivileged_user()) {
                 user_bufs = account_pipe_buffers(user, pipe_bufs, 1);
                 pipe_bufs = 1;
         }
 
-        if (too_many_pipe_buffers_hard(user_bufs))
+        if (too_many_pipe_buffers_hard(user_bufs) && is_unprivileged_user())
                 goto out_revert_acct;
 
         pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),
@@ -1020,18 +1025,16 @@ const struct file_operations pipefifo_fops = {
  * Currently we rely on the pipe array holding a power-of-2 number
  * of pages. Returns 0 on error.
  */
-unsigned int round_pipe_size(unsigned int size)
+unsigned int round_pipe_size(unsigned long size)
 {
-        unsigned long nr_pages;
-
-        if (size < pipe_min_size)
-                size = pipe_min_size;
-
-        nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
-        if (nr_pages == 0)
+        if (size > (1U << 31))
                 return 0;
 
-        return roundup_pow_of_two(nr_pages) << PAGE_SHIFT;
+        /* Minimum pipe size, as required by POSIX */
+        if (size < PAGE_SIZE)
+                return PAGE_SIZE;
+
+        return roundup_pow_of_two(size);
 }
 
 /*
@@ -1046,8 +1049,6 @@ static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long arg)
         long ret = 0;
 
         size = round_pipe_size(arg);
-        if (size == 0)
-                return -EINVAL;
         nr_pages = size >> PAGE_SHIFT;
 
         if (!nr_pages)
@@ -1069,7 +1070,7 @@ static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long arg)
         if (nr_pages > pipe->buffers &&
                         (too_many_pipe_buffers_hard(user_bufs) ||
                          too_many_pipe_buffers_soft(user_bufs)) &&
-                        !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN)) {
+                        is_unprivileged_user()) {
                 ret = -EPERM;
                 goto out_revert_acct;
         }
@@ -1125,16 +1126,6 @@ out_revert_acct:
 }
 
 /*
- * This should work even if CONFIG_PROC_FS isn't set, as proc_dopipe_max_size
- * will return an error.
- */
-int pipe_proc_fn(struct ctl_table *table, int write, void __user *buf,
-                 size_t *lenp, loff_t *ppos)
-{
-        return proc_dopipe_max_size(table, write, buf, lenp, ppos);
-}
-
-/*
  * After the inode slimming patch, i_pipe/i_bdev/i_cdev share the same
  * location, so checking ->i_pipe is not enough to verify that this is a
  * pipe.