nvme: make nvme_identify_ns propagate errors back

[linux.git] / fs / xfs / xfs_inode.c

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 71d216cf6f875e01516f15cafa673e0b3e0dbb78..6467d5e1df2dd1508f39aa9f3dc6df6ad37c2e5b 100644 (file)
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -3,7 +3,6 @@
  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
  * All Rights Reserved.
  */
-#include <linux/log2.h>
 #include <linux/iversion.h>
 
 #include "xfs.h"
@@ -16,10 +15,7 @@
 #include "xfs_mount.h"
 #include "xfs_defer.h"
 #include "xfs_inode.h"
-#include "xfs_da_format.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir2.h"
-#include "xfs_attr_sf.h"
 #include "xfs_attr.h"
 #include "xfs_trans_space.h"
 #include "xfs_trans.h"
@@ -32,7 +28,6 @@
 #include "xfs_error.h"
 #include "xfs_quota.h"
 #include "xfs_filestream.h"
-#include "xfs_cksum.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
 #include "xfs_symlink.h"
@@ -40,7 +35,6 @@
 #include "xfs_log.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_reflink.h"
-#include "xfs_dir2_priv.h"
 
 kmem_zone_t *xfs_inode_zone;
 
@@ -441,12 +435,12 @@ xfs_lock_inumorder(int lock_mode, int subclass)
  */
 static void
 xfs_lock_inodes(
-       xfs_inode_t     **ips,
-       int             inodes,
-       uint            lock_mode)
+       struct xfs_inode        **ips,
+       int                     inodes,
+       uint                    lock_mode)
 {
-       int             attempts = 0, i, j, try_lock;
-       xfs_log_item_t  *lp;
+       int                     attempts = 0, i, j, try_lock;
+       struct xfs_log_item     *lp;
 
        /*
         * Currently supports between 2 and 5 inodes with exclusive locking.  We
@@ -485,7 +479,7 @@ xfs_lock_inodes(
                 */
                if (!try_lock) {
                        for (j = (i - 1); j >= 0 && !try_lock; j--) {
-                               lp = (xfs_log_item_t *)ips[j]->i_itemp;
+                               lp = &ips[j]->i_itemp->ili_item;
                                if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags))
                                        try_lock++;
                        }
@@ -551,7 +545,7 @@ xfs_lock_two_inodes(
        struct xfs_inode        *temp;
        uint                    mode_temp;
        int                     attempts = 0;
-       xfs_log_item_t          *lp;
+       struct xfs_log_item     *lp;
 
        ASSERT(hweight32(ip0_mode) == 1);
        ASSERT(hweight32(ip1_mode) == 1);
@@ -585,7 +579,7 @@ xfs_lock_two_inodes(
         * the second lock. If we can't get it, we must release the first one
         * and try again.
         */
-       lp = (xfs_log_item_t *)ip0->i_itemp;
+       lp = &ip0->i_itemp->ili_item;
        if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags)) {
                if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(ip1_mode, 1))) {
                        xfs_iunlock(ip0, ip0_mode);
@@ -2537,13 +2531,14 @@ xfs_ifree_cluster(
        xfs_inode_log_item_t    *iip;
        struct xfs_log_item     *lip;
        struct xfs_perag        *pag;
+       struct xfs_ino_geometry *igeo = M_IGEO(mp);
        xfs_ino_t               inum;
 
        inum = xic->first_ino;
        pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, inum));
-       nbufs = mp->m_ialloc_blks / mp->m_blocks_per_cluster;
+       nbufs = igeo->ialloc_blks / igeo->blocks_per_cluster;
 
-       for (j = 0; j < nbufs; j++, inum += mp->m_inodes_per_cluster) {
+       for (j = 0; j < nbufs; j++, inum += igeo->inodes_per_cluster) {
                /*
                 * The allocation bitmap tells us which inodes of the chunk were
                 * physically allocated. Skip the cluster if an inode falls into
@@ -2551,7 +2546,7 @@ xfs_ifree_cluster(
                 */
                ioffset = inum - xic->first_ino;
                if ((xic->alloc & XFS_INOBT_MASK(ioffset)) == 0) {
-                       ASSERT(ioffset % mp->m_inodes_per_cluster == 0);
+                       ASSERT(ioffset % igeo->inodes_per_cluster == 0);
                        continue;
                }
 
@@ -2567,7 +2562,7 @@ xfs_ifree_cluster(
                 * to mark all the active inodes on the buffer stale.
                 */
                bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
-                                       mp->m_bsize * mp->m_blocks_per_cluster,
+                                       mp->m_bsize * igeo->blocks_per_cluster,
                                        XBF_UNMAPPED);
 
                if (!bp)
@@ -2614,7 +2609,7 @@ xfs_ifree_cluster(
                 * transaction stale above, which means there is no point in
                 * even trying to lock them.
                 */
-               for (i = 0; i < mp->m_inodes_per_cluster; i++) {
+               for (i = 0; i < igeo->inodes_per_cluster; i++) {
 retry:
                        rcu_read_lock();
                        ip = radix_tree_lookup(&pag->pag_ici_root,
@@ -3472,28 +3467,27 @@ xfs_iflush_cluster(
        struct xfs_mount        *mp = ip->i_mount;
        struct xfs_perag        *pag;
        unsigned long           first_index, mask;
-       unsigned long           inodes_per_cluster;
        int                     cilist_size;
        struct xfs_inode        **cilist;
        struct xfs_inode        *cip;
+       struct xfs_ino_geometry *igeo = M_IGEO(mp);
        int                     nr_found;
        int                     clcount = 0;
        int                     i;
 
        pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
 
-       inodes_per_cluster = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
-       cilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
+       cilist_size = igeo->inodes_per_cluster * sizeof(struct xfs_inode *);
        cilist = kmem_alloc(cilist_size, KM_MAYFAIL|KM_NOFS);
        if (!cilist)
                goto out_put;
 
-       mask = ~(((mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog)) - 1);
+       mask = ~(igeo->inodes_per_cluster - 1);
        first_index = XFS_INO_TO_AGINO(mp, ip->i_ino) & mask;
        rcu_read_lock();
        /* really need a gang lookup range call here */
        nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)cilist,
-                                       first_index, inodes_per_cluster);
+                                       first_index, igeo->inodes_per_cluster);
        if (nr_found == 0)
                goto out_free;