Merge tag 'dm-3.8-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/agk/linux-dm

Pull dm update from Alasdair G Kergon:
 "Miscellaneous device-mapper fixes, cleanups and performance
  improvements.

  Of particular note:
   - Disable broken WRITE SAME support in all targets except linear and
     striped.  Use it when kcopyd is zeroing blocks.
   - Remove several mempools from targets by moving the data into the
     bio's new front_pad area(which dm calls 'per_bio_data').
   - Fix a race in thin provisioning if discards are misused.
   - Prevent userspace from interfering with the ioctl parameters and
     use kmalloc for the data buffer if it's small instead of vmalloc.
   - Throttle some annoying error messages when I/O fails."

* tag 'dm-3.8-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/agk/linux-dm: (36 commits)
  dm stripe: add WRITE SAME support
  dm: remove map_info
  dm snapshot: do not use map_context
  dm thin: dont use map_context
  dm raid1: dont use map_context
  dm flakey: dont use map_context
  dm raid1: rename read_record to bio_record
  dm: move target request nr to dm_target_io
  dm snapshot: use per_bio_data
  dm verity: use per_bio_data
  dm raid1: use per_bio_data
  dm: introduce per_bio_data
  dm kcopyd: add WRITE SAME support to dm_kcopyd_zero
  dm linear: add WRITE SAME support
  dm: add WRITE SAME support
  dm: prepare to support WRITE SAME
  dm ioctl: use kmalloc if possible
  dm ioctl: remove PF_MEMALLOC
  dm persistent data: improve improve space map block alloc failure message
  dm thin: use DMERR_LIMIT for errors
  ...

1 files changed, 43 insertions, 21 deletions

diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index afd95986d099..0666b5d14b88 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -1543,7 +1543,21 @@ static int check_version(unsigned int cmd, struct dm_ioctl __user *user)
         return r;
 }
 
-static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl **param)
+#define DM_PARAMS_VMALLOC       0x0001  /* Params alloced with vmalloc not kmalloc */
+#define DM_WIPE_BUFFER          0x0010  /* Wipe input buffer before returning from ioctl */
+
+static void free_params(struct dm_ioctl *param, size_t param_size, int param_flags)
+{
+        if (param_flags & DM_WIPE_BUFFER)
+                memset(param, 0, param_size);
+
+        if (param_flags & DM_PARAMS_VMALLOC)
+                vfree(param);
+        else
+                kfree(param);
+}
+
+static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl **param, int *param_flags)
 {
         struct dm_ioctl tmp, *dmi;
         int secure_data;
@@ -1556,7 +1570,21 @@ static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl **param)
 
         secure_data = tmp.flags & DM_SECURE_DATA_FLAG;
 
-        dmi = vmalloc(tmp.data_size);
+        *param_flags = secure_data ? DM_WIPE_BUFFER : 0;
+
+        /*
+         * Try to avoid low memory issues when a device is suspended.
+         * Use kmalloc() rather than vmalloc() when we can.
+         */
+        dmi = NULL;
+        if (tmp.data_size <= KMALLOC_MAX_SIZE)
+                dmi = kmalloc(tmp.data_size, GFP_NOIO | __GFP_NORETRY | __GFP_NOMEMALLOC | __GFP_NOWARN);
+
+        if (!dmi) {
+                dmi = __vmalloc(tmp.data_size, GFP_NOIO | __GFP_REPEAT | __GFP_HIGH, PAGE_KERNEL);
+                *param_flags |= DM_PARAMS_VMALLOC;
+        }
+
         if (!dmi) {
                 if (secure_data && clear_user(user, tmp.data_size))
                         return -EFAULT;
@@ -1566,6 +1594,14 @@ static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl **param)
         if (copy_from_user(dmi, user, tmp.data_size))
                 goto bad;
 
+        /*
+         * Abort if something changed the ioctl data while it was being copied.
+         */
+        if (dmi->data_size != tmp.data_size) {
+                DMERR("rejecting ioctl: data size modified while processing parameters");
+                goto bad;
+        }
+
         /* Wipe the user buffer so we do not return it to userspace */
         if (secure_data && clear_user(user, tmp.data_size))
                 goto bad;
@@ -1574,9 +1610,8 @@ static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl **param)
         return 0;
 
 bad:
-        if (secure_data)
-                memset(dmi, 0, tmp.data_size);
-        vfree(dmi);
+        free_params(dmi, tmp.data_size, *param_flags);
+
         return -EFAULT;
 }
 
@@ -1613,7 +1648,7 @@ static int validate_params(uint cmd, struct dm_ioctl *param)
 static int ctl_ioctl(uint command, struct dm_ioctl __user *user)
 {
         int r = 0;
-        int wipe_buffer;
+        int param_flags;
         unsigned int cmd;
         struct dm_ioctl *uninitialized_var(param);
         ioctl_fn fn = NULL;
@@ -1649,24 +1684,14 @@ static int ctl_ioctl(uint command, struct dm_ioctl __user *user)
         }
 
         /*
-         * Trying to avoid low memory issues when a device is
-         * suspended.
-         */
-        current->flags |= PF_MEMALLOC;
-
-        /*
          * Copy the parameters into kernel space.
          */
-        r = copy_params(user, &param);
-
-        current->flags &= ~PF_MEMALLOC;
+        r = copy_params(user, &param, &param_flags);
 
         if (r)
                 return r;
 
         input_param_size = param->data_size;
-        wipe_buffer = param->flags & DM_SECURE_DATA_FLAG;
-
         r = validate_params(cmd, param);
         if (r)
                 goto out;
@@ -1681,10 +1706,7 @@ static int ctl_ioctl(uint command, struct dm_ioctl __user *user)
                 r = -EFAULT;
 
 out:
-        if (wipe_buffer)
-                memset(param, 0, input_param_size);
-
-        vfree(param);
+        free_params(param, input_param_size, param_flags);
         return r;
 }