Merge branch 'master'

12 files changed, 87 insertions, 72 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_file.c b/fs/xfs/linux-2.6/xfs_file.c
index ae4c4754ed31..c847416f6d10 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -252,56 +252,60 @@ xfs_file_sendfile_invis(
 STATIC ssize_t
 xfs_file_splice_read(
         struct file             *infilp,
-        struct inode            *pipe,
+        loff_t                  *ppos,
+        struct pipe_inode_info  *pipe,
         size_t                  len,
         unsigned int            flags)
 {
         vnode_t                 *vp = vn_from_inode(infilp->f_dentry->d_inode);
         ssize_t                 rval;
 
-        VOP_SPLICE_READ(vp, infilp, pipe, len, flags, 0, NULL, rval);
+        VOP_SPLICE_READ(vp, infilp, ppos, pipe, len, flags, 0, NULL, rval);
         return rval;
 }
 
 STATIC ssize_t
 xfs_file_splice_read_invis(
         struct file             *infilp,
-        struct inode            *pipe,
+        loff_t                  *ppos,
+        struct pipe_inode_info  *pipe,
         size_t                  len,
         unsigned int            flags)
 {
         vnode_t                 *vp = vn_from_inode(infilp->f_dentry->d_inode);
         ssize_t                 rval;
 
-        VOP_SPLICE_READ(vp, infilp, pipe, len, flags, IO_INVIS, NULL, rval);
+        VOP_SPLICE_READ(vp, infilp, ppos, pipe, len, flags, IO_INVIS, NULL, rval);
         return rval;
 }
 
 STATIC ssize_t
 xfs_file_splice_write(
-        struct inode            *pipe,
+        struct pipe_inode_info  *pipe,
         struct file             *outfilp,
+        loff_t                  *ppos,
         size_t                  len,
         unsigned int            flags)
 {
         vnode_t                 *vp = vn_from_inode(outfilp->f_dentry->d_inode);
         ssize_t                 rval;
 
-        VOP_SPLICE_WRITE(vp, pipe, outfilp, len, flags, 0, NULL, rval);
+        VOP_SPLICE_WRITE(vp, pipe, outfilp, ppos, len, flags, 0, NULL, rval);
         return rval;
 }
 
 STATIC ssize_t
 xfs_file_splice_write_invis(
-        struct inode            *pipe,
+        struct pipe_inode_info  *pipe,
         struct file             *outfilp,
+        loff_t                  *ppos,
         size_t                  len,
         unsigned int            flags)
 {
         vnode_t                 *vp = vn_from_inode(outfilp->f_dentry->d_inode);
         ssize_t                 rval;
 
-        VOP_SPLICE_WRITE(vp, pipe, outfilp, len, flags, IO_INVIS, NULL, rval);
+        VOP_SPLICE_WRITE(vp, pipe, outfilp, ppos, len, flags, IO_INVIS, NULL, rval);
         return rval;
 }
 
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/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index 90cd314acbaa..67efe3308980 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -338,7 +338,8 @@ ssize_t
 xfs_splice_read(
         bhv_desc_t              *bdp,
         struct file             *infilp,
-        struct inode            *pipe,
+        loff_t                  *ppos,
+        struct pipe_inode_info  *pipe,
         size_t                  count,
         int                     flags,
         int                     ioflags,
@@ -360,7 +361,7 @@ xfs_splice_read(
                 int error;
 
                 error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp),
-                                        infilp->f_pos, count,
+                                        *ppos, count,
                                         FILP_DELAY_FLAG(infilp), &locktype);
                 if (error) {
                         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
@@ -368,8 +369,8 @@ xfs_splice_read(
                 }
         }
         xfs_rw_enter_trace(XFS_SPLICE_READ_ENTER, &ip->i_iocore,
-                           pipe, count, infilp->f_pos, ioflags);
-        ret = generic_file_splice_read(infilp, pipe, count, flags);
+                           pipe, count, *ppos, ioflags);
+        ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
         if (ret > 0)
                 XFS_STATS_ADD(xs_read_bytes, ret);
 
@@ -380,8 +381,9 @@ xfs_splice_read(
 ssize_t
 xfs_splice_write(
         bhv_desc_t              *bdp,
-        struct inode            *pipe,
+        struct pipe_inode_info  *pipe,
         struct file             *outfilp,
+        loff_t                  *ppos,
         size_t                  count,
         int                     flags,
         int                     ioflags,
@@ -403,7 +405,7 @@ xfs_splice_write(
                 int error;
 
                 error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, BHV_TO_VNODE(bdp),
-                                        outfilp->f_pos, count,
+                                        *ppos, count,
                                         FILP_DELAY_FLAG(outfilp), &locktype);
                 if (error) {
                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
@@ -411,8 +413,8 @@ xfs_splice_write(
                 }
         }
         xfs_rw_enter_trace(XFS_SPLICE_WRITE_ENTER, &ip->i_iocore,
-                           pipe, count, outfilp->f_pos, ioflags);
-        ret = generic_file_splice_write(pipe, outfilp, count, flags);
+                           pipe, count, *ppos, ioflags);
+        ret = generic_file_splice_write(pipe, outfilp, ppos, count, flags);
         if (ret > 0)
                 XFS_STATS_ADD(xs_write_bytes, ret);
 
diff --git a/fs/xfs/linux-2.6/xfs_lrw.h b/fs/xfs/linux-2.6/xfs_lrw.h
index eaa5659713fb..8f4539952350 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.h
+++ b/fs/xfs/linux-2.6/xfs_lrw.h
@@ -93,11 +93,11 @@ extern ssize_t xfs_write(struct bhv_desc *, struct kiocb *,
 extern ssize_t xfs_sendfile(struct bhv_desc *, struct file *,
                                 loff_t *, int, size_t, read_actor_t,
                                 void *, struct cred *);
-extern ssize_t xfs_splice_read(struct bhv_desc *, struct file *,
-                                struct inode *, size_t, int, int,
+extern ssize_t xfs_splice_read(struct bhv_desc *, struct file *, loff_t *,
+                                struct pipe_inode_info *, size_t, int, int,
                                 struct cred *);
-extern ssize_t xfs_splice_write(struct bhv_desc *, struct inode *,
-                                struct file *, size_t, int, int,
+extern ssize_t xfs_splice_write(struct bhv_desc *, struct pipe_inode_info *,
+                                struct file *, loff_t *, size_t, int, int,
                                 struct cred *);
 
 #endif  /* __XFS_LRW_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index 6f1c79a28f8b..2a8e16c22353 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -173,11 +173,11 @@ typedef ssize_t (*vop_write_t)(bhv_desc_t *, struct kiocb *,
 typedef ssize_t (*vop_sendfile_t)(bhv_desc_t *, struct file *,
                                 loff_t *, int, size_t, read_actor_t,
                                 void *, struct cred *);
-typedef ssize_t (*vop_splice_read_t)(bhv_desc_t *, struct file *,
-                                struct inode *, size_t, int, int,
+typedef ssize_t (*vop_splice_read_t)(bhv_desc_t *, struct file *, loff_t *,
+                                struct pipe_inode_info *, size_t, int, int,
                                 struct cred *);
-typedef ssize_t (*vop_splice_write_t)(bhv_desc_t *, struct inode *,
-                                struct file *, size_t, int, int,
+typedef ssize_t (*vop_splice_write_t)(bhv_desc_t *, struct pipe_inode_info *,
+                                struct file *, loff_t *, size_t, int, int,
                                 struct cred *);
 typedef int     (*vop_ioctl_t)(bhv_desc_t *, struct inode *, struct file *,
                                 int, unsigned int, void __user *);
@@ -284,10 +284,10 @@ typedef struct vnodeops {
         rv = _VOP_(vop_write, vp)((vp)->v_fbhv,file,iov,segs,offset,ioflags,cr)
 #define VOP_SENDFILE(vp,f,off,ioflags,cnt,act,targ,cr,rv)               \
         rv = _VOP_(vop_sendfile, vp)((vp)->v_fbhv,f,off,ioflags,cnt,act,targ,cr)
-#define VOP_SPLICE_READ(vp,f,pipe,cnt,fl,iofl,cr,rv)                    \
-        rv = _VOP_(vop_splice_read, vp)((vp)->v_fbhv,f,pipe,cnt,fl,iofl,cr)
-#define VOP_SPLICE_WRITE(vp,f,pipe,cnt,fl,iofl,cr,rv)                   \
-        rv = _VOP_(vop_splice_write, vp)((vp)->v_fbhv,f,pipe,cnt,fl,iofl,cr)
+#define VOP_SPLICE_READ(vp,f,o,pipe,cnt,fl,iofl,cr,rv)                  \
+        rv = _VOP_(vop_splice_read, vp)((vp)->v_fbhv,f,o,pipe,cnt,fl,iofl,cr)
+#define VOP_SPLICE_WRITE(vp,f,o,pipe,cnt,fl,iofl,cr,rv)                 \
+        rv = _VOP_(vop_splice_write, vp)((vp)->v_fbhv,f,o,pipe,cnt,fl,iofl,cr)
 #define VOP_BMAP(vp,of,sz,rw,b,n,rv)                                    \
         rv = _VOP_(vop_bmap, vp)((vp)->v_fbhv,of,sz,rw,b,n)
 #define VOP_OPEN(vp, cr, rv)                                            \
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);
         }