2018-06-05 19:42:14 -07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2013-08-12 20:49:42 +10:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2000-2006 Silicon Graphics, Inc.
|
|
|
|
|
* All Rights Reserved.
|
|
|
|
|
*/
|
|
|
|
|
#ifndef __XFS_BMAP_UTIL_H__
|
|
|
|
|
#define __XFS_BMAP_UTIL_H__
|
|
|
|
|
|
|
|
|
|
/* Kernel only BMAP related definitions and functions */
|
|
|
|
|
|
|
|
|
|
struct xfs_bmbt_irec;
|
2016-08-03 11:18:10 +10:00
|
|
|
struct xfs_extent_free_item;
|
2013-08-12 20:49:42 +10:00
|
|
|
struct xfs_ifork;
|
|
|
|
|
struct xfs_inode;
|
|
|
|
|
struct xfs_mount;
|
|
|
|
|
struct xfs_trans;
|
2015-01-09 10:46:49 +11:00
|
|
|
struct xfs_bmalloca;
|
xfs: implement buffered writes to zoned RT devices
Implement buffered writes including page faults and block zeroing for
zoned RT devices. Buffered writes to zoned RT devices are split into
three phases:
1) a reservation for the worst case data block usage is taken before
acquiring the iolock. When there are enough free blocks but not
enough available one, garbage collection is kicked off to free the
space before continuing with the write. If there isn't enough
freeable space, the block reservation is reduced and a short write
will happen as expected by normal Linux write semantics.
2) with the iolock held, the generic iomap buffered write code is
called, which through the iomap_begin operation usually just inserts
delalloc extents for the range in a single iteration. Only for
overwrites of existing data that are not block aligned, or zeroing
operations the existing extent mapping is read to fill out the srcmap
and to figure out if zeroing is required.
3) the ->map_blocks callback to the generic iomap writeback code
calls into the zoned space allocator to actually allocate on-disk
space for the range before kicking of the writeback.
Note that because all writes are out of place, truncate or hole punches
that are not aligned to block size boundaries need to allocate space.
For block zeroing from truncate, ->setattr is called with the iolock
(aka i_rwsem) already held, so a hacky deviation from the above
scheme is needed. In this case the space reservations is called with
the iolock held, but is required not to block and can dip into the
reserved block pool. This can lead to -ENOSPC when truncating a
file, which is unfortunate. But fixing the calling conventions in
the VFS is probably much easier with code requiring it already in
mainline.
Similarly because all writes are out place, the zoned allocator can't
support unwritten extents and thus the FALLOC_FL_ALLOCATE_RANGE range
mode of fallocate. Other fallocate modes that would reserved space
but don't need to to provide proper semantics do work but do not
reserve space.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
2025-02-13 05:50:08 +01:00
|
|
|
struct xfs_zone_alloc_ctx;
|
2013-08-12 20:49:42 +10:00
|
|
|
|
2017-10-09 11:37:22 -07:00
|
|
|
#ifdef CONFIG_XFS_RT
|
2013-08-12 20:49:42 +10:00
|
|
|
int xfs_bmap_rtalloc(struct xfs_bmalloca *ap);
|
2017-10-09 11:37:22 -07:00
|
|
|
#else /* !CONFIG_XFS_RT */
|
|
|
|
|
/*
|
|
|
|
|
* Attempts to allocate RT extents when RT is disable indicates corruption and
|
|
|
|
|
* should trigger a shutdown.
|
|
|
|
|
*/
|
|
|
|
|
static inline int
|
|
|
|
|
xfs_bmap_rtalloc(struct xfs_bmalloca *ap)
|
|
|
|
|
{
|
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_XFS_RT */
|
|
|
|
|
|
2024-10-08 10:59:18 +02:00
|
|
|
void xfs_bmap_punch_delalloc_range(struct xfs_inode *ip, int whichfork,
|
xfs: implement buffered writes to zoned RT devices
Implement buffered writes including page faults and block zeroing for
zoned RT devices. Buffered writes to zoned RT devices are split into
three phases:
1) a reservation for the worst case data block usage is taken before
acquiring the iolock. When there are enough free blocks but not
enough available one, garbage collection is kicked off to free the
space before continuing with the write. If there isn't enough
freeable space, the block reservation is reduced and a short write
will happen as expected by normal Linux write semantics.
2) with the iolock held, the generic iomap buffered write code is
called, which through the iomap_begin operation usually just inserts
delalloc extents for the range in a single iteration. Only for
overwrites of existing data that are not block aligned, or zeroing
operations the existing extent mapping is read to fill out the srcmap
and to figure out if zeroing is required.
3) the ->map_blocks callback to the generic iomap writeback code
calls into the zoned space allocator to actually allocate on-disk
space for the range before kicking of the writeback.
Note that because all writes are out of place, truncate or hole punches
that are not aligned to block size boundaries need to allocate space.
For block zeroing from truncate, ->setattr is called with the iolock
(aka i_rwsem) already held, so a hacky deviation from the above
scheme is needed. In this case the space reservations is called with
the iolock held, but is required not to block and can dip into the
reserved block pool. This can lead to -ENOSPC when truncating a
file, which is unfortunate. But fixing the calling conventions in
the VFS is probably much easier with code requiring it already in
mainline.
Similarly because all writes are out place, the zoned allocator can't
support unwritten extents and thus the FALLOC_FL_ALLOCATE_RANGE range
mode of fallocate. Other fallocate modes that would reserved space
but don't need to to provide proper semantics do work but do not
reserve space.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
2025-02-13 05:50:08 +01:00
|
|
|
xfs_off_t start_byte, xfs_off_t end_byte,
|
|
|
|
|
struct xfs_zone_alloc_ctx *ac);
|
2013-08-12 20:49:42 +10:00
|
|
|
|
2017-10-17 14:16:19 -07:00
|
|
|
struct kgetbmap {
|
|
|
|
|
__s64 bmv_offset; /* file offset of segment in blocks */
|
|
|
|
|
__s64 bmv_block; /* starting block (64-bit daddr_t) */
|
|
|
|
|
__s64 bmv_length; /* length of segment, blocks */
|
|
|
|
|
__s32 bmv_oflags; /* output flags */
|
|
|
|
|
};
|
2013-08-12 20:49:42 +10:00
|
|
|
int xfs_getbmap(struct xfs_inode *ip, struct getbmapx *bmv,
|
2017-10-17 14:16:19 -07:00
|
|
|
struct kgetbmap *out);
|
2013-08-12 20:49:42 +10:00
|
|
|
|
|
|
|
|
/* functions in xfs_bmap.c that are only needed by xfs_bmap_util.c */
|
|
|
|
|
int xfs_bmap_extsize_align(struct xfs_mount *mp, struct xfs_bmbt_irec *gotp,
|
|
|
|
|
struct xfs_bmbt_irec *prevp, xfs_extlen_t extsz,
|
|
|
|
|
int rt, int eof, int delay, int convert,
|
|
|
|
|
xfs_fileoff_t *offp, xfs_extlen_t *lenp);
|
2023-12-18 05:57:24 +01:00
|
|
|
bool xfs_bmap_adjacent(struct xfs_bmalloca *ap);
|
2013-08-12 20:49:42 +10:00
|
|
|
int xfs_bmap_last_extent(struct xfs_trans *tp, struct xfs_inode *ip,
|
|
|
|
|
int whichfork, struct xfs_bmbt_irec *rec,
|
|
|
|
|
int *is_empty);
|
|
|
|
|
|
2013-08-12 20:49:45 +10:00
|
|
|
/* preallocation and hole punch interface */
|
2013-10-12 00:55:07 -07:00
|
|
|
int xfs_alloc_file_space(struct xfs_inode *ip, xfs_off_t offset,
|
xfs: implement buffered writes to zoned RT devices
Implement buffered writes including page faults and block zeroing for
zoned RT devices. Buffered writes to zoned RT devices are split into
three phases:
1) a reservation for the worst case data block usage is taken before
acquiring the iolock. When there are enough free blocks but not
enough available one, garbage collection is kicked off to free the
space before continuing with the write. If there isn't enough
freeable space, the block reservation is reduced and a short write
will happen as expected by normal Linux write semantics.
2) with the iolock held, the generic iomap buffered write code is
called, which through the iomap_begin operation usually just inserts
delalloc extents for the range in a single iteration. Only for
overwrites of existing data that are not block aligned, or zeroing
operations the existing extent mapping is read to fill out the srcmap
and to figure out if zeroing is required.
3) the ->map_blocks callback to the generic iomap writeback code
calls into the zoned space allocator to actually allocate on-disk
space for the range before kicking of the writeback.
Note that because all writes are out of place, truncate or hole punches
that are not aligned to block size boundaries need to allocate space.
For block zeroing from truncate, ->setattr is called with the iolock
(aka i_rwsem) already held, so a hacky deviation from the above
scheme is needed. In this case the space reservations is called with
the iolock held, but is required not to block and can dip into the
reserved block pool. This can lead to -ENOSPC when truncating a
file, which is unfortunate. But fixing the calling conventions in
the VFS is probably much easier with code requiring it already in
mainline.
Similarly because all writes are out place, the zoned allocator can't
support unwritten extents and thus the FALLOC_FL_ALLOCATE_RANGE range
mode of fallocate. Other fallocate modes that would reserved space
but don't need to to provide proper semantics do work but do not
reserve space.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
2025-02-13 05:50:08 +01:00
|
|
|
xfs_off_t len);
|
2013-10-12 00:55:07 -07:00
|
|
|
int xfs_free_file_space(struct xfs_inode *ip, xfs_off_t offset,
|
xfs: implement buffered writes to zoned RT devices
Implement buffered writes including page faults and block zeroing for
zoned RT devices. Buffered writes to zoned RT devices are split into
three phases:
1) a reservation for the worst case data block usage is taken before
acquiring the iolock. When there are enough free blocks but not
enough available one, garbage collection is kicked off to free the
space before continuing with the write. If there isn't enough
freeable space, the block reservation is reduced and a short write
will happen as expected by normal Linux write semantics.
2) with the iolock held, the generic iomap buffered write code is
called, which through the iomap_begin operation usually just inserts
delalloc extents for the range in a single iteration. Only for
overwrites of existing data that are not block aligned, or zeroing
operations the existing extent mapping is read to fill out the srcmap
and to figure out if zeroing is required.
3) the ->map_blocks callback to the generic iomap writeback code
calls into the zoned space allocator to actually allocate on-disk
space for the range before kicking of the writeback.
Note that because all writes are out of place, truncate or hole punches
that are not aligned to block size boundaries need to allocate space.
For block zeroing from truncate, ->setattr is called with the iolock
(aka i_rwsem) already held, so a hacky deviation from the above
scheme is needed. In this case the space reservations is called with
the iolock held, but is required not to block and can dip into the
reserved block pool. This can lead to -ENOSPC when truncating a
file, which is unfortunate. But fixing the calling conventions in
the VFS is probably much easier with code requiring it already in
mainline.
Similarly because all writes are out place, the zoned allocator can't
support unwritten extents and thus the FALLOC_FL_ALLOCATE_RANGE range
mode of fallocate. Other fallocate modes that would reserved space
but don't need to to provide proper semantics do work but do not
reserve space.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
2025-02-13 05:50:08 +01:00
|
|
|
xfs_off_t len, struct xfs_zone_alloc_ctx *ac);
|
2014-02-24 10:58:19 +11:00
|
|
|
int xfs_collapse_file_space(struct xfs_inode *, xfs_off_t offset,
|
xfs: implement buffered writes to zoned RT devices
Implement buffered writes including page faults and block zeroing for
zoned RT devices. Buffered writes to zoned RT devices are split into
three phases:
1) a reservation for the worst case data block usage is taken before
acquiring the iolock. When there are enough free blocks but not
enough available one, garbage collection is kicked off to free the
space before continuing with the write. If there isn't enough
freeable space, the block reservation is reduced and a short write
will happen as expected by normal Linux write semantics.
2) with the iolock held, the generic iomap buffered write code is
called, which through the iomap_begin operation usually just inserts
delalloc extents for the range in a single iteration. Only for
overwrites of existing data that are not block aligned, or zeroing
operations the existing extent mapping is read to fill out the srcmap
and to figure out if zeroing is required.
3) the ->map_blocks callback to the generic iomap writeback code
calls into the zoned space allocator to actually allocate on-disk
space for the range before kicking of the writeback.
Note that because all writes are out of place, truncate or hole punches
that are not aligned to block size boundaries need to allocate space.
For block zeroing from truncate, ->setattr is called with the iolock
(aka i_rwsem) already held, so a hacky deviation from the above
scheme is needed. In this case the space reservations is called with
the iolock held, but is required not to block and can dip into the
reserved block pool. This can lead to -ENOSPC when truncating a
file, which is unfortunate. But fixing the calling conventions in
the VFS is probably much easier with code requiring it already in
mainline.
Similarly because all writes are out place, the zoned allocator can't
support unwritten extents and thus the FALLOC_FL_ALLOCATE_RANGE range
mode of fallocate. Other fallocate modes that would reserved space
but don't need to to provide proper semantics do work but do not
reserve space.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
2025-02-13 05:50:08 +01:00
|
|
|
xfs_off_t len, struct xfs_zone_alloc_ctx *ac);
|
2015-03-25 15:08:56 +11:00
|
|
|
int xfs_insert_file_space(struct xfs_inode *, xfs_off_t offset,
|
xfs: implement buffered writes to zoned RT devices
Implement buffered writes including page faults and block zeroing for
zoned RT devices. Buffered writes to zoned RT devices are split into
three phases:
1) a reservation for the worst case data block usage is taken before
acquiring the iolock. When there are enough free blocks but not
enough available one, garbage collection is kicked off to free the
space before continuing with the write. If there isn't enough
freeable space, the block reservation is reduced and a short write
will happen as expected by normal Linux write semantics.
2) with the iolock held, the generic iomap buffered write code is
called, which through the iomap_begin operation usually just inserts
delalloc extents for the range in a single iteration. Only for
overwrites of existing data that are not block aligned, or zeroing
operations the existing extent mapping is read to fill out the srcmap
and to figure out if zeroing is required.
3) the ->map_blocks callback to the generic iomap writeback code
calls into the zoned space allocator to actually allocate on-disk
space for the range before kicking of the writeback.
Note that because all writes are out of place, truncate or hole punches
that are not aligned to block size boundaries need to allocate space.
For block zeroing from truncate, ->setattr is called with the iolock
(aka i_rwsem) already held, so a hacky deviation from the above
scheme is needed. In this case the space reservations is called with
the iolock held, but is required not to block and can dip into the
reserved block pool. This can lead to -ENOSPC when truncating a
file, which is unfortunate. But fixing the calling conventions in
the VFS is probably much easier with code requiring it already in
mainline.
Similarly because all writes are out place, the zoned allocator can't
support unwritten extents and thus the FALLOC_FL_ALLOCATE_RANGE range
mode of fallocate. Other fallocate modes that would reserved space
but don't need to to provide proper semantics do work but do not
reserve space.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
2025-02-13 05:50:08 +01:00
|
|
|
xfs_off_t len);
|
2013-08-12 20:49:45 +10:00
|
|
|
|
|
|
|
|
/* EOF block manipulation functions */
|
2024-06-19 10:32:43 -07:00
|
|
|
bool xfs_can_free_eofblocks(struct xfs_inode *ip);
|
2017-01-27 23:22:55 -08:00
|
|
|
int xfs_free_eofblocks(struct xfs_inode *ip);
|
2013-08-12 20:49:45 +10:00
|
|
|
|
2013-08-12 20:49:48 +10:00
|
|
|
int xfs_swap_extents(struct xfs_inode *ip, struct xfs_inode *tip,
|
|
|
|
|
struct xfs_swapext *sx);
|
|
|
|
|
|
2013-08-12 20:49:42 +10:00
|
|
|
xfs_daddr_t xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb);
|
|
|
|
|
|
2017-08-29 15:44:14 -07:00
|
|
|
xfs_extnum_t xfs_bmap_count_leaves(struct xfs_ifork *ifp, xfs_filblks_t *count);
|
2017-06-16 11:00:12 -07:00
|
|
|
int xfs_bmap_count_blocks(struct xfs_trans *tp, struct xfs_inode *ip,
|
|
|
|
|
int whichfork, xfs_extnum_t *nextents,
|
|
|
|
|
xfs_filblks_t *count);
|
|
|
|
|
|
2018-11-19 13:31:10 -08:00
|
|
|
int xfs_flush_unmap_range(struct xfs_inode *ip, xfs_off_t offset,
|
|
|
|
|
xfs_off_t len);
|
|
|
|
|
|
2013-08-12 20:49:42 +10:00
|
|
|
#endif /* __XFS_BMAP_UTIL_H__ */
|