Merge branch 'akpm' (patches from Andrew)

Merge first patchbomb from Andrew Morton:

 - arch/sh updates

 - ocfs2 updates

 - kernel/watchdog feature

 - about half of mm/

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (122 commits)
  Documentation: update arch list in the 'memtest' entry
  Kconfig: memtest: update number of test patterns up to 17
  arm: add support for memtest
  arm64: add support for memtest
  memtest: use phys_addr_t for physical addresses
  mm: move memtest under mm
  mm, hugetlb: abort __get_user_pages if current has been oom killed
  mm, mempool: do not allow atomic resizing
  memcg: print cgroup information when system panics due to panic_on_oom
  mm: numa: remove migrate_ratelimited
  mm: fold arch_randomize_brk into ARCH_HAS_ELF_RANDOMIZE
  mm: split ET_DYN ASLR from mmap ASLR
  s390: redefine randomize_et_dyn for ELF_ET_DYN_BASE
  mm: expose arch_mmap_rnd when available
  s390: standardize mmap_rnd() usage
  powerpc: standardize mmap_rnd() usage
  mips: extract logic for mmap_rnd()
  arm64: standardize mmap_rnd() usage
  x86: standardize mmap_rnd() usage
  arm: factor out mmap ASLR into mmap_rnd
  ...

24 files changed, 279 insertions, 134 deletions

diff --git a/fs/Kconfig.binfmt b/fs/Kconfig.binfmt
index 270c48148f79..2d0cbbd14cfc 100644
--- a/fs/Kconfig.binfmt
+++ b/fs/Kconfig.binfmt
@@ -27,9 +27,6 @@ config COMPAT_BINFMT_ELF
         bool
         depends on COMPAT && BINFMT_ELF
 
-config ARCH_BINFMT_ELF_RANDOMIZE_PIE
-        bool
-
 config ARCH_BINFMT_ELF_STATE
         bool
 
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 995986b8e36b..241ef68d2893 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -31,6 +31,7 @@
 #include <linux/security.h>
 #include <linux/random.h>
 #include <linux/elf.h>
+#include <linux/elf-randomize.h>
 #include <linux/utsname.h>
 #include <linux/coredump.h>
 #include <linux/sched.h>
@@ -862,6 +863,7 @@ static int load_elf_binary(struct linux_binprm *bprm)
             i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
                 int elf_prot = 0, elf_flags;
                 unsigned long k, vaddr;
+                unsigned long total_size = 0;
 
                 if (elf_ppnt->p_type != PT_LOAD)
                         continue;
@@ -909,25 +911,20 @@ static int load_elf_binary(struct linux_binprm *bprm)
                          * default mmap base, as well as whatever program they
                          * might try to exec.  This is because the brk will
                          * follow the loader, and is not movable.  */
-#ifdef CONFIG_ARCH_BINFMT_ELF_RANDOMIZE_PIE
-                        /* Memory randomization might have been switched off
-                         * in runtime via sysctl or explicit setting of
-                         * personality flags.
-                         * If that is the case, retain the original non-zero
-                         * load_bias value in order to establish proper
-                         * non-randomized mappings.
-                         */
+                        load_bias = ELF_ET_DYN_BASE - vaddr;
                         if (current->flags & PF_RANDOMIZE)
-                                load_bias = 0;
-                        else
-                                load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
-#else
-                        load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
-#endif
+                                load_bias += arch_mmap_rnd();
+                        load_bias = ELF_PAGESTART(load_bias);
+                        total_size = total_mapping_size(elf_phdata,
+                                                        loc->elf_ex.e_phnum);
+                        if (!total_size) {
+                                error = -EINVAL;
+                                goto out_free_dentry;
+                        }
                 }
 
                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
-                                elf_prot, elf_flags, 0);
+                                elf_prot, elf_flags, total_size);
                 if (BAD_ADDR(error)) {
                         retval = IS_ERR((void *)error) ?
                                 PTR_ERR((void*)error) : -EINVAL;
@@ -1053,15 +1050,13 @@ static int load_elf_binary(struct linux_binprm *bprm)
         current->mm->end_data = end_data;
         current->mm->start_stack = bprm->p;
 
-#ifdef arch_randomize_brk
         if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
                 current->mm->brk = current->mm->start_brk =
                         arch_randomize_brk(current->mm);
-#ifdef CONFIG_COMPAT_BRK
+#ifdef compat_brk_randomized
                 current->brk_randomized = 1;
 #endif
         }
-#endif
 
         if (current->personality & MMAP_PAGE_ZERO) {
                 /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
diff --git a/fs/buffer.c b/fs/buffer.c
index 20805db2c987..c7a5602d01ee 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -3243,8 +3243,8 @@ int try_to_free_buffers(struct page *page)
          * to synchronise against __set_page_dirty_buffers and prevent the
          * dirty bit from being lost.
          */
-        if (ret)
-                cancel_dirty_page(page, PAGE_CACHE_SIZE);
+        if (ret && TestClearPageDirty(page))
+                account_page_cleaned(page, mapping);
         spin_unlock(&mapping->private_lock);
 out:
         if (buffers_to_free) {
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 480cf9c81d50..f3bfe08e177b 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -773,8 +773,7 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server)
 
         length = atomic_dec_return(&tcpSesAllocCount);
         if (length > 0)
-                mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
-                                GFP_KERNEL);
+                mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 }
 
 static int
@@ -848,8 +847,7 @@ cifs_demultiplex_thread(void *p)
 
         length = atomic_inc_return(&tcpSesAllocCount);
         if (length > 1)
-                mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
-                                GFP_KERNEL);
+                mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 
         set_freezable();
         while (server->tcpStatus != CifsExiting) {
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index c274aca8e8dc..db76cec3ce21 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -319,7 +319,7 @@ static int hugetlbfs_write_end(struct file *file, struct address_space *mapping,
 
 static void truncate_huge_page(struct page *page)
 {
-        cancel_dirty_page(page, /* No IO accounting for huge pages? */0);
+        ClearPageDirty(page);
         ClearPageUptodate(page);
         delete_from_page_cache(page);
 }
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 849ed784d6ac..759931088094 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1876,11 +1876,6 @@ int nfs_wb_page_cancel(struct inode *inode, struct page *page)
                  * request from the inode / page_private pointer and
                  * release it */
                 nfs_inode_remove_request(req);
-                /*
-                 * In case nfs_inode_remove_request has marked the
-                 * page as being dirty
-                 */
-                cancel_dirty_page(page, PAGE_CACHE_SIZE);
                 nfs_unlock_and_release_request(req);
         }
 
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index 044158bd22be..2d7f76e52c37 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -3370,7 +3370,7 @@ static int ocfs2_merge_rec_right(struct ocfs2_path *left_path,
                 ret = ocfs2_get_right_path(et, left_path, &right_path);
                 if (ret) {
                         mlog_errno(ret);
-                        goto out;
+                        return ret;
                 }
 
                 right_el = path_leaf_el(right_path);
@@ -3453,8 +3453,7 @@ static int ocfs2_merge_rec_right(struct ocfs2_path *left_path,
                                            subtree_index);
         }
 out:
-        if (right_path)
-                ocfs2_free_path(right_path);
+        ocfs2_free_path(right_path);
         return ret;
 }
 
@@ -3536,7 +3535,7 @@ static int ocfs2_merge_rec_left(struct ocfs2_path *right_path,
                 ret = ocfs2_get_left_path(et, right_path, &left_path);
                 if (ret) {
                         mlog_errno(ret);
-                        goto out;
+                        return ret;
                 }
 
                 left_el = path_leaf_el(left_path);
@@ -3647,8 +3646,7 @@ static int ocfs2_merge_rec_left(struct ocfs2_path *right_path,
                                                    right_path, subtree_index);
         }
 out:
-        if (left_path)
-                ocfs2_free_path(left_path);
+        ocfs2_free_path(left_path);
         return ret;
 }
 
@@ -4334,17 +4332,17 @@ ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
         } else if (path->p_tree_depth > 0) {
                 status = ocfs2_find_cpos_for_left_leaf(sb, path, &left_cpos);
                 if (status)
-                        goto out;
+                        goto exit;
 
                 if (left_cpos != 0) {
                         left_path = ocfs2_new_path_from_path(path);
                         if (!left_path)
-                                goto out;
+                                goto exit;
 
                         status = ocfs2_find_path(et->et_ci, left_path,
                                                  left_cpos);
                         if (status)
-                                goto out;
+                                goto free_left_path;
 
                         new_el = path_leaf_el(left_path);
 
@@ -4361,7 +4359,7 @@ ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
                                             le16_to_cpu(new_el->l_next_free_rec),
                                             le16_to_cpu(new_el->l_count));
                                 status = -EINVAL;
-                                goto out;
+                                goto free_left_path;
                         }
                         rec = &new_el->l_recs[
                                 le16_to_cpu(new_el->l_next_free_rec) - 1];
@@ -4388,18 +4386,18 @@ ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
                  path->p_tree_depth > 0) {
                 status = ocfs2_find_cpos_for_right_leaf(sb, path, &right_cpos);
                 if (status)
-                        goto out;
+                        goto free_left_path;
 
                 if (right_cpos == 0)
-                        goto out;
+                        goto free_left_path;
 
                 right_path = ocfs2_new_path_from_path(path);
                 if (!right_path)
-                        goto out;
+                        goto free_left_path;
 
                 status = ocfs2_find_path(et->et_ci, right_path, right_cpos);
                 if (status)
-                        goto out;
+                        goto free_right_path;
 
                 new_el = path_leaf_el(right_path);
                 rec = &new_el->l_recs[0];
@@ -4413,7 +4411,7 @@ ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
                                             (unsigned long long)le64_to_cpu(eb->h_blkno),
                                             le16_to_cpu(new_el->l_next_free_rec));
                                 status = -EINVAL;
-                                goto out;
+                                goto free_right_path;
                         }
                         rec = &new_el->l_recs[1];
                 }
@@ -4430,12 +4428,11 @@ ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
                         ret = contig_type;
         }
 
-out:
-        if (left_path)
-                ocfs2_free_path(left_path);
-        if (right_path)
-                ocfs2_free_path(right_path);
-
+free_right_path:
+        ocfs2_free_path(right_path);
+free_left_path:
+        ocfs2_free_path(left_path);
+exit:
         return ret;
 }
 
@@ -6858,13 +6855,13 @@ int ocfs2_convert_inline_data_to_extents(struct inode *inode,
                 if (pages == NULL) {
                         ret = -ENOMEM;
                         mlog_errno(ret);
-                        goto out;
+                        return ret;
                 }
 
                 ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
                 if (ret) {
                         mlog_errno(ret);
-                        goto out;
+                        goto free_pages;
                 }
         }
 
@@ -6996,9 +6993,8 @@ out_commit:
 out:
         if (data_ac)
                 ocfs2_free_alloc_context(data_ac);
-        if (pages)
-                kfree(pages);
-
+free_pages:
+        kfree(pages);
         return ret;
 }
 
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index e1bf18c5d25e..8d2bc840c288 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -664,6 +664,117 @@ static int ocfs2_is_overwrite(struct ocfs2_super *osb,
         return 0;
 }
 
+static int ocfs2_direct_IO_zero_extend(struct ocfs2_super *osb,
+                struct inode *inode, loff_t offset,
+                u64 zero_len, int cluster_align)
+{
+        u32 p_cpos = 0;
+        u32 v_cpos = ocfs2_bytes_to_clusters(osb->sb, i_size_read(inode));
+        unsigned int num_clusters = 0;
+        unsigned int ext_flags = 0;
+        int ret = 0;
+
+        if (offset <= i_size_read(inode) || cluster_align)
+                return 0;
+
+        ret = ocfs2_get_clusters(inode, v_cpos, &p_cpos, &num_clusters,
+                        &ext_flags);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+
+        if (p_cpos && !(ext_flags & OCFS2_EXT_UNWRITTEN)) {
+                u64 s = i_size_read(inode);
+                sector_t sector = (p_cpos << (osb->s_clustersize_bits - 9)) +
+                        (do_div(s, osb->s_clustersize) >> 9);
+
+                ret = blkdev_issue_zeroout(osb->sb->s_bdev, sector,
+                                zero_len >> 9, GFP_NOFS, false);
+                if (ret < 0)
+                        mlog_errno(ret);
+        }
+
+        return ret;
+}
+
+static int ocfs2_direct_IO_extend_no_holes(struct ocfs2_super *osb,
+                struct inode *inode, loff_t offset)
+{
+        u64 zero_start, zero_len, total_zero_len;
+        u32 p_cpos = 0, clusters_to_add;
+        u32 v_cpos = ocfs2_bytes_to_clusters(osb->sb, i_size_read(inode));
+        unsigned int num_clusters = 0;
+        unsigned int ext_flags = 0;
+        u32 size_div, offset_div;
+        int ret = 0;
+
+        {
+                u64 o = offset;
+                u64 s = i_size_read(inode);
+
+                offset_div = do_div(o, osb->s_clustersize);
+                size_div = do_div(s, osb->s_clustersize);
+        }
+
+        if (offset <= i_size_read(inode))
+                return 0;
+
+        clusters_to_add = ocfs2_bytes_to_clusters(inode->i_sb, offset) -
+                ocfs2_bytes_to_clusters(inode->i_sb, i_size_read(inode));
+        total_zero_len = offset - i_size_read(inode);
+        if (clusters_to_add)
+                total_zero_len -= offset_div;
+
+        /* Allocate clusters to fill out holes, and this is only needed
+         * when we add more than one clusters. Otherwise the cluster will
+         * be allocated during direct IO */
+        if (clusters_to_add > 1) {
+                ret = ocfs2_extend_allocation(inode,
+                                OCFS2_I(inode)->ip_clusters,
+                                clusters_to_add - 1, 0);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+
+        while (total_zero_len) {
+                ret = ocfs2_get_clusters(inode, v_cpos, &p_cpos, &num_clusters,
+                                &ext_flags);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                zero_start = ocfs2_clusters_to_bytes(osb->sb, p_cpos) +
+                        size_div;
+                zero_len = ocfs2_clusters_to_bytes(osb->sb, num_clusters) -
+                        size_div;
+                zero_len = min(total_zero_len, zero_len);
+
+                if (p_cpos && !(ext_flags & OCFS2_EXT_UNWRITTEN)) {
+                        ret = blkdev_issue_zeroout(osb->sb->s_bdev,
+                                        zero_start >> 9, zero_len >> 9,
+                                        GFP_NOFS, false);
+                        if (ret < 0) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+                }
+
+                total_zero_len -= zero_len;
+                v_cpos += ocfs2_bytes_to_clusters(osb->sb, zero_len + size_div);
+
+                /* Only at first iteration can be cluster not aligned.
+                 * So set size_div to 0 for the rest */
+                size_div = 0;
+        }
+
+out:
+        return ret;
+}
+
 static ssize_t ocfs2_direct_IO_write(struct kiocb *iocb,
                 struct iov_iter *iter,
                 loff_t offset)
@@ -678,8 +789,8 @@ static ssize_t ocfs2_direct_IO_write(struct kiocb *iocb,
         struct buffer_head *di_bh = NULL;
         size_t count = iter->count;
         journal_t *journal = osb->journal->j_journal;
-        u32 zero_len;
-        int cluster_align;
+        u64 zero_len_head, zero_len_tail;
+        int cluster_align_head, cluster_align_tail;
         loff_t final_size = offset + count;
         int append_write = offset >= i_size_read(inode) ? 1 : 0;
         unsigned int num_clusters = 0;
@@ -687,9 +798,16 @@ static ssize_t ocfs2_direct_IO_write(struct kiocb *iocb,
 
         {
                 u64 o = offset;
+                u64 s = i_size_read(inode);
+
+                zero_len_head = do_div(o, 1 << osb->s_clustersize_bits);
+                cluster_align_head = !zero_len_head;
 
-                zero_len = do_div(o, 1 << osb->s_clustersize_bits);
-                cluster_align = !zero_len;
+                zero_len_tail = osb->s_clustersize -
+                        do_div(s, osb->s_clustersize);
+                if ((offset - i_size_read(inode)) < zero_len_tail)
+                        zero_len_tail = offset - i_size_read(inode);
+                cluster_align_tail = !zero_len_tail;
         }
 
         /*
@@ -707,21 +825,23 @@ static ssize_t ocfs2_direct_IO_write(struct kiocb *iocb,
         }
 
         if (append_write) {
-                ret = ocfs2_inode_lock(inode, &di_bh, 1);
+                ret = ocfs2_inode_lock(inode, NULL, 1);
                 if (ret < 0) {
                         mlog_errno(ret);
                         goto clean_orphan;
                 }
 
+                /* zeroing out the previously allocated cluster tail
+                 * that but not zeroed */
                 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
-                        ret = ocfs2_zero_extend(inode, di_bh, offset);
+                        ret = ocfs2_direct_IO_zero_extend(osb, inode, offset,
+                                        zero_len_tail, cluster_align_tail);
                 else
-                        ret = ocfs2_extend_no_holes(inode, di_bh, offset,
+                        ret = ocfs2_direct_IO_extend_no_holes(osb, inode,
                                         offset);
                 if (ret < 0) {
                         mlog_errno(ret);
                         ocfs2_inode_unlock(inode, 1);
-                        brelse(di_bh);
                         goto clean_orphan;
                 }
 
@@ -729,13 +849,10 @@ static ssize_t ocfs2_direct_IO_write(struct kiocb *iocb,
                 if (is_overwrite < 0) {
                         mlog_errno(is_overwrite);
                         ocfs2_inode_unlock(inode, 1);
-                        brelse(di_bh);
                         goto clean_orphan;
                 }
 
                 ocfs2_inode_unlock(inode, 1);
-                brelse(di_bh);
-                di_bh = NULL;
         }
 
         written = __blockdev_direct_IO(WRITE, iocb, inode, inode->i_sb->s_bdev,
@@ -772,15 +889,23 @@ static ssize_t ocfs2_direct_IO_write(struct kiocb *iocb,
                         if (ret < 0)
                                 mlog_errno(ret);
                 }
-        } else if (written < 0 && append_write && !is_overwrite &&
-                        !cluster_align) {
+        } else if (written > 0 && append_write && !is_overwrite &&
+                        !cluster_align_head) {
+                /* zeroing out the allocated cluster head */
                 u32 p_cpos = 0;
                 u32 v_cpos = ocfs2_bytes_to_clusters(osb->sb, offset);
 
+                ret = ocfs2_inode_lock(inode, NULL, 0);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto clean_orphan;
+                }
+
                 ret = ocfs2_get_clusters(inode, v_cpos, &p_cpos,
                                 &num_clusters, &ext_flags);
                 if (ret < 0) {
                         mlog_errno(ret);
+                        ocfs2_inode_unlock(inode, 0);
                         goto clean_orphan;
                 }
 
@@ -788,9 +913,11 @@ static ssize_t ocfs2_direct_IO_write(struct kiocb *iocb,
 
                 ret = blkdev_issue_zeroout(osb->sb->s_bdev,
                                 p_cpos << (osb->s_clustersize_bits - 9),
-                                zero_len >> 9, GFP_KERNEL, false);
+                                zero_len_head >> 9, GFP_NOFS, false);
                 if (ret < 0)
                         mlog_errno(ret);
+
+                ocfs2_inode_unlock(inode, 0);
         }
 
 clean_orphan:
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index 16eff45727ee..8e19b9d7aba8 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -1312,7 +1312,9 @@ static int o2hb_debug_init(void)
         int ret = -ENOMEM;
 
         o2hb_debug_dir = debugfs_create_dir(O2HB_DEBUG_DIR, NULL);
-        if (!o2hb_debug_dir) {
+        if (IS_ERR_OR_NULL(o2hb_debug_dir)) {
+                ret = o2hb_debug_dir ?
+                        PTR_ERR(o2hb_debug_dir) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
@@ -1325,7 +1327,9 @@ static int o2hb_debug_init(void)
                                                  sizeof(o2hb_live_node_bitmap),
                                                  O2NM_MAX_NODES,
                                                  o2hb_live_node_bitmap);
-        if (!o2hb_debug_livenodes) {
+        if (IS_ERR_OR_NULL(o2hb_debug_livenodes)) {
+                ret = o2hb_debug_livenodes ?
+                        PTR_ERR(o2hb_debug_livenodes) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
@@ -1338,7 +1342,9 @@ static int o2hb_debug_init(void)
                                                    sizeof(o2hb_live_region_bitmap),
                                                    O2NM_MAX_REGIONS,
                                                    o2hb_live_region_bitmap);
-        if (!o2hb_debug_liveregions) {
+        if (IS_ERR_OR_NULL(o2hb_debug_liveregions)) {
+                ret = o2hb_debug_liveregions ?
+                        PTR_ERR(o2hb_debug_liveregions) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
@@ -1352,7 +1358,9 @@ static int o2hb_debug_init(void)
                                           sizeof(o2hb_quorum_region_bitmap),
                                           O2NM_MAX_REGIONS,
                                           o2hb_quorum_region_bitmap);
-        if (!o2hb_debug_quorumregions) {
+        if (IS_ERR_OR_NULL(o2hb_debug_quorumregions)) {
+                ret = o2hb_debug_quorumregions ?
+                        PTR_ERR(o2hb_debug_quorumregions) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
@@ -1366,7 +1374,9 @@ static int o2hb_debug_init(void)
                                           sizeof(o2hb_failed_region_bitmap),
                                           O2NM_MAX_REGIONS,
                                           o2hb_failed_region_bitmap);
-        if (!o2hb_debug_failedregions) {
+        if (IS_ERR_OR_NULL(o2hb_debug_failedregions)) {
+                ret = o2hb_debug_failedregions ?
+                        PTR_ERR(o2hb_debug_failedregions) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
@@ -2000,7 +2010,8 @@ static int o2hb_debug_region_init(struct o2hb_region *reg, struct dentry *dir)
 
         reg->hr_debug_dir =
                 debugfs_create_dir(config_item_name(&reg->hr_item), dir);
-        if (!reg->hr_debug_dir) {
+        if (IS_ERR_OR_NULL(reg->hr_debug_dir)) {
+                ret = reg->hr_debug_dir ? PTR_ERR(reg->hr_debug_dir) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
@@ -2013,7 +2024,9 @@ static int o2hb_debug_region_init(struct o2hb_region *reg, struct dentry *dir)
                                           O2HB_DB_TYPE_REGION_LIVENODES,
                                           sizeof(reg->hr_live_node_bitmap),
                                           O2NM_MAX_NODES, reg);
-        if (!reg->hr_debug_livenodes) {
+        if (IS_ERR_OR_NULL(reg->hr_debug_livenodes)) {
+                ret = reg->hr_debug_livenodes ?
+                        PTR_ERR(reg->hr_debug_livenodes) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
@@ -2025,7 +2038,9 @@ static int o2hb_debug_region_init(struct o2hb_region *reg, struct dentry *dir)
                                           sizeof(*(reg->hr_db_regnum)),
                                           O2HB_DB_TYPE_REGION_NUMBER,
                                           0, O2NM_MAX_NODES, reg);
-        if (!reg->hr_debug_regnum) {
+        if (IS_ERR_OR_NULL(reg->hr_debug_regnum)) {
+                ret = reg->hr_debug_regnum ?
+                        PTR_ERR(reg->hr_debug_regnum) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
@@ -2037,7 +2052,9 @@ static int o2hb_debug_region_init(struct o2hb_region *reg, struct dentry *dir)
                                           sizeof(*(reg->hr_db_elapsed_time)),
                                           O2HB_DB_TYPE_REGION_ELAPSED_TIME,
                                           0, 0, reg);
-        if (!reg->hr_debug_elapsed_time) {
+        if (IS_ERR_OR_NULL(reg->hr_debug_elapsed_time)) {
+                ret = reg->hr_debug_elapsed_time ?
+                        PTR_ERR(reg->hr_debug_elapsed_time) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
@@ -2049,13 +2066,16 @@ static int o2hb_debug_region_init(struct o2hb_region *reg, struct dentry *dir)
                                           sizeof(*(reg->hr_db_pinned)),
                                           O2HB_DB_TYPE_REGION_PINNED,
                                           0, 0, reg);
-        if (!reg->hr_debug_pinned) {
+        if (IS_ERR_OR_NULL(reg->hr_debug_pinned)) {
+                ret = reg->hr_debug_pinned ?
+                        PTR_ERR(reg->hr_debug_pinned) : -ENOMEM;
                 mlog_errno(ret);
                 goto bail;
         }
 
-        ret = 0;
+        return 0;
 bail:
+        debugfs_remove_recursive(reg->hr_debug_dir);
         return ret;
 }
 
diff --git a/fs/ocfs2/cluster/masklog.h b/fs/ocfs2/cluster/masklog.h
index 2260fb9e6508..7fdc25a4d8c0 100644
--- a/fs/ocfs2/cluster/masklog.h
+++ b/fs/ocfs2/cluster/masklog.h
@@ -196,13 +196,14 @@ extern struct mlog_bits mlog_and_bits, mlog_not_bits;
         }                                                               \
 } while (0)
 
-#define mlog_errno(st) do {                                             \
+#define mlog_errno(st) ({                                               \
         int _st = (st);                                                 \
         if (_st != -ERESTARTSYS && _st != -EINTR &&                     \
             _st != AOP_TRUNCATED_PAGE && _st != -ENOSPC &&              \
             _st != -EDQUOT)                                             \
                 mlog(ML_ERROR, "status = %lld\n", (long long)_st);      \
-} while (0)
+        _st;                                                            \
+})
 
 #define mlog_bug_on_msg(cond, fmt, args...) do {                        \
         if (cond) {                                                     \
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index b08050bd3f2e..ccd4dcfc3645 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -18,7 +18,7 @@
  *
  *   linux/fs/minix/dir.c
  *
- *   Copyright (C) 1991, 1992 Linux Torvalds
+ *   Copyright (C) 1991, 1992 Linus Torvalds
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public
@@ -2047,22 +2047,19 @@ int ocfs2_check_dir_for_entry(struct inode *dir,
                               const char *name,
                               int namelen)
 {
-        int ret;
+        int ret = 0;
         struct ocfs2_dir_lookup_result lookup = { NULL, };
 
         trace_ocfs2_check_dir_for_entry(
                 (unsigned long long)OCFS2_I(dir)->ip_blkno, namelen, name);
 
-        ret = -EEXIST;
-        if (ocfs2_find_entry(name, namelen, dir, &lookup) == 0)
-                goto bail;
+        if (ocfs2_find_entry(name, namelen, dir, &lookup) == 0) {
+                ret = -EEXIST;
+                mlog_errno(ret);
+        }
 
-        ret = 0;
-bail:
         ocfs2_free_dir_lookup_result(&lookup);
 
-        if (ret)
-                mlog_errno(ret);
         return ret;
 }
 
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 11849a44dc5a..956edf67be20 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -1391,6 +1391,11 @@ static int __ocfs2_cluster_lock(struct ocfs2_super *osb,
         int noqueue_attempted = 0;
         int dlm_locked = 0;
 
+        if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED)) {
+                mlog_errno(-EINVAL);
+                return -EINVAL;
+        }
+
         ocfs2_init_mask_waiter(&mw);
 
         if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
@@ -2954,7 +2959,7 @@ static int ocfs2_dlm_init_debug(struct ocfs2_super *osb)
                                                          osb->osb_debug_root,
                                                          osb,
                                                          &ocfs2_dlm_debug_fops);
-        if (!dlm_debug->d_locking_state) {
+        if (IS_ERR_OR_NULL(dlm_debug->d_locking_state)) {
                 ret = -EINVAL;
                 mlog(ML_ERROR,
                      "Unable to create locking state debugfs file.\n");
diff --git a/fs/ocfs2/export.c b/fs/ocfs2/export.c
index 29651167190d..540dc4bdd042 100644
--- a/fs/ocfs2/export.c
+++ b/fs/ocfs2/export.c
@@ -82,7 +82,6 @@ static struct dentry *ocfs2_get_dentry(struct super_block *sb,
         }
 
         status = ocfs2_test_inode_bit(osb, blkno, &set);
-        trace_ocfs2_get_dentry_test_bit(status, set);
         if (status < 0) {
                 if (status == -EINVAL) {
                         /*
@@ -96,6 +95,7 @@ static struct dentry *ocfs2_get_dentry(struct super_block *sb,
                 goto unlock_nfs_sync;
         }
 
+        trace_ocfs2_get_dentry_test_bit(status, set);
         /* If the inode allocator bit is clear, this inode must be stale */
         if (!set) {
                 status = -ESTALE;
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index 3025c0da6b8a..be71ca0937f7 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -624,7 +624,7 @@ static int ocfs2_remove_inode(struct inode *inode,
                 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE,
                                             le16_to_cpu(di->i_suballoc_slot));
         if (!inode_alloc_inode) {
-                status = -EEXIST;
+                status = -ENOENT;
                 mlog_errno(status);
                 goto bail;
         }
@@ -742,7 +742,7 @@ static int ocfs2_wipe_inode(struct inode *inode,
                                                                ORPHAN_DIR_SYSTEM_INODE,
                                                                orphaned_slot);
                 if (!orphan_dir_inode) {
-                        status = -EEXIST;
+                        status = -ENOENT;
                         mlog_errno(status);
                         goto bail;
                 }
diff --git a/fs/ocfs2/localalloc.c b/fs/ocfs2/localalloc.c
index 044013455621..857bbbcd39f3 100644
--- a/fs/ocfs2/localalloc.c
+++ b/fs/ocfs2/localalloc.c
@@ -666,7 +666,7 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
         if (le32_to_cpu(alloc->id1.bitmap1.i_used) !=
             ocfs2_local_alloc_count_bits(alloc)) {
                 ocfs2_error(osb->sb, "local alloc inode %llu says it has "
-                            "%u free bits, but a count shows %u",
+                            "%u used bits, but a count shows %u",
                             (unsigned long long)le64_to_cpu(alloc->i_blkno),
                             le32_to_cpu(alloc->id1.bitmap1.i_used),
                             ocfs2_local_alloc_count_bits(alloc));
@@ -839,7 +839,7 @@ static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
                                      u32 *numbits,
                                      struct ocfs2_alloc_reservation *resv)
 {
-        int numfound, bitoff, left, startoff, lastzero;
+        int numfound = 0, bitoff, left, startoff, lastzero;
         int local_resv = 0;
         struct ocfs2_alloc_reservation r;
         void *bitmap = NULL;
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index b5c3a5ea3ee6..09f90cbf0e24 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -2322,10 +2322,10 @@ int ocfs2_orphan_del(struct ocfs2_super *osb,
 
         trace_ocfs2_orphan_del(
              (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
-             name, namelen);
+             name, strlen(name));
 
         /* find it's spot in the orphan directory */
-        status = ocfs2_find_entry(name, namelen, orphan_dir_inode,
+        status = ocfs2_find_entry(name, strlen(name), orphan_dir_inode,
                                   &lookup);
         if (status) {
                 mlog_errno(status);
@@ -2808,7 +2808,7 @@ int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
                                                        ORPHAN_DIR_SYSTEM_INODE,
                                                        osb->slot_num);
         if (!orphan_dir_inode) {
-                status = -EEXIST;
+                status = -ENOENT;
                 mlog_errno(status);
                 goto leave;
         }
diff --git a/fs/ocfs2/refcounttree.c b/fs/ocfs2/refcounttree.c
index ee541f92dab4..df3a500789c7 100644
--- a/fs/ocfs2/refcounttree.c
+++ b/fs/ocfs2/refcounttree.c
@@ -4276,7 +4276,7 @@ static int ocfs2_reflink(struct dentry *old_dentry, struct inode *dir,
         error = posix_acl_create(dir, &mode, &default_acl, &acl);
         if (error) {
                 mlog_errno(error);
-                goto out;
+                return error;
         }
 
         error = ocfs2_create_inode_in_orphan(dir, mode,
diff --git a/fs/ocfs2/slot_map.c b/fs/ocfs2/slot_map.c
index d5493e361a38..e78a203d44c8 100644
--- a/fs/ocfs2/slot_map.c
+++ b/fs/ocfs2/slot_map.c
@@ -427,7 +427,7 @@ int ocfs2_init_slot_info(struct ocfs2_super *osb)
         if (!si) {
                 status = -ENOMEM;
                 mlog_errno(status);
-                goto bail;
+                return status;
         }
 
         si->si_extended = ocfs2_uses_extended_slot_map(osb);
@@ -452,7 +452,7 @@ int ocfs2_init_slot_info(struct ocfs2_super *osb)
 
         osb->slot_info = (struct ocfs2_slot_info *)si;
 bail:
-        if (status < 0 && si)
+        if (status < 0)
                 __ocfs2_free_slot_info(si);
 
         return status;
diff --git a/fs/ocfs2/stack_o2cb.c b/fs/ocfs2/stack_o2cb.c
index 1724d43d3da1..220cae7bbdbc 100644
--- a/fs/ocfs2/stack_o2cb.c
+++ b/fs/ocfs2/stack_o2cb.c
@@ -295,7 +295,7 @@ static int o2cb_cluster_check(void)
                 set_bit(node_num, netmap);
                 if (!memcmp(hbmap, netmap, sizeof(hbmap)))
                         return 0;
-                if (i < O2CB_MAP_STABILIZE_COUNT)
+                if (i < O2CB_MAP_STABILIZE_COUNT - 1)
                         msleep(1000);
         }
 
diff --git a/fs/ocfs2/stack_user.c b/fs/ocfs2/stack_user.c
index 720aa389e0ea..2768eb1da2b8 100644
--- a/fs/ocfs2/stack_user.c
+++ b/fs/ocfs2/stack_user.c
@@ -1004,10 +1004,8 @@ static int user_cluster_connect(struct ocfs2_cluster_connection *conn)
         BUG_ON(conn == NULL);
 
         lc = kzalloc(sizeof(struct ocfs2_live_connection), GFP_KERNEL);
-        if (!lc) {
-                rc = -ENOMEM;
-                goto out;
-        }
+        if (!lc)
+                return -ENOMEM;
 
         init_waitqueue_head(&lc->oc_wait);
         init_completion(&lc->oc_sync_wait);
@@ -1063,7 +1061,7 @@ static int user_cluster_connect(struct ocfs2_cluster_connection *conn)
         }
 
 out:
-        if (rc && lc)
+        if (rc)
                 kfree(lc);
         return rc;
 }
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index 0cb889a17ae1..4479029630bb 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -2499,6 +2499,8 @@ static int _ocfs2_free_suballoc_bits(handle_t *handle,
                                          alloc_bh, OCFS2_JOURNAL_ACCESS_WRITE);
         if (status < 0) {
                 mlog_errno(status);
+                ocfs2_block_group_set_bits(handle, alloc_inode, group, group_bh,
+                                start_bit, count);
                 goto bail;
         }
 
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 26675185b886..837ddce4b659 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -1112,7 +1112,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
 
         osb->osb_debug_root = debugfs_create_dir(osb->uuid_str,
                                                  ocfs2_debugfs_root);
-        if (!osb->osb_debug_root) {
+        if (IS_ERR_OR_NULL(osb->osb_debug_root)) {
                 status = -EINVAL;
                 mlog(ML_ERROR, "Unable to create per-mount debugfs root.\n");
                 goto read_super_error;
@@ -1122,7 +1122,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
                                             osb->osb_debug_root,
                                             osb,
                                             &ocfs2_osb_debug_fops);
-        if (!osb->osb_ctxt) {
+        if (IS_ERR_OR_NULL(osb->osb_ctxt)) {
                 status = -EINVAL;
                 mlog_errno(status);
                 goto read_super_error;
@@ -1606,8 +1606,9 @@ static int __init ocfs2_init(void)
         }
 
         ocfs2_debugfs_root = debugfs_create_dir("ocfs2", NULL);
-        if (!ocfs2_debugfs_root) {
-                status = -ENOMEM;
+        if (IS_ERR_OR_NULL(ocfs2_debugfs_root)) {
+                status = ocfs2_debugfs_root ?
+                        PTR_ERR(ocfs2_debugfs_root) : -ENOMEM;
                 mlog(ML_ERROR, "Unable to create ocfs2 debugfs root.\n");
                 goto out4;
         }
@@ -2069,6 +2070,8 @@ static int ocfs2_initialize_super(struct super_block *sb,
         cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits);
         bbits = le32_to_cpu(di->id2.i_super.s_blocksize_bits);
         sb->s_maxbytes = ocfs2_max_file_offset(bbits, cbits);
+        memcpy(sb->s_uuid, di->id2.i_super.s_uuid,
+               sizeof(di->id2.i_super.s_uuid));
 
         osb->osb_dx_mask = (1 << (cbits - bbits)) - 1;
 
@@ -2333,7 +2336,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
                 mlog_errno(status);
                 goto bail;
         }
-        cleancache_init_shared_fs((char *)&di->id2.i_super.s_uuid, sb);
+        cleancache_init_shared_fs(sb);
 
 bail:
         return status;
@@ -2563,22 +2566,22 @@ static void ocfs2_handle_error(struct super_block *sb)
         ocfs2_set_ro_flag(osb, 0);
 }
 
-static char error_buf[1024];
-
-void __ocfs2_error(struct super_block *sb,
-                   const char *function,
-                   const char *fmt, ...)
+void __ocfs2_error(struct super_block *sb, const char *function,
+                  const char *fmt, ...)
 {
+        struct va_format vaf;
         va_list args;
 
         va_start(args, fmt);
-        vsnprintf(error_buf, sizeof(error_buf), fmt, args);
-        va_end(args);
+        vaf.fmt = fmt;
+        vaf.va = &args;
 
         /* Not using mlog here because we want to show the actual
          * function the error came from. */
-        printk(KERN_CRIT "OCFS2: ERROR (device %s): %s: %s\n",
-               sb->s_id, function, error_buf);
+        printk(KERN_CRIT "OCFS2: ERROR (device %s): %s: %pV\n",
+               sb->s_id, function, &vaf);
+
+        va_end(args);
 
         ocfs2_handle_error(sb);
 }
@@ -2586,18 +2589,21 @@ void __ocfs2_error(struct super_block *sb,
 /* Handle critical errors. This is intentionally more drastic than
  * ocfs2_handle_error, so we only use for things like journal errors,
  * etc. */
-void __ocfs2_abort(struct super_block* sb,
-                   const char *function,
+void __ocfs2_abort(struct super_block *sb, const char *function,
                    const char *fmt, ...)
 {
+        struct va_format vaf;
         va_list args;
 
         va_start(args, fmt);
-        vsnprintf(error_buf, sizeof(error_buf), fmt, args);
-        va_end(args);
 
-        printk(KERN_CRIT "OCFS2: abort (device %s): %s: %s\n",
-               sb->s_id, function, error_buf);
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        printk(KERN_CRIT "OCFS2: abort (device %s): %s: %pV\n",
+               sb->s_id, function, &vaf);
+
+        va_end(args);
 
         /* We don't have the cluster support yet to go straight to
          * hard readonly in here. Until then, we want to keep
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index 85b190dc132f..4ca7533be479 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -1238,6 +1238,10 @@ static int ocfs2_xattr_block_get(struct inode *inode,
                                                                 i,
                                                                 &block_off,
                                                                 &name_offset);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto cleanup;
+                        }
                         xs->base = bucket_block(xs->bucket, block_off);
                 }
                 if (ocfs2_xattr_is_local(xs->here)) {
@@ -5665,6 +5669,10 @@ static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
 
                 ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket,
                                                       i, &xv, NULL);
+                if (ret) {
+                        mlog_errno(ret);
+                        break;
+                }
 
                 ret = ocfs2_lock_xattr_remove_allocators(inode, xv,
                                                          args->ref_ci,
diff --git a/fs/super.c b/fs/super.c
index 2b7dc90ccdbb..928c20f47af9 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -224,7 +224,7 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags)
         s->s_maxbytes = MAX_NON_LFS;
         s->s_op = &default_op;
         s->s_time_gran = 1000000000;
-        s->cleancache_poolid = -1;
+        s->cleancache_poolid = CLEANCACHE_NO_POOL;
 
         s->s_shrink.seeks = DEFAULT_SEEKS;
         s->s_shrink.scan_objects = super_cache_scan;