Merge git://oss.sgi.com:8090/oss/git/xfs-2.6

1 files changed, 91 insertions, 102 deletions

diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index e92cacde02f..8076cc981e1 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -185,8 +185,7 @@ xfs_getattr(
                 break;
         }
 
-        vap->va_atime.tv_sec = ip->i_d.di_atime.t_sec;
-        vap->va_atime.tv_nsec = ip->i_d.di_atime.t_nsec;
+        vn_atime_to_timespec(vp, &vap->va_atime);
         vap->va_mtime.tv_sec = ip->i_d.di_mtime.t_sec;
         vap->va_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
         vap->va_ctime.tv_sec = ip->i_d.di_ctime.t_sec;
@@ -544,24 +543,6 @@ xfs_setattr(
                 }
 
                 /*
-                 * Can't set extent size unless the file is marked, or
-                 * about to be marked as a realtime file.
-                 *
-                 * This check will be removed when fixed size extents
-                 * with buffered data writes is implemented.
-                 *
-                 */
-                if ((mask & XFS_AT_EXTSIZE)                     &&
-                    ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
-                     vap->va_extsize) &&
-                    (!((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) ||
-                       ((mask & XFS_AT_XFLAGS) &&
-                        (vap->va_xflags & XFS_XFLAG_REALTIME))))) {
-                        code = XFS_ERROR(EINVAL);
-                        goto error_return;
-                }
-
-                /*
                  * Can't change realtime flag if any extents are allocated.
                  */
                 if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
@@ -823,13 +804,17 @@ xfs_setattr(
                                         di_flags |= XFS_DIFLAG_RTINHERIT;
                                 if (vap->va_xflags & XFS_XFLAG_NOSYMLINKS)
                                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
-                        } else {
+                                if (vap->va_xflags & XFS_XFLAG_EXTSZINHERIT)
+                                        di_flags |= XFS_DIFLAG_EXTSZINHERIT;
+                        } else if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
                                 if (vap->va_xflags & XFS_XFLAG_REALTIME) {
                                         di_flags |= XFS_DIFLAG_REALTIME;
                                         ip->i_iocore.io_flags |= XFS_IOCORE_RT;
                                 } else {
                                         ip->i_iocore.io_flags &= ~XFS_IOCORE_RT;
                                 }
+                                if (vap->va_xflags & XFS_XFLAG_EXTSIZE)
+                                        di_flags |= XFS_DIFLAG_EXTSIZE;
                         }
                         ip->i_d.di_flags = di_flags;
                 }
@@ -999,10 +984,6 @@ xfs_readlink(
                 goto error_return;
         }
 
-        if (!(ioflags & IO_INVIS)) {
-                xfs_ichgtime(ip, XFS_ICHGTIME_ACC);
-        }
-
         /*
          * See if the symlink is stored inline.
          */
@@ -1234,7 +1215,8 @@ xfs_inactive_free_eofblocks(
         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 
         if (!error && (nimaps != 0) &&
-            (imap.br_startblock != HOLESTARTBLOCK)) {
+            (imap.br_startblock != HOLESTARTBLOCK ||
+             ip->i_delayed_blks)) {
                 /*
                  * Attach the dquots to the inode up front.
                  */
@@ -1569,9 +1551,11 @@ xfs_release(
 
         if (ip->i_d.di_nlink != 0) {
                 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
-                     ((ip->i_d.di_size > 0) || (VN_CACHED(vp) > 0)) &&
+                     ((ip->i_d.di_size > 0) || (VN_CACHED(vp) > 0 ||
+                       ip->i_delayed_blks > 0)) &&
                      (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
-                    (!(ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC|XFS_DIFLAG_APPEND)))) {
+                    (!(ip->i_d.di_flags &
+                                (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
                         if ((error = xfs_inactive_free_eofblocks(mp, ip)))
                                 return (error);
                         /* Update linux inode block count after free above */
@@ -1628,7 +1612,8 @@ xfs_inactive(
          * only one with a reference to the inode.
          */
         truncate = ((ip->i_d.di_nlink == 0) &&
-            ((ip->i_d.di_size != 0) || (ip->i_d.di_nextents > 0)) &&
+            ((ip->i_d.di_size != 0) || (ip->i_d.di_nextents > 0) ||
+             (ip->i_delayed_blks > 0)) &&
             ((ip->i_d.di_mode & S_IFMT) == S_IFREG));
 
         mp = ip->i_mount;
@@ -1646,10 +1631,12 @@ xfs_inactive(
 
         if (ip->i_d.di_nlink != 0) {
                 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
-                     ((ip->i_d.di_size > 0) || (VN_CACHED(vp) > 0)) &&
-                     (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
-                    (!(ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC|XFS_DIFLAG_APPEND)) ||
-                     (ip->i_delayed_blks != 0))) {
+                     ((ip->i_d.di_size > 0) || (VN_CACHED(vp) > 0 ||
+                       ip->i_delayed_blks > 0)) &&
+                      (ip->i_df.if_flags & XFS_IFEXTENTS) &&
+                     (!(ip->i_d.di_flags &
+                                (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) ||
+                      (ip->i_delayed_blks != 0)))) {
                         if ((error = xfs_inactive_free_eofblocks(mp, ip)))
                                 return (VN_INACTIVE_CACHE);
                         /* Update linux inode block count after free above */
@@ -2593,7 +2580,6 @@ xfs_link(
         int                     cancel_flags;
         int                     committed;
         vnode_t                 *target_dir_vp;
-        bhv_desc_t              *src_bdp;
         int                     resblks;
         char                    *target_name = VNAME(dentry);
         int                     target_namelen;
@@ -2606,8 +2592,7 @@ xfs_link(
         if (VN_ISDIR(src_vp))
                 return XFS_ERROR(EPERM);
 
-        src_bdp = vn_bhv_lookup_unlocked(VN_BHV_HEAD(src_vp), &xfs_vnodeops);
-        sip = XFS_BHVTOI(src_bdp);
+        sip = xfs_vtoi(src_vp);
         tdp = XFS_BHVTOI(target_dir_bdp);
         mp = tdp->i_mount;
         if (XFS_FORCED_SHUTDOWN(mp))
@@ -3240,7 +3225,6 @@ xfs_readdir(
         xfs_trans_t     *tp = NULL;
         int             error = 0;
         uint            lock_mode;
-        xfs_off_t       start_offset;
 
         vn_trace_entry(BHV_TO_VNODE(dir_bdp), __FUNCTION__,
                                                (inst_t *)__return_address);
@@ -3251,11 +3235,7 @@ xfs_readdir(
         }
 
         lock_mode = xfs_ilock_map_shared(dp);
-        start_offset = uiop->uio_offset;
         error = XFS_DIR_GETDENTS(dp->i_mount, tp, dp, uiop, eofp);
-        if (start_offset != uiop->uio_offset) {
-                xfs_ichgtime(dp, XFS_ICHGTIME_ACC);
-        }
         xfs_iunlock_map_shared(dp, lock_mode);
         return error;
 }
@@ -3832,7 +3812,12 @@ xfs_reclaim(
         vn_iowait(vp);
 
         ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
-        ASSERT(VN_CACHED(vp) == 0);
+
+        /*
+         * Make sure the atime in the XFS inode is correct before freeing the
+         * Linux inode.
+         */
+        xfs_synchronize_atime(ip);
 
         /* If we have nothing to flush with this inode then complete the
          * teardown now, otherwise break the link between the xfs inode
@@ -4002,42 +3987,36 @@ xfs_alloc_file_space(
         int                     alloc_type,
         int                     attr_flags)
 {
+        xfs_mount_t             *mp = ip->i_mount;
+        xfs_off_t               count;
         xfs_filblks_t           allocated_fsb;
         xfs_filblks_t           allocatesize_fsb;
-        int                     committed;
-        xfs_off_t               count;
-        xfs_filblks_t           datablocks;
-        int                     error;
+        xfs_extlen_t            extsz, temp;
+        xfs_fileoff_t           startoffset_fsb;
         xfs_fsblock_t           firstfsb;
-        xfs_bmap_free_t         free_list;
-        xfs_bmbt_irec_t         *imapp;
-        xfs_bmbt_irec_t         imaps[1];
-        xfs_mount_t             *mp;
-        int                     numrtextents;
-        int                     reccount;
-        uint                    resblks;
+        int                     nimaps;
+        int                     bmapi_flag;
+        int                     quota_flag;
         int                     rt;
-        int                     rtextsize;
-        xfs_fileoff_t           startoffset_fsb;
         xfs_trans_t             *tp;
-        int                     xfs_bmapi_flags;
+        xfs_bmbt_irec_t         imaps[1], *imapp;
+        xfs_bmap_free_t         free_list;
+        uint                    qblocks, resblks, resrtextents;
+        int                     committed;
+        int                     error;
 
         vn_trace_entry(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
-        mp = ip->i_mount;
 
         if (XFS_FORCED_SHUTDOWN(mp))
                 return XFS_ERROR(EIO);
 
-        /*
-         * determine if this is a realtime file
-         */
-        if ((rt = XFS_IS_REALTIME_INODE(ip)) != 0) {
-                if (ip->i_d.di_extsize)
-                        rtextsize = ip->i_d.di_extsize;
-                else
-                        rtextsize = mp->m_sb.sb_rextsize;
-        } else
-                rtextsize = 0;
+        rt = XFS_IS_REALTIME_INODE(ip);
+        if (unlikely(rt)) {
+                if (!(extsz = ip->i_d.di_extsize))
+                        extsz = mp->m_sb.sb_rextsize;
+        } else {
+                extsz = ip->i_d.di_extsize;
+        }
 
         if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
                 return error;
@@ -4048,8 +4027,8 @@ xfs_alloc_file_space(
         count = len;
         error = 0;
         imapp = &imaps[0];
-        reccount = 1;
-        xfs_bmapi_flags = XFS_BMAPI_WRITE | (alloc_type ? XFS_BMAPI_PREALLOC : 0);
+        nimaps = 1;
+        bmapi_flag = XFS_BMAPI_WRITE | (alloc_type ? XFS_BMAPI_PREALLOC : 0);
         startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
         allocatesize_fsb = XFS_B_TO_FSB(mp, count);
 
@@ -4070,43 +4049,51 @@ xfs_alloc_file_space(
         }
 
         /*
-         * allocate file space until done or until there is an error
+         * Allocate file space until done or until there is an error
          */
 retry:
         while (allocatesize_fsb && !error) {
+                xfs_fileoff_t   s, e;
+
                 /*
-                 * determine if reserving space on
-                 * the data or realtime partition.
+                 * Determine space reservations for data/realtime.
                  */
-                if (rt) {
-                        xfs_fileoff_t s, e;
-
+                if (unlikely(extsz)) {
                         s = startoffset_fsb;
-                        do_div(s, rtextsize);
-                        s *= rtextsize;
-                        e = roundup_64(startoffset_fsb + allocatesize_fsb,
-                                rtextsize);
-                        numrtextents = (int)(e - s) / mp->m_sb.sb_rextsize;
-                        datablocks = 0;
+                        do_div(s, extsz);
+                        s *= extsz;
+                        e = startoffset_fsb + allocatesize_fsb;
+                        if ((temp = do_mod(startoffset_fsb, extsz)))
+                                e += temp;
+                        if ((temp = do_mod(e, extsz)))
+                                e += extsz - temp;
+                } else {
+                        s = 0;
+                        e = allocatesize_fsb;
+                }
+
+                if (unlikely(rt)) {
+                        resrtextents = qblocks = (uint)(e - s);
+                        resrtextents /= mp->m_sb.sb_rextsize;
+                        resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
+                        quota_flag = XFS_QMOPT_RES_RTBLKS;
                 } else {
-                        datablocks = allocatesize_fsb;
-                        numrtextents = 0;
+                        resrtextents = 0;
+                        resblks = qblocks = \
+                                XFS_DIOSTRAT_SPACE_RES(mp, (uint)(e - s));
+                        quota_flag = XFS_QMOPT_RES_REGBLKS;
                 }
 
                 /*
-                 * allocate and setup the transaction
+                 * Allocate and setup the transaction.
                  */
                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
-                resblks = XFS_DIOSTRAT_SPACE_RES(mp, datablocks);
-                error = xfs_trans_reserve(tp,
-                                          resblks,
-                                          XFS_WRITE_LOG_RES(mp),
-                                          numrtextents,
+                error = xfs_trans_reserve(tp, resblks,
+                                          XFS_WRITE_LOG_RES(mp), resrtextents,
                                           XFS_TRANS_PERM_LOG_RES,
                                           XFS_WRITE_LOG_COUNT);
-
                 /*
-                 * check for running out of space
+                 * Check for running out of space
                  */
                 if (error) {
                         /*
@@ -4117,8 +4104,8 @@ retry:
                         break;
                 }
                 xfs_ilock(ip, XFS_ILOCK_EXCL);
-                error = XFS_TRANS_RESERVE_QUOTA(mp, tp,
-                                ip->i_udquot, ip->i_gdquot, resblks, 0, 0);
+                error = XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, tp, ip,
+                                                      qblocks, 0, quota_flag);
                 if (error)
                         goto error1;
 
@@ -4126,19 +4113,19 @@ retry:
                 xfs_trans_ihold(tp, ip);
 
                 /*
-                 * issue the bmapi() call to allocate the blocks
+                 * Issue the xfs_bmapi() call to allocate the blocks
                  */
                 XFS_BMAP_INIT(&free_list, &firstfsb);
                 error = xfs_bmapi(tp, ip, startoffset_fsb,
-                                  allocatesize_fsb, xfs_bmapi_flags,
-                                  &firstfsb, 0, imapp, &reccount,
+                                  allocatesize_fsb, bmapi_flag,
+                                  &firstfsb, 0, imapp, &nimaps,
                                   &free_list);
                 if (error) {
                         goto error0;
                 }
 
                 /*
-                 * complete the transaction
+                 * Complete the transaction
                  */
                 error = xfs_bmap_finish(&tp, &free_list, firstfsb, &committed);
                 if (error) {
@@ -4153,7 +4140,7 @@ retry:
 
                 allocated_fsb = imapp->br_blockcount;
 
-                if (reccount == 0) {
+                if (nimaps == 0) {
                         error = XFS_ERROR(ENOSPC);
                         break;
                 }
@@ -4176,9 +4163,11 @@ dmapi_enospc_check:
 
         return error;
 
- error0:
+error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
         xfs_bmap_cancel(&free_list);
- error1:
+        XFS_TRANS_UNRESERVE_QUOTA_NBLKS(mp, tp, ip, qblocks, 0, quota_flag);
+
+error1: /* Just cancel transaction */
         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
         goto dmapi_enospc_check;
@@ -4423,8 +4412,8 @@ xfs_free_file_space(
                 }
                 xfs_ilock(ip, XFS_ILOCK_EXCL);
                 error = XFS_TRANS_RESERVE_QUOTA(mp, tp,
-                                ip->i_udquot, ip->i_gdquot, resblks, 0, rt ?
-                                XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS);
+                                ip->i_udquot, ip->i_gdquot, resblks, 0,
+                                XFS_QMOPT_RES_REGBLKS);
                 if (error)
                         goto error1;