xfs: kill xfs_vnodeops.[ch]

Now we have xfs_inode.c for holding kernel-only XFS inode
operations, move all the inode operations from xfs_vnodeops.c to
this new file as it holds another set of kernel-only inode
operations. The name of this file traces back to the days of Irix
and it's vnodes which we don't have anymore.

Essentially this move consolidates the inode locking functions
and a bunch of XFS inode operations into the one file. Eventually
the high level functions will be merged into the VFS interface
functions in xfs_iops.c.

This leaves only internal preallocation, EOF block manipulation and
hole punching functions in vnodeops.c. Move these to xfs_bmap_util.c
where we are already consolidating various in-kernel physical extent
manipulation and querying functions.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

1 files changed, 861 insertions, 0 deletions

diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index 8e48ddf1c11c..f557022bd0e7 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
+ * Copyright (c) 2012 Red Hat, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -41,6 +42,7 @@
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
 #include "xfs_trace.h"
+#include "xfs_icache.h"
 
 /* Kernel only BMAP related definitions and functions */
 
@@ -832,3 +834,862 @@ next_block:
 
         return error;
 }
+
+/*
+ * Test whether it is appropriate to check an inode for and free post EOF
+ * blocks. The 'force' parameter determines whether we should also consider
+ * regular files that are marked preallocated or append-only.
+ */
+bool
+xfs_can_free_eofblocks(struct xfs_inode *ip, bool force)
+{
+        /* prealloc/delalloc exists only on regular files */
+        if (!S_ISREG(ip->i_d.di_mode))
+                return false;
+
+        /*
+         * Zero sized files with no cached pages and delalloc blocks will not
+         * have speculative prealloc/delalloc blocks to remove.
+         */
+        if (VFS_I(ip)->i_size == 0 &&
+            VN_CACHED(VFS_I(ip)) == 0 &&
+            ip->i_delayed_blks == 0)
+                return false;
+
+        /* If we haven't read in the extent list, then don't do it now. */
+        if (!(ip->i_df.if_flags & XFS_IFEXTENTS))
+                return false;
+
+        /*
+         * Do not free real preallocated or append-only files unless the file
+         * has delalloc blocks and we are forced to remove them.
+         */
+        if (ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
+                if (!force || ip->i_delayed_blks == 0)
+                        return false;
+
+        return true;
+}
+
+/*
+ * This is called by xfs_inactive to free any blocks beyond eof
+ * when the link count isn't zero and by xfs_dm_punch_hole() when
+ * punching a hole to EOF.
+ */
+int
+xfs_free_eofblocks(
+        xfs_mount_t     *mp,
+        xfs_inode_t     *ip,
+        bool            need_iolock)
+{
+        xfs_trans_t     *tp;
+        int             error;
+        xfs_fileoff_t   end_fsb;
+        xfs_fileoff_t   last_fsb;
+        xfs_filblks_t   map_len;
+        int             nimaps;
+        xfs_bmbt_irec_t imap;
+
+        /*
+         * Figure out if there are any blocks beyond the end
+         * of the file.  If not, then there is nothing to do.
+         */
+        end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
+        last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
+        if (last_fsb <= end_fsb)
+                return 0;
+        map_len = last_fsb - end_fsb;
+
+        nimaps = 1;
+        xfs_ilock(ip, XFS_ILOCK_SHARED);
+        error = xfs_bmapi_read(ip, end_fsb, map_len, &imap, &nimaps, 0);
+        xfs_iunlock(ip, XFS_ILOCK_SHARED);
+
+        if (!error && (nimaps != 0) &&
+            (imap.br_startblock != HOLESTARTBLOCK ||
+             ip->i_delayed_blks)) {
+                /*
+                 * Attach the dquots to the inode up front.
+                 */
+                error = xfs_qm_dqattach(ip, 0);
+                if (error)
+                        return error;
+
+                /*
+                 * There are blocks after the end of file.
+                 * Free them up now by truncating the file to
+                 * its current size.
+                 */
+                tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
+
+                if (need_iolock) {
+                        if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
+                                xfs_trans_cancel(tp, 0);
+                                return EAGAIN;
+                        }
+                }
+
+                error = xfs_trans_reserve(tp, 0,
+                                          XFS_ITRUNCATE_LOG_RES(mp),
+                                          0, XFS_TRANS_PERM_LOG_RES,
+                                          XFS_ITRUNCATE_LOG_COUNT);
+                if (error) {
+                        ASSERT(XFS_FORCED_SHUTDOWN(mp));
+                        xfs_trans_cancel(tp, 0);
+                        if (need_iolock)
+                                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+                        return error;
+                }
+
+                xfs_ilock(ip, XFS_ILOCK_EXCL);
+                xfs_trans_ijoin(tp, ip, 0);
+
+                /*
+                 * Do not update the on-disk file size.  If we update the
+                 * on-disk file size and then the system crashes before the
+                 * contents of the file are flushed to disk then the files
+                 * may be full of holes (ie NULL files bug).
+                 */
+                error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK,
+                                              XFS_ISIZE(ip));
+                if (error) {
+                        /*
+                         * If we get an error at this point we simply don't
+                         * bother truncating the file.
+                         */
+                        xfs_trans_cancel(tp,
+                                         (XFS_TRANS_RELEASE_LOG_RES |
+                                          XFS_TRANS_ABORT));
+                } else {
+                        error = xfs_trans_commit(tp,
+                                                XFS_TRANS_RELEASE_LOG_RES);
+                        if (!error)
+                                xfs_inode_clear_eofblocks_tag(ip);
+                }
+
+                xfs_iunlock(ip, XFS_ILOCK_EXCL);
+                if (need_iolock)
+                        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+        }
+        return error;
+}
+
+/*
+ * xfs_alloc_file_space()
+ *      This routine allocates disk space for the given file.
+ *
+ *      If alloc_type == 0, this request is for an ALLOCSP type
+ *      request which will change the file size.  In this case, no
+ *      DMAPI event will be generated by the call.  A TRUNCATE event
+ *      will be generated later by xfs_setattr.
+ *
+ *      If alloc_type != 0, this request is for a RESVSP type
+ *      request, and a DMAPI DM_EVENT_WRITE will be generated if the
+ *      lower block boundary byte address is less than the file's
+ *      length.
+ *
+ * RETURNS:
+ *       0 on success
+ *      errno on error
+ *
+ */
+STATIC int
+xfs_alloc_file_space(
+        xfs_inode_t             *ip,
+        xfs_off_t               offset,
+        xfs_off_t               len,
+        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;
+        xfs_extlen_t            extsz, temp;
+        xfs_fileoff_t           startoffset_fsb;
+        xfs_fsblock_t           firstfsb;
+        int                     nimaps;
+        int                     quota_flag;
+        int                     rt;
+        xfs_trans_t             *tp;
+        xfs_bmbt_irec_t         imaps[1], *imapp;
+        xfs_bmap_free_t         free_list;
+        uint                    qblocks, resblks, resrtextents;
+        int                     committed;
+        int                     error;
+
+        trace_xfs_alloc_file_space(ip);
+
+        if (XFS_FORCED_SHUTDOWN(mp))
+                return XFS_ERROR(EIO);
+
+        error = xfs_qm_dqattach(ip, 0);
+        if (error)
+                return error;
+
+        if (len <= 0)
+                return XFS_ERROR(EINVAL);
+
+        rt = XFS_IS_REALTIME_INODE(ip);
+        extsz = xfs_get_extsz_hint(ip);
+
+        count = len;
+        imapp = &imaps[0];
+        nimaps = 1;
+        startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
+        allocatesize_fsb = XFS_B_TO_FSB(mp, count);
+
+        /*
+         * Allocate file space until done or until there is an error
+         */
+        while (allocatesize_fsb && !error) {
+                xfs_fileoff_t   s, e;
+
+                /*
+                 * Determine space reservations for data/realtime.
+                 */
+                if (unlikely(extsz)) {
+                        s = startoffset_fsb;
+                        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;
+                }
+
+                /*
+                 * The transaction reservation is limited to a 32-bit block
+                 * count, hence we need to limit the number of blocks we are
+                 * trying to reserve to avoid an overflow. We can't allocate
+                 * more than @nimaps extents, and an extent is limited on disk
+                 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
+                 */
+                resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps));
+                if (unlikely(rt)) {
+                        resrtextents = qblocks = resblks;
+                        resrtextents /= mp->m_sb.sb_rextsize;
+                        resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
+                        quota_flag = XFS_QMOPT_RES_RTBLKS;
+                } else {
+                        resrtextents = 0;
+                        resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
+                        quota_flag = XFS_QMOPT_RES_REGBLKS;
+                }
+
+                /*
+                 * Allocate and setup the transaction.
+                 */
+                tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
+                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
+                 */
+                if (error) {
+                        /*
+                         * Free the transaction structure.
+                         */
+                        ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
+                        xfs_trans_cancel(tp, 0);
+                        break;
+                }
+                xfs_ilock(ip, XFS_ILOCK_EXCL);
+                error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks,
+                                                      0, quota_flag);
+                if (error)
+                        goto error1;
+
+                xfs_trans_ijoin(tp, ip, 0);
+
+                xfs_bmap_init(&free_list, &firstfsb);
+                error = xfs_bmapi_write(tp, ip, startoffset_fsb,
+                                        allocatesize_fsb, alloc_type, &firstfsb,
+                                        0, imapp, &nimaps, &free_list);
+                if (error) {
+                        goto error0;
+                }
+
+                /*
+                 * Complete the transaction
+                 */
+                error = xfs_bmap_finish(&tp, &free_list, &committed);
+                if (error) {
+                        goto error0;
+                }
+
+                error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
+                xfs_iunlock(ip, XFS_ILOCK_EXCL);
+                if (error) {
+                        break;
+                }
+
+                allocated_fsb = imapp->br_blockcount;
+
+                if (nimaps == 0) {
+                        error = XFS_ERROR(ENOSPC);
+                        break;
+                }
+
+                startoffset_fsb += allocated_fsb;
+                allocatesize_fsb -= allocated_fsb;
+        }
+
+        return error;
+
+error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
+        xfs_bmap_cancel(&free_list);
+        xfs_trans_unreserve_quota_nblks(tp, ip, (long)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);
+        return error;
+}
+
+/*
+ * Zero file bytes between startoff and endoff inclusive.
+ * The iolock is held exclusive and no blocks are buffered.
+ *
+ * This function is used by xfs_free_file_space() to zero
+ * partial blocks when the range to free is not block aligned.
+ * When unreserving space with boundaries that are not block
+ * aligned we round up the start and round down the end
+ * boundaries and then use this function to zero the parts of
+ * the blocks that got dropped during the rounding.
+ */
+STATIC int
+xfs_zero_remaining_bytes(
+        xfs_inode_t             *ip,
+        xfs_off_t               startoff,
+        xfs_off_t               endoff)
+{
+        xfs_bmbt_irec_t         imap;
+        xfs_fileoff_t           offset_fsb;
+        xfs_off_t               lastoffset;
+        xfs_off_t               offset;
+        xfs_buf_t               *bp;
+        xfs_mount_t             *mp = ip->i_mount;
+        int                     nimap;
+        int                     error = 0;
+
+        /*
+         * Avoid doing I/O beyond eof - it's not necessary
+         * since nothing can read beyond eof.  The space will
+         * be zeroed when the file is extended anyway.
+         */
+        if (startoff >= XFS_ISIZE(ip))
+                return 0;
+
+        if (endoff > XFS_ISIZE(ip))
+                endoff = XFS_ISIZE(ip);
+
+        bp = xfs_buf_get_uncached(XFS_IS_REALTIME_INODE(ip) ?
+                                        mp->m_rtdev_targp : mp->m_ddev_targp,
+                                  BTOBB(mp->m_sb.sb_blocksize), 0);
+        if (!bp)
+                return XFS_ERROR(ENOMEM);
+
+        xfs_buf_unlock(bp);
+
+        for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
+                offset_fsb = XFS_B_TO_FSBT(mp, offset);
+                nimap = 1;
+                error = xfs_bmapi_read(ip, offset_fsb, 1, &imap, &nimap, 0);
+                if (error || nimap < 1)
+                        break;
+                ASSERT(imap.br_blockcount >= 1);
+                ASSERT(imap.br_startoff == offset_fsb);
+                lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
+                if (lastoffset > endoff)
+                        lastoffset = endoff;
+                if (imap.br_startblock == HOLESTARTBLOCK)
+                        continue;
+                ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
+                if (imap.br_state == XFS_EXT_UNWRITTEN)
+                        continue;
+                XFS_BUF_UNDONE(bp);
+                XFS_BUF_UNWRITE(bp);
+                XFS_BUF_READ(bp);
+                XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
+                xfsbdstrat(mp, bp);
+                error = xfs_buf_iowait(bp);
+                if (error) {
+                        xfs_buf_ioerror_alert(bp,
+                                        "xfs_zero_remaining_bytes(read)");
+                        break;
+                }
+                memset(bp->b_addr +
+                        (offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
+                      0, lastoffset - offset + 1);
+                XFS_BUF_UNDONE(bp);
+                XFS_BUF_UNREAD(bp);
+                XFS_BUF_WRITE(bp);
+                xfsbdstrat(mp, bp);
+                error = xfs_buf_iowait(bp);
+                if (error) {
+                        xfs_buf_ioerror_alert(bp,
+                                        "xfs_zero_remaining_bytes(write)");
+                        break;
+                }
+        }
+        xfs_buf_free(bp);
+        return error;
+}
+
+/*
+ * xfs_free_file_space()
+ *      This routine frees disk space for the given file.
+ *
+ *      This routine is only called by xfs_change_file_space
+ *      for an UNRESVSP type call.
+ *
+ * RETURNS:
+ *       0 on success
+ *      errno on error
+ *
+ */
+STATIC int
+xfs_free_file_space(
+        xfs_inode_t             *ip,
+        xfs_off_t               offset,
+        xfs_off_t               len,
+        int                     attr_flags)
+{
+        int                     committed;
+        int                     done;
+        xfs_fileoff_t           endoffset_fsb;
+        int                     error;
+        xfs_fsblock_t           firstfsb;
+        xfs_bmap_free_t         free_list;
+        xfs_bmbt_irec_t         imap;
+        xfs_off_t               ioffset;
+        xfs_extlen_t            mod=0;
+        xfs_mount_t             *mp;
+        int                     nimap;
+        uint                    resblks;
+        xfs_off_t               rounding;
+        int                     rt;
+        xfs_fileoff_t           startoffset_fsb;
+        xfs_trans_t             *tp;
+        int                     need_iolock = 1;
+
+        mp = ip->i_mount;
+
+        trace_xfs_free_file_space(ip);
+
+        error = xfs_qm_dqattach(ip, 0);
+        if (error)
+                return error;
+
+        error = 0;
+        if (len <= 0)   /* if nothing being freed */
+                return error;
+        rt = XFS_IS_REALTIME_INODE(ip);
+        startoffset_fsb = XFS_B_TO_FSB(mp, offset);
+        endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
+
+        if (attr_flags & XFS_ATTR_NOLOCK)
+                need_iolock = 0;
+        if (need_iolock) {
+                xfs_ilock(ip, XFS_IOLOCK_EXCL);
+                /* wait for the completion of any pending DIOs */
+                inode_dio_wait(VFS_I(ip));
+        }
+
+        rounding = max_t(xfs_off_t, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
+        ioffset = offset & ~(rounding - 1);
+        error = -filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
+                                              ioffset, -1);
+        if (error)
+                goto out_unlock_iolock;
+        truncate_pagecache_range(VFS_I(ip), ioffset, -1);
+
+        /*
+         * Need to zero the stuff we're not freeing, on disk.
+         * If it's a realtime file & can't use unwritten extents then we
+         * actually need to zero the extent edges.  Otherwise xfs_bunmapi
+         * will take care of it for us.
+         */
+        if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
+                nimap = 1;
+                error = xfs_bmapi_read(ip, startoffset_fsb, 1,
+                                        &imap, &nimap, 0);
+                if (error)
+                        goto out_unlock_iolock;
+                ASSERT(nimap == 0 || nimap == 1);
+                if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
+                        xfs_daddr_t     block;
+
+                        ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
+                        block = imap.br_startblock;
+                        mod = do_div(block, mp->m_sb.sb_rextsize);
+                        if (mod)
+                                startoffset_fsb += mp->m_sb.sb_rextsize - mod;
+                }
+                nimap = 1;
+                error = xfs_bmapi_read(ip, endoffset_fsb - 1, 1,
+                                        &imap, &nimap, 0);
+                if (error)
+                        goto out_unlock_iolock;
+                ASSERT(nimap == 0 || nimap == 1);
+                if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
+                        ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
+                        mod++;
+                        if (mod && (mod != mp->m_sb.sb_rextsize))
+                                endoffset_fsb -= mod;
+                }
+        }
+        if ((done = (endoffset_fsb <= startoffset_fsb)))
+                /*
+                 * One contiguous piece to clear
+                 */
+                error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
+        else {
+                /*
+                 * Some full blocks, possibly two pieces to clear
+                 */
+                if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
+                        error = xfs_zero_remaining_bytes(ip, offset,
+                                XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
+                if (!error &&
+                    XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
+                        error = xfs_zero_remaining_bytes(ip,
+                                XFS_FSB_TO_B(mp, endoffset_fsb),
+                                offset + len - 1);
+        }
+
+        /*
+         * free file space until done or until there is an error
+         */
+        resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
+        while (!error && !done) {
+
+                /*
+                 * allocate and setup the transaction. Allow this
+                 * transaction to dip into the reserve blocks to ensure
+                 * the freeing of the space succeeds at ENOSPC.
+                 */
+                tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
+                tp->t_flags |= XFS_TRANS_RESERVE;
+                error = xfs_trans_reserve(tp,
+                                          resblks,
+                                          XFS_WRITE_LOG_RES(mp),
+                                          0,
+                                          XFS_TRANS_PERM_LOG_RES,
+                                          XFS_WRITE_LOG_COUNT);
+
+                /*
+                 * check for running out of space
+                 */
+                if (error) {
+                        /*
+                         * Free the transaction structure.
+                         */
+                        ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
+                        xfs_trans_cancel(tp, 0);
+                        break;
+                }
+                xfs_ilock(ip, XFS_ILOCK_EXCL);
+                error = xfs_trans_reserve_quota(tp, mp,
+                                ip->i_udquot, ip->i_gdquot, ip->i_pdquot,
+                                resblks, 0, XFS_QMOPT_RES_REGBLKS);
+                if (error)
+                        goto error1;
+
+                xfs_trans_ijoin(tp, ip, 0);
+
+                /*
+                 * issue the bunmapi() call to free the blocks
+                 */
+                xfs_bmap_init(&free_list, &firstfsb);
+                error = xfs_bunmapi(tp, ip, startoffset_fsb,
+                                  endoffset_fsb - startoffset_fsb,
+                                  0, 2, &firstfsb, &free_list, &done);
+                if (error) {
+                        goto error0;
+                }
+
+                /*
+                 * complete the transaction
+                 */
+                error = xfs_bmap_finish(&tp, &free_list, &committed);
+                if (error) {
+                        goto error0;
+                }
+
+                error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
+                xfs_iunlock(ip, XFS_ILOCK_EXCL);
+        }
+
+ out_unlock_iolock:
+        if (need_iolock)
+                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+        return error;
+
+ error0:
+        xfs_bmap_cancel(&free_list);
+ error1:
+        xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
+        xfs_iunlock(ip, need_iolock ? (XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL) :
+                    XFS_ILOCK_EXCL);
+        return error;
+}
+
+
+STATIC int
+xfs_zero_file_space(
+        struct xfs_inode        *ip,
+        xfs_off_t               offset,
+        xfs_off_t               len,
+        int                     attr_flags)
+{
+        struct xfs_mount        *mp = ip->i_mount;
+        uint                    granularity;
+        xfs_off_t               start_boundary;
+        xfs_off_t               end_boundary;
+        int                     error;
+
+        granularity = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
+
+        /*
+         * Round the range of extents we are going to convert inwards.  If the
+         * offset is aligned, then it doesn't get changed so we zero from the
+         * start of the block offset points to.
+         */
+        start_boundary = round_up(offset, granularity);
+        end_boundary = round_down(offset + len, granularity);
+
+        ASSERT(start_boundary >= offset);
+        ASSERT(end_boundary <= offset + len);
+
+        if (!(attr_flags & XFS_ATTR_NOLOCK))
+                xfs_ilock(ip, XFS_IOLOCK_EXCL);
+
+        if (start_boundary < end_boundary - 1) {
+                /* punch out the page cache over the conversion range */
+                truncate_pagecache_range(VFS_I(ip), start_boundary,
+                                         end_boundary - 1);
+                /* convert the blocks */
+                error = xfs_alloc_file_space(ip, start_boundary,
+                                        end_boundary - start_boundary - 1,
+                                        XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT,
+                                        attr_flags);
+                if (error)
+                        goto out_unlock;
+
+                /* We've handled the interior of the range, now for the edges */
+                if (start_boundary != offset)
+                        error = xfs_iozero(ip, offset, start_boundary - offset);
+                if (error)
+                        goto out_unlock;
+
+                if (end_boundary != offset + len)
+                        error = xfs_iozero(ip, end_boundary,
+                                           offset + len - end_boundary);
+
+        } else {
+                /*
+                 * It's either a sub-granularity range or the range spanned lies
+                 * partially across two adjacent blocks.
+                 */
+                error = xfs_iozero(ip, offset, len);
+        }
+
+out_unlock:
+        if (!(attr_flags & XFS_ATTR_NOLOCK))
+                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+        return error;
+
+}
+
+/*
+ * xfs_change_file_space()
+ *      This routine allocates or frees disk space for the given file.
+ *      The user specified parameters are checked for alignment and size
+ *      limitations.
+ *
+ * RETURNS:
+ *       0 on success
+ *      errno on error
+ *
+ */
+int
+xfs_change_file_space(
+        xfs_inode_t     *ip,
+        int             cmd,
+        xfs_flock64_t   *bf,
+        xfs_off_t       offset,
+        int             attr_flags)
+{
+        xfs_mount_t     *mp = ip->i_mount;
+        int             clrprealloc;
+        int             error;
+        xfs_fsize_t     fsize;
+        int             setprealloc;
+        xfs_off_t       startoffset;
+        xfs_trans_t     *tp;
+        struct iattr    iattr;
+
+        if (!S_ISREG(ip->i_d.di_mode))
+                return XFS_ERROR(EINVAL);
+
+        switch (bf->l_whence) {
+        case 0: /*SEEK_SET*/
+                break;
+        case 1: /*SEEK_CUR*/
+                bf->l_start += offset;
+                break;
+        case 2: /*SEEK_END*/
+                bf->l_start += XFS_ISIZE(ip);
+                break;
+        default:
+                return XFS_ERROR(EINVAL);
+        }
+
+        /*
+         * length of <= 0 for resv/unresv/zero is invalid.  length for
+         * alloc/free is ignored completely and we have no idea what userspace
+         * might have set it to, so set it to zero to allow range
+         * checks to pass.
+         */
+        switch (cmd) {
+        case XFS_IOC_ZERO_RANGE:
+        case XFS_IOC_RESVSP:
+        case XFS_IOC_RESVSP64:
+        case XFS_IOC_UNRESVSP:
+        case XFS_IOC_UNRESVSP64:
+                if (bf->l_len <= 0)
+                        return XFS_ERROR(EINVAL);
+                break;
+        default:
+                bf->l_len = 0;
+                break;
+        }
+
+        if (bf->l_start < 0 ||
+            bf->l_start > mp->m_super->s_maxbytes ||
+            bf->l_start + bf->l_len < 0 ||
+            bf->l_start + bf->l_len >= mp->m_super->s_maxbytes)
+                return XFS_ERROR(EINVAL);
+
+        bf->l_whence = 0;
+
+        startoffset = bf->l_start;
+        fsize = XFS_ISIZE(ip);
+
+        setprealloc = clrprealloc = 0;
+        switch (cmd) {
+        case XFS_IOC_ZERO_RANGE:
+                error = xfs_zero_file_space(ip, startoffset, bf->l_len,
+                                                attr_flags);
+                if (error)
+                        return error;
+                setprealloc = 1;
+                break;
+
+        case XFS_IOC_RESVSP:
+        case XFS_IOC_RESVSP64:
+                error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
+                                                XFS_BMAPI_PREALLOC, attr_flags);
+                if (error)
+                        return error;
+                setprealloc = 1;
+                break;
+
+        case XFS_IOC_UNRESVSP:
+        case XFS_IOC_UNRESVSP64:
+                if ((error = xfs_free_file_space(ip, startoffset, bf->l_len,
+                                                                attr_flags)))
+                        return error;
+                break;
+
+        case XFS_IOC_ALLOCSP:
+        case XFS_IOC_ALLOCSP64:
+        case XFS_IOC_FREESP:
+        case XFS_IOC_FREESP64:
+                /*
+                 * These operations actually do IO when extending the file, but
+                 * the allocation is done seperately to the zeroing that is
+                 * done. This set of operations need to be serialised against
+                 * other IO operations, such as truncate and buffered IO. We
+                 * need to take the IOLOCK here to serialise the allocation and
+                 * zeroing IO to prevent other IOLOCK holders (e.g. getbmap,
+                 * truncate, direct IO) from racing against the transient
+                 * allocated but not written state we can have here.
+                 */
+                xfs_ilock(ip, XFS_IOLOCK_EXCL);
+                if (startoffset > fsize) {
+                        error = xfs_alloc_file_space(ip, fsize,
+                                        startoffset - fsize, 0,
+                                        attr_flags | XFS_ATTR_NOLOCK);
+                        if (error) {
+                                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+                                break;
+                        }
+                }
+
+                iattr.ia_valid = ATTR_SIZE;
+                iattr.ia_size = startoffset;
+
+                error = xfs_setattr_size(ip, &iattr,
+                                         attr_flags | XFS_ATTR_NOLOCK);
+                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+
+                if (error)
+                        return error;
+
+                clrprealloc = 1;
+                break;
+
+        default:
+                ASSERT(0);
+                return XFS_ERROR(EINVAL);
+        }
+
+        /*
+         * update the inode timestamp, mode, and prealloc flag bits
+         */
+        tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
+
+        if ((error = xfs_trans_reserve(tp, 0, XFS_WRITEID_LOG_RES(mp),
+                                      0, 0, 0))) {
+                /* ASSERT(0); */
+                xfs_trans_cancel(tp, 0);
+                return error;
+        }
+
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
+
+        if ((attr_flags & XFS_ATTR_DMI) == 0) {
+                ip->i_d.di_mode &= ~S_ISUID;
+
+                /*
+                 * Note that we don't have to worry about mandatory
+                 * file locking being disabled here because we only
+                 * clear the S_ISGID bit if the Group execute bit is
+                 * on, but if it was on then mandatory locking wouldn't
+                 * have been enabled.
+                 */
+                if (ip->i_d.di_mode & S_IXGRP)
+                        ip->i_d.di_mode &= ~S_ISGID;
+
+                xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+        }
+        if (setprealloc)
+                ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
+        else if (clrprealloc)
+                ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
+
+        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+        if (attr_flags & XFS_ATTR_SYNC)
+                xfs_trans_set_sync(tp);
+        return xfs_trans_commit(tp, 0);
+}