Merge branch 'for-linus-unmerged' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable

* 'for-linus-unmerged' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable: (45 commits)
  Btrfs: fix __btrfs_map_block on 32 bit machines
  btrfs: fix possible deadlock by clearing __GFP_FS flag
  btrfs: check link counter overflow in link(2)
  btrfs: don't mess with i_nlink of unlocked inode in rename()
  Btrfs: check return value of btrfs_alloc_path()
  Btrfs: fix OOPS of empty filesystem after balance
  Btrfs: fix memory leak of empty filesystem after balance
  Btrfs: fix return value of setflags ioctl
  Btrfs: fix uncheck memory allocations
  btrfs: make inode ref log recovery faster
  Btrfs: add btrfs_trim_fs() to handle FITRIM
  Btrfs: adjust btrfs_discard_extent() return errors and trimmed bytes
  Btrfs: make btrfs_map_block() return entire free extent for each device of RAID0/1/10/DUP
  Btrfs: make update_reserved_bytes() public
  btrfs: return EXDEV when linking from different subvolumes
  Btrfs: Per file/directory controls for COW and compression
  Btrfs: add datacow flag in inode flag
  btrfs: use GFP_NOFS instead of GFP_KERNEL
  Btrfs: check return value of read_tree_block()
  btrfs: properly access unaligned checksum buffer
  ...

Fix up trivial conflicts in fs/btrfs/volumes.c due to plug removal in
the block layer.

1 files changed, 93 insertions, 7 deletions

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index d1bace3df9b..7c07fe26b7c 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -40,6 +40,7 @@
 #include <linux/xattr.h>
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
+#include <linux/blkdev.h>
 #include "compat.h"
 #include "ctree.h"
 #include "disk-io.h"
@@ -138,6 +139,24 @@ static int btrfs_ioctl_getflags(struct file *file, void __user *arg)
         return 0;
 }
 
+static int check_flags(unsigned int flags)
+{
+        if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
+                      FS_NOATIME_FL | FS_NODUMP_FL | \
+                      FS_SYNC_FL | FS_DIRSYNC_FL | \
+                      FS_NOCOMP_FL | FS_COMPR_FL | \
+                      FS_NOCOW_FL | FS_COW_FL))
+                return -EOPNOTSUPP;
+
+        if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_FL))
+                return -EINVAL;
+
+        if ((flags & FS_NOCOW_FL) && (flags & FS_COW_FL))
+                return -EINVAL;
+
+        return 0;
+}
+
 static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
 {
         struct inode *inode = file->f_path.dentry->d_inode;
@@ -153,10 +172,9 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         if (copy_from_user(&flags, arg, sizeof(flags)))
                 return -EFAULT;
 
-        if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
-                      FS_NOATIME_FL | FS_NODUMP_FL | \
-                      FS_SYNC_FL | FS_DIRSYNC_FL))
-                return -EOPNOTSUPP;
+        ret = check_flags(flags);
+        if (ret)
+                return ret;
 
         if (!inode_owner_or_capable(inode))
                 return -EACCES;
@@ -201,6 +219,22 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         else
                 ip->flags &= ~BTRFS_INODE_DIRSYNC;
 
+        /*
+         * The COMPRESS flag can only be changed by users, while the NOCOMPRESS
+         * flag may be changed automatically if compression code won't make
+         * things smaller.
+         */
+        if (flags & FS_NOCOMP_FL) {
+                ip->flags &= ~BTRFS_INODE_COMPRESS;
+                ip->flags |= BTRFS_INODE_NOCOMPRESS;
+        } else if (flags & FS_COMPR_FL) {
+                ip->flags |= BTRFS_INODE_COMPRESS;
+                ip->flags &= ~BTRFS_INODE_NOCOMPRESS;
+        }
+        if (flags & FS_NOCOW_FL)
+                ip->flags |= BTRFS_INODE_NODATACOW;
+        else if (flags & FS_COW_FL)
+                ip->flags &= ~BTRFS_INODE_NODATACOW;
 
         trans = btrfs_join_transaction(root, 1);
         BUG_ON(IS_ERR(trans));
@@ -213,9 +247,11 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         btrfs_end_transaction(trans, root);
 
         mnt_drop_write(file->f_path.mnt);
+
+        ret = 0;
  out_unlock:
         mutex_unlock(&inode->i_mutex);
-        return 0;
+        return ret;
 }
 
 static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
@@ -225,6 +261,49 @@ static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
         return put_user(inode->i_generation, arg);
 }
 
+static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
+{
+        struct btrfs_root *root = fdentry(file)->d_sb->s_fs_info;
+        struct btrfs_fs_info *fs_info = root->fs_info;
+        struct btrfs_device *device;
+        struct request_queue *q;
+        struct fstrim_range range;
+        u64 minlen = ULLONG_MAX;
+        u64 num_devices = 0;
+        int ret;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        mutex_lock(&fs_info->fs_devices->device_list_mutex);
+        list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {
+                if (!device->bdev)
+                        continue;
+                q = bdev_get_queue(device->bdev);
+                if (blk_queue_discard(q)) {
+                        num_devices++;
+                        minlen = min((u64)q->limits.discard_granularity,
+                                     minlen);
+                }
+        }
+        mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+        if (!num_devices)
+                return -EOPNOTSUPP;
+
+        if (copy_from_user(&range, arg, sizeof(range)))
+                return -EFAULT;
+
+        range.minlen = max(range.minlen, minlen);
+        ret = btrfs_trim_fs(root, &range);
+        if (ret < 0)
+                return ret;
+
+        if (copy_to_user(arg, &range, sizeof(range)))
+                return -EFAULT;
+
+        return 0;
+}
+
 static noinline int create_subvol(struct btrfs_root *root,
                                   struct dentry *dentry,
                                   char *name, int namelen,
@@ -409,7 +488,9 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
         if (ret)
                 goto fail;
 
-        btrfs_orphan_cleanup(pending_snapshot->snap);
+        ret = btrfs_orphan_cleanup(pending_snapshot->snap);
+        if (ret)
+                goto fail;
 
         parent = dget_parent(dentry);
         inode = btrfs_lookup_dentry(parent->d_inode, dentry);
@@ -2348,12 +2429,15 @@ static noinline long btrfs_ioctl_start_sync(struct file *file, void __user *argp
         struct btrfs_root *root = BTRFS_I(file->f_dentry->d_inode)->root;
         struct btrfs_trans_handle *trans;
         u64 transid;
+        int ret;
 
         trans = btrfs_start_transaction(root, 0);
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
         transid = trans->transid;
-        btrfs_commit_transaction_async(trans, root, 0);
+        ret = btrfs_commit_transaction_async(trans, root, 0);
+        if (ret)
+                return ret;
 
         if (argp)
                 if (copy_to_user(argp, &transid, sizeof(transid)))
@@ -2388,6 +2472,8 @@ long btrfs_ioctl(struct file *file, unsigned int
                 return btrfs_ioctl_setflags(file, argp);
         case FS_IOC_GETVERSION:
                 return btrfs_ioctl_getversion(file, argp);
+        case FITRIM:
+                return btrfs_ioctl_fitrim(file, argp);
         case BTRFS_IOC_SNAP_CREATE:
                 return btrfs_ioctl_snap_create(file, argp, 0);
         case BTRFS_IOC_SNAP_CREATE_V2: