1 /* SPDX-License-Identifier: GPL-2.0 */ 2 3 #ifndef BTRFS_EXTENT_IO_H 4 #define BTRFS_EXTENT_IO_H 5 6 #include <linux/rbtree.h> 7 #include <linux/refcount.h> 8 #include <linux/fiemap.h> 9 #include <linux/btrfs_tree.h> 10 #include "ulist.h" 11 12 /* 13 * flags for bio submission. The high bits indicate the compression 14 * type for this bio 15 */ 16 #define EXTENT_BIO_COMPRESSED 1 17 #define EXTENT_BIO_FLAG_SHIFT 16 18 19 enum { 20 EXTENT_BUFFER_UPTODATE, 21 EXTENT_BUFFER_DIRTY, 22 EXTENT_BUFFER_CORRUPT, 23 /* this got triggered by readahead */ 24 EXTENT_BUFFER_READAHEAD, 25 EXTENT_BUFFER_TREE_REF, 26 EXTENT_BUFFER_STALE, 27 EXTENT_BUFFER_WRITEBACK, 28 /* read IO error */ 29 EXTENT_BUFFER_READ_ERR, 30 EXTENT_BUFFER_UNMAPPED, 31 EXTENT_BUFFER_IN_TREE, 32 /* write IO error */ 33 EXTENT_BUFFER_WRITE_ERR, 34 EXTENT_BUFFER_NO_CHECK, 35 }; 36 37 /* these are flags for __process_pages_contig */ 38 #define PAGE_UNLOCK (1 << 0) 39 /* Page starts writeback, clear dirty bit and set writeback bit */ 40 #define PAGE_START_WRITEBACK (1 << 1) 41 #define PAGE_END_WRITEBACK (1 << 2) 42 #define PAGE_SET_ORDERED (1 << 3) 43 #define PAGE_SET_ERROR (1 << 4) 44 #define PAGE_LOCK (1 << 5) 45 46 /* 47 * page->private values. Every page that is controlled by the extent 48 * map has page->private set to one. 49 */ 50 #define EXTENT_PAGE_PRIVATE 1 51 52 /* 53 * The extent buffer bitmap operations are done with byte granularity instead of 54 * word granularity for two reasons: 55 * 1. The bitmaps must be little-endian on disk. 56 * 2. Bitmap items are not guaranteed to be aligned to a word and therefore a 57 * single word in a bitmap may straddle two pages in the extent buffer. 58 */ 59 #define BIT_BYTE(nr) ((nr) / BITS_PER_BYTE) 60 #define BYTE_MASK ((1 << BITS_PER_BYTE) - 1) 61 #define BITMAP_FIRST_BYTE_MASK(start) \ 62 ((BYTE_MASK << ((start) & (BITS_PER_BYTE - 1))) & BYTE_MASK) 63 #define BITMAP_LAST_BYTE_MASK(nbits) \ 64 (BYTE_MASK >> (-(nbits) & (BITS_PER_BYTE - 1))) 65 66 struct btrfs_root; 67 struct btrfs_inode; 68 struct btrfs_io_bio; 69 struct btrfs_fs_info; 70 struct io_failure_record; 71 struct extent_io_tree; 72 73 typedef blk_status_t (submit_bio_hook_t)(struct inode *inode, struct bio *bio, 74 int mirror_num, 75 unsigned long bio_flags); 76 77 typedef blk_status_t (extent_submit_bio_start_t)(struct inode *inode, 78 struct bio *bio, u64 dio_file_offset); 79 80 #define INLINE_EXTENT_BUFFER_PAGES (BTRFS_MAX_METADATA_BLOCKSIZE / PAGE_SIZE) 81 struct extent_buffer { 82 u64 start; 83 unsigned long len; 84 unsigned long bflags; 85 struct btrfs_fs_info *fs_info; 86 spinlock_t refs_lock; 87 atomic_t refs; 88 atomic_t io_pages; 89 int read_mirror; 90 struct rcu_head rcu_head; 91 pid_t lock_owner; 92 /* >= 0 if eb belongs to a log tree, -1 otherwise */ 93 s8 log_index; 94 95 struct rw_semaphore lock; 96 97 struct page *pages[INLINE_EXTENT_BUFFER_PAGES]; 98 struct list_head release_list; 99 #ifdef CONFIG_BTRFS_DEBUG 100 struct list_head leak_list; 101 #endif 102 }; 103 104 /* 105 * Structure to record info about the bio being assembled, and other info like 106 * how many bytes are there before stripe/ordered extent boundary. 107 */ 108 struct btrfs_bio_ctrl { 109 struct bio *bio; 110 unsigned long bio_flags; 111 u32 len_to_stripe_boundary; 112 u32 len_to_oe_boundary; 113 }; 114 115 /* 116 * Structure to record how many bytes and which ranges are set/cleared 117 */ 118 struct extent_changeset { 119 /* How many bytes are set/cleared in this operation */ 120 unsigned int bytes_changed; 121 122 /* Changed ranges */ 123 struct ulist range_changed; 124 }; 125 126 static inline void extent_changeset_init(struct extent_changeset *changeset) 127 { 128 changeset->bytes_changed = 0; 129 ulist_init(&changeset->range_changed); 130 } 131 132 static inline struct extent_changeset *extent_changeset_alloc(void) 133 { 134 struct extent_changeset *ret; 135 136 ret = kmalloc(sizeof(*ret), GFP_KERNEL); 137 if (!ret) 138 return NULL; 139 140 extent_changeset_init(ret); 141 return ret; 142 } 143 144 static inline void extent_changeset_release(struct extent_changeset *changeset) 145 { 146 if (!changeset) 147 return; 148 changeset->bytes_changed = 0; 149 ulist_release(&changeset->range_changed); 150 } 151 152 static inline void extent_changeset_free(struct extent_changeset *changeset) 153 { 154 if (!changeset) 155 return; 156 extent_changeset_release(changeset); 157 kfree(changeset); 158 } 159 160 static inline void extent_set_compress_type(unsigned long *bio_flags, 161 int compress_type) 162 { 163 *bio_flags |= compress_type << EXTENT_BIO_FLAG_SHIFT; 164 } 165 166 static inline int extent_compress_type(unsigned long bio_flags) 167 { 168 return bio_flags >> EXTENT_BIO_FLAG_SHIFT; 169 } 170 171 struct extent_map_tree; 172 173 typedef struct extent_map *(get_extent_t)(struct btrfs_inode *inode, 174 struct page *page, size_t pg_offset, 175 u64 start, u64 len); 176 177 int try_release_extent_mapping(struct page *page, gfp_t mask); 178 int try_release_extent_buffer(struct page *page); 179 180 int __must_check submit_one_bio(struct bio *bio, int mirror_num, 181 unsigned long bio_flags); 182 int btrfs_do_readpage(struct page *page, struct extent_map **em_cached, 183 struct btrfs_bio_ctrl *bio_ctrl, 184 unsigned int read_flags, u64 *prev_em_start); 185 int extent_write_full_page(struct page *page, struct writeback_control *wbc); 186 int extent_write_locked_range(struct inode *inode, u64 start, u64 end, 187 int mode); 188 int extent_writepages(struct address_space *mapping, 189 struct writeback_control *wbc); 190 int btree_write_cache_pages(struct address_space *mapping, 191 struct writeback_control *wbc); 192 void extent_readahead(struct readahead_control *rac); 193 int extent_fiemap(struct btrfs_inode *inode, struct fiemap_extent_info *fieinfo, 194 u64 start, u64 len); 195 int set_page_extent_mapped(struct page *page); 196 void clear_page_extent_mapped(struct page *page); 197 198 struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info, 199 u64 start, u64 owner_root, int level); 200 struct extent_buffer *__alloc_dummy_extent_buffer(struct btrfs_fs_info *fs_info, 201 u64 start, unsigned long len); 202 struct extent_buffer *alloc_dummy_extent_buffer(struct btrfs_fs_info *fs_info, 203 u64 start); 204 struct extent_buffer *btrfs_clone_extent_buffer(const struct extent_buffer *src); 205 struct extent_buffer *find_extent_buffer(struct btrfs_fs_info *fs_info, 206 u64 start); 207 void free_extent_buffer(struct extent_buffer *eb); 208 void free_extent_buffer_stale(struct extent_buffer *eb); 209 #define WAIT_NONE 0 210 #define WAIT_COMPLETE 1 211 #define WAIT_PAGE_LOCK 2 212 int read_extent_buffer_pages(struct extent_buffer *eb, int wait, 213 int mirror_num); 214 void wait_on_extent_buffer_writeback(struct extent_buffer *eb); 215 void btrfs_readahead_tree_block(struct btrfs_fs_info *fs_info, 216 u64 bytenr, u64 owner_root, u64 gen, int level); 217 void btrfs_readahead_node_child(struct extent_buffer *node, int slot); 218 219 static inline int num_extent_pages(const struct extent_buffer *eb) 220 { 221 /* 222 * For sectorsize == PAGE_SIZE case, since nodesize is always aligned to 223 * sectorsize, it's just eb->len >> PAGE_SHIFT. 224 * 225 * For sectorsize < PAGE_SIZE case, we could have nodesize < PAGE_SIZE, 226 * thus have to ensure we get at least one page. 227 */ 228 return (eb->len >> PAGE_SHIFT) ?: 1; 229 } 230 231 static inline int extent_buffer_uptodate(const struct extent_buffer *eb) 232 { 233 return test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags); 234 } 235 236 int memcmp_extent_buffer(const struct extent_buffer *eb, const void *ptrv, 237 unsigned long start, unsigned long len); 238 void read_extent_buffer(const struct extent_buffer *eb, void *dst, 239 unsigned long start, 240 unsigned long len); 241 int read_extent_buffer_to_user_nofault(const struct extent_buffer *eb, 242 void __user *dst, unsigned long start, 243 unsigned long len); 244 void write_extent_buffer_fsid(const struct extent_buffer *eb, const void *src); 245 void write_extent_buffer_chunk_tree_uuid(const struct extent_buffer *eb, 246 const void *src); 247 void write_extent_buffer(const struct extent_buffer *eb, const void *src, 248 unsigned long start, unsigned long len); 249 void copy_extent_buffer_full(const struct extent_buffer *dst, 250 const struct extent_buffer *src); 251 void copy_extent_buffer(const struct extent_buffer *dst, 252 const struct extent_buffer *src, 253 unsigned long dst_offset, unsigned long src_offset, 254 unsigned long len); 255 void memcpy_extent_buffer(const struct extent_buffer *dst, 256 unsigned long dst_offset, unsigned long src_offset, 257 unsigned long len); 258 void memmove_extent_buffer(const struct extent_buffer *dst, 259 unsigned long dst_offset, unsigned long src_offset, 260 unsigned long len); 261 void memzero_extent_buffer(const struct extent_buffer *eb, unsigned long start, 262 unsigned long len); 263 int extent_buffer_test_bit(const struct extent_buffer *eb, unsigned long start, 264 unsigned long pos); 265 void extent_buffer_bitmap_set(const struct extent_buffer *eb, unsigned long start, 266 unsigned long pos, unsigned long len); 267 void extent_buffer_bitmap_clear(const struct extent_buffer *eb, 268 unsigned long start, unsigned long pos, 269 unsigned long len); 270 void clear_extent_buffer_dirty(const struct extent_buffer *eb); 271 bool set_extent_buffer_dirty(struct extent_buffer *eb); 272 void set_extent_buffer_uptodate(struct extent_buffer *eb); 273 void clear_extent_buffer_uptodate(struct extent_buffer *eb); 274 int extent_buffer_under_io(const struct extent_buffer *eb); 275 void extent_range_clear_dirty_for_io(struct inode *inode, u64 start, u64 end); 276 void extent_range_redirty_for_io(struct inode *inode, u64 start, u64 end); 277 void extent_clear_unlock_delalloc(struct btrfs_inode *inode, u64 start, u64 end, 278 struct page *locked_page, 279 u32 bits_to_clear, unsigned long page_ops); 280 struct bio *btrfs_bio_alloc(u64 first_byte); 281 struct bio *btrfs_io_bio_alloc(unsigned int nr_iovecs); 282 struct bio *btrfs_bio_clone(struct bio *bio); 283 struct bio *btrfs_bio_clone_partial(struct bio *orig, u64 offset, u64 size); 284 285 int repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 start, 286 u64 length, u64 logical, struct page *page, 287 unsigned int pg_offset, int mirror_num); 288 void end_extent_writepage(struct page *page, int err, u64 start, u64 end); 289 int btrfs_repair_eb_io_failure(const struct extent_buffer *eb, int mirror_num); 290 291 /* 292 * When IO fails, either with EIO or csum verification fails, we 293 * try other mirrors that might have a good copy of the data. This 294 * io_failure_record is used to record state as we go through all the 295 * mirrors. If another mirror has good data, the sector is set up to date 296 * and things continue. If a good mirror can't be found, the original 297 * bio end_io callback is called to indicate things have failed. 298 */ 299 struct io_failure_record { 300 struct page *page; 301 u64 start; 302 u64 len; 303 u64 logical; 304 unsigned long bio_flags; 305 int this_mirror; 306 int failed_mirror; 307 }; 308 309 int btrfs_repair_one_sector(struct inode *inode, 310 struct bio *failed_bio, u32 bio_offset, 311 struct page *page, unsigned int pgoff, 312 u64 start, int failed_mirror, 313 submit_bio_hook_t *submit_bio_hook); 314 315 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 316 bool find_lock_delalloc_range(struct inode *inode, 317 struct page *locked_page, u64 *start, 318 u64 *end); 319 #endif 320 struct extent_buffer *alloc_test_extent_buffer(struct btrfs_fs_info *fs_info, 321 u64 start); 322 323 #ifdef CONFIG_BTRFS_DEBUG 324 void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info); 325 #else 326 #define btrfs_extent_buffer_leak_debug_check(fs_info) do {} while (0) 327 #endif 328 329 #endif 330