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