Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux into sh-latest

Conflicts:
	drivers/tty/serial/sh-sci.c

Signed-off-by: Paul Mundt <lethal@linux-sh.org>

41 files changed, 874 insertions, 1080 deletions

diff --git a/fs/Kconfig b/fs/Kconfig
index 19891aab9c6e..9fe0b349f4cd 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -127,14 +127,21 @@ config TMPFS_POSIX_ACL
         select TMPFS_XATTR
         select GENERIC_ACL
         help
-          POSIX Access Control Lists (ACLs) support permissions for users and
-          groups beyond the owner/group/world scheme.
+          POSIX Access Control Lists (ACLs) support additional access rights
+          for users and groups beyond the standard owner/group/world scheme,
+          and this option selects support for ACLs specifically for tmpfs
+          filesystems.
+
+          If you've selected TMPFS, it's possible that you'll also need
+          this option as there are a number of Linux distros that require
+          POSIX ACL support under /dev for certain features to work properly.
+          For example, some distros need this feature for ALSA-related /dev
+          files for sound to work properly.  In short, if you're not sure,
+          say Y.
 
           To learn more about Access Control Lists, visit the POSIX ACLs for
           Linux website <http://acl.bestbits.at/>.
 
-          If you don't know what Access Control Lists are, say N.
-
 config TMPFS_XATTR
         bool "Tmpfs extended attributes"
         depends on TMPFS
diff --git a/fs/block_dev.c b/fs/block_dev.c
index f28680553288..ff77262e887c 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -387,6 +387,10 @@ int blkdev_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
         struct inode *bd_inode = filp->f_mapping->host;
         struct block_device *bdev = I_BDEV(bd_inode);
         int error;
+        
+        error = filemap_write_and_wait_range(filp->f_mapping, start, end);
+        if (error)
+                return error;
 
         /*
          * There is no need to serialise calls to blkdev_issue_flush with
diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
index 9b72dcf1cd25..40e6ac08c21f 100644
--- a/fs/btrfs/Makefile
+++ b/fs/btrfs/Makefile
@@ -6,5 +6,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
            transaction.o inode.o file.o tree-defrag.o \
            extent_map.o sysfs.o struct-funcs.o xattr.o ordered-data.o \
            extent_io.o volumes.o async-thread.o ioctl.o locking.o orphan.o \
-           export.o tree-log.o acl.o free-space-cache.o zlib.o lzo.o \
+           export.o tree-log.o free-space-cache.o zlib.o lzo.o \
            compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o
+
+btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o
diff --git a/fs/btrfs/acl.c b/fs/btrfs/acl.c
index 4cc5c0164ed6..eb159aaa5a11 100644
--- a/fs/btrfs/acl.c
+++ b/fs/btrfs/acl.c
@@ -28,8 +28,6 @@
 #include "btrfs_inode.h"
 #include "xattr.h"
 
-#ifdef CONFIG_BTRFS_FS_POSIX_ACL
-
 struct posix_acl *btrfs_get_acl(struct inode *inode, int type)
 {
         int size;
@@ -276,18 +274,3 @@ const struct xattr_handler btrfs_xattr_acl_access_handler = {
         .get    = btrfs_xattr_acl_get,
         .set    = btrfs_xattr_acl_set,
 };
-
-#else /* CONFIG_BTRFS_FS_POSIX_ACL */
-
-int btrfs_acl_chmod(struct inode *inode)
-{
-        return 0;
-}
-
-int btrfs_init_acl(struct btrfs_trans_handle *trans,
-                   struct inode *inode, struct inode *dir)
-{
-        return 0;
-}
-
-#endif /* CONFIG_BTRFS_FS_POSIX_ACL */
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index bfe42b03eaf9..8ec5d86f1734 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -338,6 +338,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
         u64 first_byte = disk_start;
         struct block_device *bdev;
         int ret;
+        int skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
         WARN_ON(start & ((u64)PAGE_CACHE_SIZE - 1));
         cb = kmalloc(compressed_bio_size(root, compressed_len), GFP_NOFS);
@@ -392,8 +393,11 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
                         ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
                         BUG_ON(ret);
 
-                        ret = btrfs_csum_one_bio(root, inode, bio, start, 1);
-                        BUG_ON(ret);
+                        if (!skip_sum) {
+                                ret = btrfs_csum_one_bio(root, inode, bio,
+                                                         start, 1);
+                                BUG_ON(ret);
+                        }
 
                         ret = btrfs_map_bio(root, WRITE, bio, 0, 1);
                         BUG_ON(ret);
@@ -418,8 +422,10 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
         ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
         BUG_ON(ret);
 
-        ret = btrfs_csum_one_bio(root, inode, bio, start, 1);
-        BUG_ON(ret);
+        if (!skip_sum) {
+                ret = btrfs_csum_one_bio(root, inode, bio, start, 1);
+                BUG_ON(ret);
+        }
 
         ret = btrfs_map_bio(root, WRITE, bio, 0, 1);
         BUG_ON(ret);
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 365c4e1dde04..0469263e327e 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2406,8 +2406,8 @@ int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
                          btrfs_root_item *item, struct btrfs_key *key);
 int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid);
 int btrfs_find_orphan_roots(struct btrfs_root *tree_root);
-int btrfs_set_root_node(struct btrfs_root_item *item,
-                        struct extent_buffer *node);
+void btrfs_set_root_node(struct btrfs_root_item *item,
+                         struct extent_buffer *node);
 void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
 
 /* dir-item.c */
@@ -2523,6 +2523,14 @@ struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *pag
 #define PageChecked PageFsMisc
 #endif
 
+/* This forces readahead on a given range of bytes in an inode */
+static inline void btrfs_force_ra(struct address_space *mapping,
+                                  struct file_ra_state *ra, struct file *file,
+                                  pgoff_t offset, unsigned long req_size)
+{
+        page_cache_sync_readahead(mapping, ra, file, offset, req_size);
+}
+
 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
 int btrfs_set_inode_index(struct inode *dir, u64 *index);
 int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
@@ -2551,9 +2559,6 @@ int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
 int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
                          size_t size, struct bio *bio, unsigned long bio_flags);
 
-unsigned long btrfs_force_ra(struct address_space *mapping,
-                              struct file_ra_state *ra, struct file *file,
-                              pgoff_t offset, pgoff_t last_index);
 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
 int btrfs_readpage(struct file *file, struct page *page);
 void btrfs_evict_inode(struct inode *inode);
@@ -2648,12 +2653,21 @@ do {								\
 /* acl.c */
 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
 struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
-#else
-#define btrfs_get_acl NULL
-#endif
 int btrfs_init_acl(struct btrfs_trans_handle *trans,
                    struct inode *inode, struct inode *dir);
 int btrfs_acl_chmod(struct inode *inode);
+#else
+#define btrfs_get_acl NULL
+static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
+                                 struct inode *inode, struct inode *dir)
+{
+        return 0;
+}
+static inline int btrfs_acl_chmod(struct inode *inode)
+{
+        return 0;
+}
+#endif
 
 /* relocation.c */
 int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start);
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index c360a848d97f..31d84e78129b 100644
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -198,8 +198,6 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
         struct btrfs_key key;
         int ins_len = mod < 0 ? -1 : 0;
         int cow = mod != 0;
-        struct btrfs_key found_key;
-        struct extent_buffer *leaf;
 
         key.objectid = dir;
         btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
@@ -209,18 +207,7 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
         ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
         if (ret < 0)
                 return ERR_PTR(ret);
-        if (ret > 0) {
-                if (path->slots[0] == 0)
-                        return NULL;
-                path->slots[0]--;
-        }
-
-        leaf = path->nodes[0];
-        btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
-
-        if (found_key.objectid != dir ||
-            btrfs_key_type(&found_key) != BTRFS_DIR_ITEM_KEY ||
-            found_key.offset != key.offset)
+        if (ret > 0)
                 return NULL;
 
         return btrfs_match_dir_item_name(root, path, name, name_len);
@@ -315,8 +302,6 @@ struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
         struct btrfs_key key;
         int ins_len = mod < 0 ? -1 : 0;
         int cow = mod != 0;
-        struct btrfs_key found_key;
-        struct extent_buffer *leaf;
 
         key.objectid = dir;
         btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
@@ -324,18 +309,7 @@ struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
         ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
         if (ret < 0)
                 return ERR_PTR(ret);
-        if (ret > 0) {
-                if (path->slots[0] == 0)
-                        return NULL;
-                path->slots[0]--;
-        }
-
-        leaf = path->nodes[0];
-        btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
-
-        if (found_key.objectid != dir ||
-            btrfs_key_type(&found_key) != BTRFS_XATTR_ITEM_KEY ||
-            found_key.offset != key.offset)
+        if (ret > 0)
                 return NULL;
 
         return btrfs_match_dir_item_name(root, path, name, name_len);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 4d08ed79405d..66bac226944e 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -663,7 +663,9 @@ int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
         struct btrfs_path *path;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
+
         key.objectid = start;
         key.offset = len;
         btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
@@ -3272,6 +3274,9 @@ again:
         }
 
         ret = btrfs_alloc_chunk(trans, extent_root, flags);
+        if (ret < 0 && ret != -ENOSPC)
+                goto out;
+
         spin_lock(&space_info->lock);
         if (ret)
                 space_info->full = 1;
@@ -3281,6 +3286,7 @@ again:
         space_info->force_alloc = CHUNK_ALLOC_NO_FORCE;
         space_info->chunk_alloc = 0;
         spin_unlock(&space_info->lock);
+out:
         mutex_unlock(&extent_root->fs_info->chunk_mutex);
         return ret;
 }
@@ -4456,7 +4462,9 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                                 printk(KERN_ERR "umm, got %d back from search"
                                        ", was looking for %llu\n", ret,
                                        (unsigned long long)bytenr);
-                                btrfs_print_leaf(extent_root, path->nodes[0]);
+                                if (ret > 0)
+                                        btrfs_print_leaf(extent_root,
+                                                         path->nodes[0]);
                         }
                         BUG_ON(ret);
                         extent_slot = path->slots[0];
@@ -5073,7 +5081,9 @@ have_block_group:
                          * group is does point to and try again
                          */
                         if (!last_ptr_loop && last_ptr->block_group &&
-                            last_ptr->block_group != block_group) {
+                            last_ptr->block_group != block_group &&
+                            index <=
+                                 get_block_group_index(last_ptr->block_group)) {
 
                                 btrfs_put_block_group(block_group);
                                 block_group = last_ptr->block_group;
@@ -5501,7 +5511,8 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
         u32 size = sizeof(*extent_item) + sizeof(*block_info) + sizeof(*iref);
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         path->leave_spinning = 1;
         ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
@@ -6272,10 +6283,14 @@ int btrfs_drop_snapshot(struct btrfs_root *root,
         int level;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         wc = kzalloc(sizeof(*wc), GFP_NOFS);
-        BUG_ON(!wc);
+        if (!wc) {
+                btrfs_free_path(path);
+                return -ENOMEM;
+        }
 
         trans = btrfs_start_transaction(tree_root, 0);
         BUG_ON(IS_ERR(trans));
@@ -6538,8 +6553,6 @@ static int set_block_group_ro(struct btrfs_block_group_cache *cache, int force)
         u64 min_allocable_bytes;
         int ret = -ENOSPC;
 
-        if (cache->ro)
-                return 0;
 
         /*
          * We need some metadata space and system metadata space for
@@ -6555,6 +6568,12 @@ static int set_block_group_ro(struct btrfs_block_group_cache *cache, int force)
 
         spin_lock(&sinfo->lock);
         spin_lock(&cache->lock);
+
+        if (cache->ro) {
+                ret = 0;
+                goto out;
+        }
+
         num_bytes = cache->key.offset - cache->reserved - cache->pinned -
                     cache->bytes_super - btrfs_block_group_used(&cache->item);
 
@@ -6568,7 +6587,7 @@ static int set_block_group_ro(struct btrfs_block_group_cache *cache, int force)
                 cache->ro = 1;
                 ret = 0;
         }
-
+out:
         spin_unlock(&cache->lock);
         spin_unlock(&sinfo->lock);
         return ret;
@@ -7183,11 +7202,15 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
         spin_unlock(&cluster->refill_lock);
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
 
         inode = lookup_free_space_inode(root, block_group, path);
         if (!IS_ERR(inode)) {
-                btrfs_orphan_add(trans, inode);
+                ret = btrfs_orphan_add(trans, inode);
+                BUG_ON(ret);
                 clear_nlink(inode);
                 /* One for the block groups ref */
                 spin_lock(&block_group->lock);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 067b1747421b..d418164a35f1 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -254,14 +254,14 @@ static void merge_cb(struct extent_io_tree *tree, struct extent_state *new,
  *
  * This should be called with the tree lock held.
  */
-static int merge_state(struct extent_io_tree *tree,
-                       struct extent_state *state)
+static void merge_state(struct extent_io_tree *tree,
+                        struct extent_state *state)
 {
         struct extent_state *other;
         struct rb_node *other_node;
 
         if (state->state & (EXTENT_IOBITS | EXTENT_BOUNDARY))
-                return 0;
+                return;
 
         other_node = rb_prev(&state->rb_node);
         if (other_node) {
@@ -287,19 +287,13 @@ static int merge_state(struct extent_io_tree *tree,
                         free_extent_state(other);
                 }
         }
-
-        return 0;
 }
 
-static int set_state_cb(struct extent_io_tree *tree,
+static void set_state_cb(struct extent_io_tree *tree,
                          struct extent_state *state, int *bits)
 {
-        if (tree->ops && tree->ops->set_bit_hook) {
-                return tree->ops->set_bit_hook(tree->mapping->host,
-                                               state, bits);
-        }
-
-        return 0;
+        if (tree->ops && tree->ops->set_bit_hook)
+                tree->ops->set_bit_hook(tree->mapping->host, state, bits);
 }
 
 static void clear_state_cb(struct extent_io_tree *tree,
@@ -309,6 +303,9 @@ static void clear_state_cb(struct extent_io_tree *tree,
                 tree->ops->clear_bit_hook(tree->mapping->host, state, bits);
 }
 
+static void set_state_bits(struct extent_io_tree *tree,
+                           struct extent_state *state, int *bits);
+
 /*
  * insert an extent_state struct into the tree.  'bits' are set on the
  * struct before it is inserted.
@@ -324,8 +321,6 @@ static int insert_state(struct extent_io_tree *tree,
                         int *bits)
 {
         struct rb_node *node;
-        int bits_to_set = *bits & ~EXTENT_CTLBITS;
-        int ret;
 
         if (end < start) {
                 printk(KERN_ERR "btrfs end < start %llu %llu\n",
@@ -335,13 +330,9 @@ static int insert_state(struct extent_io_tree *tree,
         }
         state->start = start;
         state->end = end;
-        ret = set_state_cb(tree, state, bits);
-        if (ret)
-                return ret;
 
-        if (bits_to_set & EXTENT_DIRTY)
-                tree->dirty_bytes += end - start + 1;
-        state->state |= bits_to_set;
+        set_state_bits(tree, state, bits);
+
         node = tree_insert(&tree->state, end, &state->rb_node);
         if (node) {
                 struct extent_state *found;
@@ -357,13 +348,11 @@ static int insert_state(struct extent_io_tree *tree,
         return 0;
 }
 
-static int split_cb(struct extent_io_tree *tree, struct extent_state *orig,
+static void split_cb(struct extent_io_tree *tree, struct extent_state *orig,
                      u64 split)
 {
         if (tree->ops && tree->ops->split_extent_hook)
-                return tree->ops->split_extent_hook(tree->mapping->host,
-                                                    orig, split);
-        return 0;
+                tree->ops->split_extent_hook(tree->mapping->host, orig, split);
 }
 
 /*
@@ -659,34 +648,25 @@ again:
                 if (start > end)
                         break;
 
-                if (need_resched()) {
-                        spin_unlock(&tree->lock);
-                        cond_resched();
-                        spin_lock(&tree->lock);
-                }
+                cond_resched_lock(&tree->lock);
         }
 out:
         spin_unlock(&tree->lock);
         return 0;
 }
 
-static int set_state_bits(struct extent_io_tree *tree,
+static void set_state_bits(struct extent_io_tree *tree,
                            struct extent_state *state,
                            int *bits)
 {
-        int ret;
         int bits_to_set = *bits & ~EXTENT_CTLBITS;
 
-        ret = set_state_cb(tree, state, bits);
-        if (ret)
-                return ret;
+        set_state_cb(tree, state, bits);
         if ((bits_to_set & EXTENT_DIRTY) && !(state->state & EXTENT_DIRTY)) {
                 u64 range = state->end - state->start + 1;
                 tree->dirty_bytes += range;
         }
         state->state |= bits_to_set;
-
-        return 0;
 }
 
 static void cache_state(struct extent_state *state,
@@ -779,9 +759,7 @@ hit_next:
                         goto out;
                 }
 
-                err = set_state_bits(tree, state, &bits);
-                if (err)
-                        goto out;
+                set_state_bits(tree, state, &bits);
 
                 cache_state(state, cached_state);
                 merge_state(tree, state);
@@ -830,9 +808,7 @@ hit_next:
                 if (err)
                         goto out;
                 if (state->end <= end) {
-                        err = set_state_bits(tree, state, &bits);
-                        if (err)
-                                goto out;
+                        set_state_bits(tree, state, &bits);
                         cache_state(state, cached_state);
                         merge_state(tree, state);
                         if (last_end == (u64)-1)
@@ -893,11 +869,7 @@ hit_next:
                 err = split_state(tree, state, prealloc, end + 1);
                 BUG_ON(err == -EEXIST);
 
-                err = set_state_bits(tree, prealloc, &bits);
-                if (err) {
-                        prealloc = NULL;
-                        goto out;
-                }
+                set_state_bits(tree, prealloc, &bits);
                 cache_state(prealloc, cached_state);
                 merge_state(tree, prealloc);
                 prealloc = NULL;
@@ -1059,46 +1031,6 @@ static int set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end)
         return 0;
 }
 
-/*
- * find the first offset in the io tree with 'bits' set. zero is
- * returned if we find something, and *start_ret and *end_ret are
- * set to reflect the state struct that was found.
- *
- * If nothing was found, 1 is returned, < 0 on error
- */
-int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
-                          u64 *start_ret, u64 *end_ret, int bits)
-{
-        struct rb_node *node;
-        struct extent_state *state;
-        int ret = 1;
-
-        spin_lock(&tree->lock);
-        /*
-         * this search will find all the extents that end after
-         * our range starts.
-         */
-        node = tree_search(tree, start);
-        if (!node)
-                goto out;
-
-        while (1) {
-                state = rb_entry(node, struct extent_state, rb_node);
-                if (state->end >= start && (state->state & bits)) {
-                        *start_ret = state->start;
-                        *end_ret = state->end;
-                        ret = 0;
-                        break;
-                }
-                node = rb_next(node);
-                if (!node)
-                        break;
-        }
-out:
-        spin_unlock(&tree->lock);
-        return ret;
-}
-
 /* find the first state struct with 'bits' set after 'start', and
  * return it.  tree->lock must be held.  NULL will returned if
  * nothing was found after 'start'
@@ -1131,6 +1063,30 @@ out:
 }
 
 /*
+ * find the first offset in the io tree with 'bits' set. zero is
+ * returned if we find something, and *start_ret and *end_ret are
+ * set to reflect the state struct that was found.
+ *
+ * If nothing was found, 1 is returned, < 0 on error
+ */
+int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
+                          u64 *start_ret, u64 *end_ret, int bits)
+{
+        struct extent_state *state;
+        int ret = 1;
+
+        spin_lock(&tree->lock);
+        state = find_first_extent_bit_state(tree, start, bits);
+        if (state) {
+                *start_ret = state->start;
+                *end_ret = state->end;
+                ret = 0;
+        }
+        spin_unlock(&tree->lock);
+        return ret;
+}
+
+/*
  * find a contiguous range of bytes in the file marked as delalloc, not
  * more than 'max_bytes'.  start and end are used to return the range,
  *
@@ -2546,7 +2502,6 @@ int extent_write_full_page(struct extent_io_tree *tree, struct page *page,
                           struct writeback_control *wbc)
 {
         int ret;
-        struct address_space *mapping = page->mapping;
         struct extent_page_data epd = {
                 .bio = NULL,
                 .tree = tree,
@@ -2554,17 +2509,9 @@ int extent_write_full_page(struct extent_io_tree *tree, struct page *page,
                 .extent_locked = 0,
                 .sync_io = wbc->sync_mode == WB_SYNC_ALL,
         };
-        struct writeback_control wbc_writepages = {
-                .sync_mode      = wbc->sync_mode,
-                .nr_to_write    = 64,
-                .range_start    = page_offset(page) + PAGE_CACHE_SIZE,
-                .range_end      = (loff_t)-1,
-        };
 
         ret = __extent_writepage(page, wbc, &epd);
 
-        extent_write_cache_pages(tree, mapping, &wbc_writepages,
-                                 __extent_writepage, &epd, flush_write_bio);
         flush_epd_write_bio(&epd);
         return ret;
 }
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 21a7ca9e7282..7b2f0c3e7929 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -76,15 +76,15 @@ struct extent_io_ops {
                                     struct extent_state *state);
         int (*writepage_end_io_hook)(struct page *page, u64 start, u64 end,
                                       struct extent_state *state, int uptodate);
-        int (*set_bit_hook)(struct inode *inode, struct extent_state *state,
-                            int *bits);
-        int (*clear_bit_hook)(struct inode *inode, struct extent_state *state,
-                              int *bits);
-        int (*merge_extent_hook)(struct inode *inode,
-                                 struct extent_state *new,
-                                 struct extent_state *other);
-        int (*split_extent_hook)(struct inode *inode,
-                                 struct extent_state *orig, u64 split);
+        void (*set_bit_hook)(struct inode *inode, struct extent_state *state,
+                             int *bits);
+        void (*clear_bit_hook)(struct inode *inode, struct extent_state *state,
+                               int *bits);
+        void (*merge_extent_hook)(struct inode *inode,
+                                  struct extent_state *new,
+                                  struct extent_state *other);
+        void (*split_extent_hook)(struct inode *inode,
+                                  struct extent_state *orig, u64 split);
         int (*write_cache_pages_lock_hook)(struct page *page);
 };
 
@@ -108,8 +108,6 @@ struct extent_state {
         wait_queue_head_t wq;
         atomic_t refs;
         unsigned long state;
-        u64 split_start;
-        u64 split_end;
 
         /* for use by the FS */
         u64 private;
diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 2d0410344ea3..7c97b3301459 100644
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -183,22 +183,10 @@ static int mergable_maps(struct extent_map *prev, struct extent_map *next)
         return 0;
 }
 
-int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len)
+static void try_merge_map(struct extent_map_tree *tree, struct extent_map *em)
 {
-        int ret = 0;
         struct extent_map *merge = NULL;
         struct rb_node *rb;
-        struct extent_map *em;
-
-        write_lock(&tree->lock);
-        em = lookup_extent_mapping(tree, start, len);
-
-        WARN_ON(!em || em->start != start);
-
-        if (!em)
-                goto out;
-
-        clear_bit(EXTENT_FLAG_PINNED, &em->flags);
 
         if (em->start != 0) {
                 rb = rb_prev(&em->rb_node);
@@ -225,6 +213,24 @@ int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len)
                 merge->in_tree = 0;
                 free_extent_map(merge);
         }
+}
+
+int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len)
+{
+        int ret = 0;
+        struct extent_map *em;
+
+        write_lock(&tree->lock);
+        em = lookup_extent_mapping(tree, start, len);
+
+        WARN_ON(!em || em->start != start);
+
+        if (!em)
+                goto out;
+
+        clear_bit(EXTENT_FLAG_PINNED, &em->flags);
+
+        try_merge_map(tree, em);
 
         free_extent_map(em);
 out:
@@ -247,7 +253,6 @@ int add_extent_mapping(struct extent_map_tree *tree,
                        struct extent_map *em)
 {
         int ret = 0;
-        struct extent_map *merge = NULL;
         struct rb_node *rb;
         struct extent_map *exist;
 
@@ -263,30 +268,8 @@ int add_extent_mapping(struct extent_map_tree *tree,
                 goto out;
         }
         atomic_inc(&em->refs);
-        if (em->start != 0) {
-                rb = rb_prev(&em->rb_node);
-                if (rb)
-                        merge = rb_entry(rb, struct extent_map, rb_node);
-                if (rb && mergable_maps(merge, em)) {
-                        em->start = merge->start;
-                        em->len += merge->len;
-                        em->block_len += merge->block_len;
-                        em->block_start = merge->block_start;
-                        merge->in_tree = 0;
-                        rb_erase(&merge->rb_node, &tree->map);
-                        free_extent_map(merge);
-                }
-         }
-        rb = rb_next(&em->rb_node);
-        if (rb)
-                merge = rb_entry(rb, struct extent_map, rb_node);
-        if (rb && mergable_maps(em, merge)) {
-                em->len += merge->len;
-                em->block_len += merge->len;
-                rb_erase(&merge->rb_node, &tree->map);
-                merge->in_tree = 0;
-                free_extent_map(merge);
-        }
+
+        try_merge_map(tree, em);
 out:
         return ret;
 }
@@ -299,19 +282,8 @@ static u64 range_end(u64 start, u64 len)
         return start + len;
 }
 
-/**
- * lookup_extent_mapping - lookup extent_map
- * @tree:       tree to lookup in
- * @start:      byte offset to start the search
- * @len:        length of the lookup range
- *
- * Find and return the first extent_map struct in @tree that intersects the
- * [start, len] range.  There may be additional objects in the tree that
- * intersect, so check the object returned carefully to make sure that no
- * additional lookups are needed.
- */
-struct extent_map *lookup_extent_mapping(struct extent_map_tree *tree,
-                                         u64 start, u64 len)
+struct extent_map *__lookup_extent_mapping(struct extent_map_tree *tree,
+                                           u64 start, u64 len, int strict)
 {
         struct extent_map *em;
         struct rb_node *rb_node;
@@ -320,38 +292,42 @@ struct extent_map *lookup_extent_mapping(struct extent_map_tree *tree,
         u64 end = range_end(start, len);
 
         rb_node = __tree_search(&tree->map, start, &prev, &next);
-        if (!rb_node && prev) {
-                em = rb_entry(prev, struct extent_map, rb_node);
-                if (end > em->start && start < extent_map_end(em))
-                        goto found;
-        }
-        if (!rb_node && next) {
-                em = rb_entry(next, struct extent_map, rb_node);
-                if (end > em->start && start < extent_map_end(em))
-                        goto found;
-        }
         if (!rb_node) {
-                em = NULL;
-                goto out;
-        }
-        if (IS_ERR(rb_node)) {
-                em = ERR_CAST(rb_node);
-                goto out;
+                if (prev)
+                        rb_node = prev;
+                else if (next)
+                        rb_node = next;
+                else
+                        return NULL;
         }
+
         em = rb_entry(rb_node, struct extent_map, rb_node);
-        if (end > em->start && start < extent_map_end(em))
-                goto found;
 
-        em = NULL;
-        goto out;
+        if (strict && !(end > em->start && start < extent_map_end(em)))
+                return NULL;
 
-found:
         atomic_inc(&em->refs);
-out:
         return em;
 }
 
 /**
+ * lookup_extent_mapping - lookup extent_map
+ * @tree:       tree to lookup in
+ * @start:      byte offset to start the search
+ * @len:        length of the lookup range
+ *
+ * Find and return the first extent_map struct in @tree that intersects the
+ * [start, len] range.  There may be additional objects in the tree that
+ * intersect, so check the object returned carefully to make sure that no
+ * additional lookups are needed.
+ */
+struct extent_map *lookup_extent_mapping(struct extent_map_tree *tree,
+                                         u64 start, u64 len)
+{
+        return __lookup_extent_mapping(tree, start, len, 1);
+}
+
+/**
  * search_extent_mapping - find a nearby extent map
  * @tree:       tree to lookup in
  * @start:      byte offset to start the search
@@ -365,38 +341,7 @@ out:
 struct extent_map *search_extent_mapping(struct extent_map_tree *tree,
                                          u64 start, u64 len)
 {
-        struct extent_map *em;
-        struct rb_node *rb_node;
-        struct rb_node *prev = NULL;
-        struct rb_node *next = NULL;
-
-        rb_node = __tree_search(&tree->map, start, &prev, &next);
-        if (!rb_node && prev) {
-                em = rb_entry(prev, struct extent_map, rb_node);
-                goto found;
-        }
-        if (!rb_node && next) {
-                em = rb_entry(next, struct extent_map, rb_node);
-                goto found;
-        }
-        if (!rb_node) {
-                em = NULL;
-                goto out;
-        }
-        if (IS_ERR(rb_node)) {
-                em = ERR_CAST(rb_node);
-                goto out;
-        }
-        em = rb_entry(rb_node, struct extent_map, rb_node);
-        goto found;
-
-        em = NULL;
-        goto out;
-
-found:
-        atomic_inc(&em->refs);
-out:
-        return em;
+        return __lookup_extent_mapping(tree, start, len, 0);
 }
 
 /**
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 08bcfa92a222..b910694f61ed 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -291,7 +291,8 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
         u16 csum_size = btrfs_super_csum_size(&root->fs_info->super_copy);
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         if (search_commit) {
                 path->skip_locking = 1;
@@ -677,7 +678,9 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
                 btrfs_super_csum_size(&root->fs_info->super_copy);
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
+
         sector_sum = sums->sums;
 again:
         next_offset = (u64)-1;
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index a35e51c9f235..658d66959abe 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -74,7 +74,7 @@ struct inode_defrag {
  * If an existing record is found the defrag item you
  * pass in is freed
  */
-static int __btrfs_add_inode_defrag(struct inode *inode,
+static void __btrfs_add_inode_defrag(struct inode *inode,
                                     struct inode_defrag *defrag)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -106,11 +106,11 @@ static int __btrfs_add_inode_defrag(struct inode *inode,
         BTRFS_I(inode)->in_defrag = 1;
         rb_link_node(&defrag->rb_node, parent, p);
         rb_insert_color(&defrag->rb_node, &root->fs_info->defrag_inodes);
-        return 0;
+        return;
 
 exists:
         kfree(defrag);
-        return 0;
+        return;
 
 }
 
@@ -123,7 +123,6 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct inode_defrag *defrag;
-        int ret = 0;
         u64 transid;
 
         if (!btrfs_test_opt(root, AUTO_DEFRAG))
@@ -150,9 +149,9 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
 
         spin_lock(&root->fs_info->defrag_inodes_lock);
         if (!BTRFS_I(inode)->in_defrag)
-                ret = __btrfs_add_inode_defrag(inode, defrag);
+                __btrfs_add_inode_defrag(inode, defrag);
         spin_unlock(&root->fs_info->defrag_inodes_lock);
-        return ret;
+        return 0;
 }
 
 /*
@@ -855,7 +854,8 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
         btrfs_drop_extent_cache(inode, start, end - 1, 0);
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 again:
         recow = 0;
         split = start;
@@ -1059,7 +1059,7 @@ static int prepare_uptodate_page(struct page *page, u64 pos)
 static noinline int prepare_pages(struct btrfs_root *root, struct file *file,
                          struct page **pages, size_t num_pages,
                          loff_t pos, unsigned long first_index,
-                         unsigned long last_index, size_t write_bytes)
+                         size_t write_bytes)
 {
         struct extent_state *cached_state = NULL;
         int i;
@@ -1159,7 +1159,6 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct page **pages = NULL;
         unsigned long first_index;
-        unsigned long last_index;
         size_t num_written = 0;
         int nrptrs;
         int ret = 0;
@@ -1172,7 +1171,6 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                 return -ENOMEM;
 
         first_index = pos >> PAGE_CACHE_SHIFT;
-        last_index = (pos + iov_iter_count(i)) >> PAGE_CACHE_SHIFT;
 
         while (iov_iter_count(i) > 0) {
                 size_t offset = pos & (PAGE_CACHE_SIZE - 1);
@@ -1206,8 +1204,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                  * contents of pages from loop to loop
                  */
                 ret = prepare_pages(root, file, pages, num_pages,
-                                    pos, first_index, last_index,
-                                    write_bytes);
+                                    pos, first_index, write_bytes);
                 if (ret) {
                         btrfs_delalloc_release_space(inode,
                                         num_pages << PAGE_CACHE_SHIFT);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index ae762dab37f8..15fceefbca0a 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1061,7 +1061,8 @@ static noinline int run_delalloc_nocow(struct inode *inode,
         u64 ino = btrfs_ino(inode);
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         nolock = btrfs_is_free_space_inode(root, inode);
 
@@ -1282,17 +1283,16 @@ static int run_delalloc_range(struct inode *inode, struct page *locked_page,
         return ret;
 }
 
-static int btrfs_split_extent_hook(struct inode *inode,
-                                   struct extent_state *orig, u64 split)
+static void btrfs_split_extent_hook(struct inode *inode,
+                                    struct extent_state *orig, u64 split)
 {
         /* not delalloc, ignore it */
         if (!(orig->state & EXTENT_DELALLOC))
-                return 0;
+                return;
 
         spin_lock(&BTRFS_I(inode)->lock);
         BTRFS_I(inode)->outstanding_extents++;
         spin_unlock(&BTRFS_I(inode)->lock);
-        return 0;
 }
 
 /*
@@ -1301,18 +1301,17 @@ static int btrfs_split_extent_hook(struct inode *inode,
  * extents, such as when we are doing sequential writes, so we can properly
  * account for the metadata space we'll need.
  */
-static int btrfs_merge_extent_hook(struct inode *inode,
-                                   struct extent_state *new,
-                                   struct extent_state *other)
+static void btrfs_merge_extent_hook(struct inode *inode,
+                                    struct extent_state *new,
+                                    struct extent_state *other)
 {
         /* not delalloc, ignore it */
         if (!(other->state & EXTENT_DELALLOC))
-                return 0;
+                return;
 
         spin_lock(&BTRFS_I(inode)->lock);
         BTRFS_I(inode)->outstanding_extents--;
         spin_unlock(&BTRFS_I(inode)->lock);
-        return 0;
 }
 
 /*
@@ -1320,8 +1319,8 @@ static int btrfs_merge_extent_hook(struct inode *inode,
  * bytes in this file, and to maintain the list of inodes that
  * have pending delalloc work to be done.
  */
-static int btrfs_set_bit_hook(struct inode *inode,
-                              struct extent_state *state, int *bits)
+static void btrfs_set_bit_hook(struct inode *inode,
+                               struct extent_state *state, int *bits)
 {
 
         /*
@@ -1351,14 +1350,13 @@ static int btrfs_set_bit_hook(struct inode *inode,
                 }
                 spin_unlock(&root->fs_info->delalloc_lock);
         }
-        return 0;
 }
 
 /*
  * extent_io.c clear_bit_hook, see set_bit_hook for why
  */
-static int btrfs_clear_bit_hook(struct inode *inode,
-                                struct extent_state *state, int *bits)
+static void btrfs_clear_bit_hook(struct inode *inode,
+                                 struct extent_state *state, int *bits)
 {
         /*
          * set_bit and clear bit hooks normally require _irqsave/restore
@@ -1395,7 +1393,6 @@ static int btrfs_clear_bit_hook(struct inode *inode,
                 }
                 spin_unlock(&root->fs_info->delalloc_lock);
         }
-        return 0;
 }
 
 /*
@@ -1645,7 +1642,8 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
         int ret;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         path->leave_spinning = 1;
 
@@ -2215,7 +2213,8 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
 
         if (!root->orphan_block_rsv) {
                 block_rsv = btrfs_alloc_block_rsv(root);
-                BUG_ON(!block_rsv);
+                if (!block_rsv)
+                        return -ENOMEM;
         }
 
         spin_lock(&root->orphan_lock);
@@ -2517,7 +2516,9 @@ static void btrfs_read_locked_inode(struct inode *inode)
                 filled = true;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                goto make_bad;
+
         path->leave_spinning = 1;
         memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
 
@@ -2998,13 +2999,16 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
 
         ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
                                  dentry->d_name.name, dentry->d_name.len);
-        BUG_ON(ret);
+        if (ret)
+                goto out;
 
         if (inode->i_nlink == 0) {
                 ret = btrfs_orphan_add(trans, inode);
-                BUG_ON(ret);
+                if (ret)
+                        goto out;
         }
 
+out:
         nr = trans->blocks_used;
         __unlink_end_trans(trans, root);
         btrfs_btree_balance_dirty(root, nr);
@@ -3147,6 +3151,11 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
 
         BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
 
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+        path->reada = -1;
+
         if (root->ref_cows || root == root->fs_info->tree_root)
                 btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
 
@@ -3159,10 +3168,6 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         if (min_type == 0 && root == BTRFS_I(inode)->root)
                 btrfs_kill_delayed_inode_items(inode);
 
-        path = btrfs_alloc_path();
-        BUG_ON(!path);
-        path->reada = -1;
-
         key.objectid = ino;
         key.offset = (u64)-1;
         key.type = (u8)-1;
@@ -3690,7 +3695,8 @@ static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
         int ret = 0;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
                                     namelen, 0);
@@ -3946,6 +3952,7 @@ struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
                          struct btrfs_root *root, int *new)
 {
         struct inode *inode;
+        int bad_inode = 0;
 
         inode = btrfs_iget_locked(s, location->objectid, root);
         if (!inode)
@@ -3955,10 +3962,19 @@ struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
                 BTRFS_I(inode)->root = root;
                 memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
                 btrfs_read_locked_inode(inode);
-                inode_tree_add(inode);
-                unlock_new_inode(inode);
-                if (new)
-                        *new = 1;
+                if (!is_bad_inode(inode)) {
+                        inode_tree_add(inode);
+                        unlock_new_inode(inode);
+                        if (new)
+                                *new = 1;
+                } else {
+                        bad_inode = 1;
+                }
+        }
+
+        if (bad_inode) {
+                iput(inode);
+                inode = ERR_PTR(-ESTALE);
         }
 
         return inode;
@@ -4451,7 +4467,8 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         int owner;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return ERR_PTR(-ENOMEM);
 
         inode = new_inode(root->fs_info->sb);
         if (!inode) {
@@ -6711,19 +6728,6 @@ int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
         return 0;
 }
 
-/* helper function for file defrag and space balancing.  This
- * forces readahead on a given range of bytes in an inode
- */
-unsigned long btrfs_force_ra(struct address_space *mapping,
-                              struct file_ra_state *ra, struct file *file,
-                              pgoff_t offset, pgoff_t last_index)
-{
-        pgoff_t req_size = last_index - offset + 1;
-
-        page_cache_sync_readahead(mapping, ra, file, offset, req_size);
-        return offset + req_size;
-}
-
 struct inode *btrfs_alloc_inode(struct super_block *sb)
 {
         struct btrfs_inode *ei;
@@ -7206,7 +7210,11 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
                 goto out_unlock;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path) {
+                err = -ENOMEM;
+                drop_inode = 1;
+                goto out_unlock;
+        }
         key.objectid = btrfs_ino(inode);
         key.offset = 0;
         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 0b980afc5edd..7cf013349941 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -1749,11 +1749,10 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
                 key.objectid = key.offset;
                 key.offset = (u64)-1;
                 dirid = key.objectid;
-
         }
         if (ptr < name)
                 goto out;
-        memcpy(name, ptr, total_len);
+        memmove(name, ptr, total_len);
         name[total_len]='\0';
         ret = 0;
 out:
diff --git a/fs/btrfs/ref-cache.c b/fs/btrfs/ref-cache.c
deleted file mode 100644
index 82d569cb6267..000000000000
--- a/fs/btrfs/ref-cache.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2008 Oracle.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
-
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/sort.h>
-#include "ctree.h"
-#include "ref-cache.h"
-#include "transaction.h"
-
-static struct rb_node *tree_insert(struct rb_root *root, u64 bytenr,
-                                   struct rb_node *node)
-{
-        struct rb_node **p = &root->rb_node;
-        struct rb_node *parent = NULL;
-        struct btrfs_leaf_ref *entry;
-
-        while (*p) {
-                parent = *p;
-                entry = rb_entry(parent, struct btrfs_leaf_ref, rb_node);
-
-                if (bytenr < entry->bytenr)
-                        p = &(*p)->rb_left;
-                else if (bytenr > entry->bytenr)
-                        p = &(*p)->rb_right;
-                else
-                        return parent;
-        }
-
-        entry = rb_entry(node, struct btrfs_leaf_ref, rb_node);
-        rb_link_node(node, parent, p);
-        rb_insert_color(node, root);
-        return NULL;
-}
-
-static struct rb_node *tree_search(struct rb_root *root, u64 bytenr)
-{
-        struct rb_node *n = root->rb_node;
-        struct btrfs_leaf_ref *entry;
-
-        while (n) {
-                entry = rb_entry(n, struct btrfs_leaf_ref, rb_node);
-                WARN_ON(!entry->in_tree);
-
-                if (bytenr < entry->bytenr)
-                        n = n->rb_left;
-                else if (bytenr > entry->bytenr)
-                        n = n->rb_right;
-                else
-                        return n;
-        }
-        return NULL;
-}
diff --git a/fs/btrfs/ref-cache.h b/fs/btrfs/ref-cache.h
deleted file mode 100644
index 24f7001f6387..000000000000
--- a/fs/btrfs/ref-cache.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2008 Oracle.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
-#ifndef __REFCACHE__
-#define __REFCACHE__
-
-struct btrfs_extent_info {
-        /* bytenr and num_bytes find the extent in the extent allocation tree */
-        u64 bytenr;
-        u64 num_bytes;
-
-        /* objectid and offset find the back reference for the file */
-        u64 objectid;
-        u64 offset;
-};
-
-struct btrfs_leaf_ref {
-        struct rb_node rb_node;
-        struct btrfs_leaf_ref_tree *tree;
-        int in_tree;
-        atomic_t usage;
-
-        u64 root_gen;
-        u64 bytenr;
-        u64 owner;
-        u64 generation;
-        int nritems;
-
-        struct list_head list;
-        struct btrfs_extent_info extents[];
-};
-
-static inline size_t btrfs_leaf_ref_size(int nr_extents)
-{
-        return sizeof(struct btrfs_leaf_ref) +
-               sizeof(struct btrfs_extent_info) * nr_extents;
-}
-#endif
diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index ebe45443de06..f4099904565a 100644
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -71,13 +71,12 @@ out:
         return ret;
 }
 
-int btrfs_set_root_node(struct btrfs_root_item *item,
-                        struct extent_buffer *node)
+void btrfs_set_root_node(struct btrfs_root_item *item,
+                         struct extent_buffer *node)
 {
         btrfs_set_root_bytenr(item, node->start);
         btrfs_set_root_level(item, btrfs_header_level(node));
         btrfs_set_root_generation(item, btrfs_header_generation(node));
-        return 0;
 }
 
 /*
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index eb55863bb4ae..7dc36fab4afc 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -216,17 +216,11 @@ static void wait_current_trans(struct btrfs_root *root)
         spin_lock(&root->fs_info->trans_lock);
         cur_trans = root->fs_info->running_transaction;
         if (cur_trans && cur_trans->blocked) {
-                DEFINE_WAIT(wait);
                 atomic_inc(&cur_trans->use_count);
                 spin_unlock(&root->fs_info->trans_lock);
-                while (1) {
-                        prepare_to_wait(&root->fs_info->transaction_wait, &wait,
-                                        TASK_UNINTERRUPTIBLE);
-                        if (!cur_trans->blocked)
-                                break;
-                        schedule();
-                }
-                finish_wait(&root->fs_info->transaction_wait, &wait);
+
+                wait_event(root->fs_info->transaction_wait,
+                           !cur_trans->blocked);
                 put_transaction(cur_trans);
         } else {
                 spin_unlock(&root->fs_info->trans_lock);
@@ -357,19 +351,10 @@ struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root
 }
 
 /* wait for a transaction commit to be fully complete */
-static noinline int wait_for_commit(struct btrfs_root *root,
+static noinline void wait_for_commit(struct btrfs_root *root,
                                     struct btrfs_transaction *commit)
 {
-        DEFINE_WAIT(wait);
-        while (!commit->commit_done) {
-                prepare_to_wait(&commit->commit_wait, &wait,
-                                TASK_UNINTERRUPTIBLE);
-                if (commit->commit_done)
-                        break;
-                schedule();
-        }
-        finish_wait(&commit->commit_wait, &wait);
-        return 0;
+        wait_event(commit->commit_wait, commit->commit_done);
 }
 
 int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
@@ -1085,22 +1070,7 @@ int btrfs_transaction_blocked(struct btrfs_fs_info *info)
 static void wait_current_trans_commit_start(struct btrfs_root *root,
                                             struct btrfs_transaction *trans)
 {
-        DEFINE_WAIT(wait);
-
-        if (trans->in_commit)
-                return;
-
-        while (1) {
-                prepare_to_wait(&root->fs_info->transaction_blocked_wait, &wait,
-                                TASK_UNINTERRUPTIBLE);
-                if (trans->in_commit) {
-                        finish_wait(&root->fs_info->transaction_blocked_wait,
-                                    &wait);
-                        break;
-                }
-                schedule();
-                finish_wait(&root->fs_info->transaction_blocked_wait, &wait);
-        }
+        wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
 }
 
 /*
@@ -1110,24 +1080,8 @@ static void wait_current_trans_commit_start(struct btrfs_root *root,
 static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
                                          struct btrfs_transaction *trans)
 {
-        DEFINE_WAIT(wait);
-
-        if (trans->commit_done || (trans->in_commit && !trans->blocked))
-                return;
-
-        while (1) {
-                prepare_to_wait(&root->fs_info->transaction_wait, &wait,
-                                TASK_UNINTERRUPTIBLE);
-                if (trans->commit_done ||
-                    (trans->in_commit && !trans->blocked)) {
-                        finish_wait(&root->fs_info->transaction_wait,
-                                    &wait);
-                        break;
-                }
-                schedule();
-                finish_wait(&root->fs_info->transaction_wait,
-                            &wait);
-        }
+        wait_event(root->fs_info->transaction_wait,
+                   trans->commit_done || (trans->in_commit && !trans->blocked));
 }
 
 /*
@@ -1234,8 +1188,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
                 atomic_inc(&cur_trans->use_count);
                 btrfs_end_transaction(trans, root);
 
-                ret = wait_for_commit(root, cur_trans);
-                BUG_ON(ret);
+                wait_for_commit(root, cur_trans);
 
                 put_transaction(cur_trans);
 
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index ac278dd83175..babee65f8eda 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -1617,7 +1617,8 @@ static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
                 return 0;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         nritems = btrfs_header_nritems(eb);
         for (i = 0; i < nritems; i++) {
@@ -1723,7 +1724,9 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
                         return -ENOMEM;
 
                 if (*level == 1) {
-                        wc->process_func(root, next, wc, ptr_gen);
+                        ret = wc->process_func(root, next, wc, ptr_gen);
+                        if (ret)
+                                return ret;
 
                         path->slots[*level]++;
                         if (wc->free) {
@@ -1788,8 +1791,11 @@ static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
                                 parent = path->nodes[*level + 1];
 
                         root_owner = btrfs_header_owner(parent);
-                        wc->process_func(root, path->nodes[*level], wc,
+                        ret = wc->process_func(root, path->nodes[*level], wc,
                                  btrfs_header_generation(path->nodes[*level]));
+                        if (ret)
+                                return ret;
+
                         if (wc->free) {
                                 struct extent_buffer *next;
 
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index b89e372c7544..53875ae73ad4 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -1037,7 +1037,8 @@ static noinline int find_next_chunk(struct btrfs_root *root,
         struct btrfs_key found_key;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         key.objectid = objectid;
         key.offset = (u64)-1;
@@ -2061,8 +2062,10 @@ int btrfs_balance(struct btrfs_root *dev_root)
 
         /* step two, relocate all the chunks */
         path = btrfs_alloc_path();
-        BUG_ON(!path);
-
+        if (!path) {
+                ret = -ENOMEM;
+                goto error;
+        }
         key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
         key.offset = (u64)-1;
         key.type = BTRFS_CHUNK_ITEM_KEY;
@@ -2661,7 +2664,8 @@ static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
 
         ret = find_next_chunk(fs_info->chunk_root,
                               BTRFS_FIRST_CHUNK_TREE_OBJECTID, &chunk_offset);
-        BUG_ON(ret);
+        if (ret)
+                return ret;
 
         alloc_profile = BTRFS_BLOCK_GROUP_METADATA |
                         (fs_info->metadata_alloc_profile &
diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
index 8d8f28c94c0f..6873bb634a97 100644
--- a/fs/cifs/cifs_dfs_ref.c
+++ b/fs/cifs/cifs_dfs_ref.c
@@ -141,10 +141,11 @@ char *cifs_compose_mount_options(const char *sb_mountdata,
 
         rc = dns_resolve_server_name_to_ip(*devname, &srvIP);
         if (rc < 0) {
-                cERROR(1, "%s: Failed to resolve server part of %s to IP: %d",
-                          __func__, *devname, rc);
+                cFYI(1, "%s: Failed to resolve server part of %s to IP: %d",
+                        __func__, *devname, rc);
                 goto compose_mount_options_err;
         }
+
         /* md_len = strlen(...) + 12 for 'sep+prefixpath='
          * assuming that we have 'unc=' and 'ip=' in
          * the original sb_mountdata
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 212e5629cc1d..f93eb948d071 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -563,6 +563,10 @@ cifs_get_root(struct smb_vol *vol, struct super_block *sb)
                 mutex_unlock(&dir->i_mutex);
                 dput(dentry);
                 dentry = child;
+                if (!dentry->d_inode) {
+                        dput(dentry);
+                        dentry = ERR_PTR(-ENOENT);
+                }
         } while (!IS_ERR(dentry));
         _FreeXid(xid);
         kfree(full_path);
diff --git a/fs/cifs/dns_resolve.c b/fs/cifs/dns_resolve.c
index 548f06230a6d..1d2d91d9bf65 100644
--- a/fs/cifs/dns_resolve.c
+++ b/fs/cifs/dns_resolve.c
@@ -79,8 +79,8 @@ dns_resolve_server_name_to_ip(const char *unc, char **ip_addr)
         /* Perform the upcall */
         rc = dns_query(NULL, hostname, len, NULL, ip_addr, NULL);
         if (rc < 0)
-                cERROR(1, "%s: unable to resolve: %*.*s",
-                       __func__, len, len, hostname);
+                cFYI(1, "%s: unable to resolve: %*.*s",
+                        __func__, len, len, hostname);
         else
                 cFYI(1, "%s: resolved: %*.*s to %s",
                      __func__, len, len, hostname, *ip_addr);
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 9b018c8334fa..a7b2dcd4a53e 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -764,20 +764,10 @@ char *cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
         if (full_path == NULL)
                 return full_path;
 
-        if (dfsplen) {
+        if (dfsplen)
                 strncpy(full_path, tcon->treeName, dfsplen);
-                /* switch slash direction in prepath depending on whether
-                 * windows or posix style path names
-                 */
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
-                        int i;
-                        for (i = 0; i < dfsplen; i++) {
-                                if (full_path[i] == '\\')
-                                        full_path[i] = '/';
-                        }
-                }
-        }
         strncpy(full_path + dfsplen, vol->prepath, pplen);
+        convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
         full_path[dfsplen + pplen] = 0; /* add trailing null */
         return full_path;
 }
diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
index 243d58720513..d3e619692ee0 100644
--- a/fs/cifs/sess.c
+++ b/fs/cifs/sess.c
@@ -124,8 +124,7 @@ static __u32 cifs_ssetup_hdr(struct cifs_ses *ses, SESSION_SETUP_ANDX *pSMB)
         /*      that we use in next few lines                               */
         /* Note that header is initialized to zero in header_assemble */
         pSMB->req.AndXCommand = 0xFF;
-        pSMB->req.MaxBufferSize = cpu_to_le16(min_t(u32, CIFSMaxBufSize - 4,
-                                                USHRT_MAX));
+        pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
         pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
         pSMB->req.VcNumber = get_next_vcnum(ses);
 
diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index 147aa22c3c3a..c1b9c4b10739 100644
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -362,6 +362,8 @@ cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
         mid = AllocMidQEntry(hdr, server);
         if (mid == NULL) {
                 mutex_unlock(&server->srv_mutex);
+                atomic_dec(&server->inFlight);
+                wake_up(&server->request_q);
                 return -ENOMEM;
         }
 
diff --git a/fs/dcache.c b/fs/dcache.c
index 2347cdb15abb..a88948b8bd17 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -795,6 +795,7 @@ relock:
 
 /**
  * prune_dcache_sb - shrink the dcache
+ * @sb: superblock
  * @nr_to_scan: number of entries to try to free
  *
  * Attempt to shrink the superblock dcache LRU by @nr_to_scan entries. This is
@@ -1728,7 +1729,7 @@ seqretry:
                  */
                 if (read_seqcount_retry(&dentry->d_seq, *seq))
                         goto seqretry;
-                if (parent->d_flags & DCACHE_OP_COMPARE) {
+                if (unlikely(parent->d_flags & DCACHE_OP_COMPARE)) {
                         if (parent->d_op->d_compare(parent, *inode,
                                                 dentry, i,
                                                 tlen, tname, name))
diff --git a/fs/exofs/Kbuild b/fs/exofs/Kbuild
index 2d0f757fda3e..c5a5855a6c44 100644
--- a/fs/exofs/Kbuild
+++ b/fs/exofs/Kbuild
@@ -12,5 +12,8 @@
 # Kbuild - Gets included from the Kernels Makefile and build system
 #
 
-exofs-y := ios.o inode.o file.o symlink.o namei.o dir.o super.o
+# ore module library
+obj-$(CONFIG_ORE) += ore.o
+
+exofs-y := inode.o file.o symlink.o namei.o dir.o super.o
 obj-$(CONFIG_EXOFS_FS) += exofs.o
diff --git a/fs/exofs/Kconfig b/fs/exofs/Kconfig
index 86194b2f799d..70bae4149291 100644
--- a/fs/exofs/Kconfig
+++ b/fs/exofs/Kconfig
@@ -1,6 +1,10 @@
+config ORE
+        tristate
+
 config EXOFS_FS
         tristate "exofs: OSD based file system support"
         depends on SCSI_OSD_ULD
+        select ORE
         help
           EXOFS is a file system that uses an OSD storage device,
           as its backing storage.
diff --git a/fs/exofs/exofs.h b/fs/exofs/exofs.h
index c965806c2821..f4e442ec7445 100644
--- a/fs/exofs/exofs.h
+++ b/fs/exofs/exofs.h
@@ -36,12 +36,9 @@
 #include <linux/fs.h>
 #include <linux/time.h>
 #include <linux/backing-dev.h>
-#include "common.h"
+#include <scsi/osd_ore.h>
 
-/* FIXME: Remove once pnfs hits mainline
- * #include <linux/exportfs/pnfs_osd_xdr.h>
- */
-#include "pnfs.h"
+#include "common.h"
 
 #define EXOFS_ERR(fmt, a...) printk(KERN_ERR "exofs: " fmt, ##a)
 
@@ -56,27 +53,11 @@
 /* u64 has problems with printk this will cast it to unsigned long long */
 #define _LLU(x) (unsigned long long)(x)
 
-struct exofs_layout {
-        osd_id          s_pid;                  /* partition ID of file system*/
-
-        /* Our way of looking at the data_map */
-        unsigned stripe_unit;
-        unsigned mirrors_p1;
-
-        unsigned group_width;
-        u64      group_depth;
-        unsigned group_count;
-
-        enum exofs_inode_layout_gen_functions lay_func;
-
-        unsigned        s_numdevs;              /* Num of devices in array    */
-        struct osd_dev  *s_ods[0];              /* Variable length            */
-};
-
 /*
  * our extension to the in-memory superblock
  */
 struct exofs_sb_info {
+        struct backing_dev_info bdi;            /* register our bdi with VFS  */
         struct exofs_sb_stats s_ess;            /* Written often, pre-allocate*/
         int             s_timeout;              /* timeout for OSD operations */
         uint64_t        s_nextid;               /* highest object ID used     */
@@ -84,16 +65,13 @@ struct exofs_sb_info {
         spinlock_t      s_next_gen_lock;        /* spinlock for gen # update  */
         u32             s_next_generation;      /* next gen # to use          */
         atomic_t        s_curr_pending;         /* number of pending commands */
-        uint8_t         s_cred[OSD_CAP_LEN];    /* credential for the fscb    */
-        struct          backing_dev_info bdi;   /* register our bdi with VFS  */
 
         struct pnfs_osd_data_map data_map;      /* Default raid to use
                                                  * FIXME: Needed ?
                                                  */
-/*      struct exofs_layout     dir_layout;*/   /* Default dir layout */
-        struct exofs_layout     layout;         /* Default files layout,
-                                                 * contains the variable osd_dev
-                                                 * array. Keep last */
+        struct ore_layout       layout;         /* Default files layout       */
+        struct ore_comp one_comp;               /* id & cred of partition id=0*/
+        struct ore_components comps;            /* comps for the partition    */
         struct osd_dev  *_min_one_dev[1];       /* Place holder for one dev   */
 };
 
@@ -107,7 +85,8 @@ struct exofs_i_info {
         uint32_t       i_data[EXOFS_IDATA];/*short symlink names and device #s*/
         uint32_t       i_dir_start_lookup; /* which page to start lookup      */
         uint64_t       i_commit_size;      /* the object's written length     */
-        uint8_t        i_cred[OSD_CAP_LEN];/* all-powerful credential         */
+        struct ore_comp one_comp;          /* same component for all devices  */
+        struct ore_components comps;       /* inode view of the device table  */
 };
 
 static inline osd_id exofs_oi_objno(struct exofs_i_info *oi)
@@ -115,52 +94,6 @@ static inline osd_id exofs_oi_objno(struct exofs_i_info *oi)
         return oi->vfs_inode.i_ino + EXOFS_OBJ_OFF;
 }
 
-struct exofs_io_state;
-typedef void (*exofs_io_done_fn)(struct exofs_io_state *or, void *private);
-
-struct exofs_io_state {
-        struct kref             kref;
-
-        void                    *private;
-        exofs_io_done_fn        done;
-
-        struct exofs_layout     *layout;
-        struct osd_obj_id       obj;
-        u8                      *cred;
-
-        /* Global read/write IO*/
-        loff_t                  offset;
-        unsigned long           length;
-        void                    *kern_buff;
-
-        struct page             **pages;
-        unsigned                nr_pages;
-        unsigned                pgbase;
-        unsigned                pages_consumed;
-
-        /* Attributes */
-        unsigned                in_attr_len;
-        struct osd_attr         *in_attr;
-        unsigned                out_attr_len;
-        struct osd_attr         *out_attr;
-
-        /* Variable array of size numdevs */
-        unsigned numdevs;
-        struct exofs_per_dev_state {
-                struct osd_request *or;
-                struct bio *bio;
-                loff_t offset;
-                unsigned length;
-                unsigned dev;
-        } per_dev[];
-};
-
-static inline unsigned exofs_io_state_size(unsigned numdevs)
-{
-        return sizeof(struct exofs_io_state) +
-                sizeof(struct exofs_per_dev_state) * numdevs;
-}
-
 /*
  * our inode flags
  */
@@ -205,12 +138,6 @@ static inline struct exofs_i_info *exofs_i(struct inode *inode)
 }
 
 /*
- * Given a layout, object_number and stripe_index return the associated global
- * dev_index
- */
-unsigned exofs_layout_od_id(struct exofs_layout *layout,
-                            osd_id obj_no, unsigned layout_index);
-/*
  * Maximum count of links to a file
  */
 #define EXOFS_LINK_MAX           32000
@@ -219,44 +146,8 @@ unsigned exofs_layout_od_id(struct exofs_layout *layout,
  * function declarations *
  *************************/
 
-/* ios.c */
-void exofs_make_credential(u8 cred_a[OSD_CAP_LEN],
-                           const struct osd_obj_id *obj);
-int exofs_read_kern(struct osd_dev *od, u8 *cred, struct osd_obj_id *obj,
-                    u64 offset, void *p, unsigned length);
-
-int  exofs_get_io_state(struct exofs_layout *layout,
-                        struct exofs_io_state **ios);
-void exofs_put_io_state(struct exofs_io_state *ios);
-
-int exofs_check_io(struct exofs_io_state *ios, u64 *resid);
-
-int exofs_sbi_create(struct exofs_io_state *ios);
-int exofs_sbi_remove(struct exofs_io_state *ios);
-int exofs_sbi_write(struct exofs_io_state *ios);
-int exofs_sbi_read(struct exofs_io_state *ios);
-
-int extract_attr_from_ios(struct exofs_io_state *ios, struct osd_attr *attr);
-
-int exofs_oi_truncate(struct exofs_i_info *oi, u64 new_len);
-static inline int exofs_oi_write(struct exofs_i_info *oi,
-                                 struct exofs_io_state *ios)
-{
-        ios->obj.id = exofs_oi_objno(oi);
-        ios->cred = oi->i_cred;
-        return exofs_sbi_write(ios);
-}
-
-static inline int exofs_oi_read(struct exofs_i_info *oi,
-                                struct exofs_io_state *ios)
-{
-        ios->obj.id = exofs_oi_objno(oi);
-        ios->cred = oi->i_cred;
-        return exofs_sbi_read(ios);
-}
-
 /* inode.c               */
-unsigned exofs_max_io_pages(struct exofs_layout *layout,
+unsigned exofs_max_io_pages(struct ore_layout *layout,
                             unsigned expected_pages);
 int exofs_setattr(struct dentry *, struct iattr *);
 int exofs_write_begin(struct file *file, struct address_space *mapping,
@@ -281,6 +172,8 @@ int exofs_set_link(struct inode *, struct exofs_dir_entry *, struct page *,
                     struct inode *);
 
 /* super.c               */
+void exofs_make_credential(u8 cred_a[OSD_CAP_LEN],
+                           const struct osd_obj_id *obj);
 int exofs_sbi_write_stats(struct exofs_sb_info *sbi);
 
 /*********************
@@ -295,7 +188,6 @@ extern const struct file_operations exofs_file_operations;
 
 /* inode.c           */
 extern const struct address_space_operations exofs_aops;
-extern const struct osd_attr g_attr_logical_length;
 
 /* namei.c           */
 extern const struct inode_operations exofs_dir_inode_operations;
@@ -305,4 +197,33 @@ extern const struct inode_operations exofs_special_inode_operations;
 extern const struct inode_operations exofs_symlink_inode_operations;
 extern const struct inode_operations exofs_fast_symlink_inode_operations;
 
+/* exofs_init_comps will initialize an ore_components device array
+ * pointing to a single ore_comp struct, and a round-robin view
+ * of the device table.
+ * The first device of each inode is the [inode->ino % num_devices]
+ * and the rest of the devices sequentially following where the
+ * first device is after the last device.
+ * It is assumed that the global device array at @sbi is twice
+ * bigger and that the device table repeats twice.
+ * See: exofs_read_lookup_dev_table()
+ */
+static inline void exofs_init_comps(struct ore_components *comps,
+                                    struct ore_comp *one_comp,
+                                    struct exofs_sb_info *sbi, osd_id oid)
+{
+        unsigned dev_mod = (unsigned)oid, first_dev;
+
+        one_comp->obj.partition = sbi->one_comp.obj.partition;
+        one_comp->obj.id = oid;
+        exofs_make_credential(one_comp->cred, &one_comp->obj);
+
+        comps->numdevs = sbi->comps.numdevs;
+        comps->single_comp = EC_SINGLE_COMP;
+        comps->comps = one_comp;
+
+        /* Round robin device view of the table */
+        first_dev = (dev_mod * sbi->layout.mirrors_p1) % sbi->comps.numdevs;
+        comps->ods = sbi->comps.ods + first_dev;
+}
+
 #endif
diff --git a/fs/exofs/inode.c b/fs/exofs/inode.c
index 8472c098445d..f39a38fc2349 100644
--- a/fs/exofs/inode.c
+++ b/fs/exofs/inode.c
@@ -43,7 +43,7 @@ enum { BIO_MAX_PAGES_KMALLOC =
                 PAGE_SIZE / sizeof(struct page *),
 };
 
-unsigned exofs_max_io_pages(struct exofs_layout *layout,
+unsigned exofs_max_io_pages(struct ore_layout *layout,
                             unsigned expected_pages)
 {
         unsigned pages = min_t(unsigned, expected_pages, MAX_PAGES_KMALLOC);
@@ -58,7 +58,7 @@ struct page_collect {
         struct exofs_sb_info *sbi;
         struct inode *inode;
         unsigned expected_pages;
-        struct exofs_io_state *ios;
+        struct ore_io_state *ios;
 
         struct page **pages;
         unsigned alloc_pages;
@@ -110,13 +110,6 @@ static int pcol_try_alloc(struct page_collect *pcol)
 {
         unsigned pages;
 
-        if (!pcol->ios) { /* First time allocate io_state */
-                int ret = exofs_get_io_state(&pcol->sbi->layout, &pcol->ios);
-
-                if (ret)
-                        return ret;
-        }
-
         /* TODO: easily support bio chaining */
         pages =  exofs_max_io_pages(&pcol->sbi->layout, pcol->expected_pages);
 
@@ -140,7 +133,7 @@ static void pcol_free(struct page_collect *pcol)
         pcol->pages = NULL;
 
         if (pcol->ios) {
-                exofs_put_io_state(pcol->ios);
+                ore_put_io_state(pcol->ios);
                 pcol->ios = NULL;
         }
 }
@@ -200,7 +193,7 @@ static int __readpages_done(struct page_collect *pcol)
         u64 resid;
         u64 good_bytes;
         u64 length = 0;
-        int ret = exofs_check_io(pcol->ios, &resid);
+        int ret = ore_check_io(pcol->ios, &resid);
 
         if (likely(!ret))
                 good_bytes = pcol->length;
@@ -241,7 +234,7 @@ static int __readpages_done(struct page_collect *pcol)
 }
 
 /* callback of async reads */
-static void readpages_done(struct exofs_io_state *ios, void *p)
+static void readpages_done(struct ore_io_state *ios, void *p)
 {
         struct page_collect *pcol = p;
 
@@ -269,20 +262,28 @@ static void _unlock_pcol_pages(struct page_collect *pcol, int ret, int rw)
 static int read_exec(struct page_collect *pcol)
 {
         struct exofs_i_info *oi = exofs_i(pcol->inode);
-        struct exofs_io_state *ios = pcol->ios;
+        struct ore_io_state *ios;
         struct page_collect *pcol_copy = NULL;
         int ret;
 
         if (!pcol->pages)
                 return 0;
 
+        if (!pcol->ios) {
+                int ret = ore_get_rw_state(&pcol->sbi->layout, &oi->comps, true,
+                                             pcol->pg_first << PAGE_CACHE_SHIFT,
+                                             pcol->length, &pcol->ios);
+
+                if (ret)
+                        return ret;
+        }
+
+        ios = pcol->ios;
         ios->pages = pcol->pages;
         ios->nr_pages = pcol->nr_pages;
-        ios->length = pcol->length;
-        ios->offset = pcol->pg_first << PAGE_CACHE_SHIFT;
 
         if (pcol->read_4_write) {
-                exofs_oi_read(oi, pcol->ios);
+                ore_read(pcol->ios);
                 return __readpages_done(pcol);
         }
 
@@ -295,14 +296,14 @@ static int read_exec(struct page_collect *pcol)
         *pcol_copy = *pcol;
         ios->done = readpages_done;
         ios->private = pcol_copy;
-        ret = exofs_oi_read(oi, ios);
+        ret = ore_read(ios);
         if (unlikely(ret))
                 goto err;
 
         atomic_inc(&pcol->sbi->s_curr_pending);
 
         EXOFS_DBGMSG2("read_exec obj=0x%llx start=0x%llx length=0x%lx\n",
-                  ios->obj.id, _LLU(ios->offset), pcol->length);
+                  oi->one_comp.obj.id, _LLU(ios->offset), pcol->length);
 
         /* pages ownership was passed to pcol_copy */
         _pcol_reset(pcol);
@@ -457,14 +458,14 @@ static int exofs_readpage(struct file *file, struct page *page)
 }
 
 /* Callback for osd_write. All writes are asynchronous */
-static void writepages_done(struct exofs_io_state *ios, void *p)
+static void writepages_done(struct ore_io_state *ios, void *p)
 {
         struct page_collect *pcol = p;
         int i;
         u64 resid;
         u64  good_bytes;
         u64  length = 0;
-        int ret = exofs_check_io(ios, &resid);
+        int ret = ore_check_io(ios, &resid);
 
         atomic_dec(&pcol->sbi->s_curr_pending);
 
@@ -507,13 +508,21 @@ static void writepages_done(struct exofs_io_state *ios, void *p)
 static int write_exec(struct page_collect *pcol)
 {
         struct exofs_i_info *oi = exofs_i(pcol->inode);
-        struct exofs_io_state *ios = pcol->ios;
+        struct ore_io_state *ios;
         struct page_collect *pcol_copy = NULL;
         int ret;
 
         if (!pcol->pages)
                 return 0;
 
+        BUG_ON(pcol->ios);
+        ret = ore_get_rw_state(&pcol->sbi->layout, &oi->comps, false,
+                                 pcol->pg_first << PAGE_CACHE_SHIFT,
+                                 pcol->length, &pcol->ios);
+
+        if (unlikely(ret))
+                goto err;
+
         pcol_copy = kmalloc(sizeof(*pcol_copy), GFP_KERNEL);
         if (!pcol_copy) {
                 EXOFS_ERR("write_exec: Failed to kmalloc(pcol)\n");
@@ -523,16 +532,15 @@ static int write_exec(struct page_collect *pcol)
 
         *pcol_copy = *pcol;
 
+        ios = pcol->ios;
         ios->pages = pcol_copy->pages;
         ios->nr_pages = pcol_copy->nr_pages;
-        ios->offset = pcol_copy->pg_first << PAGE_CACHE_SHIFT;
-        ios->length = pcol_copy->length;
         ios->done = writepages_done;
         ios->private = pcol_copy;
 
-        ret = exofs_oi_write(oi, ios);
+        ret = ore_write(ios);
         if (unlikely(ret)) {
-                EXOFS_ERR("write_exec: exofs_oi_write() Failed\n");
+                EXOFS_ERR("write_exec: ore_write() Failed\n");
                 goto err;
         }
 
@@ -844,17 +852,15 @@ static inline int exofs_inode_is_fast_symlink(struct inode *inode)
         return S_ISLNK(inode->i_mode) && (oi->i_data[0] != 0);
 }
 
-const struct osd_attr g_attr_logical_length = ATTR_DEF(
-        OSD_APAGE_OBJECT_INFORMATION, OSD_ATTR_OI_LOGICAL_LENGTH, 8);
-
 static int _do_truncate(struct inode *inode, loff_t newsize)
 {
         struct exofs_i_info *oi = exofs_i(inode);
+        struct exofs_sb_info *sbi = inode->i_sb->s_fs_info;
         int ret;
 
         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 
-        ret = exofs_oi_truncate(oi, (u64)newsize);
+        ret = ore_truncate(&sbi->layout, &oi->comps, (u64)newsize);
         if (likely(!ret))
                 truncate_setsize(inode, newsize);
 
@@ -917,30 +923,26 @@ static int exofs_get_inode(struct super_block *sb, struct exofs_i_info *oi,
                 [1] = g_attr_inode_file_layout,
                 [2] = g_attr_inode_dir_layout,
         };
-        struct exofs_io_state *ios;
+        struct ore_io_state *ios;
         struct exofs_on_disk_inode_layout *layout;
         int ret;
 
-        ret = exofs_get_io_state(&sbi->layout, &ios);
+        ret = ore_get_io_state(&sbi->layout, &oi->comps, &ios);
         if (unlikely(ret)) {
-                EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__);
+                EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__);
                 return ret;
         }
 
-        ios->obj.id = exofs_oi_objno(oi);
-        exofs_make_credential(oi->i_cred, &ios->obj);
-        ios->cred = oi->i_cred;
-
-        attrs[1].len = exofs_on_disk_inode_layout_size(sbi->layout.s_numdevs);
-        attrs[2].len = exofs_on_disk_inode_layout_size(sbi->layout.s_numdevs);
+        attrs[1].len = exofs_on_disk_inode_layout_size(sbi->comps.numdevs);
+        attrs[2].len = exofs_on_disk_inode_layout_size(sbi->comps.numdevs);
 
         ios->in_attr = attrs;
         ios->in_attr_len = ARRAY_SIZE(attrs);
 
-        ret = exofs_sbi_read(ios);
+        ret = ore_read(ios);
         if (unlikely(ret)) {
                 EXOFS_ERR("object(0x%llx) corrupted, return empty file=>%d\n",
-                          _LLU(ios->obj.id), ret);
+                          _LLU(oi->one_comp.obj.id), ret);
                 memset(inode, 0, sizeof(*inode));
                 inode->i_mode = 0040000 | (0777 & ~022);
                 /* If object is lost on target we might as well enable it's
@@ -990,7 +992,7 @@ static int exofs_get_inode(struct super_block *sb, struct exofs_i_info *oi,
         }
 
 out:
-        exofs_put_io_state(ios);
+        ore_put_io_state(ios);
         return ret;
 }
 
@@ -1016,6 +1018,8 @@ struct inode *exofs_iget(struct super_block *sb, unsigned long ino)
                 return inode;
         oi = exofs_i(inode);
         __oi_init(oi);
+        exofs_init_comps(&oi->comps, &oi->one_comp, sb->s_fs_info,
+                         exofs_oi_objno(oi));
 
         /* read the inode from the osd */
         ret = exofs_get_inode(sb, oi, &fcb);
@@ -1107,21 +1111,22 @@ int __exofs_wait_obj_created(struct exofs_i_info *oi)
  * set the obj_created flag so that other methods know that the object exists on
  * the OSD.
  */
-static void create_done(struct exofs_io_state *ios, void *p)
+static void create_done(struct ore_io_state *ios, void *p)
 {
         struct inode *inode = p;
         struct exofs_i_info *oi = exofs_i(inode);
         struct exofs_sb_info *sbi = inode->i_sb->s_fs_info;
         int ret;
 
-        ret = exofs_check_io(ios, NULL);
-        exofs_put_io_state(ios);
+        ret = ore_check_io(ios, NULL);
+        ore_put_io_state(ios);
 
         atomic_dec(&sbi->s_curr_pending);
 
         if (unlikely(ret)) {
                 EXOFS_ERR("object=0x%llx creation failed in pid=0x%llx",
-                          _LLU(exofs_oi_objno(oi)), _LLU(sbi->layout.s_pid));
+                          _LLU(exofs_oi_objno(oi)),
+                          _LLU(oi->one_comp.obj.partition));
                 /*TODO: When FS is corrupted creation can fail, object already
                  * exist. Get rid of this asynchronous creation, if exist
                  * increment the obj counter and try the next object. Until we
@@ -1140,14 +1145,13 @@ static void create_done(struct exofs_io_state *ios, void *p)
  */
 struct inode *exofs_new_inode(struct inode *dir, int mode)
 {
-        struct super_block *sb;
+        struct super_block *sb = dir->i_sb;
+        struct exofs_sb_info *sbi = sb->s_fs_info;
         struct inode *inode;
         struct exofs_i_info *oi;
-        struct exofs_sb_info *sbi;
-        struct exofs_io_state *ios;
+        struct ore_io_state *ios;
         int ret;
 
-        sb = dir->i_sb;
         inode = new_inode(sb);
         if (!inode)
                 return ERR_PTR(-ENOMEM);
@@ -1157,8 +1161,6 @@ struct inode *exofs_new_inode(struct inode *dir, int mode)
 
         set_obj_2bcreated(oi);
 
-        sbi = sb->s_fs_info;
-
         inode->i_mapping->backing_dev_info = sb->s_bdi;
         inode_init_owner(inode, dir, mode);
         inode->i_ino = sbi->s_nextid++;
@@ -1170,25 +1172,24 @@ struct inode *exofs_new_inode(struct inode *dir, int mode)
         spin_unlock(&sbi->s_next_gen_lock);
         insert_inode_hash(inode);
 
+        exofs_init_comps(&oi->comps, &oi->one_comp, sb->s_fs_info,
+                         exofs_oi_objno(oi));
         exofs_sbi_write_stats(sbi); /* Make sure new sbi->s_nextid is on disk */
 
         mark_inode_dirty(inode);
 
-        ret = exofs_get_io_state(&sbi->layout, &ios);
+        ret = ore_get_io_state(&sbi->layout, &oi->comps, &ios);
         if (unlikely(ret)) {
-                EXOFS_ERR("exofs_new_inode: exofs_get_io_state failed\n");
+                EXOFS_ERR("exofs_new_inode: ore_get_io_state failed\n");
                 return ERR_PTR(ret);
         }
 
-        ios->obj.id = exofs_oi_objno(oi);
-        exofs_make_credential(oi->i_cred, &ios->obj);
-
         ios->done = create_done;
         ios->private = inode;
-        ios->cred = oi->i_cred;
-        ret = exofs_sbi_create(ios);
+
+        ret = ore_create(ios);
         if (ret) {
-                exofs_put_io_state(ios);
+                ore_put_io_state(ios);
                 return ERR_PTR(ret);
         }
         atomic_inc(&sbi->s_curr_pending);
@@ -1207,11 +1208,11 @@ struct updatei_args {
 /*
  * Callback function from exofs_update_inode().
  */
-static void updatei_done(struct exofs_io_state *ios, void *p)
+static void updatei_done(struct ore_io_state *ios, void *p)
 {
         struct updatei_args *args = p;
 
-        exofs_put_io_state(ios);
+        ore_put_io_state(ios);
 
         atomic_dec(&args->sbi->s_curr_pending);
 
@@ -1227,7 +1228,7 @@ static int exofs_update_inode(struct inode *inode, int do_sync)
         struct exofs_i_info *oi = exofs_i(inode);
         struct super_block *sb = inode->i_sb;
         struct exofs_sb_info *sbi = sb->s_fs_info;
-        struct exofs_io_state *ios;
+        struct ore_io_state *ios;
         struct osd_attr attr;
         struct exofs_fcb *fcb;
         struct updatei_args *args;
@@ -1266,9 +1267,9 @@ static int exofs_update_inode(struct inode *inode, int do_sync)
         } else
                 memcpy(fcb->i_data, oi->i_data, sizeof(fcb->i_data));
 
-        ret = exofs_get_io_state(&sbi->layout, &ios);
+        ret = ore_get_io_state(&sbi->layout, &oi->comps, &ios);
         if (unlikely(ret)) {
-                EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__);
+                EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__);
                 goto free_args;
         }
 
@@ -1285,13 +1286,13 @@ static int exofs_update_inode(struct inode *inode, int do_sync)
                 ios->private = args;
         }
 
-        ret = exofs_oi_write(oi, ios);
+        ret = ore_write(ios);
         if (!do_sync && !ret) {
                 atomic_inc(&sbi->s_curr_pending);
                 goto out; /* deallocation in updatei_done */
         }
 
-        exofs_put_io_state(ios);
+        ore_put_io_state(ios);
 free_args:
         kfree(args);
 out:
@@ -1310,11 +1311,11 @@ int exofs_write_inode(struct inode *inode, struct writeback_control *wbc)
  * Callback function from exofs_delete_inode() - don't have much cleaning up to
  * do.
  */
-static void delete_done(struct exofs_io_state *ios, void *p)
+static void delete_done(struct ore_io_state *ios, void *p)
 {
         struct exofs_sb_info *sbi = p;
 
-        exofs_put_io_state(ios);
+        ore_put_io_state(ios);
 
         atomic_dec(&sbi->s_curr_pending);
 }
@@ -1329,7 +1330,7 @@ void exofs_evict_inode(struct inode *inode)
         struct exofs_i_info *oi = exofs_i(inode);
         struct super_block *sb = inode->i_sb;
         struct exofs_sb_info *sbi = sb->s_fs_info;
-        struct exofs_io_state *ios;
+        struct ore_io_state *ios;
         int ret;
 
         truncate_inode_pages(&inode->i_data, 0);
@@ -1349,20 +1350,19 @@ void exofs_evict_inode(struct inode *inode)
         /* ignore the error, attempt a remove anyway */
 
         /* Now Remove the OSD objects */
-        ret = exofs_get_io_state(&sbi->layout, &ios);
+        ret = ore_get_io_state(&sbi->layout, &oi->comps, &ios);
         if (unlikely(ret)) {
-                EXOFS_ERR("%s: exofs_get_io_state failed\n", __func__);
+                EXOFS_ERR("%s: ore_get_io_state failed\n", __func__);
                 return;
         }
 
-        ios->obj.id = exofs_oi_objno(oi);
         ios->done = delete_done;
         ios->private = sbi;
-        ios->cred = oi->i_cred;
-        ret = exofs_sbi_remove(ios);
+
+        ret = ore_remove(ios);
         if (ret) {
-                EXOFS_ERR("%s: exofs_sbi_remove failed\n", __func__);
-                exofs_put_io_state(ios);
+                EXOFS_ERR("%s: ore_remove failed\n", __func__);
+                ore_put_io_state(ios);
                 return;
         }
         atomic_inc(&sbi->s_curr_pending);
diff --git a/fs/exofs/ios.c b/fs/exofs/ore.c
index f74a2ec027a6..25305af88198 100644
--- a/fs/exofs/ios.c
+++ b/fs/exofs/ore.c
@@ -23,81 +23,87 @@
  */
 
 #include <linux/slab.h>
-#include <scsi/scsi_device.h>
 #include <asm/div64.h>
 
-#include "exofs.h"
+#include <scsi/osd_ore.h>
 
-#define EXOFS_DBGMSG2(M...) do {} while (0)
-/* #define EXOFS_DBGMSG2 EXOFS_DBGMSG */
+#define ORE_ERR(fmt, a...) printk(KERN_ERR "ore: " fmt, ##a)
 
-void exofs_make_credential(u8 cred_a[OSD_CAP_LEN], const struct osd_obj_id *obj)
-{
-        osd_sec_init_nosec_doall_caps(cred_a, obj, false, true);
-}
+#ifdef CONFIG_EXOFS_DEBUG
+#define ORE_DBGMSG(fmt, a...) \
+        printk(KERN_NOTICE "ore @%s:%d: " fmt, __func__, __LINE__, ##a)
+#else
+#define ORE_DBGMSG(fmt, a...) \
+        do { if (0) printk(fmt, ##a); } while (0)
+#endif
 
-int exofs_read_kern(struct osd_dev *od, u8 *cred, struct osd_obj_id *obj,
-                    u64 offset, void *p, unsigned length)
-{
-        struct osd_request *or = osd_start_request(od, GFP_KERNEL);
-/*      struct osd_sense_info osi = {.key = 0};*/
-        int ret;
+/* u64 has problems with printk this will cast it to unsigned long long */
+#define _LLU(x) (unsigned long long)(x)
 
-        if (unlikely(!or)) {
-                EXOFS_DBGMSG("%s: osd_start_request failed.\n", __func__);
-                return -ENOMEM;
-        }
-        ret = osd_req_read_kern(or, obj, offset, p, length);
-        if (unlikely(ret)) {
-                EXOFS_DBGMSG("%s: osd_req_read_kern failed.\n", __func__);
-                goto out;
-        }
+#define ORE_DBGMSG2(M...) do {} while (0)
+/* #define ORE_DBGMSG2 ORE_DBGMSG */
 
-        ret = osd_finalize_request(or, 0, cred, NULL);
-        if (unlikely(ret)) {
-                EXOFS_DBGMSG("Failed to osd_finalize_request() => %d\n", ret);
-                goto out;
-        }
+MODULE_AUTHOR("Boaz Harrosh <bharrosh@panasas.com>");
+MODULE_DESCRIPTION("Objects Raid Engine ore.ko");
+MODULE_LICENSE("GPL");
 
-        ret = osd_execute_request(or);
-        if (unlikely(ret))
-                EXOFS_DBGMSG("osd_execute_request() => %d\n", ret);
-        /* osd_req_decode_sense(or, ret); */
+static u8 *_ios_cred(struct ore_io_state *ios, unsigned index)
+{
+        return ios->comps->comps[index & ios->comps->single_comp].cred;
+}
 
-out:
-        osd_end_request(or);
-        return ret;
+static struct osd_obj_id *_ios_obj(struct ore_io_state *ios, unsigned index)
+{
+        return &ios->comps->comps[index & ios->comps->single_comp].obj;
 }
 
-int exofs_get_io_state(struct exofs_layout *layout,
-                       struct exofs_io_state **pios)
+static struct osd_dev *_ios_od(struct ore_io_state *ios, unsigned index)
 {
-        struct exofs_io_state *ios;
+        return ios->comps->ods[index];
+}
+
+int  ore_get_rw_state(struct ore_layout *layout, struct ore_components *comps,
+                      bool is_reading, u64 offset, u64 length,
+                      struct ore_io_state **pios)
+{
+        struct ore_io_state *ios;
 
         /*TODO: Maybe use kmem_cach per sbi of size
          * exofs_io_state_size(layout->s_numdevs)
          */
-        ios = kzalloc(exofs_io_state_size(layout->s_numdevs), GFP_KERNEL);
+        ios = kzalloc(ore_io_state_size(comps->numdevs), GFP_KERNEL);
         if (unlikely(!ios)) {
-                EXOFS_DBGMSG("Failed kzalloc bytes=%d\n",
-                             exofs_io_state_size(layout->s_numdevs));
+                ORE_DBGMSG("Failed kzalloc bytes=%d\n",
+                             ore_io_state_size(comps->numdevs));
                 *pios = NULL;
                 return -ENOMEM;
         }
 
         ios->layout = layout;
-        ios->obj.partition = layout->s_pid;
+        ios->comps = comps;
+        ios->offset = offset;
+        ios->length = length;
+        ios->reading = is_reading;
+
         *pios = ios;
         return 0;
 }
+EXPORT_SYMBOL(ore_get_rw_state);
+
+int  ore_get_io_state(struct ore_layout *layout, struct ore_components *comps,
+                      struct ore_io_state **ios)
+{
+        return ore_get_rw_state(layout, comps, true, 0, 0, ios);
+}
+EXPORT_SYMBOL(ore_get_io_state);
 
-void exofs_put_io_state(struct exofs_io_state *ios)
+void ore_put_io_state(struct ore_io_state *ios)
 {
         if (ios) {
                 unsigned i;
 
                 for (i = 0; i < ios->numdevs; i++) {
-                        struct exofs_per_dev_state *per_dev = &ios->per_dev[i];
+                        struct ore_per_dev_state *per_dev = &ios->per_dev[i];
 
                         if (per_dev->or)
                                 osd_end_request(per_dev->or);
@@ -108,31 +114,9 @@ void exofs_put_io_state(struct exofs_io_state *ios)
                 kfree(ios);
         }
 }
+EXPORT_SYMBOL(ore_put_io_state);
 
-unsigned exofs_layout_od_id(struct exofs_layout *layout,
-                            osd_id obj_no, unsigned layout_index)
-{
-/*      switch (layout->lay_func) {
-        case LAYOUT_MOVING_WINDOW:
-        {*/
-                unsigned dev_mod = obj_no;
-
-                return (layout_index + dev_mod * layout->mirrors_p1) %
-                                                              layout->s_numdevs;
-/*      }
-        case LAYOUT_FUNC_IMPLICT:
-                return layout->devs[layout_index];
-        }*/
-}
-
-static inline struct osd_dev *exofs_ios_od(struct exofs_io_state *ios,
-                                           unsigned layout_index)
-{
-        return ios->layout->s_ods[
-                exofs_layout_od_id(ios->layout, ios->obj.id, layout_index)];
-}
-
-static void _sync_done(struct exofs_io_state *ios, void *p)
+static void _sync_done(struct ore_io_state *ios, void *p)
 {
         struct completion *waiting = p;
 
@@ -141,20 +125,20 @@ static void _sync_done(struct exofs_io_state *ios, void *p)
 
 static void _last_io(struct kref *kref)
 {
-        struct exofs_io_state *ios = container_of(
-                                        kref, struct exofs_io_state, kref);
+        struct ore_io_state *ios = container_of(
+                                        kref, struct ore_io_state, kref);
 
         ios->done(ios, ios->private);
 }
 
 static void _done_io(struct osd_request *or, void *p)
 {
-        struct exofs_io_state *ios = p;
+        struct ore_io_state *ios = p;
 
         kref_put(&ios->kref, _last_io);
 }
 
-static int exofs_io_execute(struct exofs_io_state *ios)
+static int ore_io_execute(struct ore_io_state *ios)
 {
         DECLARE_COMPLETION_ONSTACK(wait);
         bool sync = (ios->done == NULL);
@@ -170,9 +154,9 @@ static int exofs_io_execute(struct exofs_io_state *ios)
                 if (unlikely(!or))
                         continue;
 
-                ret = osd_finalize_request(or, 0, ios->cred, NULL);
+                ret = osd_finalize_request(or, 0, _ios_cred(ios, i), NULL);
                 if (unlikely(ret)) {
-                        EXOFS_DBGMSG("Failed to osd_finalize_request() => %d\n",
+                        ORE_DBGMSG("Failed to osd_finalize_request() => %d\n",
                                      ret);
                         return ret;
                 }
@@ -194,7 +178,7 @@ static int exofs_io_execute(struct exofs_io_state *ios)
 
         if (sync) {
                 wait_for_completion(&wait);
-                ret = exofs_check_io(ios, NULL);
+                ret = ore_check_io(ios, NULL);
         }
         return ret;
 }
@@ -214,7 +198,7 @@ static void _clear_bio(struct bio *bio)
         }
 }
 
-int exofs_check_io(struct exofs_io_state *ios, u64 *resid)
+int ore_check_io(struct ore_io_state *ios, u64 *resid)
 {
         enum osd_err_priority acumulated_osd_err = 0;
         int acumulated_lin_err = 0;
@@ -235,7 +219,7 @@ int exofs_check_io(struct exofs_io_state *ios, u64 *resid)
                 if (OSD_ERR_PRI_CLEAR_PAGES == osi.osd_err_pri) {
                         /* start read offset passed endof file */
                         _clear_bio(ios->per_dev[i].bio);
-                        EXOFS_DBGMSG("start read offset passed end of file "
+                        ORE_DBGMSG("start read offset passed end of file "
                                 "offset=0x%llx, length=0x%llx\n",
                                 _LLU(ios->per_dev[i].offset),
                                 _LLU(ios->per_dev[i].length));
@@ -259,6 +243,7 @@ int exofs_check_io(struct exofs_io_state *ios, u64 *resid)
 
         return acumulated_lin_err;
 }
+EXPORT_SYMBOL(ore_check_io);
 
 /*
  * L - logical offset into the file
@@ -305,20 +290,21 @@ int exofs_check_io(struct exofs_io_state *ios, u64 *resid)
 struct _striping_info {
         u64 obj_offset;
         u64 group_length;
+        u64 M; /* for truncate */
         unsigned dev;
         unsigned unit_off;
 };
 
-static void _calc_stripe_info(struct exofs_io_state *ios, u64 file_offset,
+static void _calc_stripe_info(struct ore_layout *layout, u64 file_offset,
                               struct _striping_info *si)
 {
-        u32     stripe_unit = ios->layout->stripe_unit;
-        u32     group_width = ios->layout->group_width;
-        u64     group_depth = ios->layout->group_depth;
+        u32     stripe_unit = layout->stripe_unit;
+        u32     group_width = layout->group_width;
+        u64     group_depth = layout->group_depth;
 
         u32     U = stripe_unit * group_width;
         u64     T = U * group_depth;
-        u64     S = T * ios->layout->group_count;
+        u64     S = T * layout->group_count;
         u64     M = div64_u64(file_offset, S);
 
         /*
@@ -333,7 +319,7 @@ static void _calc_stripe_info(struct exofs_io_state *ios, u64 file_offset,
 
         /* "H - (N * U)" is just "H % U" so it's bound to u32 */
         si->dev = (u32)(H - (N * U)) / stripe_unit + G * group_width;
-        si->dev *= ios->layout->mirrors_p1;
+        si->dev *= layout->mirrors_p1;
 
         div_u64_rem(file_offset, stripe_unit, &si->unit_off);
 
@@ -341,15 +327,16 @@ static void _calc_stripe_info(struct exofs_io_state *ios, u64 file_offset,
                                   (M * group_depth * stripe_unit);
 
         si->group_length = T - H;
+        si->M = M;
 }
 
-static int _add_stripe_unit(struct exofs_io_state *ios,  unsigned *cur_pg,
-                unsigned pgbase, struct exofs_per_dev_state *per_dev,
+static int _add_stripe_unit(struct ore_io_state *ios,  unsigned *cur_pg,
+                unsigned pgbase, struct ore_per_dev_state *per_dev,
                 int cur_len)
 {
         unsigned pg = *cur_pg;
         struct request_queue *q =
-                        osd_request_queue(exofs_ios_od(ios, per_dev->dev));
+                        osd_request_queue(_ios_od(ios, per_dev->dev));
 
         per_dev->length += cur_len;
 
@@ -361,7 +348,7 @@ static int _add_stripe_unit(struct exofs_io_state *ios,  unsigned *cur_pg,
 
                 per_dev->bio = bio_kmalloc(GFP_KERNEL, bio_size);
                 if (unlikely(!per_dev->bio)) {
-                        EXOFS_DBGMSG("Failed to allocate BIO size=%u\n",
+                        ORE_DBGMSG("Failed to allocate BIO size=%u\n",
                                      bio_size);
                         return -ENOMEM;
                 }
@@ -387,7 +374,7 @@ static int _add_stripe_unit(struct exofs_io_state *ios,  unsigned *cur_pg,
         return 0;
 }
 
-static int _prepare_one_group(struct exofs_io_state *ios, u64 length,
+static int _prepare_one_group(struct ore_io_state *ios, u64 length,
                               struct _striping_info *si)
 {
         unsigned stripe_unit = ios->layout->stripe_unit;
@@ -400,7 +387,7 @@ static int _prepare_one_group(struct exofs_io_state *ios, u64 length,
         int ret = 0;
 
         while (length) {
-                struct exofs_per_dev_state *per_dev = &ios->per_dev[dev];
+                struct ore_per_dev_state *per_dev = &ios->per_dev[dev];
                 unsigned cur_len, page_off = 0;
 
                 if (!per_dev->length) {
@@ -443,7 +430,7 @@ out:
         return ret;
 }
 
-static int _prepare_for_striping(struct exofs_io_state *ios)
+static int _prepare_for_striping(struct ore_io_state *ios)
 {
         u64 length = ios->length;
         u64 offset = ios->offset;
@@ -452,9 +439,9 @@ static int _prepare_for_striping(struct exofs_io_state *ios)
 
         if (!ios->pages) {
                 if (ios->kern_buff) {
-                        struct exofs_per_dev_state *per_dev = &ios->per_dev[0];
+                        struct ore_per_dev_state *per_dev = &ios->per_dev[0];
 
-                        _calc_stripe_info(ios, ios->offset, &si);
+                        _calc_stripe_info(ios->layout, ios->offset, &si);
                         per_dev->offset = si.obj_offset;
                         per_dev->dev = si.dev;
 
@@ -468,7 +455,7 @@ static int _prepare_for_striping(struct exofs_io_state *ios)
         }
 
         while (length) {
-                _calc_stripe_info(ios, offset, &si);
+                _calc_stripe_info(ios->layout, offset, &si);
 
                 if (length < si.group_length)
                         si.group_length = length;
@@ -485,57 +472,59 @@ out:
         return ret;
 }
 
-int exofs_sbi_create(struct exofs_io_state *ios)
+int ore_create(struct ore_io_state *ios)
 {
         int i, ret;
 
-        for (i = 0; i < ios->layout->s_numdevs; i++) {
+        for (i = 0; i < ios->comps->numdevs; i++) {
                 struct osd_request *or;
 
-                or = osd_start_request(exofs_ios_od(ios, i), GFP_KERNEL);
+                or = osd_start_request(_ios_od(ios, i), GFP_KERNEL);
                 if (unlikely(!or)) {
-                        EXOFS_ERR("%s: osd_start_request failed\n", __func__);
+                        ORE_ERR("%s: osd_start_request failed\n", __func__);
                         ret = -ENOMEM;
                         goto out;
                 }
                 ios->per_dev[i].or = or;
                 ios->numdevs++;
 
-                osd_req_create_object(or, &ios->obj);
+                osd_req_create_object(or, _ios_obj(ios, i));
         }
-        ret = exofs_io_execute(ios);
+        ret = ore_io_execute(ios);
 
 out:
         return ret;
 }
+EXPORT_SYMBOL(ore_create);
 
-int exofs_sbi_remove(struct exofs_io_state *ios)
+int ore_remove(struct ore_io_state *ios)
 {
         int i, ret;
 
-        for (i = 0; i < ios->layout->s_numdevs; i++) {
+        for (i = 0; i < ios->comps->numdevs; i++) {
                 struct osd_request *or;
 
-                or = osd_start_request(exofs_ios_od(ios, i), GFP_KERNEL);
+                or = osd_start_request(_ios_od(ios, i), GFP_KERNEL);
                 if (unlikely(!or)) {
-                        EXOFS_ERR("%s: osd_start_request failed\n", __func__);
+                        ORE_ERR("%s: osd_start_request failed\n", __func__);
                         ret = -ENOMEM;
                         goto out;
                 }
                 ios->per_dev[i].or = or;
                 ios->numdevs++;
 
-                osd_req_remove_object(or, &ios->obj);
+                osd_req_remove_object(or, _ios_obj(ios, i));
         }
-        ret = exofs_io_execute(ios);
+        ret = ore_io_execute(ios);
 
 out:
         return ret;
 }
+EXPORT_SYMBOL(ore_remove);
 
-static int _sbi_write_mirror(struct exofs_io_state *ios, int cur_comp)
+static int _write_mirror(struct ore_io_state *ios, int cur_comp)
 {
-        struct exofs_per_dev_state *master_dev = &ios->per_dev[cur_comp];
+        struct ore_per_dev_state *master_dev = &ios->per_dev[cur_comp];
         unsigned dev = ios->per_dev[cur_comp].dev;
         unsigned last_comp = cur_comp + ios->layout->mirrors_p1;
         int ret = 0;
@@ -544,12 +533,12 @@ static int _sbi_write_mirror(struct exofs_io_state *ios, int cur_comp)
                 return 0; /* Just an empty slot */
 
         for (; cur_comp < last_comp; ++cur_comp, ++dev) {
-                struct exofs_per_dev_state *per_dev = &ios->per_dev[cur_comp];
+                struct ore_per_dev_state *per_dev = &ios->per_dev[cur_comp];
                 struct osd_request *or;
 
-                or = osd_start_request(exofs_ios_od(ios, dev), GFP_KERNEL);
+                or = osd_start_request(_ios_od(ios, dev), GFP_KERNEL);
                 if (unlikely(!or)) {
-                        EXOFS_ERR("%s: osd_start_request failed\n", __func__);
+                        ORE_ERR("%s: osd_start_request failed\n", __func__);
                         ret = -ENOMEM;
                         goto out;
                 }
@@ -563,7 +552,7 @@ static int _sbi_write_mirror(struct exofs_io_state *ios, int cur_comp)
                                 bio = bio_kmalloc(GFP_KERNEL,
                                                   master_dev->bio->bi_max_vecs);
                                 if (unlikely(!bio)) {
-                                        EXOFS_DBGMSG(
+                                        ORE_DBGMSG(
                                               "Failed to allocate BIO size=%u\n",
                                               master_dev->bio->bi_max_vecs);
                                         ret = -ENOMEM;
@@ -582,25 +571,29 @@ static int _sbi_write_mirror(struct exofs_io_state *ios, int cur_comp)
                                 bio->bi_rw |= REQ_WRITE;
                         }
 
-                        osd_req_write(or, &ios->obj, per_dev->offset, bio,
-                                      per_dev->length);
-                        EXOFS_DBGMSG("write(0x%llx) offset=0x%llx "
+                        osd_req_write(or, _ios_obj(ios, dev), per_dev->offset,
+                                      bio, per_dev->length);
+                        ORE_DBGMSG("write(0x%llx) offset=0x%llx "
                                       "length=0x%llx dev=%d\n",
-                                     _LLU(ios->obj.id), _LLU(per_dev->offset),
+                                     _LLU(_ios_obj(ios, dev)->id),
+                                     _LLU(per_dev->offset),
                                      _LLU(per_dev->length), dev);
                 } else if (ios->kern_buff) {
-                        ret = osd_req_write_kern(or, &ios->obj, per_dev->offset,
-                                           ios->kern_buff, ios->length);
+                        ret = osd_req_write_kern(or, _ios_obj(ios, dev),
+                                                 per_dev->offset,
+                                                 ios->kern_buff, ios->length);
                         if (unlikely(ret))
                                 goto out;
-                        EXOFS_DBGMSG2("write_kern(0x%llx) offset=0x%llx "
+                        ORE_DBGMSG2("write_kern(0x%llx) offset=0x%llx "
                                       "length=0x%llx dev=%d\n",
-                                     _LLU(ios->obj.id), _LLU(per_dev->offset),
+                                     _LLU(_ios_obj(ios, dev)->id),
+                                     _LLU(per_dev->offset),
                                      _LLU(ios->length), dev);
                 } else {
-                        osd_req_set_attributes(or, &ios->obj);
-                        EXOFS_DBGMSG2("obj(0x%llx) set_attributes=%d dev=%d\n",
-                                     _LLU(ios->obj.id), ios->out_attr_len, dev);
+                        osd_req_set_attributes(or, _ios_obj(ios, dev));
+                        ORE_DBGMSG2("obj(0x%llx) set_attributes=%d dev=%d\n",
+                                     _LLU(_ios_obj(ios, dev)->id),
+                                     ios->out_attr_len, dev);
                 }
 
                 if (ios->out_attr)
@@ -616,7 +609,7 @@ out:
         return ret;
 }
 
-int exofs_sbi_write(struct exofs_io_state *ios)
+int ore_write(struct ore_io_state *ios)
 {
         int i;
         int ret;
@@ -626,52 +619,55 @@ int exofs_sbi_write(struct exofs_io_state *ios)
                 return ret;
 
         for (i = 0; i < ios->numdevs; i += ios->layout->mirrors_p1) {
-                ret = _sbi_write_mirror(ios, i);
+                ret = _write_mirror(ios, i);
                 if (unlikely(ret))
                         return ret;
         }
 
-        ret = exofs_io_execute(ios);
+        ret = ore_io_execute(ios);
         return ret;
 }
+EXPORT_SYMBOL(ore_write);
 
-static int _sbi_read_mirror(struct exofs_io_state *ios, unsigned cur_comp)
+static int _read_mirror(struct ore_io_state *ios, unsigned cur_comp)
 {
         struct osd_request *or;
-        struct exofs_per_dev_state *per_dev = &ios->per_dev[cur_comp];
-        unsigned first_dev = (unsigned)ios->obj.id;
+        struct ore_per_dev_state *per_dev = &ios->per_dev[cur_comp];
+        struct osd_obj_id *obj = _ios_obj(ios, cur_comp);
+        unsigned first_dev = (unsigned)obj->id;
 
         if (ios->pages && !per_dev->length)
                 return 0; /* Just an empty slot */
 
         first_dev = per_dev->dev + first_dev % ios->layout->mirrors_p1;
-        or = osd_start_request(exofs_ios_od(ios, first_dev), GFP_KERNEL);
+        or = osd_start_request(_ios_od(ios, first_dev), GFP_KERNEL);
         if (unlikely(!or)) {
-                EXOFS_ERR("%s: osd_start_request failed\n", __func__);
+                ORE_ERR("%s: osd_start_request failed\n", __func__);
                 return -ENOMEM;
         }
         per_dev->or = or;
 
         if (ios->pages) {
-                osd_req_read(or, &ios->obj, per_dev->offset,
+                osd_req_read(or, obj, per_dev->offset,
                                 per_dev->bio, per_dev->length);
-                EXOFS_DBGMSG("read(0x%llx) offset=0x%llx length=0x%llx"
-                             " dev=%d\n", _LLU(ios->obj.id),
+                ORE_DBGMSG("read(0x%llx) offset=0x%llx length=0x%llx"
+                             " dev=%d\n", _LLU(obj->id),
                              _LLU(per_dev->offset), _LLU(per_dev->length),
                              first_dev);
         } else if (ios->kern_buff) {
-                int ret = osd_req_read_kern(or, &ios->obj, per_dev->offset,
+                int ret = osd_req_read_kern(or, obj, per_dev->offset,
                                             ios->kern_buff, ios->length);
-                EXOFS_DBGMSG2("read_kern(0x%llx) offset=0x%llx "
+                ORE_DBGMSG2("read_kern(0x%llx) offset=0x%llx "
                               "length=0x%llx dev=%d ret=>%d\n",
-                              _LLU(ios->obj.id), _LLU(per_dev->offset),
+                              _LLU(obj->id), _LLU(per_dev->offset),
                               _LLU(ios->length), first_dev, ret);
                 if (unlikely(ret))
                         return ret;
         } else {
-                osd_req_get_attributes(or, &ios->obj);
-                EXOFS_DBGMSG2("obj(0x%llx) get_attributes=%d dev=%d\n",
-                              _LLU(ios->obj.id), ios->in_attr_len, first_dev);
+                osd_req_get_attributes(or, obj);
+                ORE_DBGMSG2("obj(0x%llx) get_attributes=%d dev=%d\n",
+                              _LLU(obj->id),
+                              ios->in_attr_len, first_dev);
         }
         if (ios->out_attr)
                 osd_req_add_set_attr_list(or, ios->out_attr, ios->out_attr_len);
@@ -682,7 +678,7 @@ static int _sbi_read_mirror(struct exofs_io_state *ios, unsigned cur_comp)
         return 0;
 }
 
-int exofs_sbi_read(struct exofs_io_state *ios)
+int ore_read(struct ore_io_state *ios)
 {
         int i;
         int ret;
@@ -692,16 +688,17 @@ int exofs_sbi_read(struct exofs_io_state *ios)
                 return ret;
 
         for (i = 0; i < ios->numdevs; i += ios->layout->mirrors_p1) {
-                ret = _sbi_read_mirror(ios, i);
+                ret = _read_mirror(ios, i);
                 if (unlikely(ret))
                         return ret;
         }
 
-        ret = exofs_io_execute(ios);
+        ret = ore_io_execute(ios);
         return ret;
 }
+EXPORT_SYMBOL(ore_read);
 
-int extract_attr_from_ios(struct exofs_io_state *ios, struct osd_attr *attr)
+int extract_attr_from_ios(struct ore_io_state *ios, struct osd_attr *attr)
 {
         struct osd_attr cur_attr = {.attr_page = 0}; /* start with zeros */
         void *iter = NULL;
@@ -721,83 +718,118 @@ int extract_attr_from_ios(struct exofs_io_state *ios, struct osd_attr *attr)
 
         return -EIO;
 }
+EXPORT_SYMBOL(extract_attr_from_ios);
 
-static int _truncate_mirrors(struct exofs_io_state *ios, unsigned cur_comp,
+static int _truncate_mirrors(struct ore_io_state *ios, unsigned cur_comp,
                              struct osd_attr *attr)
 {
         int last_comp = cur_comp + ios->layout->mirrors_p1;
 
         for (; cur_comp < last_comp; ++cur_comp) {
-                struct exofs_per_dev_state *per_dev = &ios->per_dev[cur_comp];
+                struct ore_per_dev_state *per_dev = &ios->per_dev[cur_comp];
                 struct osd_request *or;
 
-                or = osd_start_request(exofs_ios_od(ios, cur_comp), GFP_KERNEL);
+                or = osd_start_request(_ios_od(ios, cur_comp), GFP_KERNEL);
                 if (unlikely(!or)) {
-                        EXOFS_ERR("%s: osd_start_request failed\n", __func__);
+                        ORE_ERR("%s: osd_start_request failed\n", __func__);
                         return -ENOMEM;
                 }
                 per_dev->or = or;
 
-                osd_req_set_attributes(or, &ios->obj);
+                osd_req_set_attributes(or, _ios_obj(ios, cur_comp));
                 osd_req_add_set_attr_list(or, attr, 1);
         }
 
         return 0;
 }
 
-int exofs_oi_truncate(struct exofs_i_info *oi, u64 size)
+struct _trunc_info {
+        struct _striping_info si;
+        u64 prev_group_obj_off;
+        u64 next_group_obj_off;
+
+        unsigned first_group_dev;
+        unsigned nex_group_dev;
+        unsigned max_devs;
+};
+
+void _calc_trunk_info(struct ore_layout *layout, u64 file_offset,
+                       struct _trunc_info *ti)
+{
+        unsigned stripe_unit = layout->stripe_unit;
+
+        _calc_stripe_info(layout, file_offset, &ti->si);
+
+        ti->prev_group_obj_off = ti->si.M * stripe_unit;
+        ti->next_group_obj_off = ti->si.M ? (ti->si.M - 1) * stripe_unit : 0;
+
+        ti->first_group_dev = ti->si.dev - (ti->si.dev % layout->group_width);
+        ti->nex_group_dev = ti->first_group_dev + layout->group_width;
+        ti->max_devs = layout->group_width * layout->group_count;
+}
+
+int ore_truncate(struct ore_layout *layout, struct ore_components *comps,
+                   u64 size)
 {
-        struct exofs_sb_info *sbi = oi->vfs_inode.i_sb->s_fs_info;
-        struct exofs_io_state *ios;
+        struct ore_io_state *ios;
         struct exofs_trunc_attr {
                 struct osd_attr attr;
                 __be64 newsize;
         } *size_attrs;
-        struct _striping_info si;
+        struct _trunc_info ti;
         int i, ret;
 
-        ret = exofs_get_io_state(&sbi->layout, &ios);
+        ret = ore_get_io_state(layout, comps, &ios);
         if (unlikely(ret))
                 return ret;
 
-        size_attrs = kcalloc(ios->layout->group_width, sizeof(*size_attrs),
+        _calc_trunk_info(ios->layout, size, &ti);
+
+        size_attrs = kcalloc(ti.max_devs, sizeof(*size_attrs),
                              GFP_KERNEL);
         if (unlikely(!size_attrs)) {
                 ret = -ENOMEM;
                 goto out;
         }
 
-        ios->obj.id = exofs_oi_objno(oi);
-        ios->cred = oi->i_cred;
+        ios->numdevs = ios->comps->numdevs;
 
-        ios->numdevs = ios->layout->s_numdevs;
-        _calc_stripe_info(ios, size, &si);
-
-        for (i = 0; i < ios->layout->group_width; ++i) {
+        for (i = 0; i < ti.max_devs; ++i) {
                 struct exofs_trunc_attr *size_attr = &size_attrs[i];
                 u64 obj_size;
 
-                if (i < si.dev)
-                        obj_size = si.obj_offset +
-                                        ios->layout->stripe_unit - si.unit_off;
-                else if (i == si.dev)
-                        obj_size = si.obj_offset;
-                else /* i > si.dev */
-                        obj_size = si.obj_offset - si.unit_off;
+                if (i < ti.first_group_dev)
+                        obj_size = ti.prev_group_obj_off;
+                else if (i >= ti.nex_group_dev)
+                        obj_size = ti.next_group_obj_off;
+                else if (i < ti.si.dev) /* dev within this group */
+                        obj_size = ti.si.obj_offset +
+                                      ios->layout->stripe_unit - ti.si.unit_off;
+                else if (i == ti.si.dev)
+                        obj_size = ti.si.obj_offset;
+                else /* i > ti.dev */
+                        obj_size = ti.si.obj_offset - ti.si.unit_off;
 
                 size_attr->newsize = cpu_to_be64(obj_size);
                 size_attr->attr = g_attr_logical_length;
                 size_attr->attr.val_ptr = &size_attr->newsize;
 
+                ORE_DBGMSG("trunc(0x%llx) obj_offset=0x%llx dev=%d\n",
+                             _LLU(comps->comps->obj.id), _LLU(obj_size), i);
                 ret = _truncate_mirrors(ios, i * ios->layout->mirrors_p1,
                                         &size_attr->attr);
                 if (unlikely(ret))
                         goto out;
         }
-        ret = exofs_io_execute(ios);
+        ret = ore_io_execute(ios);
 
 out:
         kfree(size_attrs);
-        exofs_put_io_state(ios);
+        ore_put_io_state(ios);
         return ret;
 }
+EXPORT_SYMBOL(ore_truncate);
+
+const struct osd_attr g_attr_logical_length = ATTR_DEF(
+        OSD_APAGE_OBJECT_INFORMATION, OSD_ATTR_OI_LOGICAL_LENGTH, 8);
+EXPORT_SYMBOL(g_attr_logical_length);
diff --git a/fs/exofs/pnfs.h b/fs/exofs/pnfs.h
deleted file mode 100644
index c52e9888b8ab..000000000000
--- a/fs/exofs/pnfs.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2008, 2009
- * Boaz Harrosh <bharrosh@panasas.com>
- *
- * This file is part of exofs.
- *
- * exofs is free software; you can redistribute it and/or modify it under the
- * terms of the GNU General Public License  version 2 as published by the Free
- * Software Foundation.
- *
- */
-
-/* FIXME: Remove this file once pnfs hits mainline */
-
-#ifndef __EXOFS_PNFS_H__
-#define __EXOFS_PNFS_H__
-
-#if ! defined(__PNFS_OSD_XDR_H__)
-
-enum pnfs_iomode {
-        IOMODE_READ = 1,
-        IOMODE_RW = 2,
-        IOMODE_ANY = 3,
-};
-
-/* Layout Structure */
-enum pnfs_osd_raid_algorithm4 {
-        PNFS_OSD_RAID_0         = 1,
-        PNFS_OSD_RAID_4         = 2,
-        PNFS_OSD_RAID_5         = 3,
-        PNFS_OSD_RAID_PQ        = 4     /* Reed-Solomon P+Q */
-};
-
-struct pnfs_osd_data_map {
-        u32     odm_num_comps;
-        u64     odm_stripe_unit;
-        u32     odm_group_width;
-        u32     odm_group_depth;
-        u32     odm_mirror_cnt;
-        u32     odm_raid_algorithm;
-};
-
-#endif /* ! defined(__PNFS_OSD_XDR_H__) */
-
-#endif /* __EXOFS_PNFS_H__ */
diff --git a/fs/exofs/super.c b/fs/exofs/super.c
index c57beddcc217..274894053b02 100644
--- a/fs/exofs/super.c
+++ b/fs/exofs/super.c
@@ -40,6 +40,8 @@
 
 #include "exofs.h"
 
+#define EXOFS_DBGMSG2(M...) do {} while (0)
+
 /******************************************************************************
  * MOUNT OPTIONS
  *****************************************************************************/
@@ -208,10 +210,48 @@ static void destroy_inodecache(void)
 }
 
 /******************************************************************************
- * SUPERBLOCK FUNCTIONS
+ * Some osd helpers
  *****************************************************************************/
-static const struct super_operations exofs_sops;
-static const struct export_operations exofs_export_ops;
+void exofs_make_credential(u8 cred_a[OSD_CAP_LEN], const struct osd_obj_id *obj)
+{
+        osd_sec_init_nosec_doall_caps(cred_a, obj, false, true);
+}
+
+static int exofs_read_kern(struct osd_dev *od, u8 *cred, struct osd_obj_id *obj,
+                    u64 offset, void *p, unsigned length)
+{
+        struct osd_request *or = osd_start_request(od, GFP_KERNEL);
+/*      struct osd_sense_info osi = {.key = 0};*/
+        int ret;
+
+        if (unlikely(!or)) {
+                EXOFS_DBGMSG("%s: osd_start_request failed.\n", __func__);
+                return -ENOMEM;
+        }
+        ret = osd_req_read_kern(or, obj, offset, p, length);
+        if (unlikely(ret)) {
+                EXOFS_DBGMSG("%s: osd_req_read_kern failed.\n", __func__);
+                goto out;
+        }
+
+        ret = osd_finalize_request(or, 0, cred, NULL);
+        if (unlikely(ret)) {
+                EXOFS_DBGMSG("Failed to osd_finalize_request() => %d\n", ret);
+                goto out;
+        }
+
+        ret = osd_execute_request(or);
+        if (unlikely(ret))
+                EXOFS_DBGMSG("osd_execute_request() => %d\n", ret);
+        /* osd_req_decode_sense(or, ret); */
+
+out:
+        osd_end_request(or);
+        EXOFS_DBGMSG2("read_kern(0x%llx) offset=0x%llx "
+                      "length=0x%llx dev=%p ret=>%d\n",
+                      _LLU(obj->id), _LLU(offset), _LLU(length), od, ret);
+        return ret;
+}
 
 static const struct osd_attr g_attr_sb_stats = ATTR_DEF(
         EXOFS_APAGE_SB_DATA,
@@ -223,21 +263,19 @@ static int __sbi_read_stats(struct exofs_sb_info *sbi)
         struct osd_attr attrs[] = {
                 [0] = g_attr_sb_stats,
         };
-        struct exofs_io_state *ios;
+        struct ore_io_state *ios;
         int ret;
 
-        ret = exofs_get_io_state(&sbi->layout, &ios);
+        ret = ore_get_io_state(&sbi->layout, &sbi->comps, &ios);
         if (unlikely(ret)) {
-                EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__);
+                EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__);
                 return ret;
         }
 
-        ios->cred = sbi->s_cred;
-
         ios->in_attr = attrs;
         ios->in_attr_len = ARRAY_SIZE(attrs);
 
-        ret = exofs_sbi_read(ios);
+        ret = ore_read(ios);
         if (unlikely(ret)) {
                 EXOFS_ERR("Error reading super_block stats => %d\n", ret);
                 goto out;
@@ -264,13 +302,13 @@ static int __sbi_read_stats(struct exofs_sb_info *sbi)
         }
 
 out:
-        exofs_put_io_state(ios);
+        ore_put_io_state(ios);
         return ret;
 }
 
-static void stats_done(struct exofs_io_state *ios, void *p)
+static void stats_done(struct ore_io_state *ios, void *p)
 {
-        exofs_put_io_state(ios);
+        ore_put_io_state(ios);
         /* Good thanks nothing to do anymore */
 }
 
@@ -280,12 +318,12 @@ int exofs_sbi_write_stats(struct exofs_sb_info *sbi)
         struct osd_attr attrs[] = {
                 [0] = g_attr_sb_stats,
         };
-        struct exofs_io_state *ios;
+        struct ore_io_state *ios;
         int ret;
 
-        ret = exofs_get_io_state(&sbi->layout, &ios);
+        ret = ore_get_io_state(&sbi->layout, &sbi->comps, &ios);
         if (unlikely(ret)) {
-                EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__);
+                EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__);
                 return ret;
         }
 
@@ -293,21 +331,27 @@ int exofs_sbi_write_stats(struct exofs_sb_info *sbi)
         sbi->s_ess.s_numfiles = cpu_to_le64(sbi->s_numfiles);
         attrs[0].val_ptr = &sbi->s_ess;
 
-        ios->cred = sbi->s_cred;
+
         ios->done = stats_done;
         ios->private = sbi;
         ios->out_attr = attrs;
         ios->out_attr_len = ARRAY_SIZE(attrs);
 
-        ret = exofs_sbi_write(ios);
+        ret = ore_write(ios);
         if (unlikely(ret)) {
-                EXOFS_ERR("%s: exofs_sbi_write failed.\n", __func__);
-                exofs_put_io_state(ios);
+                EXOFS_ERR("%s: ore_write failed.\n", __func__);
+                ore_put_io_state(ios);
         }
 
         return ret;
 }
 
+/******************************************************************************
+ * SUPERBLOCK FUNCTIONS
+ *****************************************************************************/
+static const struct super_operations exofs_sops;
+static const struct export_operations exofs_export_ops;
+
 /*
  * Write the superblock to the OSD
  */
@@ -315,7 +359,9 @@ int exofs_sync_fs(struct super_block *sb, int wait)
 {
         struct exofs_sb_info *sbi;
         struct exofs_fscb *fscb;
-        struct exofs_io_state *ios;
+        struct ore_comp one_comp;
+        struct ore_components comps;
+        struct ore_io_state *ios;
         int ret = -ENOMEM;
 
         fscb = kmalloc(sizeof(*fscb), GFP_KERNEL);
@@ -331,7 +377,10 @@ int exofs_sync_fs(struct super_block *sb, int wait)
          * version). Otherwise the exofs_fscb is read-only from mkfs time. All
          * the writeable info is set in exofs_sbi_write_stats() above.
          */
-        ret = exofs_get_io_state(&sbi->layout, &ios);
+
+        exofs_init_comps(&comps, &one_comp, sbi, EXOFS_SUPER_ID);
+
+        ret = ore_get_io_state(&sbi->layout, &comps, &ios);
         if (unlikely(ret))
                 goto out;
 
@@ -345,14 +394,12 @@ int exofs_sync_fs(struct super_block *sb, int wait)
         fscb->s_newfs = 0;
         fscb->s_version = EXOFS_FSCB_VER;
 
-        ios->obj.id = EXOFS_SUPER_ID;
         ios->offset = 0;
         ios->kern_buff = fscb;
-        ios->cred = sbi->s_cred;
 
-        ret = exofs_sbi_write(ios);
+        ret = ore_write(ios);
         if (unlikely(ret))
-                EXOFS_ERR("%s: exofs_sbi_write failed.\n", __func__);
+                EXOFS_ERR("%s: ore_write failed.\n", __func__);
         else
                 sb->s_dirt = 0;
 
@@ -360,7 +407,7 @@ int exofs_sync_fs(struct super_block *sb, int wait)
         unlock_super(sb);
 out:
         EXOFS_DBGMSG("s_nextid=0x%llx ret=%d\n", _LLU(sbi->s_nextid), ret);
-        exofs_put_io_state(ios);
+        ore_put_io_state(ios);
         kfree(fscb);
         return ret;
 }
@@ -384,15 +431,17 @@ static void _exofs_print_device(const char *msg, const char *dev_path,
 
 void exofs_free_sbi(struct exofs_sb_info *sbi)
 {
-        while (sbi->layout.s_numdevs) {
-                int i = --sbi->layout.s_numdevs;
-                struct osd_dev *od = sbi->layout.s_ods[i];
+        while (sbi->comps.numdevs) {
+                int i = --sbi->comps.numdevs;
+                struct osd_dev *od = sbi->comps.ods[i];
 
                 if (od) {
-                        sbi->layout.s_ods[i] = NULL;
+                        sbi->comps.ods[i] = NULL;
                         osduld_put_device(od);
                 }
         }
+        if (sbi->comps.ods != sbi->_min_one_dev)
+                kfree(sbi->comps.ods);
         kfree(sbi);
 }
 
@@ -419,8 +468,8 @@ static void exofs_put_super(struct super_block *sb)
                                   msecs_to_jiffies(100));
         }
 
-        _exofs_print_device("Unmounting", NULL, sbi->layout.s_ods[0],
-                            sbi->layout.s_pid);
+        _exofs_print_device("Unmounting", NULL, sbi->comps.ods[0],
+                            sbi->one_comp.obj.partition);
 
         bdi_destroy(&sbi->bdi);
         exofs_free_sbi(sbi);
@@ -501,10 +550,19 @@ static int _read_and_match_data_map(struct exofs_sb_info *sbi, unsigned numdevs,
                 return -EINVAL;
         }
 
+        EXOFS_DBGMSG("exofs: layout: "
+                "num_comps=%u stripe_unit=0x%x group_width=%u "
+                "group_depth=0x%llx mirrors_p1=%u raid_algorithm=%u\n",
+                numdevs,
+                sbi->layout.stripe_unit,
+                sbi->layout.group_width,
+                _LLU(sbi->layout.group_depth),
+                sbi->layout.mirrors_p1,
+                sbi->data_map.odm_raid_algorithm);
         return 0;
 }
 
-static unsigned __ra_pages(struct exofs_layout *layout)
+static unsigned __ra_pages(struct ore_layout *layout)
 {
         const unsigned _MIN_RA = 32; /* min 128K read-ahead */
         unsigned ra_pages = layout->group_width * layout->stripe_unit /
@@ -547,13 +605,11 @@ static int exofs_devs_2_odi(struct exofs_dt_device_info *dt_dev,
         return !(odi->systemid_len || odi->osdname_len);
 }
 
-static int exofs_read_lookup_dev_table(struct exofs_sb_info **psbi,
+static int exofs_read_lookup_dev_table(struct exofs_sb_info *sbi,
+                                       struct osd_dev *fscb_od,
                                        unsigned table_count)
 {
-        struct exofs_sb_info *sbi = *psbi;
-        struct osd_dev *fscb_od;
-        struct osd_obj_id obj = {.partition = sbi->layout.s_pid,
-                                 .id = EXOFS_DEVTABLE_ID};
+        struct ore_comp comp;
         struct exofs_device_table *dt;
         unsigned table_bytes = table_count * sizeof(dt->dt_dev_table[0]) +
                                              sizeof(*dt);
@@ -567,10 +623,14 @@ static int exofs_read_lookup_dev_table(struct exofs_sb_info **psbi,
                 return -ENOMEM;
         }
 
-        fscb_od = sbi->layout.s_ods[0];
-        sbi->layout.s_ods[0] = NULL;
-        sbi->layout.s_numdevs = 0;
-        ret = exofs_read_kern(fscb_od, sbi->s_cred, &obj, 0, dt, table_bytes);
+        sbi->comps.numdevs = 0;
+
+        comp.obj.partition = sbi->one_comp.obj.partition;
+        comp.obj.id = EXOFS_DEVTABLE_ID;
+        exofs_make_credential(comp.cred, &comp.obj);
+
+        ret = exofs_read_kern(fscb_od, comp.cred, &comp.obj, 0, dt,
+                              table_bytes);
         if (unlikely(ret)) {
                 EXOFS_ERR("ERROR: reading device table\n");
                 goto out;
@@ -588,16 +648,18 @@ static int exofs_read_lookup_dev_table(struct exofs_sb_info **psbi,
                 goto out;
 
         if (likely(numdevs > 1)) {
-                unsigned size = numdevs * sizeof(sbi->layout.s_ods[0]);
+                unsigned size = numdevs * sizeof(sbi->comps.ods[0]);
 
-                sbi = krealloc(sbi, sizeof(*sbi) + size, GFP_KERNEL);
-                if (unlikely(!sbi)) {
+                /* Twice bigger table: See exofs_init_comps() and below
+                 * comment
+                 */
+                sbi->comps.ods = kzalloc(size + size - 1, GFP_KERNEL);
+                if (unlikely(!sbi->comps.ods)) {
+                        EXOFS_ERR("ERROR: faild allocating Device array[%d]\n",
+                                  numdevs);
                         ret = -ENOMEM;
                         goto out;
                 }
-                memset(&sbi->layout.s_ods[1], 0,
-                       size - sizeof(sbi->layout.s_ods[0]));
-                *psbi = sbi;
         }
 
         for (i = 0; i < numdevs; i++) {
@@ -619,8 +681,8 @@ static int exofs_read_lookup_dev_table(struct exofs_sb_info **psbi,
                  * line. We always keep them in device-table order.
                  */
                 if (fscb_od && osduld_device_same(fscb_od, &odi)) {
-                        sbi->layout.s_ods[i] = fscb_od;
-                        ++sbi->layout.s_numdevs;
+                        sbi->comps.ods[i] = fscb_od;
+                        ++sbi->comps.numdevs;
                         fscb_od = NULL;
                         continue;
                 }
@@ -633,13 +695,13 @@ static int exofs_read_lookup_dev_table(struct exofs_sb_info **psbi,
                         goto out;
                 }
 
-                sbi->layout.s_ods[i] = od;
-                ++sbi->layout.s_numdevs;
+                sbi->comps.ods[i] = od;
+                ++sbi->comps.numdevs;
 
                 /* Read the fscb of the other devices to make sure the FS
                  * partition is there.
                  */
-                ret = exofs_read_kern(od, sbi->s_cred, &obj, 0, &fscb,
+                ret = exofs_read_kern(od, comp.cred, &comp.obj, 0, &fscb,
                                       sizeof(fscb));
                 if (unlikely(ret)) {
                         EXOFS_ERR("ERROR: Malformed participating device "
@@ -656,13 +718,22 @@ static int exofs_read_lookup_dev_table(struct exofs_sb_info **psbi,
 
 out:
         kfree(dt);
-        if (unlikely(!ret && fscb_od)) {
-                EXOFS_ERR(
-                      "ERROR: Bad device-table container device not present\n");
-                osduld_put_device(fscb_od);
-                ret = -EINVAL;
-        }
+        if (likely(!ret)) {
+                unsigned numdevs = sbi->comps.numdevs;
 
+                if (unlikely(fscb_od)) {
+                        EXOFS_ERR("ERROR: Bad device-table container device not present\n");
+                        osduld_put_device(fscb_od);
+                        return -EINVAL;
+                }
+                /* exofs round-robins the device table view according to inode
+                 * number. We hold a: twice bigger table hence inodes can point
+                 * to any device and have a sequential view of the table
+                 * starting at this device. See exofs_init_comps()
+                 */
+                for (i = 0; i < numdevs - 1; ++i)
+                        sbi->comps.ods[i + numdevs] = sbi->comps.ods[i];
+        }
         return ret;
 }
 
@@ -676,7 +747,7 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent)
         struct exofs_sb_info *sbi;      /*extended info                  */
         struct osd_dev *od;             /* Master device                 */
         struct exofs_fscb fscb;         /*on-disk superblock info        */
-        struct osd_obj_id obj;
+        struct ore_comp comp;
         unsigned table_count;
         int ret;
 
@@ -684,10 +755,6 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent)
         if (!sbi)
                 return -ENOMEM;
 
-        ret = bdi_setup_and_register(&sbi->bdi, "exofs", BDI_CAP_MAP_COPY);
-        if (ret)
-                goto free_bdi;
-
         /* use mount options to fill superblock */
         if (opts->is_osdname) {
                 struct osd_dev_info odi = {.systemid_len = 0};
@@ -695,6 +762,8 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent)
                 odi.osdname_len = strlen(opts->dev_name);
                 odi.osdname = (u8 *)opts->dev_name;
                 od = osduld_info_lookup(&odi);
+                kfree(opts->dev_name);
+                opts->dev_name = NULL;
         } else {
                 od = osduld_path_lookup(opts->dev_name);
         }
@@ -709,11 +778,16 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent)
         sbi->layout.group_width = 1;
         sbi->layout.group_depth = -1;
         sbi->layout.group_count = 1;
-        sbi->layout.s_ods[0] = od;
-        sbi->layout.s_numdevs = 1;
-        sbi->layout.s_pid = opts->pid;
         sbi->s_timeout = opts->timeout;
 
+        sbi->one_comp.obj.partition = opts->pid;
+        sbi->one_comp.obj.id = 0;
+        exofs_make_credential(sbi->one_comp.cred, &sbi->one_comp.obj);
+        sbi->comps.numdevs = 1;
+        sbi->comps.single_comp = EC_SINGLE_COMP;
+        sbi->comps.comps = &sbi->one_comp;
+        sbi->comps.ods = sbi->_min_one_dev;
+
         /* fill in some other data by hand */
         memset(sb->s_id, 0, sizeof(sb->s_id));
         strcpy(sb->s_id, "exofs");
@@ -724,11 +798,11 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent)
         sb->s_bdev = NULL;
         sb->s_dev = 0;
 
-        obj.partition = sbi->layout.s_pid;
-        obj.id = EXOFS_SUPER_ID;
-        exofs_make_credential(sbi->s_cred, &obj);
+        comp.obj.partition = sbi->one_comp.obj.partition;
+        comp.obj.id = EXOFS_SUPER_ID;
+        exofs_make_credential(comp.cred, &comp.obj);
 
-        ret = exofs_read_kern(od, sbi->s_cred, &obj, 0, &fscb, sizeof(fscb));
+        ret = exofs_read_kern(od, comp.cred, &comp.obj, 0, &fscb, sizeof(fscb));
         if (unlikely(ret))
                 goto free_sbi;
 
@@ -757,9 +831,11 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent)
 
         table_count = le64_to_cpu(fscb.s_dev_table_count);
         if (table_count) {
-                ret = exofs_read_lookup_dev_table(&sbi, table_count);
+                ret = exofs_read_lookup_dev_table(sbi, od, table_count);
                 if (unlikely(ret))
                         goto free_sbi;
+        } else {
+                sbi->comps.ods[0] = od;
         }
 
         __sbi_read_stats(sbi);
@@ -793,20 +869,20 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent)
                 goto free_sbi;
         }
 
-        _exofs_print_device("Mounting", opts->dev_name, sbi->layout.s_ods[0],
-                            sbi->layout.s_pid);
-        if (opts->is_osdname)
-                kfree(opts->dev_name);
+        ret = bdi_setup_and_register(&sbi->bdi, "exofs", BDI_CAP_MAP_COPY);
+        if (ret) {
+                EXOFS_DBGMSG("Failed to bdi_setup_and_register\n");
+                goto free_sbi;
+        }
+
+        _exofs_print_device("Mounting", opts->dev_name, sbi->comps.ods[0],
+                            sbi->one_comp.obj.partition);
         return 0;
 
 free_sbi:
-        bdi_destroy(&sbi->bdi);
-free_bdi:
         EXOFS_ERR("Unable to mount exofs on %s pid=0x%llx err=%d\n",
-                  opts->dev_name, sbi->layout.s_pid, ret);
+                  opts->dev_name, sbi->one_comp.obj.partition, ret);
         exofs_free_sbi(sbi);
-        if (opts->is_osdname)
-                kfree(opts->dev_name);
         return ret;
 }
 
@@ -837,7 +913,7 @@ static int exofs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
         struct super_block *sb = dentry->d_sb;
         struct exofs_sb_info *sbi = sb->s_fs_info;
-        struct exofs_io_state *ios;
+        struct ore_io_state *ios;
         struct osd_attr attrs[] = {
                 ATTR_DEF(OSD_APAGE_PARTITION_QUOTAS,
                         OSD_ATTR_PQ_CAPACITY_QUOTA, sizeof(__be64)),
@@ -846,21 +922,18 @@ static int exofs_statfs(struct dentry *dentry, struct kstatfs *buf)
         };
         uint64_t capacity = ULLONG_MAX;
         uint64_t used = ULLONG_MAX;
-        uint8_t cred_a[OSD_CAP_LEN];
         int ret;
 
-        ret = exofs_get_io_state(&sbi->layout, &ios);
+        ret = ore_get_io_state(&sbi->layout, &sbi->comps, &ios);
         if (ret) {
-                EXOFS_DBGMSG("exofs_get_io_state failed.\n");
+                EXOFS_DBGMSG("ore_get_io_state failed.\n");
                 return ret;
         }
 
-        exofs_make_credential(cred_a, &ios->obj);
-        ios->cred = sbi->s_cred;
         ios->in_attr = attrs;
         ios->in_attr_len = ARRAY_SIZE(attrs);
 
-        ret = exofs_sbi_read(ios);
+        ret = ore_read(ios);
         if (unlikely(ret))
                 goto out;
 
@@ -889,7 +962,7 @@ static int exofs_statfs(struct dentry *dentry, struct kstatfs *buf)
         buf->f_namelen = EXOFS_NAME_LEN;
 
 out:
-        exofs_put_io_state(ios);
+        ore_put_io_state(ios);
         return ret;
 }
 
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index e2d88baf91d3..4687fea0c00f 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -124,7 +124,7 @@ void *ext4_kvzalloc(size_t size, gfp_t flags)
 {
         void *ret;
 
-        ret = kmalloc(size, flags);
+        ret = kzalloc(size, flags);
         if (!ret)
                 ret = __vmalloc(size, flags | __GFP_ZERO, PAGE_KERNEL);
         return ret;
diff --git a/fs/inode.c b/fs/inode.c
index 5aab80dc008c..73920d555c88 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -143,6 +143,7 @@ int inode_init_always(struct super_block *sb, struct inode *inode)
         inode->i_op = &empty_iops;
         inode->i_fop = &empty_fops;
         inode->i_nlink = 1;
+        inode->i_opflags = 0;
         inode->i_uid = 0;
         inode->i_gid = 0;
         atomic_set(&inode->i_writecount, 0);
diff --git a/fs/namei.c b/fs/namei.c
index 445fd5da11fa..2826db35dc25 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -179,19 +179,14 @@ static int check_acl(struct inode *inode, int mask)
 #ifdef CONFIG_FS_POSIX_ACL
         struct posix_acl *acl;
 
-        /*
-         * Under RCU walk, we cannot even do a "get_cached_acl()",
-         * because that involves locking and getting a refcount on
-         * a cached ACL.
-         *
-         * So the only case we handle during RCU walking is the
-         * case of a cached "no ACL at all", which needs no locks
-         * or refcounts.
-         */
         if (mask & MAY_NOT_BLOCK) {
-                if (negative_cached_acl(inode, ACL_TYPE_ACCESS))
+                acl = get_cached_acl_rcu(inode, ACL_TYPE_ACCESS);
+                if (!acl)
                         return -EAGAIN;
-                return -ECHILD;
+                /* no ->get_acl() calls in RCU mode... */
+                if (acl == ACL_NOT_CACHED)
+                        return -ECHILD;
+                return posix_acl_permission(inode, acl, mask & ~MAY_NOT_BLOCK);
         }
 
         acl = get_cached_acl(inode, ACL_TYPE_ACCESS);
@@ -313,6 +308,26 @@ int generic_permission(struct inode *inode, int mask)
         return -EACCES;
 }
 
+/*
+ * We _really_ want to just do "generic_permission()" without
+ * even looking at the inode->i_op values. So we keep a cache
+ * flag in inode->i_opflags, that says "this has not special
+ * permission function, use the fast case".
+ */
+static inline int do_inode_permission(struct inode *inode, int mask)
+{
+        if (unlikely(!(inode->i_opflags & IOP_FASTPERM))) {
+                if (likely(inode->i_op->permission))
+                        return inode->i_op->permission(inode, mask);
+
+                /* This gets set once for the inode lifetime */
+                spin_lock(&inode->i_lock);
+                inode->i_opflags |= IOP_FASTPERM;
+                spin_unlock(&inode->i_lock);
+        }
+        return generic_permission(inode, mask);
+}
+
 /**
  * inode_permission  -  check for access rights to a given inode
  * @inode:      inode to check permission on
@@ -327,7 +342,7 @@ int inode_permission(struct inode *inode, int mask)
 {
         int retval;
 
-        if (mask & MAY_WRITE) {
+        if (unlikely(mask & MAY_WRITE)) {
                 umode_t mode = inode->i_mode;
 
                 /*
@@ -344,11 +359,7 @@ int inode_permission(struct inode *inode, int mask)
                         return -EACCES;
         }
 
-        if (inode->i_op->permission)
-                retval = inode->i_op->permission(inode, mask);
-        else
-                retval = generic_permission(inode, mask);
-
+        retval = do_inode_permission(inode, mask);
         if (retval)
                 return retval;
 
@@ -1250,6 +1261,26 @@ static void terminate_walk(struct nameidata *nd)
         }
 }
 
+/*
+ * Do we need to follow links? We _really_ want to be able
+ * to do this check without having to look at inode->i_op,
+ * so we keep a cache of "no, this doesn't need follow_link"
+ * for the common case.
+ */
+static inline int should_follow_link(struct inode *inode, int follow)
+{
+        if (unlikely(!(inode->i_opflags & IOP_NOFOLLOW))) {
+                if (likely(inode->i_op->follow_link))
+                        return follow;
+
+                /* This gets set once for the inode lifetime */
+                spin_lock(&inode->i_lock);
+                inode->i_opflags |= IOP_NOFOLLOW;
+                spin_unlock(&inode->i_lock);
+        }
+        return 0;
+}
+
 static inline int walk_component(struct nameidata *nd, struct path *path,
                 struct qstr *name, int type, int follow)
 {
@@ -1272,7 +1303,7 @@ static inline int walk_component(struct nameidata *nd, struct path *path,
                 terminate_walk(nd);
                 return -ENOENT;
         }
-        if (unlikely(inode->i_op->follow_link) && follow) {
+        if (should_follow_link(inode, follow)) {
                 if (nd->flags & LOOKUP_RCU) {
                         if (unlikely(unlazy_walk(nd, path->dentry))) {
                                 terminate_walk(nd);
@@ -1325,6 +1356,26 @@ static inline int nested_symlink(struct path *path, struct nameidata *nd)
 }
 
 /*
+ * We really don't want to look at inode->i_op->lookup
+ * when we don't have to. So we keep a cache bit in
+ * the inode ->i_opflags field that says "yes, we can
+ * do lookup on this inode".
+ */
+static inline int can_lookup(struct inode *inode)
+{
+        if (likely(inode->i_opflags & IOP_LOOKUP))
+                return 1;
+        if (likely(!inode->i_op->lookup))
+                return 0;
+
+        /* We do this once for the lifetime of the inode */
+        spin_lock(&inode->i_lock);
+        inode->i_opflags |= IOP_LOOKUP;
+        spin_unlock(&inode->i_lock);
+        return 1;
+}
+
+/*
  * Name resolution.
  * This is the basic name resolution function, turning a pathname into
  * the final dentry. We expect 'base' to be positive and a directory.
@@ -1403,10 +1454,10 @@ static int link_path_walk(const char *name, struct nameidata *nd)
                         if (err)
                                 return err;
                 }
+                if (can_lookup(nd->inode))
+                        continue;
                 err = -ENOTDIR; 
-                if (!nd->inode->i_op->lookup)
-                        break;
-                continue;
+                break;
                 /* here ends the main loop */
 
 last_component:
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 08e3eccf9a12..5eb02069e1b8 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -1118,7 +1118,7 @@ static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
          * Warn that /proc/pid/oom_adj is deprecated, see
          * Documentation/feature-removal-schedule.txt.
          */
-        WARN_ONCE(1, "%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
+        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;
@@ -1919,6 +1919,14 @@ static int proc_fd_info(struct inode *inode, struct path *path, char *info)
                 spin_lock(&files->file_lock);
                 file = fcheck_files(files, fd);
                 if (file) {
+                        unsigned int f_flags;
+                        struct fdtable *fdt;
+
+                        fdt = files_fdtable(files);
+                        f_flags = file->f_flags & ~O_CLOEXEC;
+                        if (FD_ISSET(fd, fdt->close_on_exec))
+                                f_flags |= O_CLOEXEC;
+
                         if (path) {
                                 *path = file->f_path;
                                 path_get(&file->f_path);
@@ -1928,7 +1936,7 @@ static int proc_fd_info(struct inode *inode, struct path *path, char *info)
                                          "pos:\t%lli\n"
                                          "flags:\t0%o\n",
                                          (long long) file->f_pos,
-                                         file->f_flags);
+                                         f_flags);
                         spin_unlock(&files->file_lock);
                         put_files_struct(files);
                         return 0;
diff --git a/fs/stack.c b/fs/stack.c
index 4a6f7f440658..b4f2ab48a61f 100644
--- a/fs/stack.c
+++ b/fs/stack.c
@@ -29,10 +29,7 @@ void fsstack_copy_inode_size(struct inode *dst, struct inode *src)
          *
          * We don't actually know what locking is used at the lower level;
          * but if it's a filesystem that supports quotas, it will be using
-         * i_lock as in inode_add_bytes().  tmpfs uses other locking, and
-         * its 32-bit is (just) able to exceed 2TB i_size with the aid of
-         * holes; but its i_blocks cannot carry into the upper long without
-         * almost 2TB swap - let's ignore that case.
+         * i_lock as in inode_add_bytes().
          */
         if (sizeof(i_blocks) > sizeof(long))
                 spin_lock(&src->i_lock);
diff --git a/fs/stat.c b/fs/stat.c
index 961039121cb8..ba5316ffac61 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -27,12 +27,12 @@ void generic_fillattr(struct inode *inode, struct kstat *stat)
         stat->uid = inode->i_uid;
         stat->gid = inode->i_gid;
         stat->rdev = inode->i_rdev;
+        stat->size = i_size_read(inode);
         stat->atime = inode->i_atime;
         stat->mtime = inode->i_mtime;
         stat->ctime = inode->i_ctime;
-        stat->size = i_size_read(inode);
-        stat->blocks = inode->i_blocks;
         stat->blksize = (1 << inode->i_blkbits);
+        stat->blocks = inode->i_blocks;
 }
 
 EXPORT_SYMBOL(generic_fillattr);