On Sat, Sep 24, 2016 at 08:22:35PM -0700, Christoph Hellwig wrote:
> This patch rewrites xfs_reflink_reserve_cow_range and everything below it
> in a similar fashion to what I did for the delayed allocation path
> earlier. We now remove the number of lookups quite a bit and simplify
> the code. The steps are:
>
> 1) check if we already have an extent in the COW fork for the area.
> If so nothing to do, we can move along.
> 2) look up block number for the current extent, and if there is none
> it's not shared move along.
> 3) last but not least unshare the current extent as far as we are
> going to write into it. For this we avoid an additional COW
> for lookup and use the information we set aside in step 1) above.
> 4) Goto 1) unless we've covered the whole range
>
> As a nice side effect this also removes all the intrusions the reflink
> support added to the existing delated allocation code.
>
> Last but not least this updates the xfs_reflink_reserve_cow_range
> calling convention to pass a byte offset and length, as that is
> what both callers expect anyway.
Seems reasonable, tests ok, so:
Reviewed-by: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
--D
>
> Signed-off-by: Christoph Hellwig <hch@xxxxxx>
> ---
> fs/xfs/xfs_file.c | 11 +---
> fs/xfs/xfs_iomap.c | 104 +++++++++---------------------
> fs/xfs/xfs_iomap.h | 5 +-
> fs/xfs/xfs_pnfs.c | 2 +-
> fs/xfs/xfs_reflink.c | 174 ++++++++++++++++++++++++---------------------------
> fs/xfs/xfs_reflink.h | 2 +-
> fs/xfs/xfs_trace.h | 6 +-
> 7 files changed, 118 insertions(+), 186 deletions(-)
>
> diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
> index fc357d4..aee0c4c 100644
> --- a/fs/xfs/xfs_file.c
> +++ b/fs/xfs/xfs_file.c
> @@ -675,16 +675,7 @@ xfs_file_dio_aio_write(
>
> /* If this is a block-aligned directio CoW, remap immediately. */
> if (xfs_is_reflink_inode(ip) && !unaligned_io) {
> - /*
> - * XXX(hch): this seems all a little messy, I'd much prefer to
> - * do this in the get_blocks handler or equivalent. It's
> - * probably time to rewrite DIO using the iomap infrastructure..
> - */
> - xfs_ilock(ip, XFS_ILOCK_EXCL);
> - ret = xfs_reflink_reserve_cow_range(ip,
> - XFS_B_TO_FSBT(mp, iocb->ki_pos),
> - XFS_B_TO_FSB(mp, iocb->ki_pos + count));
> - xfs_iunlock(ip, XFS_ILOCK_EXCL);
> + ret = xfs_reflink_reserve_cow_range(ip, iocb->ki_pos, count);
> if (ret)
> goto out;
>
> diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
> index 5afbfa5..d907eb9 100644
> --- a/fs/xfs/xfs_iomap.c
> +++ b/fs/xfs/xfs_iomap.c
> @@ -49,13 +49,10 @@ void
> xfs_bmbt_to_iomap(
> struct xfs_inode *ip,
> struct iomap *iomap,
> - struct xfs_bmbt_irec *imap,
> - bool is_shared)
> + struct xfs_bmbt_irec *imap)
> {
> struct xfs_mount *mp = ip->i_mount;
>
> - if (is_shared)
> - iomap->flags |= IOMAP_F_SHARED;
> if (imap->br_startblock == HOLESTARTBLOCK) {
> iomap->blkno = IOMAP_NULL_BLOCK;
> iomap->type = IOMAP_HOLE;
> @@ -74,7 +71,7 @@ xfs_bmbt_to_iomap(
> iomap->bdev = xfs_find_bdev_for_inode(VFS_I(ip));
> }
>
> -static xfs_extlen_t
> +xfs_extlen_t
> xfs_eof_alignment(
> struct xfs_inode *ip,
> xfs_extlen_t extsize)
> @@ -525,15 +522,16 @@ check_writeio:
> }
>
> static int
> -xfs_file_iomap_delay(
> - struct xfs_inode *ip,
> - int whichfork,
> - xfs_off_t offset,
> - xfs_off_t count,
> - struct xfs_bmbt_irec *imap)
> +xfs_file_iomap_begin_delay(
> + struct inode *inode,
> + loff_t offset,
> + loff_t count,
> + unsigned flags,
> + struct iomap *iomap)
> {
> + struct xfs_inode *ip = XFS_I(inode);
> struct xfs_mount *mp = ip->i_mount;
> - struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
> + struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
> xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
> xfs_fileoff_t maxbytes_fsb =
> XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
> @@ -544,11 +542,13 @@ xfs_file_iomap_delay(
> xfs_extnum_t idx;
>
> ASSERT(!XFS_IS_REALTIME_INODE(ip));
> - ASSERT(whichfork == XFS_COW_FORK || !xfs_get_extsz_hint(ip));
> + ASSERT(!xfs_get_extsz_hint(ip));
> +
> + xfs_ilock(ip, XFS_ILOCK_EXCL);
>
> if (unlikely(XFS_TEST_ERROR(
> - (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
> - XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
> + (XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_EXTENTS &&
> + XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE),
> mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
> XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
> error = -EFSCORRUPTED;
> @@ -557,13 +557,13 @@ xfs_file_iomap_delay(
>
> XFS_STATS_INC(mp, xs_blk_mapw);
>
> - if (whichfork == XFS_DATA_FORK && !(ifp->if_flags & XFS_IFEXTENTS)) {
> - error = xfs_iread_extents(NULL, ip, whichfork);
> + if (!(ifp->if_flags & XFS_IFEXTENTS)) {
> + error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
> if (error)
> goto out_unlock;
> }
>
> - xfs_bmap_search_extents(ip, offset_fsb, whichfork, &eof, &idx,
> + xfs_bmap_search_extents(ip, offset_fsb, XFS_DATA_FORK, &eof, &idx,
> &got, &prev);
> if (!eof && got.br_startoff <= offset_fsb) {
> trace_xfs_iomap_found(ip, offset, count, 0, &got);
> @@ -587,7 +587,7 @@ xfs_file_iomap_delay(
> end_fsb = orig_end_fsb =
> min(XFS_B_TO_FSB(mp, offset + count), maxbytes_fsb);
>
> - if (eof && whichfork == XFS_DATA_FORK) {
> + if (eof) {
> xfs_fsblock_t prealloc_blocks;
>
> prealloc_blocks =
> @@ -609,16 +609,8 @@ xfs_file_iomap_delay(
> }
> }
>
> - if (whichfork == XFS_COW_FORK) {
> - xfs_extlen_t align;
> -
> - align = xfs_eof_alignment(ip, xfs_get_cowextsz_hint(ip));
> - if (align)
> - end_fsb = roundup_64(end_fsb, align);
> - }
> -
> retry:
> - error = xfs_bmapi_reserve_delalloc(ip, whichfork, offset_fsb,
> + error = xfs_bmapi_reserve_delalloc(ip, XFS_DATA_FORK, offset_fsb,
> end_fsb - offset_fsb, &got,
> &prev, &idx, eof);
> switch (error) {
> @@ -641,7 +633,7 @@ retry:
> * Tag the inode as speculatively preallocated so we can reclaim this
> * space on demand, if necessary.
> */
> - if (end_fsb != orig_end_fsb && whichfork == XFS_DATA_FORK)
> + if (end_fsb != orig_end_fsb)
> xfs_inode_set_eofblocks_tag(ip);
>
> trace_xfs_iomap_alloc(ip, offset, count, 0, &got);
> @@ -655,48 +647,13 @@ done:
> goto out_unlock;
> }
>
> - *imap = got;
> + xfs_bmbt_to_iomap(ip, iomap, &got);
>
> out_unlock:
> - return error;
> -}
> -
> -/* Create a delalloc reservation in the data fork. */
> -static int
> -xfs_file_iomap_begin_delay(
> - struct inode *inode,
> - loff_t offset,
> - loff_t count,
> - unsigned flags,
> - struct iomap *iomap)
> -{
> - struct xfs_bmbt_irec got;
> - struct xfs_inode *ip = XFS_I(inode);
> - int error;
> -
> - xfs_ilock(ip, XFS_ILOCK_EXCL);
> - error = xfs_file_iomap_delay(ip, XFS_DATA_FORK, offset, count, &got);
> xfs_iunlock(ip, XFS_ILOCK_EXCL);
> - if (error)
> - goto out;
> - xfs_bmbt_to_iomap(ip, iomap, &got, false);
> -out:
> return error;
> }
>
> -/* Create a delalloc reservation in the CoW fork. */
> -int
> -xfs_iomap_cow_delay(
> - struct xfs_inode *ip,
> - xfs_off_t offset,
> - size_t count,
> - struct xfs_bmbt_irec *ret_imap)
> -{
> - trace_xfs_iomap_cow_delay(ip, offset, count);
> -
> - return xfs_file_iomap_delay(ip, XFS_COW_FORK, offset, count, ret_imap);
> -}
> -
> /*
> * Pass in a delayed allocate extent, convert it to real extents;
> * return to the caller the extent we create which maps on top of
> @@ -1012,15 +969,8 @@ xfs_file_iomap_begin(
> return -EIO;
>
> if ((flags & (IOMAP_WRITE | IOMAP_ZERO)) && xfs_is_reflink_inode(ip)) {
> - /* Reserve delalloc blocks for CoW. */
> - offset_fsb = XFS_B_TO_FSBT(mp, offset);
> - end_fsb = XFS_B_TO_FSB(mp, offset + length);
> - trace_xfs_reflink_reserve_cow_range(ip, length, offset);
> -
> - xfs_ilock(ip, XFS_ILOCK_EXCL);
> - error = xfs_reflink_reserve_cow_range(ip, offset_fsb, end_fsb);
> - xfs_iunlock(ip, XFS_ILOCK_EXCL);
> - if (error)
> + error = xfs_reflink_reserve_cow_range(ip, offset, length);
> + if (error < 0)
> return error;
> }
>
> @@ -1085,7 +1035,9 @@ xfs_file_iomap_begin(
> trace_xfs_iomap_found(ip, offset, length, 0, &imap);
> }
>
> - xfs_bmbt_to_iomap(ip, iomap, &imap, shared);
> + xfs_bmbt_to_iomap(ip, iomap, &imap);
> + if (shared)
> + iomap->flags |= IOMAP_F_SHARED;
> return 0;
> }
>
> @@ -1183,7 +1135,7 @@ out_unlock:
>
> if (!error) {
> ASSERT(nimaps);
> - xfs_bmbt_to_iomap(ip, iomap, &imap, false);
> + xfs_bmbt_to_iomap(ip, iomap, &imap);
> }
>
> return error;
> diff --git a/fs/xfs/xfs_iomap.h b/fs/xfs/xfs_iomap.h
> index 8886532..6d45cf0 100644
> --- a/fs/xfs/xfs_iomap.h
> +++ b/fs/xfs/xfs_iomap.h
> @@ -28,11 +28,10 @@ int xfs_iomap_write_direct(struct xfs_inode *, xfs_off_t, size_t,
> int xfs_iomap_write_allocate(struct xfs_inode *, int, xfs_off_t,
> struct xfs_bmbt_irec *);
> int xfs_iomap_write_unwritten(struct xfs_inode *, xfs_off_t, xfs_off_t);
> -int xfs_iomap_cow_delay(struct xfs_inode *, xfs_off_t, size_t,
> - struct xfs_bmbt_irec *);
>
> void xfs_bmbt_to_iomap(struct xfs_inode *, struct iomap *,
> - struct xfs_bmbt_irec *, bool);
> + struct xfs_bmbt_irec *);
> +xfs_extlen_t xfs_eof_alignment(struct xfs_inode *ip, xfs_extlen_t extsize);
>
> extern struct iomap_ops xfs_iomap_ops;
> extern struct iomap_ops xfs_xattr_iomap_ops;
> diff --git a/fs/xfs/xfs_pnfs.c b/fs/xfs/xfs_pnfs.c
> index 5519e4b..93a7aaf 100644
> --- a/fs/xfs/xfs_pnfs.c
> +++ b/fs/xfs/xfs_pnfs.c
> @@ -188,7 +188,7 @@ xfs_fs_map_blocks(
> }
> xfs_iunlock(ip, XFS_IOLOCK_EXCL);
>
> - xfs_bmbt_to_iomap(ip, iomap, &imap, false);
> + xfs_bmbt_to_iomap(ip, iomap, &imap);
> *device_generation = mp->m_generation;
> return error;
> out_unlock:
> diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c
> index a1ba7f5..09e0e27 100644
> --- a/fs/xfs/xfs_reflink.c
> +++ b/fs/xfs/xfs_reflink.c
> @@ -249,122 +249,112 @@ xfs_reflink_trim_around_shared(
> }
> }
>
> -/* Find the shared ranges under an irec, and set up delalloc extents. */
> static int
> -xfs_reflink_reserve_cow_extent(
> +__xfs_reflink_reserve_cow(
> struct xfs_inode *ip,
> - struct xfs_bmbt_irec *irec)
> + xfs_fileoff_t *offset_fsb,
> + xfs_fileoff_t end_fsb)
> {
> - struct xfs_bmbt_irec rec;
> - xfs_agnumber_t agno;
> - xfs_agblock_t agbno;
> - xfs_extlen_t aglen;
> - xfs_agblock_t fbno;
> - xfs_extlen_t flen;
> - xfs_fileoff_t lblk;
> - xfs_off_t foffset;
> - xfs_extlen_t distance;
> - size_t fsize;
> - int error = 0;
> + struct xfs_bmbt_irec got, prev, imap;
> + xfs_fileoff_t orig_end_fsb;
> + int nimaps, eof = 0, error = 0;
> + bool shared = false, trimmed = false;
> + xfs_extnum_t idx;
> + xfs_extlen_t align;
> +
> + /* Already reserved? Skip the refcount btree access. */
> + xfs_bmap_search_extents(ip, *offset_fsb, XFS_COW_FORK, &eof, &idx,
> + &got, &prev);
> + if (!eof && got.br_startoff <= *offset_fsb) {
> + end_fsb = orig_end_fsb = got.br_startoff + got.br_blockcount;
> + trace_xfs_reflink_cow_found(ip, &got);
> + goto done;
> + }
>
> - /* Holes, unwritten, and delalloc extents cannot be shared */
> - if (ISUNWRITTEN(irec) ||
> - irec->br_startblock == HOLESTARTBLOCK ||
> - irec->br_startblock == DELAYSTARTBLOCK)
> - return 0;
> + /* Read extent from the source file. */
> + nimaps = 1;
> + error = xfs_bmapi_read(ip, *offset_fsb, end_fsb - *offset_fsb,
> + &imap, &nimaps, 0);
> + if (error)
> + goto out_unlock;
> + ASSERT(nimaps == 1);
>
> - trace_xfs_reflink_reserve_cow_extent(ip, irec);
> - agno = XFS_FSB_TO_AGNO(ip->i_mount, irec->br_startblock);
> - agbno = XFS_FSB_TO_AGBNO(ip->i_mount, irec->br_startblock);
> - lblk = irec->br_startoff;
> - aglen = irec->br_blockcount;
> + /* Trim the mapping to the nearest shared extent boundary. */
> + error = xfs_reflink_trim_around_shared(ip, &imap, &shared, &trimmed);
> + if (error)
> + goto out_unlock;
>
> - while (aglen > 0) {
> - /* Find maximal fork range within this extent */
> - error = xfs_reflink_find_shared(ip->i_mount, agno, agbno,
> - aglen, &fbno, &flen, true);
> - if (error)
> - break;
> - if (flen == 0) {
> - distance = fbno - agbno;
> - goto advloop;
> - }
> + end_fsb = orig_end_fsb = imap.br_startoff + imap.br_blockcount;
>
> - /* Add as much as we can to the cow fork */
> - foffset = XFS_FSB_TO_B(ip->i_mount, lblk + fbno - agbno);
> - fsize = XFS_FSB_TO_B(ip->i_mount, flen);
> - error = xfs_iomap_cow_delay(ip, foffset, fsize, &rec);
> - if (error)
> - break;
> + /* Not shared? Just report the (potentially capped) extent. */
> + if (!shared)
> + goto done;
>
> - distance = (rec.br_startoff - lblk) + rec.br_blockcount;
> -advloop:
> - if (aglen < distance)
> - break;
> - aglen -= distance;
> - agbno += distance;
> - lblk += distance;
> + /*
> + * Fork all the shared blocks from our write offset until the end of
> + * the extent.
> + */
> + error = xfs_qm_dqattach_locked(ip, 0);
> + if (error)
> + goto out_unlock;
> +
> + align = xfs_eof_alignment(ip, xfs_get_cowextsz_hint(ip));
> + if (align)
> + end_fsb = roundup_64(end_fsb, align);
> +
> +retry:
> + error = xfs_bmapi_reserve_delalloc(ip, XFS_COW_FORK, *offset_fsb,
> + end_fsb - *offset_fsb, &got,
> + &prev, &idx, eof);
> + switch (error) {
> + case 0:
> + break;
> + case -ENOSPC:
> + case -EDQUOT:
> + /* retry without any preallocation */
> + trace_xfs_reflink_cow_enospc(ip, &imap);
> + if (end_fsb != orig_end_fsb) {
> + end_fsb = orig_end_fsb;
> + goto retry;
> + }
> + /*FALLTHRU*/
> + default:
> + goto out_unlock;
> }
>
> - if (error)
> - trace_xfs_reflink_reserve_cow_extent_error(ip, error, _RET_IP_);
> + trace_xfs_reflink_cow_alloc(ip, &got);
> +done:
> + *offset_fsb = end_fsb;
> +out_unlock:
> return error;
> }
>
> -/*
> - * Create CoW reservations for all shared blocks within a byte range of
> - * a file.
> - */
> int
> xfs_reflink_reserve_cow_range(
> struct xfs_inode *ip,
> - xfs_fileoff_t offset_fsb,
> - xfs_fileoff_t end_fsb)
> + xfs_off_t offset,
> + xfs_off_t count)
> {
> - struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
> - struct xfs_bmbt_rec_host *gotp;
> - struct xfs_bmbt_irec imap;
> - xfs_extnum_t idx;
> - int nimaps, error = 0;
> + struct xfs_mount *mp = ip->i_mount;
> + xfs_fileoff_t offset_fsb, end_fsb;
> + int error;
>
> - ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
> + trace_xfs_reflink_reserve_cow_range(ip, offset, count);
>
> - trace_xfs_reflink_reserve_cow_range(ip,
> - XFS_FSB_TO_B(ip->i_mount, end_fsb - offset_fsb),
> - XFS_FSB_TO_B(ip->i_mount, offset_fsb));
> + offset_fsb = XFS_B_TO_FSBT(mp, offset);
> + end_fsb = XFS_B_TO_FSB(mp, offset + count);
>
> + xfs_ilock(ip, XFS_ILOCK_EXCL);
> while (offset_fsb < end_fsb) {
> - /* Already reserved? Skip the refcount btree access. */
> - gotp = xfs_iext_bno_to_ext(ifp, offset_fsb, &idx);
> - if (gotp) {
> - xfs_bmbt_get_all(gotp, &imap);
> - if (imap.br_startoff <= offset_fsb &&
> - imap.br_startoff + imap.br_blockcount > offset_fsb) {
> - offset_fsb = imap.br_startoff + imap.br_blockcount;
> - continue;
> - }
> - }
> -
> - /* Read extent from the source file. */
> - nimaps = 1;
> - error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
> - &imap, &nimaps, 0);
> - if (error)
> - break;
> -
> - if (nimaps == 0)
> + error = __xfs_reflink_reserve_cow(ip, &offset_fsb, end_fsb);
> + if (error) {
> + trace_xfs_reflink_reserve_cow_range_error(ip, error,
> + _RET_IP_);
> break;
> -
> - /* Fork all the shared blocks in this extent. */
> - error = xfs_reflink_reserve_cow_extent(ip, &imap);
> - if (error)
> - break;
> -
> - offset_fsb += imap.br_blockcount;
> + }
> }
> + xfs_iunlock(ip, XFS_ILOCK_EXCL);
>
> - if (error)
> - trace_xfs_reflink_reserve_cow_range_error(ip, error, _RET_IP_);
> return error;
> }
>
> diff --git a/fs/xfs/xfs_reflink.h b/fs/xfs/xfs_reflink.h
> index 6519f19..0e19ec6 100644
> --- a/fs/xfs/xfs_reflink.h
> +++ b/fs/xfs/xfs_reflink.h
> @@ -27,7 +27,7 @@ extern int xfs_reflink_trim_around_shared(struct xfs_inode *ip,
> struct xfs_bmbt_irec *irec, bool *shared, bool *trimmed);
>
> extern int xfs_reflink_reserve_cow_range(struct xfs_inode *ip,
> - xfs_fileoff_t offset_fsb, xfs_fileoff_t end_fsb);
> + xfs_off_t offset, xfs_off_t count);
> extern int xfs_reflink_allocate_cow_range(struct xfs_inode *ip, xfs_off_t pos,
> xfs_off_t len);
> extern bool xfs_reflink_find_cow_mapping(struct xfs_inode *ip, xfs_off_t offset,
> diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
> index dc891f4..c8fb91c 100644
> --- a/fs/xfs/xfs_trace.h
> +++ b/fs/xfs/xfs_trace.h
> @@ -3314,16 +3314,17 @@ DEFINE_INODE_ERROR_EVENT(xfs_reflink_dirty_page_error);
>
> /* copy on write */
> DEFINE_INODE_IREC_EVENT(xfs_reflink_trim_around_shared);
> +DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_alloc);
> +DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_found);
> +DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_enospc);
>
> DEFINE_RW_EVENT(xfs_reflink_reserve_cow_range);
> -DEFINE_INODE_IREC_EVENT(xfs_reflink_reserve_cow_extent);
> DEFINE_RW_EVENT(xfs_reflink_allocate_cow_range);
> DEFINE_INODE_IREC_EVENT(xfs_reflink_allocate_cow_extent);
>
> DEFINE_INODE_IREC_EVENT(xfs_reflink_bounce_dio_write);
> DEFINE_IOMAP_EVENT(xfs_reflink_find_cow_mapping);
> DEFINE_INODE_IREC_EVENT(xfs_reflink_trim_irec);
> -DEFINE_SIMPLE_IO_EVENT(xfs_iomap_cow_delay);
>
> DEFINE_SIMPLE_IO_EVENT(xfs_reflink_cancel_cow_range);
> DEFINE_SIMPLE_IO_EVENT(xfs_reflink_end_cow);
> @@ -3331,7 +3332,6 @@ DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap);
> DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_piece);
>
> DEFINE_INODE_ERROR_EVENT(xfs_reflink_reserve_cow_range_error);
> -DEFINE_INODE_ERROR_EVENT(xfs_reflink_reserve_cow_extent_error);
> DEFINE_INODE_ERROR_EVENT(xfs_reflink_allocate_cow_range_error);
> DEFINE_INODE_ERROR_EVENT(xfs_reflink_cancel_cow_range_error);
> DEFINE_INODE_ERROR_EVENT(xfs_reflink_end_cow_error);
> --
> 2.1.4
>
--
To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
