Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 1107 insertions, 233 deletions

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 9254b3d58dbe..a3c4751e07db 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"
@@ -49,6 +50,7 @@
 #include "print-tree.h"
 #include "volumes.h"
 #include "locking.h"
+#include "inode-map.h"
 
 /* Mask out flags that are inappropriate for the given type of inode. */
 static inline __u32 btrfs_mask_flags(umode_t mode, __u32 flags)
@@ -80,6 +82,13 @@ static unsigned int btrfs_flags_to_ioctl(unsigned int flags)
                 iflags |= FS_NOATIME_FL;
         if (flags & BTRFS_INODE_DIRSYNC)
                 iflags |= FS_DIRSYNC_FL;
+        if (flags & BTRFS_INODE_NODATACOW)
+                iflags |= FS_NOCOW_FL;
+
+        if ((flags & BTRFS_INODE_COMPRESS) && !(flags & BTRFS_INODE_NOCOMPRESS))
+                iflags |= FS_COMPR_FL;
+        else if (flags & BTRFS_INODE_NOCOMPRESS)
+                iflags |= FS_NOCOMP_FL;
 
         return iflags;
 }
@@ -138,6 +147,21 @@ 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))
+                return -EOPNOTSUPP;
+
+        if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_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;
@@ -147,15 +171,17 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         unsigned int flags, oldflags;
         int ret;
 
+        if (btrfs_root_readonly(root))
+                return -EROFS;
+
         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 (!is_owner_or_cap(inode))
+        if (!inode_owner_or_capable(inode))
                 return -EACCES;
 
         mutex_lock(&inode->i_mutex);
@@ -197,10 +223,28 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
                 ip->flags |= BTRFS_INODE_DIRSYNC;
         else
                 ip->flags &= ~BTRFS_INODE_DIRSYNC;
+        if (flags & FS_NOCOW_FL)
+                ip->flags |= BTRFS_INODE_NODATACOW;
+        else
+                ip->flags &= ~BTRFS_INODE_NODATACOW;
 
+        /*
+         * 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;
+        } else {
+                ip->flags &= ~(BTRFS_INODE_COMPRESS | BTRFS_INODE_NOCOMPRESS);
+        }
 
-        trans = btrfs_join_transaction(root, 1);
-        BUG_ON(!trans);
+        trans = btrfs_join_transaction(root);
+        BUG_ON(IS_ERR(trans));
 
         ret = btrfs_update_inode(trans, root, inode);
         BUG_ON(ret);
@@ -210,9 +254,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)
@@ -222,9 +268,54 @@ 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;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(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);
+                }
+        }
+        rcu_read_unlock();
+        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)
+                                  char *name, int namelen,
+                                  u64 *async_transid)
 {
         struct btrfs_trans_handle *trans;
         struct btrfs_key key;
@@ -232,17 +323,22 @@ static noinline int create_subvol(struct btrfs_root *root,
         struct btrfs_inode_item *inode_item;
         struct extent_buffer *leaf;
         struct btrfs_root *new_root;
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct dentry *parent = dget_parent(dentry);
+        struct inode *dir;
         int ret;
         int err;
         u64 objectid;
         u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
         u64 index = 0;
 
-        ret = btrfs_find_free_objectid(NULL, root->fs_info->tree_root,
-                                       0, &objectid);
-        if (ret)
+        ret = btrfs_find_free_objectid(root->fs_info->tree_root, &objectid);
+        if (ret) {
+                dput(parent);
                 return ret;
+        }
+
+        dir = parent->d_inode;
+
         /*
          * 1 - inode item
          * 2 - refs
@@ -250,8 +346,10 @@ static noinline int create_subvol(struct btrfs_root *root,
          * 2 - dir items
          */
         trans = btrfs_start_transaction(root, 6);
-        if (IS_ERR(trans))
+        if (IS_ERR(trans)) {
+                dput(parent);
                 return PTR_ERR(trans);
+        }
 
         leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
                                       0, objectid, NULL, 0, 0, 0);
@@ -282,6 +380,10 @@ static noinline int create_subvol(struct btrfs_root *root,
         inode_item->nbytes = cpu_to_le64(root->leafsize);
         inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
 
+        root_item.flags = 0;
+        root_item.byte_limit = 0;
+        inode_item->flags = cpu_to_le64(BTRFS_INODE_ROOT_ITEM_INIT);
+
         btrfs_set_root_bytenr(&root_item, leaf->start);
         btrfs_set_root_generation(&root_item, trans->transid);
         btrfs_set_root_level(&root_item, 0);
@@ -312,8 +414,7 @@ static noinline int create_subvol(struct btrfs_root *root,
 
         btrfs_record_root_in_trans(trans, new_root);
 
-        ret = btrfs_create_subvol_root(trans, new_root, new_dirid,
-                                       BTRFS_I(dir)->block_group);
+        ret = btrfs_create_subvol_root(trans, new_root, new_dirid);
         /*
          * insert the directory item
          */
@@ -321,7 +422,7 @@ static noinline int create_subvol(struct btrfs_root *root,
         BUG_ON(ret);
 
         ret = btrfs_insert_dir_item(trans, root,
-                                    name, namelen, dir->i_ino, &key,
+                                    name, namelen, dir, &key,
                                     BTRFS_FT_DIR, index);
         if (ret)
                 goto fail;
@@ -332,21 +433,30 @@ static noinline int create_subvol(struct btrfs_root *root,
 
         ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
                                  objectid, root->root_key.objectid,
-                                 dir->i_ino, index, name, namelen);
+                                 btrfs_ino(dir), index, name, namelen);
 
         BUG_ON(ret);
 
         d_instantiate(dentry, btrfs_lookup_dentry(dir, dentry));
 fail:
-        err = btrfs_commit_transaction(trans, root);
+        dput(parent);
+        if (async_transid) {
+                *async_transid = trans->transid;
+                err = btrfs_commit_transaction_async(trans, root, 1);
+        } else {
+                err = btrfs_commit_transaction(trans, root);
+        }
         if (err && !ret)
                 ret = err;
         return ret;
 }
 
-static int create_snapshot(struct btrfs_root *root, struct dentry *dentry)
+static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
+                           char *name, int namelen, u64 *async_transid,
+                           bool readonly)
 {
         struct inode *inode;
+        struct dentry *parent;
         struct btrfs_pending_snapshot *pending_snapshot;
         struct btrfs_trans_handle *trans;
         int ret;
@@ -361,6 +471,7 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry)
         btrfs_init_block_rsv(&pending_snapshot->block_rsv);
         pending_snapshot->dentry = dentry;
         pending_snapshot->root = root;
+        pending_snapshot->readonly = readonly;
 
         trans = btrfs_start_transaction(root->fs_info->extent_root, 5);
         if (IS_ERR(trans)) {
@@ -371,18 +482,31 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry)
         ret = btrfs_snap_reserve_metadata(trans, pending_snapshot);
         BUG_ON(ret);
 
+        spin_lock(&root->fs_info->trans_lock);
         list_add(&pending_snapshot->list,
                  &trans->transaction->pending_snapshots);
-        ret = btrfs_commit_transaction(trans, root->fs_info->extent_root);
+        spin_unlock(&root->fs_info->trans_lock);
+        if (async_transid) {
+                *async_transid = trans->transid;
+                ret = btrfs_commit_transaction_async(trans,
+                                     root->fs_info->extent_root, 1);
+        } else {
+                ret = btrfs_commit_transaction(trans,
+                                               root->fs_info->extent_root);
+        }
         BUG_ON(ret);
 
         ret = pending_snapshot->error;
         if (ret)
                 goto fail;
 
-        btrfs_orphan_cleanup(pending_snapshot->snap);
+        ret = btrfs_orphan_cleanup(pending_snapshot->snap);
+        if (ret)
+                goto fail;
 
-        inode = btrfs_lookup_dentry(dentry->d_parent->d_inode, dentry);
+        parent = dget_parent(dentry);
+        inode = btrfs_lookup_dentry(parent->d_inode, dentry);
+        dput(parent);
         if (IS_ERR(inode)) {
                 ret = PTR_ERR(inode);
                 goto fail;
@@ -395,6 +519,76 @@ fail:
         return ret;
 }
 
+/*  copy of check_sticky in fs/namei.c()
+* It's inline, so penalty for filesystems that don't use sticky bit is
+* minimal.
+*/
+static inline int btrfs_check_sticky(struct inode *dir, struct inode *inode)
+{
+        uid_t fsuid = current_fsuid();
+
+        if (!(dir->i_mode & S_ISVTX))
+                return 0;
+        if (inode->i_uid == fsuid)
+                return 0;
+        if (dir->i_uid == fsuid)
+                return 0;
+        return !capable(CAP_FOWNER);
+}
+
+/*  copy of may_delete in fs/namei.c()
+ *      Check whether we can remove a link victim from directory dir, check
+ *  whether the type of victim is right.
+ *  1. We can't do it if dir is read-only (done in permission())
+ *  2. We should have write and exec permissions on dir
+ *  3. We can't remove anything from append-only dir
+ *  4. We can't do anything with immutable dir (done in permission())
+ *  5. If the sticky bit on dir is set we should either
+ *      a. be owner of dir, or
+ *      b. be owner of victim, or
+ *      c. have CAP_FOWNER capability
+ *  6. If the victim is append-only or immutable we can't do antyhing with
+ *     links pointing to it.
+ *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
+ *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
+ *  9. We can't remove a root or mountpoint.
+ * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
+ *     nfs_async_unlink().
+ */
+
+static int btrfs_may_delete(struct inode *dir,struct dentry *victim,int isdir)
+{
+        int error;
+
+        if (!victim->d_inode)
+                return -ENOENT;
+
+        BUG_ON(victim->d_parent->d_inode != dir);
+        audit_inode_child(victim, dir);
+
+        error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
+        if (error)
+                return error;
+        if (IS_APPEND(dir))
+                return -EPERM;
+        if (btrfs_check_sticky(dir, victim->d_inode)||
+                IS_APPEND(victim->d_inode)||
+            IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
+                return -EPERM;
+        if (isdir) {
+                if (!S_ISDIR(victim->d_inode->i_mode))
+                        return -ENOTDIR;
+                if (IS_ROOT(victim))
+                        return -EBUSY;
+        } else if (S_ISDIR(victim->d_inode->i_mode))
+                return -EISDIR;
+        if (IS_DEADDIR(dir))
+                return -ENOENT;
+        if (victim->d_flags & DCACHE_NFSFS_RENAMED)
+                return -EBUSY;
+        return 0;
+}
+
 /* copy of may_create in fs/namei.c() */
 static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
 {
@@ -412,7 +606,8 @@ static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
  */
 static noinline int btrfs_mksubvol(struct path *parent,
                                    char *name, int namelen,
-                                   struct btrfs_root *snap_src)
+                                   struct btrfs_root *snap_src,
+                                   u64 *async_transid, bool readonly)
 {
         struct inode *dir  = parent->dentry->d_inode;
         struct dentry *dentry;
@@ -443,10 +638,11 @@ static noinline int btrfs_mksubvol(struct path *parent,
                 goto out_up_read;
 
         if (snap_src) {
-                error = create_snapshot(snap_src, dentry);
+                error = create_snapshot(snap_src, dentry,
+                                        name, namelen, async_transid, readonly);
         } else {
                 error = create_subvol(BTRFS_I(dir)->root, dentry,
-                                      name, namelen);
+                                      name, namelen, async_transid);
         }
         if (!error)
                 fsnotify_mkdir(dir, dentry);
@@ -461,6 +657,107 @@ out_unlock:
         return error;
 }
 
+/*
+ * When we're defragging a range, we don't want to kick it off again
+ * if it is really just waiting for delalloc to send it down.
+ * If we find a nice big extent or delalloc range for the bytes in the
+ * file you want to defrag, we return 0 to let you know to skip this
+ * part of the file
+ */
+static int check_defrag_in_cache(struct inode *inode, u64 offset, int thresh)
+{
+        struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
+        struct extent_map *em = NULL;
+        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+        u64 end;
+
+        read_lock(&em_tree->lock);
+        em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE);
+        read_unlock(&em_tree->lock);
+
+        if (em) {
+                end = extent_map_end(em);
+                free_extent_map(em);
+                if (end - offset > thresh)
+                        return 0;
+        }
+        /* if we already have a nice delalloc here, just stop */
+        thresh /= 2;
+        end = count_range_bits(io_tree, &offset, offset + thresh,
+                               thresh, EXTENT_DELALLOC, 1);
+        if (end >= thresh)
+                return 0;
+        return 1;
+}
+
+/*
+ * helper function to walk through a file and find extents
+ * newer than a specific transid, and smaller than thresh.
+ *
+ * This is used by the defragging code to find new and small
+ * extents
+ */
+static int find_new_extents(struct btrfs_root *root,
+                            struct inode *inode, u64 newer_than,
+                            u64 *off, int thresh)
+{
+        struct btrfs_path *path;
+        struct btrfs_key min_key;
+        struct btrfs_key max_key;
+        struct extent_buffer *leaf;
+        struct btrfs_file_extent_item *extent;
+        int type;
+        int ret;
+        u64 ino = btrfs_ino(inode);
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        min_key.objectid = ino;
+        min_key.type = BTRFS_EXTENT_DATA_KEY;
+        min_key.offset = *off;
+
+        max_key.objectid = ino;
+        max_key.type = (u8)-1;
+        max_key.offset = (u64)-1;
+
+        path->keep_locks = 1;
+
+        while(1) {
+                ret = btrfs_search_forward(root, &min_key, &max_key,
+                                           path, 0, newer_than);
+                if (ret != 0)
+                        goto none;
+                if (min_key.objectid != ino)
+                        goto none;
+                if (min_key.type != BTRFS_EXTENT_DATA_KEY)
+                        goto none;
+
+                leaf = path->nodes[0];
+                extent = btrfs_item_ptr(leaf, path->slots[0],
+                                        struct btrfs_file_extent_item);
+
+                type = btrfs_file_extent_type(leaf, extent);
+                if (type == BTRFS_FILE_EXTENT_REG &&
+                    btrfs_file_extent_num_bytes(leaf, extent) < thresh &&
+                    check_defrag_in_cache(inode, min_key.offset, thresh)) {
+                        *off = min_key.offset;
+                        btrfs_free_path(path);
+                        return 0;
+                }
+
+                if (min_key.offset == (u64)-1)
+                        goto none;
+
+                min_key.offset++;
+                btrfs_release_path(path);
+        }
+none:
+        btrfs_free_path(path);
+        return -ENOENT;
+}
+
 static int should_defrag_range(struct inode *inode, u64 start, u64 len,
                                int thresh, u64 *last_len, u64 *skip,
                                u64 *defrag_end)
@@ -470,10 +767,6 @@ static int should_defrag_range(struct inode *inode, u64 start, u64 len,
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         int ret = 1;
 
-
-        if (thresh == 0)
-                thresh = 256 * 1024;
-
         /*
          * make sure that once we start defragging and extent, we keep on
          * defragging it
@@ -532,28 +825,208 @@ static int should_defrag_range(struct inode *inode, u64 start, u64 len,
         return ret;
 }
 
-static int btrfs_defrag_file(struct file *file,
-                             struct btrfs_ioctl_defrag_range_args *range)
+/*
+ * it doesn't do much good to defrag one or two pages
+ * at a time.  This pulls in a nice chunk of pages
+ * to COW and defrag.
+ *
+ * It also makes sure the delalloc code has enough
+ * dirty data to avoid making new small extents as part
+ * of the defrag
+ *
+ * It's a good idea to start RA on this range
+ * before calling this.
+ */
+static int cluster_pages_for_defrag(struct inode *inode,
+                                    struct page **pages,
+                                    unsigned long start_index,
+                                    int num_pages)
 {
-        struct inode *inode = fdentry(file)->d_inode;
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
-        struct btrfs_ordered_extent *ordered;
-        struct page *page;
-        unsigned long last_index;
-        unsigned long ra_pages = root->fs_info->bdi.ra_pages;
-        unsigned long total_read = 0;
+        unsigned long file_end;
+        u64 isize = i_size_read(inode);
         u64 page_start;
         u64 page_end;
+        int ret;
+        int i;
+        int i_done;
+        struct btrfs_ordered_extent *ordered;
+        struct extent_state *cached_state = NULL;
+
+        if (isize == 0)
+                return 0;
+        file_end = (isize - 1) >> PAGE_CACHE_SHIFT;
+
+        ret = btrfs_delalloc_reserve_space(inode,
+                                           num_pages << PAGE_CACHE_SHIFT);
+        if (ret)
+                return ret;
+again:
+        ret = 0;
+        i_done = 0;
+
+        /* step one, lock all the pages */
+        for (i = 0; i < num_pages; i++) {
+                struct page *page;
+                page = grab_cache_page(inode->i_mapping,
+                                            start_index + i);
+                if (!page)
+                        break;
+
+                if (!PageUptodate(page)) {
+                        btrfs_readpage(NULL, page);
+                        lock_page(page);
+                        if (!PageUptodate(page)) {
+                                unlock_page(page);
+                                page_cache_release(page);
+                                ret = -EIO;
+                                break;
+                        }
+                }
+                isize = i_size_read(inode);
+                file_end = (isize - 1) >> PAGE_CACHE_SHIFT;
+                if (!isize || page->index > file_end ||
+                    page->mapping != inode->i_mapping) {
+                        /* whoops, we blew past eof, skip this page */
+                        unlock_page(page);
+                        page_cache_release(page);
+                        break;
+                }
+                pages[i] = page;
+                i_done++;
+        }
+        if (!i_done || ret)
+                goto out;
+
+        if (!(inode->i_sb->s_flags & MS_ACTIVE))
+                goto out;
+
+        /*
+         * so now we have a nice long stream of locked
+         * and up to date pages, lets wait on them
+         */
+        for (i = 0; i < i_done; i++)
+                wait_on_page_writeback(pages[i]);
+
+        page_start = page_offset(pages[0]);
+        page_end = page_offset(pages[i_done - 1]) + PAGE_CACHE_SIZE;
+
+        lock_extent_bits(&BTRFS_I(inode)->io_tree,
+                         page_start, page_end - 1, 0, &cached_state,
+                         GFP_NOFS);
+        ordered = btrfs_lookup_first_ordered_extent(inode, page_end - 1);
+        if (ordered &&
+            ordered->file_offset + ordered->len > page_start &&
+            ordered->file_offset < page_end) {
+                btrfs_put_ordered_extent(ordered);
+                unlock_extent_cached(&BTRFS_I(inode)->io_tree,
+                                     page_start, page_end - 1,
+                                     &cached_state, GFP_NOFS);
+                for (i = 0; i < i_done; i++) {
+                        unlock_page(pages[i]);
+                        page_cache_release(pages[i]);
+                }
+                btrfs_wait_ordered_range(inode, page_start,
+                                         page_end - page_start);
+                goto again;
+        }
+        if (ordered)
+                btrfs_put_ordered_extent(ordered);
+
+        clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start,
+                          page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
+                          EXTENT_DO_ACCOUNTING, 0, 0, &cached_state,
+                          GFP_NOFS);
+
+        if (i_done != num_pages) {
+                atomic_inc(&BTRFS_I(inode)->outstanding_extents);
+                btrfs_delalloc_release_space(inode,
+                                     (num_pages - i_done) << PAGE_CACHE_SHIFT);
+        }
+
+
+        btrfs_set_extent_delalloc(inode, page_start, page_end - 1,
+                                  &cached_state);
+
+        unlock_extent_cached(&BTRFS_I(inode)->io_tree,
+                             page_start, page_end - 1, &cached_state,
+                             GFP_NOFS);
+
+        for (i = 0; i < i_done; i++) {
+                clear_page_dirty_for_io(pages[i]);
+                ClearPageChecked(pages[i]);
+                set_page_extent_mapped(pages[i]);
+                set_page_dirty(pages[i]);
+                unlock_page(pages[i]);
+                page_cache_release(pages[i]);
+        }
+        return i_done;
+out:
+        for (i = 0; i < i_done; i++) {
+                unlock_page(pages[i]);
+                page_cache_release(pages[i]);
+        }
+        btrfs_delalloc_release_space(inode, num_pages << PAGE_CACHE_SHIFT);
+        return ret;
+
+}
+
+int btrfs_defrag_file(struct inode *inode, struct file *file,
+                      struct btrfs_ioctl_defrag_range_args *range,
+                      u64 newer_than, unsigned long max_to_defrag)
+{
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct btrfs_super_block *disk_super;
+        struct file_ra_state *ra = NULL;
+        unsigned long last_index;
+        u64 features;
         u64 last_len = 0;
         u64 skip = 0;
         u64 defrag_end = 0;
+        u64 newer_off = range->start;
+        int newer_left = 0;
         unsigned long i;
         int ret;
+        int defrag_count = 0;
+        int compress_type = BTRFS_COMPRESS_ZLIB;
+        int extent_thresh = range->extent_thresh;
+        int newer_cluster = (256 * 1024) >> PAGE_CACHE_SHIFT;
+        u64 new_align = ~((u64)128 * 1024 - 1);
+        struct page **pages = NULL;
+
+        if (extent_thresh == 0)
+                extent_thresh = 256 * 1024;
+
+        if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) {
+                if (range->compress_type > BTRFS_COMPRESS_TYPES)
+                        return -EINVAL;
+                if (range->compress_type)
+                        compress_type = range->compress_type;
+        }
 
         if (inode->i_size == 0)
                 return 0;
 
+        /*
+         * if we were not given a file, allocate a readahead
+         * context
+         */
+        if (!file) {
+                ra = kzalloc(sizeof(*ra), GFP_NOFS);
+                if (!ra)
+                        return -ENOMEM;
+                file_ra_state_init(ra, inode->i_mapping);
+        } else {
+                ra = &file->f_ra;
+        }
+
+        pages = kmalloc(sizeof(struct page *) * newer_cluster,
+                        GFP_NOFS);
+        if (!pages) {
+                ret = -ENOMEM;
+                goto out_ra;
+        }
+
+        /* find the last page to defrag */
         if (range->start + range->len > range->start) {
                 last_index = min_t(u64, inode->i_size - 1,
                          range->start + range->len - 1) >> PAGE_CACHE_SHIFT;
@@ -561,11 +1034,37 @@ static int btrfs_defrag_file(struct file *file,
                 last_index = (inode->i_size - 1) >> PAGE_CACHE_SHIFT;
         }
 
-        i = range->start >> PAGE_CACHE_SHIFT;
-        while (i <= last_index) {
-                if (!should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
+        if (newer_than) {
+                ret = find_new_extents(root, inode, newer_than,
+                                       &newer_off, 64 * 1024);
+                if (!ret) {
+                        range->start = newer_off;
+                        /*
+                         * we always align our defrag to help keep
+                         * the extents in the file evenly spaced
+                         */
+                        i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
+                        newer_left = newer_cluster;
+                } else
+                        goto out_ra;
+        } else {
+                i = range->start >> PAGE_CACHE_SHIFT;
+        }
+        if (!max_to_defrag)
+                max_to_defrag = last_index - 1;
+
+        while (i <= last_index && defrag_count < max_to_defrag) {
+                /*
+                 * make sure we stop running if someone unmounts
+                 * the FS
+                 */
+                if (!(inode->i_sb->s_flags & MS_ACTIVE))
+                        break;
+
+                if (!newer_than &&
+                    !should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
                                         PAGE_CACHE_SIZE,
-                                        range->extent_thresh,
+                                        extent_thresh,
                                         &last_len, &skip,
                                         &defrag_end)) {
                         unsigned long next;
@@ -577,92 +1076,39 @@ static int btrfs_defrag_file(struct file *file,
                         i = max(i + 1, next);
                         continue;
                 }
-
-                if (total_read % ra_pages == 0) {
-                        btrfs_force_ra(inode->i_mapping, &file->f_ra, file, i,
-                                       min(last_index, i + ra_pages - 1));
-                }
-                total_read++;
-                mutex_lock(&inode->i_mutex);
                 if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)
-                        BTRFS_I(inode)->force_compress = 1;
+                        BTRFS_I(inode)->force_compress = compress_type;
 
-                ret  = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
-                if (ret)
-                        goto err_unlock;
-again:
-                if (inode->i_size == 0 ||
-                    i > ((inode->i_size - 1) >> PAGE_CACHE_SHIFT)) {
-                        ret = 0;
-                        goto err_reservations;
-                }
+                btrfs_force_ra(inode->i_mapping, ra, file, i, newer_cluster);
 
-                page = grab_cache_page(inode->i_mapping, i);
-                if (!page) {
-                        ret = -ENOMEM;
-                        goto err_reservations;
-                }
-
-                if (!PageUptodate(page)) {
-                        btrfs_readpage(NULL, page);
-                        lock_page(page);
-                        if (!PageUptodate(page)) {
-                                unlock_page(page);
-                                page_cache_release(page);
-                                ret = -EIO;
-                                goto err_reservations;
-                        }
-                }
-
-                if (page->mapping != inode->i_mapping) {
-                        unlock_page(page);
-                        page_cache_release(page);
-                        goto again;
-                }
-
-                wait_on_page_writeback(page);
+                ret = cluster_pages_for_defrag(inode, pages, i, newer_cluster);
+                if (ret < 0)
+                        goto out_ra;
 
-                if (PageDirty(page)) {
-                        btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
-                        goto loop_unlock;
-                }
+                defrag_count += ret;
+                balance_dirty_pages_ratelimited_nr(inode->i_mapping, ret);
+                i += ret;
 
-                page_start = (u64)page->index << PAGE_CACHE_SHIFT;
-                page_end = page_start + PAGE_CACHE_SIZE - 1;
-                lock_extent(io_tree, page_start, page_end, GFP_NOFS);
+                if (newer_than) {
+                        if (newer_off == (u64)-1)
+                                break;
 
-                ordered = btrfs_lookup_ordered_extent(inode, page_start);
-                if (ordered) {
-                        unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
-                        unlock_page(page);
-                        page_cache_release(page);
-                        btrfs_start_ordered_extent(inode, ordered, 1);
-                        btrfs_put_ordered_extent(ordered);
-                        goto again;
+                        newer_off = max(newer_off + 1,
+                                        (u64)i << PAGE_CACHE_SHIFT);
+
+                        ret = find_new_extents(root, inode,
+                                               newer_than, &newer_off,
+                                               64 * 1024);
+                        if (!ret) {
+                                range->start = newer_off;
+                                i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
+                                newer_left = newer_cluster;
+                        } else {
+                                break;
+                        }
+                } else {
+                        i++;
                 }
-                set_page_extent_mapped(page);
-
-                /*
-                 * this makes sure page_mkwrite is called on the
-                 * page if it is dirtied again later
-                 */
-                clear_page_dirty_for_io(page);
-                clear_extent_bits(&BTRFS_I(inode)->io_tree, page_start,
-                                  page_end, EXTENT_DIRTY | EXTENT_DELALLOC |
-                                  EXTENT_DO_ACCOUNTING, GFP_NOFS);
-
-                btrfs_set_extent_delalloc(inode, page_start, page_end, NULL);
-                ClearPageChecked(page);
-                set_page_dirty(page);
-                unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
-
-loop_unlock:
-                unlock_page(page);
-                page_cache_release(page);
-                mutex_unlock(&inode->i_mutex);
-
-                balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1);
-                i++;
         }
 
         if ((range->flags & BTRFS_DEFRAG_RANGE_START_IO))
@@ -683,16 +1129,25 @@ loop_unlock:
                 atomic_dec(&root->fs_info->async_submit_draining);
 
                 mutex_lock(&inode->i_mutex);
-                BTRFS_I(inode)->force_compress = 0;
+                BTRFS_I(inode)->force_compress = BTRFS_COMPRESS_NONE;
                 mutex_unlock(&inode->i_mutex);
         }
 
-        return 0;
+        disk_super = &root->fs_info->super_copy;
+        features = btrfs_super_incompat_flags(disk_super);
+        if (range->compress_type == BTRFS_COMPRESS_LZO) {
+                features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
+                btrfs_set_super_incompat_flags(disk_super, features);
+        }
 
-err_reservations:
-        btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
-err_unlock:
-        mutex_unlock(&inode->i_mutex);
+        if (!file)
+                kfree(ra);
+        return defrag_count;
+
+out_ra:
+        if (!file)
+                kfree(ra);
+        kfree(pages);
         return ret;
 }
 
@@ -708,7 +1163,6 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
         char *sizestr;
         char *devstr = NULL;
         int ret = 0;
-        int namelen;
         int mod = 0;
 
         if (root->fs_info->sb->s_flags & MS_RDONLY)
@@ -722,7 +1176,6 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
                 return PTR_ERR(vol_args);
 
         vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
-        namelen = strlen(vol_args->name);
 
         mutex_lock(&root->fs_info->volume_mutex);
         sizestr = vol_args->name;
@@ -789,6 +1242,10 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
 
         if (new_size > old_size) {
                 trans = btrfs_start_transaction(root, 0);
+                if (IS_ERR(trans)) {
+                        ret = PTR_ERR(trans);
+                        goto out_unlock;
+                }
                 ret = btrfs_grow_device(trans, device, new_size);
                 btrfs_commit_transaction(trans, root);
         } else {
@@ -801,11 +1258,14 @@ out_unlock:
         return ret;
 }
 
-static noinline int btrfs_ioctl_snap_create(struct file *file,
-                                            void __user *arg, int subvol)
+static noinline int btrfs_ioctl_snap_create_transid(struct file *file,
+                                                    char *name,
+                                                    unsigned long fd,
+                                                    int subvol,
+                                                    u64 *transid,
+                                                    bool readonly)
 {
         struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
-        struct btrfs_ioctl_vol_args *vol_args;
         struct file *src_file;
         int namelen;
         int ret = 0;
@@ -813,23 +1273,18 @@ static noinline int btrfs_ioctl_snap_create(struct file *file,
         if (root->fs_info->sb->s_flags & MS_RDONLY)
                 return -EROFS;
 
-        vol_args = memdup_user(arg, sizeof(*vol_args));
-        if (IS_ERR(vol_args))
-                return PTR_ERR(vol_args);
-
-        vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
-        namelen = strlen(vol_args->name);
-        if (strchr(vol_args->name, '/')) {
+        namelen = strlen(name);
+        if (strchr(name, '/')) {
                 ret = -EINVAL;
                 goto out;
         }
 
         if (subvol) {
-                ret = btrfs_mksubvol(&file->f_path, vol_args->name, namelen,
-                                     NULL);
+                ret = btrfs_mksubvol(&file->f_path, name, namelen,
+                                     NULL, transid, readonly);
         } else {
                 struct inode *src_inode;
-                src_file = fget(vol_args->fd);
+                src_file = fget(fd);
                 if (!src_file) {
                         ret = -EINVAL;
                         goto out;
@@ -843,15 +1298,155 @@ static noinline int btrfs_ioctl_snap_create(struct file *file,
                         fput(src_file);
                         goto out;
                 }
-                ret = btrfs_mksubvol(&file->f_path, vol_args->name, namelen,
-                                     BTRFS_I(src_inode)->root);
+                ret = btrfs_mksubvol(&file->f_path, name, namelen,
+                                     BTRFS_I(src_inode)->root,
+                                     transid, readonly);
                 fput(src_file);
         }
 out:
+        return ret;
+}
+
+static noinline int btrfs_ioctl_snap_create(struct file *file,
+                                            void __user *arg, int subvol)
+{
+        struct btrfs_ioctl_vol_args *vol_args;
+        int ret;
+
+        vol_args = memdup_user(arg, sizeof(*vol_args));
+        if (IS_ERR(vol_args))
+                return PTR_ERR(vol_args);
+        vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
+
+        ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
+                                              vol_args->fd, subvol,
+                                              NULL, false);
+
+        kfree(vol_args);
+        return ret;
+}
+
+static noinline int btrfs_ioctl_snap_create_v2(struct file *file,
+                                               void __user *arg, int subvol)
+{
+        struct btrfs_ioctl_vol_args_v2 *vol_args;
+        int ret;
+        u64 transid = 0;
+        u64 *ptr = NULL;
+        bool readonly = false;
+
+        vol_args = memdup_user(arg, sizeof(*vol_args));
+        if (IS_ERR(vol_args))
+                return PTR_ERR(vol_args);
+        vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0';
+
+        if (vol_args->flags &
+            ~(BTRFS_SUBVOL_CREATE_ASYNC | BTRFS_SUBVOL_RDONLY)) {
+                ret = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (vol_args->flags & BTRFS_SUBVOL_CREATE_ASYNC)
+                ptr = &transid;
+        if (vol_args->flags & BTRFS_SUBVOL_RDONLY)
+                readonly = true;
+
+        ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
+                                              vol_args->fd, subvol,
+                                              ptr, readonly);
+
+        if (ret == 0 && ptr &&
+            copy_to_user(arg +
+                         offsetof(struct btrfs_ioctl_vol_args_v2,
+                                  transid), ptr, sizeof(*ptr)))
+                ret = -EFAULT;
+out:
         kfree(vol_args);
         return ret;
 }
 
+static noinline int btrfs_ioctl_subvol_getflags(struct file *file,
+                                                void __user *arg)
+{
+        struct inode *inode = fdentry(file)->d_inode;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret = 0;
+        u64 flags = 0;
+
+        if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID)
+                return -EINVAL;
+
+        down_read(&root->fs_info->subvol_sem);
+        if (btrfs_root_readonly(root))
+                flags |= BTRFS_SUBVOL_RDONLY;
+        up_read(&root->fs_info->subvol_sem);
+
+        if (copy_to_user(arg, &flags, sizeof(flags)))
+                ret = -EFAULT;
+
+        return ret;
+}
+
+static noinline int btrfs_ioctl_subvol_setflags(struct file *file,
+                                              void __user *arg)
+{
+        struct inode *inode = fdentry(file)->d_inode;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct btrfs_trans_handle *trans;
+        u64 root_flags;
+        u64 flags;
+        int ret = 0;
+
+        if (root->fs_info->sb->s_flags & MS_RDONLY)
+                return -EROFS;
+
+        if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID)
+                return -EINVAL;
+
+        if (copy_from_user(&flags, arg, sizeof(flags)))
+                return -EFAULT;
+
+        if (flags & BTRFS_SUBVOL_CREATE_ASYNC)
+                return -EINVAL;
+
+        if (flags & ~BTRFS_SUBVOL_RDONLY)
+                return -EOPNOTSUPP;
+
+        if (!inode_owner_or_capable(inode))
+                return -EACCES;
+
+        down_write(&root->fs_info->subvol_sem);
+
+        /* nothing to do */
+        if (!!(flags & BTRFS_SUBVOL_RDONLY) == btrfs_root_readonly(root))
+                goto out;
+
+        root_flags = btrfs_root_flags(&root->root_item);
+        if (flags & BTRFS_SUBVOL_RDONLY)
+                btrfs_set_root_flags(&root->root_item,
+                                     root_flags | BTRFS_ROOT_SUBVOL_RDONLY);
+        else
+                btrfs_set_root_flags(&root->root_item,
+                                     root_flags & ~BTRFS_ROOT_SUBVOL_RDONLY);
+
+        trans = btrfs_start_transaction(root, 1);
+        if (IS_ERR(trans)) {
+                ret = PTR_ERR(trans);
+                goto out_reset;
+        }
+
+        ret = btrfs_update_root(trans, root->fs_info->tree_root,
+                                &root->root_key, &root->root_item);
+
+        btrfs_commit_transaction(trans, root);
+out_reset:
+        if (ret)
+                btrfs_set_root_flags(&root->root_item, root_flags);
+out:
+        up_write(&root->fs_info->subvol_sem);
+        return ret;
+}
+
 /*
  * helper to check if the subvolume references other subvolumes
  */
@@ -928,7 +1523,6 @@ static noinline int copy_to_sk(struct btrfs_root *root,
         int nritems;
         int i;
         int slot;
-        int found = 0;
         int ret = 0;
 
         leaf = path->nodes[0];
@@ -975,7 +1569,7 @@ static noinline int copy_to_sk(struct btrfs_root *root,
                                            item_off, item_len);
                         *sk_offset += item_len;
                 }
-                found++;
+                (*num_found)++;
 
                 if (*num_found >= sk->nr_items)
                         break;
@@ -994,7 +1588,6 @@ advance_key:
         } else
                 ret = 1;
 overflow:
-        *num_found += found;
         return ret;
 }
 
@@ -1051,7 +1644,7 @@ static noinline int search_ioctl(struct inode *inode,
                 }
                 ret = copy_to_sk(root, path, &key, sk, args->buf,
                                  &sk_offset, &num_found);
-                btrfs_release_path(root, path);
+                btrfs_release_path(path);
                 if (ret || num_found >= sk->nr_items)
                         break;
 
@@ -1073,14 +1666,10 @@ static noinline int btrfs_ioctl_tree_search(struct file *file,
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        args = kmalloc(sizeof(*args), GFP_KERNEL);
-        if (!args)
-                return -ENOMEM;
+        args = memdup_user(argp, sizeof(*args));
+        if (IS_ERR(args))
+                return PTR_ERR(args);
 
-        if (copy_from_user(args, argp, sizeof(*args))) {
-                kfree(args);
-                return -EFAULT;
-        }
         inode = fdentry(file)->d_inode;
         ret = search_ioctl(inode, args);
         if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
@@ -1162,7 +1751,7 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
                 if (key.offset == BTRFS_FIRST_FREE_OBJECTID)
                         break;
 
-                btrfs_release_path(root, path);
+                btrfs_release_path(path);
                 key.objectid = key.offset;
                 key.offset = (u64)-1;
                 dirid = key.objectid;
@@ -1188,14 +1777,10 @@ static noinline int btrfs_ioctl_ino_lookup(struct file *file,
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        args = kmalloc(sizeof(*args), GFP_KERNEL);
-        if (!args)
-                return -ENOMEM;
+        args = memdup_user(argp, sizeof(*args));
+        if (IS_ERR(args))
+                return PTR_ERR(args);
 
-        if (copy_from_user(args, argp, sizeof(*args))) {
-                kfree(args);
-                return -EFAULT;
-        }
         inode = fdentry(file)->d_inode;
 
         if (args->treeid == 0)
@@ -1227,9 +1812,6 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
         int ret;
         int err = 0;
 
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-
         vol_args = memdup_user(arg, sizeof(*vol_args));
         if (IS_ERR(vol_args))
                 return PTR_ERR(vol_args);
@@ -1259,12 +1841,50 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
         }
 
         inode = dentry->d_inode;
-        if (inode->i_ino != BTRFS_FIRST_FREE_OBJECTID) {
+        dest = BTRFS_I(inode)->root;
+        if (!capable(CAP_SYS_ADMIN)){
+                /*
+                 * Regular user.  Only allow this with a special mount
+                 * option, when the user has write+exec access to the
+                 * subvol root, and when rmdir(2) would have been
+                 * allowed.
+                 *
+                 * Note that this is _not_ check that the subvol is
+                 * empty or doesn't contain data that we wouldn't
+                 * otherwise be able to delete.
+                 *
+                 * Users who want to delete empty subvols should try
+                 * rmdir(2).
+                 */
+                err = -EPERM;
+                if (!btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
+                        goto out_dput;
+
+                /*
+                 * Do not allow deletion if the parent dir is the same
+                 * as the dir to be deleted.  That means the ioctl
+                 * must be called on the dentry referencing the root
+                 * of the subvol, not a random directory contained
+                 * within it.
+                 */
                 err = -EINVAL;
-                goto out_dput;
+                if (root == dest)
+                        goto out_dput;
+
+                err = inode_permission(inode, MAY_WRITE | MAY_EXEC);
+                if (err)
+                        goto out_dput;
+
+                /* check if subvolume may be deleted by a non-root user */
+                err = btrfs_may_delete(dir, dentry, 1);
+                if (err)
+                        goto out_dput;
         }
 
-        dest = BTRFS_I(inode)->root;
+        if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
+                err = -EINVAL;
+                goto out_dput;
+        }
 
         mutex_lock(&inode->i_mutex);
         err = d_invalidate(dentry);
@@ -1304,7 +1924,7 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
                 BUG_ON(ret);
         }
 
-        ret = btrfs_commit_transaction(trans, root);
+        ret = btrfs_end_transaction(trans, root);
         BUG_ON(ret);
         inode->i_flags |= S_DEAD;
 out_up_write:
@@ -1333,6 +1953,9 @@ static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
         struct btrfs_ioctl_defrag_range_args *range;
         int ret;
 
+        if (btrfs_root_readonly(root))
+                return -EROFS;
+
         ret = mnt_want_write(file->f_path.mnt);
         if (ret)
                 return ret;
@@ -1376,7 +1999,10 @@ static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
                         /* the rest are all set to zero by kzalloc */
                         range->len = (u64)-1;
                 }
-                ret = btrfs_defrag_file(file, range);
+                ret = btrfs_defrag_file(fdentry(file)->d_inode, file,
+                                        range, 0, 0);
+                if (ret > 0)
+                        ret = 0;
                 kfree(range);
                 break;
         default:
@@ -1428,6 +2054,80 @@ static long btrfs_ioctl_rm_dev(struct btrfs_root *root, void __user *arg)
         return ret;
 }
 
+static long btrfs_ioctl_fs_info(struct btrfs_root *root, void __user *arg)
+{
+        struct btrfs_ioctl_fs_info_args *fi_args;
+        struct btrfs_device *device;
+        struct btrfs_device *next;
+        struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
+        int ret = 0;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        fi_args = kzalloc(sizeof(*fi_args), GFP_KERNEL);
+        if (!fi_args)
+                return -ENOMEM;
+
+        fi_args->num_devices = fs_devices->num_devices;
+        memcpy(&fi_args->fsid, root->fs_info->fsid, sizeof(fi_args->fsid));
+
+        mutex_lock(&fs_devices->device_list_mutex);
+        list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
+                if (device->devid > fi_args->max_id)
+                        fi_args->max_id = device->devid;
+        }
+        mutex_unlock(&fs_devices->device_list_mutex);
+
+        if (copy_to_user(arg, fi_args, sizeof(*fi_args)))
+                ret = -EFAULT;
+
+        kfree(fi_args);
+        return ret;
+}
+
+static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg)
+{
+        struct btrfs_ioctl_dev_info_args *di_args;
+        struct btrfs_device *dev;
+        struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
+        int ret = 0;
+        char *s_uuid = NULL;
+        char empty_uuid[BTRFS_UUID_SIZE] = {0};
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        di_args = memdup_user(arg, sizeof(*di_args));
+        if (IS_ERR(di_args))
+                return PTR_ERR(di_args);
+
+        if (memcmp(empty_uuid, di_args->uuid, BTRFS_UUID_SIZE) != 0)
+                s_uuid = di_args->uuid;
+
+        mutex_lock(&fs_devices->device_list_mutex);
+        dev = btrfs_find_device(root, di_args->devid, s_uuid, NULL);
+        mutex_unlock(&fs_devices->device_list_mutex);
+
+        if (!dev) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        di_args->devid = dev->devid;
+        di_args->bytes_used = dev->bytes_used;
+        di_args->total_bytes = dev->total_bytes;
+        memcpy(di_args->uuid, dev->uuid, sizeof(di_args->uuid));
+        strncpy(di_args->path, dev->name, sizeof(di_args->path));
+
+out:
+        if (ret == 0 && copy_to_user(arg, di_args, sizeof(*di_args)))
+                ret = -EFAULT;
+
+        kfree(di_args);
+        return ret;
+}
+
 static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                        u64 off, u64 olen, u64 destoff)
 {
@@ -1461,6 +2161,9 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
         if (!(file->f_mode & FMODE_WRITE) || (file->f_flags & O_APPEND))
                 return -EINVAL;
 
+        if (btrfs_root_readonly(root))
+                return -EROFS;
+
         ret = mnt_want_write(file->f_path.mnt);
         if (ret)
                 return ret;
@@ -1502,11 +2205,11 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
         path->reada = 2;
 
         if (inode < src) {
-                mutex_lock(&inode->i_mutex);
-                mutex_lock(&src->i_mutex);
+                mutex_lock_nested(&inode->i_mutex, I_MUTEX_PARENT);
+                mutex_lock_nested(&src->i_mutex, I_MUTEX_CHILD);
         } else {
-                mutex_lock(&src->i_mutex);
-                mutex_lock(&inode->i_mutex);
+                mutex_lock_nested(&src->i_mutex, I_MUTEX_PARENT);
+                mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
         }
 
         /* determine range to clone */
@@ -1517,12 +2220,11 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                 olen = len = src->i_size - off;
         /* if we extend to eof, continue to block boundary */
         if (off + len == src->i_size)
-                len = ((src->i_size + bs-1) & ~(bs-1))
-                        - off;
+                len = ALIGN(src->i_size, bs) - off;
 
         /* verify the end result is block aligned */
-        if ((off & (bs-1)) ||
-            ((off + len) & (bs-1)))
+        if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs) ||
+            !IS_ALIGNED(destoff, bs))
                 goto out_unlock;
 
         /* do any pending delalloc/csum calc on src, one way or
@@ -1530,17 +2232,19 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
         while (1) {
                 struct btrfs_ordered_extent *ordered;
                 lock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS);
-                ordered = btrfs_lookup_first_ordered_extent(inode, off+len);
-                if (BTRFS_I(src)->delalloc_bytes == 0 && !ordered)
+                ordered = btrfs_lookup_first_ordered_extent(src, off+len);
+                if (!ordered &&
+                    !test_range_bit(&BTRFS_I(src)->io_tree, off, off+len,
+                                   EXTENT_DELALLOC, 0, NULL))
                         break;
                 unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS);
                 if (ordered)
                         btrfs_put_ordered_extent(ordered);
-                btrfs_wait_ordered_range(src, off, off+len);
+                btrfs_wait_ordered_range(src, off, len);
         }
 
         /* clone data */
-        key.objectid = src->i_ino;
+        key.objectid = btrfs_ino(src);
         key.type = BTRFS_EXTENT_DATA_KEY;
         key.offset = 0;
 
@@ -1567,7 +2271,7 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
 
                 btrfs_item_key_to_cpu(leaf, &key, slot);
                 if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY ||
-                    key.objectid != src->i_ino)
+                    key.objectid != btrfs_ino(src))
                         break;
 
                 if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
@@ -1603,15 +2307,18 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                 datal = btrfs_file_extent_ram_bytes(leaf,
                                                                     extent);
                         }
-                        btrfs_release_path(root, path);
+                        btrfs_release_path(path);
 
-                        if (key.offset + datal < off ||
+                        if (key.offset + datal <= off ||
                             key.offset >= off+len)
                                 goto next;
 
                         memcpy(&new_key, &key, sizeof(new_key));
-                        new_key.objectid = inode->i_ino;
-                        new_key.offset = key.offset + destoff - off;
+                        new_key.objectid = btrfs_ino(inode);
+                        if (off <= key.offset)
+                                new_key.offset = key.offset + destoff - off;
+                        else
+                                new_key.offset = destoff;
 
                         trans = btrfs_start_transaction(root, 1);
                         if (IS_ERR(trans)) {
@@ -1661,7 +2368,7 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                         ret = btrfs_inc_extent_ref(trans, root,
                                                         disko, diskl, 0,
                                                         root->root_key.objectid,
-                                                        inode->i_ino,
+                                                        btrfs_ino(inode),
                                                         new_key.offset - datao);
                                         BUG_ON(ret);
                                 }
@@ -1710,7 +2417,7 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                         }
 
                         btrfs_mark_buffer_dirty(leaf);
-                        btrfs_release_path(root, path);
+                        btrfs_release_path(path);
 
                         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 
@@ -1720,8 +2427,8 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                          * but shouldn't round up the file size
                          */
                         endoff = new_key.offset + datal;
-                        if (endoff > off+olen)
-                                endoff = off+olen;
+                        if (endoff > destoff+olen)
+                                endoff = destoff+olen;
                         if (endoff > inode->i_size)
                                 btrfs_i_size_write(inode, endoff);
 
@@ -1731,12 +2438,12 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                         btrfs_end_transaction(trans, root);
                 }
 next:
-                btrfs_release_path(root, path);
+                btrfs_release_path(path);
                 key.offset++;
         }
         ret = 0;
 out:
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
         unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS);
 out_unlock:
         mutex_unlock(&src->i_mutex);
@@ -1781,26 +2488,26 @@ static long btrfs_ioctl_trans_start(struct file *file)
         if (file->private_data)
                 goto out;
 
+        ret = -EROFS;
+        if (btrfs_root_readonly(root))
+                goto out;
+
         ret = mnt_want_write(file->f_path.mnt);
         if (ret)
                 goto out;
 
-        mutex_lock(&root->fs_info->trans_mutex);
-        root->fs_info->open_ioctl_trans++;
-        mutex_unlock(&root->fs_info->trans_mutex);
+        atomic_inc(&root->fs_info->open_ioctl_trans);
 
         ret = -ENOMEM;
-        trans = btrfs_start_ioctl_transaction(root, 0);
-        if (!trans)
+        trans = btrfs_start_ioctl_transaction(root);
+        if (IS_ERR(trans))
                 goto out_drop;
 
         file->private_data = trans;
         return 0;
 
 out_drop:
-        mutex_lock(&root->fs_info->trans_mutex);
-        root->fs_info->open_ioctl_trans--;
-        mutex_unlock(&root->fs_info->trans_mutex);
+        atomic_dec(&root->fs_info->open_ioctl_trans);
         mnt_drop_write(file->f_path.mnt);
 out:
         return ret;
@@ -1847,9 +2554,9 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
         path->leave_spinning = 1;
 
         trans = btrfs_start_transaction(root, 1);
-        if (!trans) {
+        if (IS_ERR(trans)) {
                 btrfs_free_path(path);
-                return -ENOMEM;
+                return PTR_ERR(trans);
         }
 
         dir_id = btrfs_super_root_dir(&root->fs_info->super_copy);
@@ -1879,35 +2586,80 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
         return 0;
 }
 
+static void get_block_group_info(struct list_head *groups_list,
+                                 struct btrfs_ioctl_space_info *space)
+{
+        struct btrfs_block_group_cache *block_group;
+
+        space->total_bytes = 0;
+        space->used_bytes = 0;
+        space->flags = 0;
+        list_for_each_entry(block_group, groups_list, list) {
+                space->flags = block_group->flags;
+                space->total_bytes += block_group->key.offset;
+                space->used_bytes +=
+                        btrfs_block_group_used(&block_group->item);
+        }
+}
+
 long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg)
 {
         struct btrfs_ioctl_space_args space_args;
         struct btrfs_ioctl_space_info space;
         struct btrfs_ioctl_space_info *dest;
         struct btrfs_ioctl_space_info *dest_orig;
-        struct btrfs_ioctl_space_info *user_dest;
+        struct btrfs_ioctl_space_info __user *user_dest;
         struct btrfs_space_info *info;
+        u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
+                       BTRFS_BLOCK_GROUP_SYSTEM,
+                       BTRFS_BLOCK_GROUP_METADATA,
+                       BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
+        int num_types = 4;
         int alloc_size;
         int ret = 0;
-        int slot_count = 0;
+        u64 slot_count = 0;
+        int i, c;
 
         if (copy_from_user(&space_args,
                            (struct btrfs_ioctl_space_args __user *)arg,
                            sizeof(space_args)))
                 return -EFAULT;
 
-        /* first we count slots */
-        rcu_read_lock();
-        list_for_each_entry_rcu(info, &root->fs_info->space_info, list)
-                slot_count++;
-        rcu_read_unlock();
+        for (i = 0; i < num_types; i++) {
+                struct btrfs_space_info *tmp;
+
+                info = NULL;
+                rcu_read_lock();
+                list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
+                                        list) {
+                        if (tmp->flags == types[i]) {
+                                info = tmp;
+                                break;
+                        }
+                }
+                rcu_read_unlock();
+
+                if (!info)
+                        continue;
+
+                down_read(&info->groups_sem);
+                for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
+                        if (!list_empty(&info->block_groups[c]))
+                                slot_count++;
+                }
+                up_read(&info->groups_sem);
+        }
 
         /* space_slots == 0 means they are asking for a count */
         if (space_args.space_slots == 0) {
                 space_args.total_spaces = slot_count;
                 goto out;
         }
+
+        slot_count = min_t(u64, space_args.space_slots, slot_count);
+
         alloc_size = sizeof(*dest) * slot_count;
+
         /* we generally have at most 6 or so space infos, one for each raid
          * level.  So, a whole page should be more than enough for everyone
          */
@@ -1921,27 +2673,40 @@ long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg)
         dest_orig = dest;
 
         /* now we have a buffer to copy into */
-        rcu_read_lock();
-        list_for_each_entry_rcu(info, &root->fs_info->space_info, list) {
-                /* make sure we don't copy more than we allocated
-                 * in our buffer
-                 */
-                if (slot_count == 0)
-                        break;
-                slot_count--;
+        for (i = 0; i < num_types; i++) {
+                struct btrfs_space_info *tmp;
 
-                /* make sure userland has enough room in their buffer */
-                if (space_args.total_spaces >= space_args.space_slots)
+                if (!slot_count)
                         break;
 
-                space.flags = info->flags;
-                space.total_bytes = info->total_bytes;
-                space.used_bytes = info->bytes_used;
-                memcpy(dest, &space, sizeof(space));
-                dest++;
-                space_args.total_spaces++;
+                info = NULL;
+                rcu_read_lock();
+                list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
+                                        list) {
+                        if (tmp->flags == types[i]) {
+                                info = tmp;
+                                break;
+                        }
+                }
+                rcu_read_unlock();
+
+                if (!info)
+                        continue;
+                down_read(&info->groups_sem);
+                for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
+                        if (!list_empty(&info->block_groups[c])) {
+                                get_block_group_info(&info->block_groups[c],
+                                                     &space);
+                                memcpy(dest, &space, sizeof(space));
+                                dest++;
+                                space_args.total_spaces++;
+                                slot_count--;
+                        }
+                        if (!slot_count)
+                                break;
+                }
+                up_read(&info->groups_sem);
         }
-        rcu_read_unlock();
 
         user_dest = (struct btrfs_ioctl_space_info *)
                 (arg + sizeof(struct btrfs_ioctl_space_args));
@@ -1976,14 +2741,101 @@ long btrfs_ioctl_trans_end(struct file *file)
 
         btrfs_end_transaction(trans, root);
 
-        mutex_lock(&root->fs_info->trans_mutex);
-        root->fs_info->open_ioctl_trans--;
-        mutex_unlock(&root->fs_info->trans_mutex);
+        atomic_dec(&root->fs_info->open_ioctl_trans);
 
         mnt_drop_write(file->f_path.mnt);
         return 0;
 }
 
+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;
+        ret = btrfs_commit_transaction_async(trans, root, 0);
+        if (ret) {
+                btrfs_end_transaction(trans, root);
+                return ret;
+        }
+
+        if (argp)
+                if (copy_to_user(argp, &transid, sizeof(transid)))
+                        return -EFAULT;
+        return 0;
+}
+
+static noinline long btrfs_ioctl_wait_sync(struct file *file, void __user *argp)
+{
+        struct btrfs_root *root = BTRFS_I(file->f_dentry->d_inode)->root;
+        u64 transid;
+
+        if (argp) {
+                if (copy_from_user(&transid, argp, sizeof(transid)))
+                        return -EFAULT;
+        } else {
+                transid = 0;  /* current trans */
+        }
+        return btrfs_wait_for_commit(root, transid);
+}
+
+static long btrfs_ioctl_scrub(struct btrfs_root *root, void __user *arg)
+{
+        int ret;
+        struct btrfs_ioctl_scrub_args *sa;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        sa = memdup_user(arg, sizeof(*sa));
+        if (IS_ERR(sa))
+                return PTR_ERR(sa);
+
+        ret = btrfs_scrub_dev(root, sa->devid, sa->start, sa->end,
+                              &sa->progress, sa->flags & BTRFS_SCRUB_READONLY);
+
+        if (copy_to_user(arg, sa, sizeof(*sa)))
+                ret = -EFAULT;
+
+        kfree(sa);
+        return ret;
+}
+
+static long btrfs_ioctl_scrub_cancel(struct btrfs_root *root, void __user *arg)
+{
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        return btrfs_scrub_cancel(root);
+}
+
+static long btrfs_ioctl_scrub_progress(struct btrfs_root *root,
+                                       void __user *arg)
+{
+        struct btrfs_ioctl_scrub_args *sa;
+        int ret;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        sa = memdup_user(arg, sizeof(*sa));
+        if (IS_ERR(sa))
+                return PTR_ERR(sa);
+
+        ret = btrfs_scrub_progress(root, sa->devid, &sa->progress);
+
+        if (copy_to_user(arg, sa, sizeof(*sa)))
+                ret = -EFAULT;
+
+        kfree(sa);
+        return ret;
+}
+
 long btrfs_ioctl(struct file *file, unsigned int
                 cmd, unsigned long arg)
 {
@@ -1997,12 +2849,20 @@ 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:
+                return btrfs_ioctl_snap_create_v2(file, argp, 0);
         case BTRFS_IOC_SUBVOL_CREATE:
                 return btrfs_ioctl_snap_create(file, argp, 1);
         case BTRFS_IOC_SNAP_DESTROY:
                 return btrfs_ioctl_snap_destroy(file, argp);
+        case BTRFS_IOC_SUBVOL_GETFLAGS:
+                return btrfs_ioctl_subvol_getflags(file, argp);
+        case BTRFS_IOC_SUBVOL_SETFLAGS:
+                return btrfs_ioctl_subvol_setflags(file, argp);
         case BTRFS_IOC_DEFAULT_SUBVOL:
                 return btrfs_ioctl_default_subvol(file, argp);
         case BTRFS_IOC_DEFRAG:
@@ -2015,6 +2875,10 @@ long btrfs_ioctl(struct file *file, unsigned int
                 return btrfs_ioctl_add_dev(root, argp);
         case BTRFS_IOC_RM_DEV:
                 return btrfs_ioctl_rm_dev(root, argp);
+        case BTRFS_IOC_FS_INFO:
+                return btrfs_ioctl_fs_info(root, argp);
+        case BTRFS_IOC_DEV_INFO:
+                return btrfs_ioctl_dev_info(root, argp);
         case BTRFS_IOC_BALANCE:
                 return btrfs_balance(root->fs_info->dev_root);
         case BTRFS_IOC_CLONE:
@@ -2034,6 +2898,16 @@ long btrfs_ioctl(struct file *file, unsigned int
         case BTRFS_IOC_SYNC:
                 btrfs_sync_fs(file->f_dentry->d_sb, 1);
                 return 0;
+        case BTRFS_IOC_START_SYNC:
+                return btrfs_ioctl_start_sync(file, argp);
+        case BTRFS_IOC_WAIT_SYNC:
+                return btrfs_ioctl_wait_sync(file, argp);
+        case BTRFS_IOC_SCRUB:
+                return btrfs_ioctl_scrub(root, argp);
+        case BTRFS_IOC_SCRUB_CANCEL:
+                return btrfs_ioctl_scrub_cancel(root, argp);
+        case BTRFS_IOC_SCRUB_PROGRESS:
+                return btrfs_ioctl_scrub_progress(root, argp);
         }
 
         return -ENOTTY;