1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * Copyright (C) 2007 Oracle. All rights reserved. |
4 | */ |
5 | |
6 | #ifndef BTRFS_VOLUMES_H |
7 | #define BTRFS_VOLUMES_H |
8 | |
9 | #include <linux/blk_types.h> |
10 | #include <linux/sizes.h> |
11 | #include <linux/atomic.h> |
12 | #include <linux/sort.h> |
13 | #include <linux/list.h> |
14 | #include <linux/mutex.h> |
15 | #include <linux/log2.h> |
16 | #include <linux/kobject.h> |
17 | #include <linux/refcount.h> |
18 | #include <linux/completion.h> |
19 | #include <linux/rbtree.h> |
20 | #include <uapi/linux/btrfs.h> |
21 | #include "messages.h" |
22 | #include "rcu-string.h" |
23 | |
24 | struct block_device; |
25 | struct bdev_handle; |
26 | struct btrfs_fs_info; |
27 | struct btrfs_block_group; |
28 | struct btrfs_trans_handle; |
29 | struct btrfs_zoned_device_info; |
30 | |
31 | #define BTRFS_MAX_DATA_CHUNK_SIZE (10ULL * SZ_1G) |
32 | |
33 | extern struct mutex uuid_mutex; |
34 | |
35 | #define BTRFS_STRIPE_LEN SZ_64K |
36 | #define BTRFS_STRIPE_LEN_SHIFT (16) |
37 | #define BTRFS_STRIPE_LEN_MASK (BTRFS_STRIPE_LEN - 1) |
38 | |
39 | static_assert(const_ilog2(BTRFS_STRIPE_LEN) == BTRFS_STRIPE_LEN_SHIFT); |
40 | |
41 | /* Used by sanity check for btrfs_raid_types. */ |
42 | #define const_ffs(n) (__builtin_ctzll(n) + 1) |
43 | |
44 | /* |
45 | * The conversion from BTRFS_BLOCK_GROUP_* bits to btrfs_raid_type requires |
46 | * RAID0 always to be the lowest profile bit. |
47 | * Although it's part of on-disk format and should never change, do extra |
48 | * compile-time sanity checks. |
49 | */ |
50 | static_assert(const_ffs(BTRFS_BLOCK_GROUP_RAID0) < |
51 | const_ffs(BTRFS_BLOCK_GROUP_PROFILE_MASK & ~BTRFS_BLOCK_GROUP_RAID0)); |
52 | static_assert(const_ilog2(BTRFS_BLOCK_GROUP_RAID0) > |
53 | ilog2(BTRFS_BLOCK_GROUP_TYPE_MASK)); |
54 | |
55 | /* ilog2() can handle both constants and variables */ |
56 | #define BTRFS_BG_FLAG_TO_INDEX(profile) \ |
57 | ilog2((profile) >> (ilog2(BTRFS_BLOCK_GROUP_RAID0) - 1)) |
58 | |
59 | enum btrfs_raid_types { |
60 | /* SINGLE is the special one as it doesn't have on-disk bit. */ |
61 | BTRFS_RAID_SINGLE = 0, |
62 | |
63 | BTRFS_RAID_RAID0 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID0), |
64 | BTRFS_RAID_RAID1 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID1), |
65 | BTRFS_RAID_DUP = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_DUP), |
66 | BTRFS_RAID_RAID10 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID10), |
67 | BTRFS_RAID_RAID5 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID5), |
68 | BTRFS_RAID_RAID6 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID6), |
69 | BTRFS_RAID_RAID1C3 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID1C3), |
70 | BTRFS_RAID_RAID1C4 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID1C4), |
71 | |
72 | BTRFS_NR_RAID_TYPES |
73 | }; |
74 | |
75 | /* |
76 | * Use sequence counter to get consistent device stat data on |
77 | * 32-bit processors. |
78 | */ |
79 | #if BITS_PER_LONG==32 && defined(CONFIG_SMP) |
80 | #include <linux/seqlock.h> |
81 | #define __BTRFS_NEED_DEVICE_DATA_ORDERED |
82 | #define btrfs_device_data_ordered_init(device) \ |
83 | seqcount_init(&device->data_seqcount) |
84 | #else |
85 | #define btrfs_device_data_ordered_init(device) do { } while (0) |
86 | #endif |
87 | |
88 | #define BTRFS_DEV_STATE_WRITEABLE (0) |
89 | #define BTRFS_DEV_STATE_IN_FS_METADATA (1) |
90 | #define BTRFS_DEV_STATE_MISSING (2) |
91 | #define BTRFS_DEV_STATE_REPLACE_TGT (3) |
92 | #define BTRFS_DEV_STATE_FLUSH_SENT (4) |
93 | #define BTRFS_DEV_STATE_NO_READA (5) |
94 | |
95 | struct btrfs_fs_devices; |
96 | |
97 | struct btrfs_device { |
98 | struct list_head dev_list; /* device_list_mutex */ |
99 | struct list_head dev_alloc_list; /* chunk mutex */ |
100 | struct list_head post_commit_list; /* chunk mutex */ |
101 | struct btrfs_fs_devices *fs_devices; |
102 | struct btrfs_fs_info *fs_info; |
103 | |
104 | struct rcu_string __rcu *name; |
105 | |
106 | u64 generation; |
107 | |
108 | struct file *bdev_file; |
109 | struct block_device *bdev; |
110 | |
111 | struct btrfs_zoned_device_info *zone_info; |
112 | |
113 | /* |
114 | * Device's major-minor number. Must be set even if the device is not |
115 | * opened (bdev == NULL), unless the device is missing. |
116 | */ |
117 | dev_t devt; |
118 | unsigned long dev_state; |
119 | blk_status_t last_flush_error; |
120 | |
121 | #ifdef __BTRFS_NEED_DEVICE_DATA_ORDERED |
122 | seqcount_t data_seqcount; |
123 | #endif |
124 | |
125 | /* the internal btrfs device id */ |
126 | u64 devid; |
127 | |
128 | /* size of the device in memory */ |
129 | u64 total_bytes; |
130 | |
131 | /* size of the device on disk */ |
132 | u64 disk_total_bytes; |
133 | |
134 | /* bytes used */ |
135 | u64 bytes_used; |
136 | |
137 | /* optimal io alignment for this device */ |
138 | u32 io_align; |
139 | |
140 | /* optimal io width for this device */ |
141 | u32 io_width; |
142 | /* type and info about this device */ |
143 | u64 type; |
144 | |
145 | /* minimal io size for this device */ |
146 | u32 sector_size; |
147 | |
148 | /* physical drive uuid (or lvm uuid) */ |
149 | u8 uuid[BTRFS_UUID_SIZE]; |
150 | |
151 | /* |
152 | * size of the device on the current transaction |
153 | * |
154 | * This variant is update when committing the transaction, |
155 | * and protected by chunk mutex |
156 | */ |
157 | u64 commit_total_bytes; |
158 | |
159 | /* bytes used on the current transaction */ |
160 | u64 commit_bytes_used; |
161 | |
162 | /* Bio used for flushing device barriers */ |
163 | struct bio flush_bio; |
164 | struct completion flush_wait; |
165 | |
166 | /* per-device scrub information */ |
167 | struct scrub_ctx *scrub_ctx; |
168 | |
169 | /* disk I/O failure stats. For detailed description refer to |
170 | * enum btrfs_dev_stat_values in ioctl.h */ |
171 | int dev_stats_valid; |
172 | |
173 | /* Counter to record the change of device stats */ |
174 | atomic_t dev_stats_ccnt; |
175 | atomic_t dev_stat_values[BTRFS_DEV_STAT_VALUES_MAX]; |
176 | |
177 | struct extent_io_tree alloc_state; |
178 | |
179 | struct completion kobj_unregister; |
180 | /* For sysfs/FSID/devinfo/devid/ */ |
181 | struct kobject devid_kobj; |
182 | |
183 | /* Bandwidth limit for scrub, in bytes */ |
184 | u64 scrub_speed_max; |
185 | }; |
186 | |
187 | /* |
188 | * Block group or device which contains an active swapfile. Used for preventing |
189 | * unsafe operations while a swapfile is active. |
190 | * |
191 | * These are sorted on (ptr, inode) (note that a block group or device can |
192 | * contain more than one swapfile). We compare the pointer values because we |
193 | * don't actually care what the object is, we just need a quick check whether |
194 | * the object exists in the rbtree. |
195 | */ |
196 | struct btrfs_swapfile_pin { |
197 | struct rb_node node; |
198 | void *ptr; |
199 | struct inode *inode; |
200 | /* |
201 | * If true, ptr points to a struct btrfs_block_group. Otherwise, ptr |
202 | * points to a struct btrfs_device. |
203 | */ |
204 | bool is_block_group; |
205 | /* |
206 | * Only used when 'is_block_group' is true and it is the number of |
207 | * extents used by a swapfile for this block group ('ptr' field). |
208 | */ |
209 | int bg_extent_count; |
210 | }; |
211 | |
212 | /* |
213 | * If we read those variants at the context of their own lock, we needn't |
214 | * use the following helpers, reading them directly is safe. |
215 | */ |
216 | #if BITS_PER_LONG==32 && defined(CONFIG_SMP) |
217 | #define BTRFS_DEVICE_GETSET_FUNCS(name) \ |
218 | static inline u64 \ |
219 | btrfs_device_get_##name(const struct btrfs_device *dev) \ |
220 | { \ |
221 | u64 size; \ |
222 | unsigned int seq; \ |
223 | \ |
224 | do { \ |
225 | seq = read_seqcount_begin(&dev->data_seqcount); \ |
226 | size = dev->name; \ |
227 | } while (read_seqcount_retry(&dev->data_seqcount, seq)); \ |
228 | return size; \ |
229 | } \ |
230 | \ |
231 | static inline void \ |
232 | btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \ |
233 | { \ |
234 | preempt_disable(); \ |
235 | write_seqcount_begin(&dev->data_seqcount); \ |
236 | dev->name = size; \ |
237 | write_seqcount_end(&dev->data_seqcount); \ |
238 | preempt_enable(); \ |
239 | } |
240 | #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION) |
241 | #define BTRFS_DEVICE_GETSET_FUNCS(name) \ |
242 | static inline u64 \ |
243 | btrfs_device_get_##name(const struct btrfs_device *dev) \ |
244 | { \ |
245 | u64 size; \ |
246 | \ |
247 | preempt_disable(); \ |
248 | size = dev->name; \ |
249 | preempt_enable(); \ |
250 | return size; \ |
251 | } \ |
252 | \ |
253 | static inline void \ |
254 | btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \ |
255 | { \ |
256 | preempt_disable(); \ |
257 | dev->name = size; \ |
258 | preempt_enable(); \ |
259 | } |
260 | #else |
261 | #define BTRFS_DEVICE_GETSET_FUNCS(name) \ |
262 | static inline u64 \ |
263 | btrfs_device_get_##name(const struct btrfs_device *dev) \ |
264 | { \ |
265 | return dev->name; \ |
266 | } \ |
267 | \ |
268 | static inline void \ |
269 | btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \ |
270 | { \ |
271 | dev->name = size; \ |
272 | } |
273 | #endif |
274 | |
275 | BTRFS_DEVICE_GETSET_FUNCS(total_bytes); |
276 | BTRFS_DEVICE_GETSET_FUNCS(disk_total_bytes); |
277 | BTRFS_DEVICE_GETSET_FUNCS(bytes_used); |
278 | |
279 | enum btrfs_chunk_allocation_policy { |
280 | BTRFS_CHUNK_ALLOC_REGULAR, |
281 | BTRFS_CHUNK_ALLOC_ZONED, |
282 | }; |
283 | |
284 | /* |
285 | * Read policies for mirrored block group profiles, read picks the stripe based |
286 | * on these policies. |
287 | */ |
288 | enum btrfs_read_policy { |
289 | /* Use process PID to choose the stripe */ |
290 | BTRFS_READ_POLICY_PID, |
291 | BTRFS_NR_READ_POLICY, |
292 | }; |
293 | |
294 | #ifdef CONFIG_BTRFS_DEBUG |
295 | /* |
296 | * Checksum mode - offload it to workqueues or do it synchronously in |
297 | * btrfs_submit_chunk(). |
298 | */ |
299 | enum btrfs_offload_csum_mode { |
300 | /* |
301 | * Choose offloading checksum or do it synchronously automatically. |
302 | * Do it synchronously if the checksum is fast, or offload to workqueues |
303 | * otherwise. |
304 | */ |
305 | BTRFS_OFFLOAD_CSUM_AUTO, |
306 | /* Always offload checksum to workqueues. */ |
307 | BTRFS_OFFLOAD_CSUM_FORCE_ON, |
308 | /* Never offload checksum to workqueues. */ |
309 | BTRFS_OFFLOAD_CSUM_FORCE_OFF, |
310 | }; |
311 | #endif |
312 | |
313 | struct btrfs_fs_devices { |
314 | u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ |
315 | |
316 | /* |
317 | * UUID written into the btree blocks: |
318 | * |
319 | * - If metadata_uuid != fsid then super block must have |
320 | * BTRFS_FEATURE_INCOMPAT_METADATA_UUID flag set. |
321 | * |
322 | * - Following shall be true at all times: |
323 | * - metadata_uuid == btrfs_header::fsid |
324 | * - metadata_uuid == btrfs_dev_item::fsid |
325 | * |
326 | * - Relations between fsid and metadata_uuid in sb and fs_devices: |
327 | * - Normal: |
328 | * fs_devices->fsid == fs_devices->metadata_uuid == sb->fsid |
329 | * sb->metadata_uuid == 0 |
330 | * |
331 | * - When the BTRFS_FEATURE_INCOMPAT_METADATA_UUID flag is set: |
332 | * fs_devices->fsid == sb->fsid |
333 | * fs_devices->metadata_uuid == sb->metadata_uuid |
334 | * |
335 | * - When in-memory fs_devices->temp_fsid is true |
336 | * fs_devices->fsid = random |
337 | * fs_devices->metadata_uuid == sb->fsid |
338 | */ |
339 | u8 metadata_uuid[BTRFS_FSID_SIZE]; |
340 | |
341 | struct list_head fs_list; |
342 | |
343 | /* |
344 | * Number of devices under this fsid including missing and |
345 | * replace-target device and excludes seed devices. |
346 | */ |
347 | u64 num_devices; |
348 | |
349 | /* |
350 | * The number of devices that successfully opened, including |
351 | * replace-target, excludes seed devices. |
352 | */ |
353 | u64 open_devices; |
354 | |
355 | /* The number of devices that are under the chunk allocation list. */ |
356 | u64 rw_devices; |
357 | |
358 | /* Count of missing devices under this fsid excluding seed device. */ |
359 | u64 missing_devices; |
360 | u64 total_rw_bytes; |
361 | |
362 | /* |
363 | * Count of devices from btrfs_super_block::num_devices for this fsid, |
364 | * which includes the seed device, excludes the transient replace-target |
365 | * device. |
366 | */ |
367 | u64 total_devices; |
368 | |
369 | /* Highest generation number of seen devices */ |
370 | u64 latest_generation; |
371 | |
372 | /* |
373 | * The mount device or a device with highest generation after removal |
374 | * or replace. |
375 | */ |
376 | struct btrfs_device *latest_dev; |
377 | |
378 | /* |
379 | * All of the devices in the filesystem, protected by a mutex so we can |
380 | * safely walk it to write out the super blocks without worrying about |
381 | * adding/removing by the multi-device code. Scrubbing super block can |
382 | * kick off supers writing by holding this mutex lock. |
383 | */ |
384 | struct mutex device_list_mutex; |
385 | |
386 | /* List of all devices, protected by device_list_mutex */ |
387 | struct list_head devices; |
388 | |
389 | /* Devices which can satisfy space allocation. Protected by * chunk_mutex. */ |
390 | struct list_head alloc_list; |
391 | |
392 | struct list_head seed_list; |
393 | |
394 | /* Count fs-devices opened. */ |
395 | int opened; |
396 | |
397 | /* Set when we find or add a device that doesn't have the nonrot flag set. */ |
398 | bool rotating; |
399 | /* Devices support TRIM/discard commands. */ |
400 | bool discardable; |
401 | /* The filesystem is a seed filesystem. */ |
402 | bool seeding; |
403 | /* The mount needs to use a randomly generated fsid. */ |
404 | bool temp_fsid; |
405 | |
406 | struct btrfs_fs_info *fs_info; |
407 | /* sysfs kobjects */ |
408 | struct kobject fsid_kobj; |
409 | struct kobject *devices_kobj; |
410 | struct kobject *devinfo_kobj; |
411 | struct completion kobj_unregister; |
412 | |
413 | enum btrfs_chunk_allocation_policy chunk_alloc_policy; |
414 | |
415 | /* Policy used to read the mirrored stripes. */ |
416 | enum btrfs_read_policy read_policy; |
417 | |
418 | #ifdef CONFIG_BTRFS_DEBUG |
419 | /* Checksum mode - offload it or do it synchronously. */ |
420 | enum btrfs_offload_csum_mode offload_csum_mode; |
421 | #endif |
422 | }; |
423 | |
424 | #define BTRFS_MAX_DEVS(info) ((BTRFS_MAX_ITEM_SIZE(info) \ |
425 | - sizeof(struct btrfs_chunk)) \ |
426 | / sizeof(struct btrfs_stripe) + 1) |
427 | |
428 | #define BTRFS_MAX_DEVS_SYS_CHUNK ((BTRFS_SYSTEM_CHUNK_ARRAY_SIZE \ |
429 | - 2 * sizeof(struct btrfs_disk_key) \ |
430 | - 2 * sizeof(struct btrfs_chunk)) \ |
431 | / sizeof(struct btrfs_stripe) + 1) |
432 | |
433 | struct btrfs_io_stripe { |
434 | struct btrfs_device *dev; |
435 | /* Block mapping. */ |
436 | u64 physical; |
437 | u64 length; |
438 | bool is_scrub; |
439 | /* For the endio handler. */ |
440 | struct btrfs_io_context *bioc; |
441 | }; |
442 | |
443 | struct btrfs_discard_stripe { |
444 | struct btrfs_device *dev; |
445 | u64 physical; |
446 | u64 length; |
447 | }; |
448 | |
449 | /* |
450 | * Context for IO subsmission for device stripe. |
451 | * |
452 | * - Track the unfinished mirrors for mirror based profiles |
453 | * Mirror based profiles are SINGLE/DUP/RAID1/RAID10. |
454 | * |
455 | * - Contain the logical -> physical mapping info |
456 | * Used by submit_stripe_bio() for mapping logical bio |
457 | * into physical device address. |
458 | * |
459 | * - Contain device replace info |
460 | * Used by handle_ops_on_dev_replace() to copy logical bios |
461 | * into the new device. |
462 | * |
463 | * - Contain RAID56 full stripe logical bytenrs |
464 | */ |
465 | struct btrfs_io_context { |
466 | refcount_t refs; |
467 | struct btrfs_fs_info *fs_info; |
468 | /* Taken from struct btrfs_chunk_map::type. */ |
469 | u64 map_type; |
470 | struct bio *orig_bio; |
471 | atomic_t error; |
472 | u16 max_errors; |
473 | |
474 | u64 logical; |
475 | u64 size; |
476 | /* Raid stripe tree ordered entry. */ |
477 | struct list_head rst_ordered_entry; |
478 | |
479 | /* |
480 | * The total number of stripes, including the extra duplicated |
481 | * stripe for replace. |
482 | */ |
483 | u16 num_stripes; |
484 | |
485 | /* |
486 | * The mirror_num of this bioc. |
487 | * |
488 | * This is for reads which use 0 as mirror_num, thus we should return a |
489 | * valid mirror_num (>0) for the reader. |
490 | */ |
491 | u16 mirror_num; |
492 | |
493 | /* |
494 | * The following two members are for dev-replace case only. |
495 | * |
496 | * @replace_nr_stripes: Number of duplicated stripes which need to be |
497 | * written to replace target. |
498 | * Should be <= 2 (2 for DUP, otherwise <= 1). |
499 | * @replace_stripe_src: The array indicates where the duplicated stripes |
500 | * are from. |
501 | * |
502 | * The @replace_stripe_src[] array is mostly for RAID56 cases. |
503 | * As non-RAID56 stripes share the same contents of the mapped range, |
504 | * thus no need to bother where the duplicated ones are from. |
505 | * |
506 | * But for RAID56 case, all stripes contain different contents, thus |
507 | * we need a way to know the mapping. |
508 | * |
509 | * There is an example for the two members, using a RAID5 write: |
510 | * |
511 | * num_stripes: 4 (3 + 1 duplicated write) |
512 | * stripes[0]: dev = devid 1, physical = X |
513 | * stripes[1]: dev = devid 2, physical = Y |
514 | * stripes[2]: dev = devid 3, physical = Z |
515 | * stripes[3]: dev = devid 0, physical = Y |
516 | * |
517 | * replace_nr_stripes = 1 |
518 | * replace_stripe_src = 1 <- Means stripes[1] is involved in replace. |
519 | * The duplicated stripe index would be |
520 | * (@num_stripes - 1). |
521 | * |
522 | * Note, that we can still have cases replace_nr_stripes = 2 for DUP. |
523 | * In that case, all stripes share the same content, thus we don't |
524 | * need to bother @replace_stripe_src value at all. |
525 | */ |
526 | u16 replace_nr_stripes; |
527 | s16 replace_stripe_src; |
528 | /* |
529 | * Logical bytenr of the full stripe start, only for RAID56 cases. |
530 | * |
531 | * When this value is set to other than (u64)-1, the stripes[] should |
532 | * follow this pattern: |
533 | * |
534 | * (real_stripes = num_stripes - replace_nr_stripes) |
535 | * (data_stripes = (is_raid6) ? (real_stripes - 2) : (real_stripes - 1)) |
536 | * |
537 | * stripes[0]: The first data stripe |
538 | * stripes[1]: The second data stripe |
539 | * ... |
540 | * stripes[data_stripes - 1]: The last data stripe |
541 | * stripes[data_stripes]: The P stripe |
542 | * stripes[data_stripes + 1]: The Q stripe (only for RAID6). |
543 | */ |
544 | u64 full_stripe_logical; |
545 | struct btrfs_io_stripe stripes[]; |
546 | }; |
547 | |
548 | struct btrfs_device_info { |
549 | struct btrfs_device *dev; |
550 | u64 dev_offset; |
551 | u64 max_avail; |
552 | u64 total_avail; |
553 | }; |
554 | |
555 | struct btrfs_raid_attr { |
556 | u8 sub_stripes; /* sub_stripes info for map */ |
557 | u8 dev_stripes; /* stripes per dev */ |
558 | u8 devs_max; /* max devs to use */ |
559 | u8 devs_min; /* min devs needed */ |
560 | u8 tolerated_failures; /* max tolerated fail devs */ |
561 | u8 devs_increment; /* ndevs has to be a multiple of this */ |
562 | u8 ncopies; /* how many copies to data has */ |
563 | u8 nparity; /* number of stripes worth of bytes to store |
564 | * parity information */ |
565 | u8 mindev_error; /* error code if min devs requisite is unmet */ |
566 | const char raid_name[8]; /* name of the raid */ |
567 | u64 bg_flag; /* block group flag of the raid */ |
568 | }; |
569 | |
570 | extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES]; |
571 | |
572 | struct btrfs_chunk_map { |
573 | struct rb_node rb_node; |
574 | /* For mount time dev extent verification. */ |
575 | int verified_stripes; |
576 | refcount_t refs; |
577 | u64 start; |
578 | u64 chunk_len; |
579 | u64 stripe_size; |
580 | u64 type; |
581 | int io_align; |
582 | int io_width; |
583 | int num_stripes; |
584 | int sub_stripes; |
585 | struct btrfs_io_stripe stripes[]; |
586 | }; |
587 | |
588 | #define btrfs_chunk_map_size(n) (sizeof(struct btrfs_chunk_map) + \ |
589 | (sizeof(struct btrfs_io_stripe) * (n))) |
590 | |
591 | static inline void btrfs_free_chunk_map(struct btrfs_chunk_map *map) |
592 | { |
593 | if (map && refcount_dec_and_test(r: &map->refs)) { |
594 | ASSERT(RB_EMPTY_NODE(&map->rb_node)); |
595 | kfree(objp: map); |
596 | } |
597 | } |
598 | |
599 | struct btrfs_balance_control { |
600 | struct btrfs_balance_args data; |
601 | struct btrfs_balance_args meta; |
602 | struct btrfs_balance_args sys; |
603 | |
604 | u64 flags; |
605 | |
606 | struct btrfs_balance_progress stat; |
607 | }; |
608 | |
609 | /* |
610 | * Search for a given device by the set parameters |
611 | */ |
612 | struct btrfs_dev_lookup_args { |
613 | u64 devid; |
614 | u8 *uuid; |
615 | u8 *fsid; |
616 | bool missing; |
617 | }; |
618 | |
619 | /* We have to initialize to -1 because BTRFS_DEV_REPLACE_DEVID is 0 */ |
620 | #define BTRFS_DEV_LOOKUP_ARGS_INIT { .devid = (u64)-1 } |
621 | |
622 | #define BTRFS_DEV_LOOKUP_ARGS(name) \ |
623 | struct btrfs_dev_lookup_args name = BTRFS_DEV_LOOKUP_ARGS_INIT |
624 | |
625 | enum btrfs_map_op { |
626 | BTRFS_MAP_READ, |
627 | BTRFS_MAP_WRITE, |
628 | BTRFS_MAP_GET_READ_MIRRORS, |
629 | }; |
630 | |
631 | static inline enum btrfs_map_op btrfs_op(struct bio *bio) |
632 | { |
633 | switch (bio_op(bio)) { |
634 | case REQ_OP_WRITE: |
635 | case REQ_OP_ZONE_APPEND: |
636 | return BTRFS_MAP_WRITE; |
637 | default: |
638 | WARN_ON_ONCE(1); |
639 | fallthrough; |
640 | case REQ_OP_READ: |
641 | return BTRFS_MAP_READ; |
642 | } |
643 | } |
644 | |
645 | static inline unsigned long btrfs_chunk_item_size(int num_stripes) |
646 | { |
647 | ASSERT(num_stripes); |
648 | return sizeof(struct btrfs_chunk) + |
649 | sizeof(struct btrfs_stripe) * (num_stripes - 1); |
650 | } |
651 | |
652 | /* |
653 | * Do the type safe conversion from stripe_nr to offset inside the chunk. |
654 | * |
655 | * @stripe_nr is u32, with left shift it can overflow u32 for chunks larger |
656 | * than 4G. This does the proper type cast to avoid overflow. |
657 | */ |
658 | static inline u64 btrfs_stripe_nr_to_offset(u32 stripe_nr) |
659 | { |
660 | return (u64)stripe_nr << BTRFS_STRIPE_LEN_SHIFT; |
661 | } |
662 | |
663 | void btrfs_get_bioc(struct btrfs_io_context *bioc); |
664 | void btrfs_put_bioc(struct btrfs_io_context *bioc); |
665 | int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, |
666 | u64 logical, u64 *length, |
667 | struct btrfs_io_context **bioc_ret, |
668 | struct btrfs_io_stripe *smap, int *mirror_num_ret); |
669 | int btrfs_map_repair_block(struct btrfs_fs_info *fs_info, |
670 | struct btrfs_io_stripe *smap, u64 logical, |
671 | u32 length, int mirror_num); |
672 | struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info, |
673 | u64 logical, u64 *length_ret, |
674 | u32 *num_stripes); |
675 | int btrfs_read_sys_array(struct btrfs_fs_info *fs_info); |
676 | int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info); |
677 | struct btrfs_block_group *btrfs_create_chunk(struct btrfs_trans_handle *trans, |
678 | u64 type); |
679 | void btrfs_mapping_tree_free(struct btrfs_fs_info *fs_info); |
680 | int btrfs_open_devices(struct btrfs_fs_devices *fs_devices, |
681 | blk_mode_t flags, void *holder); |
682 | struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags, |
683 | bool mount_arg_dev); |
684 | int btrfs_forget_devices(dev_t devt); |
685 | void btrfs_close_devices(struct btrfs_fs_devices *fs_devices); |
686 | void (struct btrfs_fs_devices *fs_devices); |
687 | void btrfs_assign_next_active_device(struct btrfs_device *device, |
688 | struct btrfs_device *this_dev); |
689 | struct btrfs_device *btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, |
690 | u64 devid, |
691 | const char *devpath); |
692 | int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info, |
693 | struct btrfs_dev_lookup_args *args, |
694 | const char *path); |
695 | struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info, |
696 | const u64 *devid, const u8 *uuid, |
697 | const char *path); |
698 | void btrfs_put_dev_args_from_path(struct btrfs_dev_lookup_args *args); |
699 | int btrfs_rm_device(struct btrfs_fs_info *fs_info, |
700 | struct btrfs_dev_lookup_args *args, |
701 | struct file **bdev_file); |
702 | void __exit btrfs_cleanup_fs_uuids(void); |
703 | int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len); |
704 | int btrfs_grow_device(struct btrfs_trans_handle *trans, |
705 | struct btrfs_device *device, u64 new_size); |
706 | struct btrfs_device *btrfs_find_device(const struct btrfs_fs_devices *fs_devices, |
707 | const struct btrfs_dev_lookup_args *args); |
708 | int btrfs_shrink_device(struct btrfs_device *device, u64 new_size); |
709 | int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *path); |
710 | int btrfs_balance(struct btrfs_fs_info *fs_info, |
711 | struct btrfs_balance_control *bctl, |
712 | struct btrfs_ioctl_balance_args *bargs); |
713 | void btrfs_describe_block_groups(u64 flags, char *buf, u32 size_buf); |
714 | int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info); |
715 | int btrfs_recover_balance(struct btrfs_fs_info *fs_info); |
716 | int btrfs_pause_balance(struct btrfs_fs_info *fs_info); |
717 | int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset); |
718 | int btrfs_cancel_balance(struct btrfs_fs_info *fs_info); |
719 | int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info); |
720 | int btrfs_uuid_scan_kthread(void *data); |
721 | bool btrfs_chunk_writeable(struct btrfs_fs_info *fs_info, u64 chunk_offset); |
722 | void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index); |
723 | int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info, |
724 | struct btrfs_ioctl_get_dev_stats *stats); |
725 | int btrfs_init_devices_late(struct btrfs_fs_info *fs_info); |
726 | int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info); |
727 | int btrfs_run_dev_stats(struct btrfs_trans_handle *trans); |
728 | void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_device *srcdev); |
729 | void btrfs_rm_dev_replace_free_srcdev(struct btrfs_device *srcdev); |
730 | void btrfs_destroy_dev_replace_tgtdev(struct btrfs_device *tgtdev); |
731 | int btrfs_is_parity_mirror(struct btrfs_fs_info *fs_info, |
732 | u64 logical, u64 len); |
733 | unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info, |
734 | u64 logical); |
735 | u64 btrfs_calc_stripe_length(const struct btrfs_chunk_map *map); |
736 | int btrfs_nr_parity_stripes(u64 type); |
737 | int btrfs_chunk_alloc_add_chunk_item(struct btrfs_trans_handle *trans, |
738 | struct btrfs_block_group *bg); |
739 | int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset); |
740 | |
741 | #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS |
742 | struct btrfs_chunk_map *btrfs_alloc_chunk_map(int num_stripes, gfp_t gfp); |
743 | int btrfs_add_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map); |
744 | #endif |
745 | |
746 | struct btrfs_chunk_map *btrfs_clone_chunk_map(struct btrfs_chunk_map *map, gfp_t gfp); |
747 | struct btrfs_chunk_map *btrfs_find_chunk_map(struct btrfs_fs_info *fs_info, |
748 | u64 logical, u64 length); |
749 | struct btrfs_chunk_map *btrfs_find_chunk_map_nolock(struct btrfs_fs_info *fs_info, |
750 | u64 logical, u64 length); |
751 | struct btrfs_chunk_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info, |
752 | u64 logical, u64 length); |
753 | void btrfs_remove_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map); |
754 | void btrfs_release_disk_super(struct btrfs_super_block *super); |
755 | |
756 | static inline void btrfs_dev_stat_inc(struct btrfs_device *dev, |
757 | int index) |
758 | { |
759 | atomic_inc(v: dev->dev_stat_values + index); |
760 | /* |
761 | * This memory barrier orders stores updating statistics before stores |
762 | * updating dev_stats_ccnt. |
763 | * |
764 | * It pairs with smp_rmb() in btrfs_run_dev_stats(). |
765 | */ |
766 | smp_mb__before_atomic(); |
767 | atomic_inc(v: &dev->dev_stats_ccnt); |
768 | } |
769 | |
770 | static inline int btrfs_dev_stat_read(struct btrfs_device *dev, |
771 | int index) |
772 | { |
773 | return atomic_read(v: dev->dev_stat_values + index); |
774 | } |
775 | |
776 | static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device *dev, |
777 | int index) |
778 | { |
779 | int ret; |
780 | |
781 | ret = atomic_xchg(v: dev->dev_stat_values + index, new: 0); |
782 | /* |
783 | * atomic_xchg implies a full memory barriers as per atomic_t.txt: |
784 | * - RMW operations that have a return value are fully ordered; |
785 | * |
786 | * This implicit memory barriers is paired with the smp_rmb in |
787 | * btrfs_run_dev_stats |
788 | */ |
789 | atomic_inc(v: &dev->dev_stats_ccnt); |
790 | return ret; |
791 | } |
792 | |
793 | static inline void btrfs_dev_stat_set(struct btrfs_device *dev, |
794 | int index, unsigned long val) |
795 | { |
796 | atomic_set(v: dev->dev_stat_values + index, i: val); |
797 | /* |
798 | * This memory barrier orders stores updating statistics before stores |
799 | * updating dev_stats_ccnt. |
800 | * |
801 | * It pairs with smp_rmb() in btrfs_run_dev_stats(). |
802 | */ |
803 | smp_mb__before_atomic(); |
804 | atomic_inc(v: &dev->dev_stats_ccnt); |
805 | } |
806 | |
807 | static inline const char *btrfs_dev_name(const struct btrfs_device *device) |
808 | { |
809 | if (!device || test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) |
810 | return "<missing disk>" ; |
811 | else |
812 | return rcu_str_deref(device->name); |
813 | } |
814 | |
815 | void btrfs_commit_device_sizes(struct btrfs_transaction *trans); |
816 | |
817 | struct list_head * __attribute_const__ btrfs_get_fs_uuids(void); |
818 | bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info, |
819 | struct btrfs_device *failing_dev); |
820 | void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info, struct btrfs_device *device); |
821 | |
822 | enum btrfs_raid_types __attribute_const__ btrfs_bg_flags_to_raid_index(u64 flags); |
823 | int btrfs_bg_type_to_factor(u64 flags); |
824 | const char *btrfs_bg_type_to_raid_name(u64 flags); |
825 | int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info); |
826 | bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical); |
827 | |
828 | bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr); |
829 | u8 *btrfs_sb_fsid_ptr(struct btrfs_super_block *sb); |
830 | |
831 | #endif |
832 | |