Dave Chinner | 0b61f8a | 2018-06-05 19:42:14 -0700 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
Olaf Weber | 3e57ecf | 2006-06-09 14:48:12 +1000 | [diff] [blame] | 3 | * Copyright (c) 2000-2006 Silicon Graphics, Inc. |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 4 | * All Rights Reserved. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | */ |
| 6 | #ifndef __XFS_BMAP_H__ |
| 7 | #define __XFS_BMAP_H__ |
| 8 | |
| 9 | struct getbmap; |
| 10 | struct xfs_bmbt_irec; |
Mandy Kirkconnell | 4eea22f | 2006-03-14 13:29:52 +1100 | [diff] [blame] | 11 | struct xfs_ifork; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | struct xfs_inode; |
| 13 | struct xfs_mount; |
| 14 | struct xfs_trans; |
| 15 | |
David Chinner | a8272ce | 2007-11-23 16:28:09 +1100 | [diff] [blame] | 16 | extern kmem_zone_t *xfs_bmap_free_item_zone; |
| 17 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | /* |
Dave Chinner | 9799b43 | 2015-01-09 10:46:49 +1100 | [diff] [blame] | 19 | * Argument structure for xfs_bmap_alloc. |
| 20 | */ |
| 21 | struct xfs_bmalloca { |
Dave Chinner | 9799b43 | 2015-01-09 10:46:49 +1100 | [diff] [blame] | 22 | struct xfs_trans *tp; /* transaction pointer */ |
| 23 | struct xfs_inode *ip; /* incore inode pointer */ |
| 24 | struct xfs_bmbt_irec prev; /* extent before the new one */ |
| 25 | struct xfs_bmbt_irec got; /* extent after, or delayed */ |
| 26 | |
| 27 | xfs_fileoff_t offset; /* offset in file filling in */ |
| 28 | xfs_extlen_t length; /* i/o length asked/allocated */ |
| 29 | xfs_fsblock_t blkno; /* starting block of new extent */ |
| 30 | |
| 31 | struct xfs_btree_cur *cur; /* btree cursor */ |
Christoph Hellwig | b2b1712 | 2017-11-03 10:34:43 -0700 | [diff] [blame] | 32 | struct xfs_iext_cursor icur; /* incore extent cursor */ |
Dave Chinner | 9799b43 | 2015-01-09 10:46:49 +1100 | [diff] [blame] | 33 | int nallocs;/* number of extents alloc'd */ |
| 34 | int logflags;/* flags for transaction logging */ |
| 35 | |
| 36 | xfs_extlen_t total; /* total blocks needed for xaction */ |
| 37 | xfs_extlen_t minlen; /* minimum allocation size (blocks) */ |
| 38 | xfs_extlen_t minleft; /* amount must be left after alloc */ |
| 39 | bool eof; /* set if allocating past last extent */ |
| 40 | bool wasdel; /* replacing a delayed allocation */ |
Dave Chinner | 9799b43 | 2015-01-09 10:46:49 +1100 | [diff] [blame] | 41 | bool aeof; /* allocated space at eof */ |
| 42 | bool conv; /* overwriting unwritten extents */ |
Dave Chinner | 292378e | 2016-09-26 08:21:28 +1000 | [diff] [blame] | 43 | int datatype;/* data type being allocated */ |
Dave Chinner | 9799b43 | 2015-01-09 10:46:49 +1100 | [diff] [blame] | 44 | int flags; |
| 45 | }; |
| 46 | |
| 47 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | * List of extents to be free "later". |
| 49 | * The list is kept sorted on xbf_startblock. |
| 50 | */ |
Darrick J. Wong | 310a75a | 2016-08-03 11:18:10 +1000 | [diff] [blame] | 51 | struct xfs_extent_free_item |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | { |
Darrick J. Wong | 310a75a | 2016-08-03 11:18:10 +1000 | [diff] [blame] | 53 | xfs_fsblock_t xefi_startblock;/* starting fs block number */ |
| 54 | xfs_extlen_t xefi_blockcount;/* number of blocks in extent */ |
| 55 | struct list_head xefi_list; |
Darrick J. Wong | 340785c | 2016-08-03 11:33:42 +1000 | [diff] [blame] | 56 | struct xfs_owner_info xefi_oinfo; /* extent owner */ |
Brian Foster | fcb762f | 2018-05-09 08:45:04 -0700 | [diff] [blame] | 57 | bool xefi_skip_discard; |
Darrick J. Wong | e66a4c6 | 2016-06-21 11:53:28 +1000 | [diff] [blame] | 58 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | #define XFS_BMAP_MAX_NMAP 4 |
| 61 | |
| 62 | /* |
Dave Chinner | c0dc782 | 2011-09-18 20:40:52 +0000 | [diff] [blame] | 63 | * Flags for xfs_bmapi_* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | */ |
Dave Chinner | c0dc782 | 2011-09-18 20:40:52 +0000 | [diff] [blame] | 65 | #define XFS_BMAPI_ENTIRE 0x001 /* return entire extent, not trimmed */ |
| 66 | #define XFS_BMAPI_METADATA 0x002 /* mapping metadata not user data */ |
| 67 | #define XFS_BMAPI_ATTRFORK 0x004 /* use attribute fork not data */ |
| 68 | #define XFS_BMAPI_PREALLOC 0x008 /* preallocation op: unwritten space */ |
Dave Chinner | c0dc782 | 2011-09-18 20:40:52 +0000 | [diff] [blame] | 69 | #define XFS_BMAPI_CONTIG 0x020 /* must allocate only one extent */ |
Dave Chinner | 4472235 | 2010-08-24 12:02:11 +1000 | [diff] [blame] | 70 | /* |
| 71 | * unwritten extent conversion - this needs write cache flushing and no additional |
| 72 | * allocation alignments. When specified with XFS_BMAPI_PREALLOC it converts |
| 73 | * from written to unwritten, otherwise convert from unwritten to written. |
| 74 | */ |
Dave Chinner | c0dc782 | 2011-09-18 20:40:52 +0000 | [diff] [blame] | 75 | #define XFS_BMAPI_CONVERT 0x040 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | |
Dave Chinner | 3fbbbea | 2015-11-03 12:27:22 +1100 | [diff] [blame] | 77 | /* |
| 78 | * allocate zeroed extents - this requires all newly allocated user data extents |
| 79 | * to be initialised to zero. It will be ignored if XFS_BMAPI_METADATA is set. |
| 80 | * Use in conjunction with XFS_BMAPI_CONVERT to convert unwritten extents found |
| 81 | * during the allocation range to zeroed written extents. |
| 82 | */ |
| 83 | #define XFS_BMAPI_ZERO 0x080 |
| 84 | |
Darrick J. Wong | f65306e | 2016-10-03 09:11:27 -0700 | [diff] [blame] | 85 | /* |
| 86 | * Map the inode offset to the block given in ap->firstblock. Primarily |
| 87 | * used for reflink. The range must be in a hole, and this flag cannot be |
| 88 | * turned on with PREALLOC or CONVERT, and cannot be used on the attr fork. |
Darrick J. Wong | 4847acf | 2016-10-03 09:11:27 -0700 | [diff] [blame] | 89 | * |
| 90 | * For bunmapi, this flag unmaps the range without adjusting quota, reducing |
| 91 | * refcount, or freeing the blocks. |
Darrick J. Wong | f65306e | 2016-10-03 09:11:27 -0700 | [diff] [blame] | 92 | */ |
| 93 | #define XFS_BMAPI_REMAP 0x100 |
| 94 | |
Darrick J. Wong | 3993bae | 2016-10-03 09:11:32 -0700 | [diff] [blame] | 95 | /* Map something in the CoW fork. */ |
| 96 | #define XFS_BMAPI_COWFORK 0x200 |
| 97 | |
Brian Foster | fcb762f | 2018-05-09 08:45:04 -0700 | [diff] [blame] | 98 | /* Skip online discard of freed extents */ |
| 99 | #define XFS_BMAPI_NODISCARD 0x1000 |
| 100 | |
Darrick J. Wong | 95eb308 | 2018-05-09 10:02:32 -0700 | [diff] [blame] | 101 | /* Do not update the rmap btree. Used for reconstructing bmbt from rmapbt. */ |
| 102 | #define XFS_BMAPI_NORMAP 0x2000 |
| 103 | |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 104 | #define XFS_BMAPI_FLAGS \ |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 105 | { XFS_BMAPI_ENTIRE, "ENTIRE" }, \ |
| 106 | { XFS_BMAPI_METADATA, "METADATA" }, \ |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 107 | { XFS_BMAPI_ATTRFORK, "ATTRFORK" }, \ |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 108 | { XFS_BMAPI_PREALLOC, "PREALLOC" }, \ |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 109 | { XFS_BMAPI_CONTIG, "CONTIG" }, \ |
Dave Chinner | 3fbbbea | 2015-11-03 12:27:22 +1100 | [diff] [blame] | 110 | { XFS_BMAPI_CONVERT, "CONVERT" }, \ |
Darrick J. Wong | f65306e | 2016-10-03 09:11:27 -0700 | [diff] [blame] | 111 | { XFS_BMAPI_ZERO, "ZERO" }, \ |
Darrick J. Wong | 3993bae | 2016-10-03 09:11:32 -0700 | [diff] [blame] | 112 | { XFS_BMAPI_REMAP, "REMAP" }, \ |
Christoph Hellwig | d2b3964 | 2017-01-20 09:31:54 -0800 | [diff] [blame] | 113 | { XFS_BMAPI_COWFORK, "COWFORK" }, \ |
Darrick J. Wong | 95eb308 | 2018-05-09 10:02:32 -0700 | [diff] [blame] | 114 | { XFS_BMAPI_NODISCARD, "NODISCARD" }, \ |
| 115 | { XFS_BMAPI_NORMAP, "NORMAP" } |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 116 | |
| 117 | |
Nathan Scott | a844f45 | 2005-11-02 14:38:42 +1100 | [diff] [blame] | 118 | static inline int xfs_bmapi_aflag(int w) |
| 119 | { |
Darrick J. Wong | 3993bae | 2016-10-03 09:11:32 -0700 | [diff] [blame] | 120 | return (w == XFS_ATTR_FORK ? XFS_BMAPI_ATTRFORK : |
| 121 | (w == XFS_COW_FORK ? XFS_BMAPI_COWFORK : 0)); |
| 122 | } |
| 123 | |
| 124 | static inline int xfs_bmapi_whichfork(int bmapi_flags) |
| 125 | { |
| 126 | if (bmapi_flags & XFS_BMAPI_COWFORK) |
| 127 | return XFS_COW_FORK; |
| 128 | else if (bmapi_flags & XFS_BMAPI_ATTRFORK) |
| 129 | return XFS_ATTR_FORK; |
| 130 | return XFS_DATA_FORK; |
Nathan Scott | a844f45 | 2005-11-02 14:38:42 +1100 | [diff] [blame] | 131 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | |
| 133 | /* |
| 134 | * Special values for xfs_bmbt_irec_t br_startblock field. |
| 135 | */ |
| 136 | #define DELAYSTARTBLOCK ((xfs_fsblock_t)-1LL) |
| 137 | #define HOLESTARTBLOCK ((xfs_fsblock_t)-2LL) |
| 138 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | /* |
Christoph Hellwig | 7574aa9 | 2009-11-25 00:00:19 +0000 | [diff] [blame] | 140 | * Flags for xfs_bmap_add_extent*. |
| 141 | */ |
| 142 | #define BMAP_LEFT_CONTIG (1 << 0) |
| 143 | #define BMAP_RIGHT_CONTIG (1 << 1) |
| 144 | #define BMAP_LEFT_FILLING (1 << 2) |
| 145 | #define BMAP_RIGHT_FILLING (1 << 3) |
| 146 | #define BMAP_LEFT_DELAY (1 << 4) |
| 147 | #define BMAP_RIGHT_DELAY (1 << 5) |
| 148 | #define BMAP_LEFT_VALID (1 << 6) |
| 149 | #define BMAP_RIGHT_VALID (1 << 7) |
Christoph Hellwig | 6ef3554 | 2009-11-25 00:00:21 +0000 | [diff] [blame] | 150 | #define BMAP_ATTRFORK (1 << 8) |
Darrick J. Wong | 3993bae | 2016-10-03 09:11:32 -0700 | [diff] [blame] | 151 | #define BMAP_COWFORK (1 << 9) |
Christoph Hellwig | 7574aa9 | 2009-11-25 00:00:19 +0000 | [diff] [blame] | 152 | |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 153 | #define XFS_BMAP_EXT_FLAGS \ |
| 154 | { BMAP_LEFT_CONTIG, "LC" }, \ |
| 155 | { BMAP_RIGHT_CONTIG, "RC" }, \ |
| 156 | { BMAP_LEFT_FILLING, "LF" }, \ |
| 157 | { BMAP_RIGHT_FILLING, "RF" }, \ |
Darrick J. Wong | 3993bae | 2016-10-03 09:11:32 -0700 | [diff] [blame] | 158 | { BMAP_ATTRFORK, "ATTR" }, \ |
| 159 | { BMAP_COWFORK, "COW" } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | |
Namjae Jeon | e1d8fb8 | 2014-02-24 10:58:19 +1100 | [diff] [blame] | 161 | |
| 162 | /* |
Christoph Hellwig | 9c4f29d | 2017-03-28 14:53:35 -0700 | [diff] [blame] | 163 | * Return true if the extent is a real, allocated extent, or false if it is a |
| 164 | * delayed allocation, and unwritten extent or a hole. |
| 165 | */ |
| 166 | static inline bool xfs_bmap_is_real_extent(struct xfs_bmbt_irec *irec) |
| 167 | { |
| 168 | return irec->br_state != XFS_EXT_UNWRITTEN && |
| 169 | irec->br_startblock != HOLESTARTBLOCK && |
| 170 | irec->br_startblock != DELAYSTARTBLOCK && |
| 171 | !isnullstartblock(irec->br_startblock); |
| 172 | } |
| 173 | |
Darrick J. Wong | 0a0af28 | 2016-10-20 15:51:50 +1100 | [diff] [blame] | 174 | void xfs_trim_extent(struct xfs_bmbt_irec *irec, xfs_fileoff_t bno, |
| 175 | xfs_filblks_t len); |
Christoph Hellwig | d952e2f | 2011-09-18 20:41:07 +0000 | [diff] [blame] | 176 | int xfs_bmap_add_attrfork(struct xfs_inode *ip, int size, int rsvd); |
Allison Henderson | 2f3cd80 | 2018-10-18 17:21:16 +1100 | [diff] [blame] | 177 | int xfs_bmap_set_attrforkoff(struct xfs_inode *ip, int size, int *version); |
Dave Chinner | f3508bc | 2013-07-10 07:04:00 +1000 | [diff] [blame] | 178 | void xfs_bmap_local_to_extents_empty(struct xfs_inode *ip, int whichfork); |
Brian Foster | 0f37d17 | 2018-08-01 07:20:34 -0700 | [diff] [blame] | 179 | void __xfs_bmap_add_free(struct xfs_trans *tp, xfs_fsblock_t bno, |
Darrick J. Wong | 66e3237 | 2018-12-12 08:46:23 -0800 | [diff] [blame] | 180 | xfs_filblks_t len, const struct xfs_owner_info *oinfo, |
Brian Foster | 0f37d17 | 2018-08-01 07:20:34 -0700 | [diff] [blame] | 181 | bool skip_discard); |
Christoph Hellwig | d952e2f | 2011-09-18 20:41:07 +0000 | [diff] [blame] | 182 | void xfs_bmap_compute_maxlevels(struct xfs_mount *mp, int whichfork); |
| 183 | int xfs_bmap_first_unused(struct xfs_trans *tp, struct xfs_inode *ip, |
| 184 | xfs_extlen_t len, xfs_fileoff_t *unused, int whichfork); |
| 185 | int xfs_bmap_last_before(struct xfs_trans *tp, struct xfs_inode *ip, |
| 186 | xfs_fileoff_t *last_block, int whichfork); |
Eric Sandeen | 7fb2cd4 | 2014-04-14 18:58:05 +1000 | [diff] [blame] | 187 | int xfs_bmap_last_offset(struct xfs_inode *ip, xfs_fileoff_t *unused, |
| 188 | int whichfork); |
Christoph Hellwig | d952e2f | 2011-09-18 20:41:07 +0000 | [diff] [blame] | 189 | int xfs_bmap_one_block(struct xfs_inode *ip, int whichfork); |
Dave Chinner | 5c8ed20 | 2011-09-18 20:40:45 +0000 | [diff] [blame] | 190 | int xfs_bmapi_read(struct xfs_inode *ip, xfs_fileoff_t bno, |
| 191 | xfs_filblks_t len, struct xfs_bmbt_irec *mval, |
| 192 | int *nmap, int flags); |
Dave Chinner | c0dc782 | 2011-09-18 20:40:52 +0000 | [diff] [blame] | 193 | int xfs_bmapi_write(struct xfs_trans *tp, struct xfs_inode *ip, |
| 194 | xfs_fileoff_t bno, xfs_filblks_t len, int flags, |
Brian Foster | a7beabe | 2018-07-11 22:26:25 -0700 | [diff] [blame] | 195 | xfs_extlen_t total, struct xfs_bmbt_irec *mval, int *nmap); |
Darrick J. Wong | 4453593 | 2016-10-03 09:11:29 -0700 | [diff] [blame] | 196 | int __xfs_bunmapi(struct xfs_trans *tp, struct xfs_inode *ip, |
| 197 | xfs_fileoff_t bno, xfs_filblks_t *rlen, int flags, |
Brian Foster | 2af5284 | 2018-07-11 22:26:25 -0700 | [diff] [blame] | 198 | xfs_extnum_t nexts); |
Christoph Hellwig | d952e2f | 2011-09-18 20:41:07 +0000 | [diff] [blame] | 199 | int xfs_bunmapi(struct xfs_trans *tp, struct xfs_inode *ip, |
| 200 | xfs_fileoff_t bno, xfs_filblks_t len, int flags, |
Brian Foster | 2af5284 | 2018-07-11 22:26:25 -0700 | [diff] [blame] | 201 | xfs_extnum_t nexts, int *done); |
Christoph Hellwig | fa5c836 | 2016-10-20 15:54:14 +1100 | [diff] [blame] | 202 | int xfs_bmap_del_extent_delay(struct xfs_inode *ip, int whichfork, |
Christoph Hellwig | b2b1712 | 2017-11-03 10:34:43 -0700 | [diff] [blame] | 203 | struct xfs_iext_cursor *cur, struct xfs_bmbt_irec *got, |
Christoph Hellwig | fa5c836 | 2016-10-20 15:54:14 +1100 | [diff] [blame] | 204 | struct xfs_bmbt_irec *del); |
Christoph Hellwig | b2b1712 | 2017-11-03 10:34:43 -0700 | [diff] [blame] | 205 | void xfs_bmap_del_extent_cow(struct xfs_inode *ip, |
| 206 | struct xfs_iext_cursor *cur, struct xfs_bmbt_irec *got, |
| 207 | struct xfs_bmbt_irec *del); |
Christoph Hellwig | d952e2f | 2011-09-18 20:41:07 +0000 | [diff] [blame] | 208 | uint xfs_default_attroffset(struct xfs_inode *ip); |
Christoph Hellwig | ecfea3f | 2017-10-19 11:07:11 -0700 | [diff] [blame] | 209 | int xfs_bmap_collapse_extents(struct xfs_trans *tp, struct xfs_inode *ip, |
Namjae Jeon | a904b1c | 2015-03-25 15:08:56 +1100 | [diff] [blame] | 210 | xfs_fileoff_t *next_fsb, xfs_fileoff_t offset_shift_fsb, |
Brian Foster | 333f950 | 2018-07-11 22:26:27 -0700 | [diff] [blame] | 211 | bool *done); |
Darrick J. Wong | f62cb48 | 2018-06-21 23:26:57 -0700 | [diff] [blame] | 212 | int xfs_bmap_can_insert_extents(struct xfs_inode *ip, xfs_fileoff_t off, |
| 213 | xfs_fileoff_t shift); |
Christoph Hellwig | ecfea3f | 2017-10-19 11:07:11 -0700 | [diff] [blame] | 214 | int xfs_bmap_insert_extents(struct xfs_trans *tp, struct xfs_inode *ip, |
| 215 | xfs_fileoff_t *next_fsb, xfs_fileoff_t offset_shift_fsb, |
Brian Foster | 333f950 | 2018-07-11 22:26:27 -0700 | [diff] [blame] | 216 | bool *done, xfs_fileoff_t stop_fsb); |
Namjae Jeon | a904b1c | 2015-03-25 15:08:56 +1100 | [diff] [blame] | 217 | int xfs_bmap_split_extent(struct xfs_inode *ip, xfs_fileoff_t split_offset); |
Darrick J. Wong | be51f81 | 2016-10-03 09:11:32 -0700 | [diff] [blame] | 218 | int xfs_bmapi_reserve_delalloc(struct xfs_inode *ip, int whichfork, |
Brian Foster | 974ae92 | 2016-11-28 14:57:42 +1100 | [diff] [blame] | 219 | xfs_fileoff_t off, xfs_filblks_t len, xfs_filblks_t prealloc, |
Christoph Hellwig | b2b1712 | 2017-11-03 10:34:43 -0700 | [diff] [blame] | 220 | struct xfs_bmbt_irec *got, struct xfs_iext_cursor *cur, |
| 221 | int eof); |
Christoph Hellwig | 491ce61 | 2019-02-15 08:02:49 -0800 | [diff] [blame] | 222 | int xfs_bmapi_convert_delalloc(struct xfs_inode *ip, int whichfork, |
| 223 | xfs_fileoff_t offset_fsb, struct xfs_bmbt_irec *imap, |
| 224 | unsigned int *seq); |
Christoph Hellwig | 26b91c7 | 2019-02-18 09:38:48 -0800 | [diff] [blame] | 225 | int xfs_bmap_add_extent_unwritten_real(struct xfs_trans *tp, |
| 226 | struct xfs_inode *ip, int whichfork, |
| 227 | struct xfs_iext_cursor *icur, struct xfs_btree_cur **curp, |
| 228 | struct xfs_bmbt_irec *new, int *logflagsp); |
Christoph Hellwig | 1a5902c | 2009-03-29 19:26:46 +0200 | [diff] [blame] | 229 | |
Brian Foster | fcb762f | 2018-05-09 08:45:04 -0700 | [diff] [blame] | 230 | static inline void |
| 231 | xfs_bmap_add_free( |
Brian Foster | 0f37d17 | 2018-08-01 07:20:34 -0700 | [diff] [blame] | 232 | struct xfs_trans *tp, |
Brian Foster | fcb762f | 2018-05-09 08:45:04 -0700 | [diff] [blame] | 233 | xfs_fsblock_t bno, |
| 234 | xfs_filblks_t len, |
Darrick J. Wong | 66e3237 | 2018-12-12 08:46:23 -0800 | [diff] [blame] | 235 | const struct xfs_owner_info *oinfo) |
Brian Foster | fcb762f | 2018-05-09 08:45:04 -0700 | [diff] [blame] | 236 | { |
Brian Foster | 0f37d17 | 2018-08-01 07:20:34 -0700 | [diff] [blame] | 237 | __xfs_bmap_add_free(tp, bno, len, oinfo, false); |
Brian Foster | fcb762f | 2018-05-09 08:45:04 -0700 | [diff] [blame] | 238 | } |
| 239 | |
Darrick J. Wong | 77d61fe | 2016-10-03 09:11:26 -0700 | [diff] [blame] | 240 | enum xfs_bmap_intent_type { |
| 241 | XFS_BMAP_MAP = 1, |
| 242 | XFS_BMAP_UNMAP, |
| 243 | }; |
| 244 | |
| 245 | struct xfs_bmap_intent { |
| 246 | struct list_head bi_list; |
| 247 | enum xfs_bmap_intent_type bi_type; |
| 248 | struct xfs_inode *bi_owner; |
| 249 | int bi_whichfork; |
| 250 | struct xfs_bmbt_irec bi_bmap; |
| 251 | }; |
| 252 | |
Brian Foster | 7dbddba | 2018-08-01 07:20:32 -0700 | [diff] [blame] | 253 | int xfs_bmap_finish_one(struct xfs_trans *tp, struct xfs_inode *ip, |
| 254 | enum xfs_bmap_intent_type type, int whichfork, |
| 255 | xfs_fileoff_t startoff, xfs_fsblock_t startblock, |
Darrick J. Wong | e1a4e37 | 2017-06-14 21:25:57 -0700 | [diff] [blame] | 256 | xfs_filblks_t *blockcount, xfs_exntst_t state); |
Brian Foster | 0f37d17 | 2018-08-01 07:20:34 -0700 | [diff] [blame] | 257 | int xfs_bmap_map_extent(struct xfs_trans *tp, struct xfs_inode *ip, |
| 258 | struct xfs_bmbt_irec *imap); |
| 259 | int xfs_bmap_unmap_extent(struct xfs_trans *tp, struct xfs_inode *ip, |
| 260 | struct xfs_bmbt_irec *imap); |
Darrick J. Wong | 9f3afb5 | 2016-10-03 09:11:28 -0700 | [diff] [blame] | 261 | |
Christoph Hellwig | 060ea65 | 2017-10-19 11:02:29 -0700 | [diff] [blame] | 262 | static inline int xfs_bmap_fork_to_state(int whichfork) |
| 263 | { |
| 264 | switch (whichfork) { |
| 265 | case XFS_ATTR_FORK: |
| 266 | return BMAP_ATTRFORK; |
| 267 | case XFS_COW_FORK: |
| 268 | return BMAP_COWFORK; |
| 269 | default: |
| 270 | return 0; |
| 271 | } |
| 272 | } |
| 273 | |
Darrick J. Wong | 30b0984 | 2018-03-23 10:06:52 -0700 | [diff] [blame] | 274 | xfs_failaddr_t xfs_bmap_validate_extent(struct xfs_inode *ip, int whichfork, |
| 275 | struct xfs_bmbt_irec *irec); |
| 276 | |
Darrick J. Wong | 7cf199b | 2018-05-14 06:34:34 -0700 | [diff] [blame] | 277 | int xfs_bmapi_remap(struct xfs_trans *tp, struct xfs_inode *ip, |
| 278 | xfs_fileoff_t bno, xfs_filblks_t len, xfs_fsblock_t startblock, |
Brian Foster | ff3edf2 | 2018-07-11 22:26:14 -0700 | [diff] [blame] | 279 | int flags); |
Darrick J. Wong | 7cf199b | 2018-05-14 06:34:34 -0700 | [diff] [blame] | 280 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | #endif /* __XFS_BMAP_H__ */ |