8 files changed, 53 insertions, 44 deletions

diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 6cbbd165c60d..4d191ef39b67 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -870,12 +870,14 @@ xfs_page_state_convert(
         pgoff_t                 end_index, last_index, tlast;
         ssize_t                 size, len;
         int                     flags, err, iomap_valid = 0, uptodate = 1;
-        int                     page_dirty, count = 0, trylock_flag = 0;
+        int                     page_dirty, count = 0;
+        int                     trylock = 0;
         int                     all_bh = unmapped;
 
-        /* wait for other IO threads? */
-        if (startio && (wbc->sync_mode == WB_SYNC_NONE && wbc->nonblocking))
-                trylock_flag |= BMAPI_TRYLOCK;
+        if (startio) {
+                if (wbc->sync_mode == WB_SYNC_NONE && wbc->nonblocking)
+                        trylock |= BMAPI_TRYLOCK;
+        }
 
         /* Is this page beyond the end of the file? */
         offset = i_size_read(inode);
@@ -956,15 +958,13 @@ xfs_page_state_convert(
 
                         if (buffer_unwritten(bh)) {
                                 type = IOMAP_UNWRITTEN;
-                                flags = BMAPI_WRITE|BMAPI_IGNSTATE;
+                                flags = BMAPI_WRITE | BMAPI_IGNSTATE;
                         } else if (buffer_delay(bh)) {
                                 type = IOMAP_DELAY;
-                                flags = BMAPI_ALLOCATE;
-                                if (!startio)
-                                        flags |= trylock_flag;
+                                flags = BMAPI_ALLOCATE | trylock;
                         } else {
                                 type = IOMAP_NEW;
-                                flags = BMAPI_WRITE|BMAPI_MMAP;
+                                flags = BMAPI_WRITE | BMAPI_MMAP;
                         }
 
                         if (!iomap_valid) {
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 9fb0312665ca..26fed0756f01 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -182,7 +182,7 @@ free_address(
 {
         a_list_t        *aentry;
 
-        aentry = kmalloc(sizeof(a_list_t), GFP_ATOMIC & ~__GFP_HIGH);
+        aentry = kmalloc(sizeof(a_list_t), GFP_NOWAIT);
         if (likely(aentry)) {
                 spin_lock(&as_lock);
                 aentry->next = as_free_head;
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 149237304fb6..2e2e275c786f 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -673,8 +673,7 @@ xfs_vn_setattr(
         if (ia_valid & ATTR_ATIME) {
                 vattr.va_mask |= XFS_AT_ATIME;
                 vattr.va_atime = attr->ia_atime;
-                if (ia_valid & ATTR_ATIME_SET)
-                        inode->i_atime = attr->ia_atime;
+                inode->i_atime = attr->ia_atime;
         }
         if (ia_valid & ATTR_MTIME) {
                 vattr.va_mask |= XFS_AT_MTIME;
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index 4eeb856183b1..deddbd03c166 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -158,9 +158,10 @@ xfs_ialloc_ag_alloc(
          */
         agi = XFS_BUF_TO_AGI(agbp);
         newino = be32_to_cpu(agi->agi_newino);
-        if(likely(newino != NULLAGINO)) {
-                args.agbno = XFS_AGINO_TO_AGBNO(args.mp, newino) +
-                                XFS_IALLOC_BLOCKS(args.mp);
+        args.agbno = XFS_AGINO_TO_AGBNO(args.mp, newino) +
+                        XFS_IALLOC_BLOCKS(args.mp);
+        if (likely(newino != NULLAGINO &&
+                  (args.agbno < be32_to_cpu(agi->agi_length)))) {
                 args.fsbno = XFS_AGB_TO_FSB(args.mp,
                                 be32_to_cpu(agi->agi_seqno), args.agbno);
                 args.type = XFS_ALLOCTYPE_THIS_BNO;
@@ -182,8 +183,8 @@ xfs_ialloc_ag_alloc(
                  * Set the alignment for the allocation.
                  * If stripe alignment is turned on then align at stripe unit
                  * boundary.
-                 * If the cluster size is smaller than a filesystem block 
-                 * then we're doing I/O for inodes in filesystem block size 
+                 * If the cluster size is smaller than a filesystem block
+                 * then we're doing I/O for inodes in filesystem block size
                  * pieces, so don't need alignment anyway.
                  */
                 isaligned = 0;
@@ -192,7 +193,7 @@ xfs_ialloc_ag_alloc(
                         args.alignment = args.mp->m_dalign;
                         isaligned = 1;
                 } else if (XFS_SB_VERSION_HASALIGN(&args.mp->m_sb) &&
-                           args.mp->m_sb.sb_inoalignmt >= 
+                           args.mp->m_sb.sb_inoalignmt >=
                            XFS_B_TO_FSBT(args.mp,
                                 XFS_INODE_CLUSTER_SIZE(args.mp)))
                                 args.alignment = args.mp->m_sb.sb_inoalignmt;
@@ -220,7 +221,7 @@ xfs_ialloc_ag_alloc(
                 if ((error = xfs_alloc_vextent(&args)))
                         return error;
         }
- 
+
         /*
          * If stripe alignment is turned on, then try again with cluster
          * alignment.
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index bb33113eef9f..b53854325266 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -421,7 +421,10 @@ finish_inode:
                         ip->i_chash = chlnew;
                         chlnew->chl_ip = ip;
                         chlnew->chl_blkno = ip->i_blkno;
+                        if (ch->ch_list)
+                                ch->ch_list->chl_prev = chlnew;
                         chlnew->chl_next = ch->ch_list;
+                        chlnew->chl_prev = NULL;
                         ch->ch_list = chlnew;
                         chlnew = NULL;
                 }
@@ -723,23 +726,15 @@ xfs_iextract(
                 ASSERT(ip->i_cnext == ip && ip->i_cprev == ip);
                 ASSERT(ip->i_chash != NULL);
                 chm=NULL;
-                for (chl = ch->ch_list; chl != NULL; chl = chl->chl_next) {
-                        if (chl->chl_blkno == ip->i_blkno) {
-                                if (chm == NULL) {
-                                        /* first item on the list */
-                                        ch->ch_list = chl->chl_next;
-                                } else {
-                                        chm->chl_next = chl->chl_next;
-                                }
-                                kmem_zone_free(xfs_chashlist_zone, chl);
-                                break;
-                        } else {
-                                ASSERT(chl->chl_ip != ip);
-                                chm = chl;
-                        }
-                }
-                ASSERT_ALWAYS(chl != NULL);
-       } else {
+                chl = ip->i_chash;
+                if (chl->chl_prev)
+                        chl->chl_prev->chl_next = chl->chl_next;
+                else
+                        ch->ch_list = chl->chl_next;
+                if (chl->chl_next)
+                        chl->chl_next->chl_prev = chl->chl_prev;
+                kmem_zone_free(xfs_chashlist_zone, chl);
+        } else {
                 /* delete one inode from a non-empty list */
                 iq = ip->i_cnext;
                 iq->i_cprev = ip->i_cprev;
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 48146bdc6bdd..94b60dd03801 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2732,16 +2732,29 @@ xfs_iunpin(
         ASSERT(atomic_read(&ip->i_pincount) > 0);
 
         if (atomic_dec_and_test(&ip->i_pincount)) {
-                vnode_t *vp = XFS_ITOV_NULL(ip);
+                /*
+                 * If the inode is currently being reclaimed, the
+                 * linux inode _and_ the xfs vnode may have been
+                 * freed so we cannot reference either of them safely.
+                 * Hence we should not try to do anything to them
+                 * if the xfs inode is currently in the reclaim
+                 * path.
+                 *
+                 * However, we still need to issue the unpin wakeup
+                 * call as the inode reclaim may be blocked waiting for
+                 * the inode to become unpinned.
+                 */
+                if (!(ip->i_flags & (XFS_IRECLAIM|XFS_IRECLAIMABLE))) {
+                        vnode_t *vp = XFS_ITOV_NULL(ip);
 
-                /* make sync come back and flush this inode */
-                if (vp) {
-                        struct inode    *inode = vn_to_inode(vp);
+                        /* make sync come back and flush this inode */
+                        if (vp) {
+                                struct inode    *inode = vn_to_inode(vp);
 
-                        if (!(inode->i_state & I_NEW))
-                                mark_inode_dirty_sync(inode);
+                                if (!(inode->i_state & I_NEW))
+                                        mark_inode_dirty_sync(inode);
+                        }
                 }
-
                 wake_up(&ip->i_ipin_wait);
         }
 }
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 39ef9c36ea55..3b544db1790b 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -189,6 +189,7 @@ typedef struct xfs_ihash {
  */
 typedef struct xfs_chashlist {
         struct xfs_chashlist    *chl_next;
+        struct xfs_chashlist    *chl_prev;
         struct xfs_inode        *chl_ip;
         xfs_daddr_t             chl_blkno;      /* starting block number of
                                                  * the cluster */
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 049fabb7f7e0..c0b1c2906880 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -270,7 +270,7 @@ xfs_mount_validate_sb(
             (sbp->sb_blocklog - sbp->sb_inodelog != sbp->sb_inopblog)   ||
             (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE)  ||
             (sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE)  ||
-            (sbp->sb_imax_pct > 100 || sbp->sb_imax_pct < 1))) {
+            (sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */))) {
                 xfs_fs_mount_cmn_err(flags, "SB sanity check 1 failed");
                 return XFS_ERROR(EFSCORRUPTED);
         }