We'll add more modes that affect scanning.
Signed-off-by: David Sterba <dsterba@suse.com>
disk_super = fs_info->super_copy;
ret = btrfs_read_dev_super(fs_info->fs_devices->latest_bdev,
- disk_super, fs_info->super_bytenr, 1);
+ disk_super, fs_info->super_bytenr,
+ SBREAD_RECOVER);
if (ret) {
fprintf(stderr, "No valid btrfs found\n");
goto out_devices;
}
sb = (struct btrfs_super_block*)buf;
- ret = btrfs_read_dev_super(fd, sb, BTRFS_SUPER_INFO_OFFSET, 1);
+ ret = btrfs_read_dev_super(fd, sb, BTRFS_SUPER_INFO_OFFSET,
+ SBREAD_RECOVER);
if (ret) {
fprintf(stderr, "read super block error\n");
goto out_close_fd;
goto out_close_fd;
}
- ret = btrfs_scan_fs_devices(fd, path, &fs_devices, 0, 1, 0);
+ ret = btrfs_scan_fs_devices(fd, path, &fs_devices, 0, SBREAD_RECOVER, 0);
if (ret)
goto out_close_fd;
disk_super = (struct btrfs_super_block *)buf;
ret = btrfs_read_dev_super(fd, disk_super,
- BTRFS_SUPER_INFO_OFFSET, 0);
+ BTRFS_SUPER_INFO_OFFSET, SBREAD_DEFAULT);
if (ret)
goto out;
int btrfs_scan_fs_devices(int fd, const char *path,
struct btrfs_fs_devices **fs_devices,
- u64 sb_bytenr, int super_recover,
+ u64 sb_bytenr, unsigned sbflags,
int skip_devices)
{
u64 total_devs;
}
ret = btrfs_scan_one_device(fd, path, fs_devices,
- &total_devs, sb_bytenr, super_recover);
+ &total_devs, sb_bytenr, sbflags);
if (ret) {
fprintf(stderr, "No valid Btrfs found on %s\n", path);
return ret;
fs_info->ignore_chunk_tree_error = 1;
ret = btrfs_scan_fs_devices(fp, path, &fs_devices, sb_bytenr,
- (flags & OPEN_CTREE_RECOVER_SUPER),
- (flags & OPEN_CTREE_NO_DEVICES));
+ (flags & OPEN_CTREE_RECOVER_SUPER) ? SBREAD_RECOVER : SBREAD_DEFAULT,
+ (flags & OPEN_CTREE_NO_DEVICES));
if (ret)
goto out;
disk_super = fs_info->super_copy;
if (flags & OPEN_CTREE_RECOVER_SUPER)
- ret = btrfs_read_dev_super(fs_devices->latest_bdev,
- disk_super, sb_bytenr, 1);
+ ret = btrfs_read_dev_super(fs_devices->latest_bdev, disk_super,
+ sb_bytenr, SBREAD_RECOVER);
else
- ret = btrfs_read_dev_super(fp, disk_super, sb_bytenr, 0);
+ ret = btrfs_read_dev_super(fp, disk_super, sb_bytenr,
+ SBREAD_DEFAULT);
if (ret) {
printk("No valid btrfs found\n");
goto out_devices;
* - number of devices - something sane
* - sys array size - maximum
*/
-static int check_super(struct btrfs_super_block *sb)
+static int check_super(struct btrfs_super_block *sb, unsigned sbflags)
{
char result[BTRFS_CSUM_SIZE];
u32 crc;
}
int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr,
- int super_recover)
+ unsigned sbflags)
{
u8 fsid[BTRFS_FSID_SIZE];
int fsid_is_initialized = 0;
struct btrfs_super_block *buf = (struct btrfs_super_block *)tmp;
int i;
int ret;
- int max_super = super_recover ? BTRFS_SUPER_MIRROR_MAX : 1;
+ int max_super = sbflags & SBREAD_RECOVER ? BTRFS_SUPER_MIRROR_MAX : 1;
u64 transid = 0;
u64 bytenr;
if (btrfs_super_bytenr(buf) != sb_bytenr)
return -1;
- if (check_super(buf))
+ if (check_super(buf, sbflags))
return -1;
memcpy(sb, buf, BTRFS_SUPER_INFO_SIZE);
return 0;
/* if magic is NULL, the device was removed */
if (btrfs_super_magic(buf) == 0 && i == 0)
break;
- if (check_super(buf))
+ if (check_super(buf, sbflags))
continue;
if (!fsid_is_initialized) {
OPEN_CTREE_IGNORE_CHUNK_TREE_ERROR = (1 << 11)
};
+/*
+ * Modes of superblock access
+ */
+enum btrfs_read_sb_flags {
+ SBREAD_DEFAULT = 0,
+ /* Reading superblock during recovery */
+ SBREAD_RECOVER = (1 << 0),
+};
+
static inline u64 btrfs_sb_offset(int mirror)
{
u64 start = 16 * 1024;
void btrfs_cleanup_all_caches(struct btrfs_fs_info *fs_info);
int btrfs_scan_fs_devices(int fd, const char *path,
struct btrfs_fs_devices **fs_devices, u64 sb_bytenr,
- int super_recover, int skip_devices);
+ unsigned sbflags, int skip_devices);
int btrfs_setup_chunk_tree_and_device_map(struct btrfs_fs_info *fs_info,
u64 chunk_root_bytenr);
int write_ctree_super(struct btrfs_trans_handle *trans,
struct btrfs_root *root);
int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr,
- int super_recover);
+ unsigned sbflags);
int btrfs_map_bh_to_logical(struct btrfs_root *root, struct extent_buffer *bh,
u64 logical);
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
}
init_recover_superblock(&recover);
- ret = btrfs_scan_fs_devices(fd, dname, &recover.fs_devices, 0, 1, 0);
+ ret = btrfs_scan_fs_devices(fd, dname, &recover.fs_devices, 0,
+ SBREAD_RECOVER, 0);
close(fd);
if (ret) {
ret = 1;
/* scan the initial device */
ret = btrfs_scan_one_device(fd, file, &fs_devices_mnt,
- &total_devs, BTRFS_SUPER_INFO_OFFSET, 0);
+ &total_devs, BTRFS_SUPER_INFO_OFFSET, SBREAD_DEFAULT);
is_btrfs = (ret >= 0);
/* scan other devices */
continue;
}
ret = btrfs_scan_one_device(fd, path, &tmp_devices,
- &num_devices, BTRFS_SUPER_INFO_OFFSET, 0);
+ &num_devices, BTRFS_SUPER_INFO_OFFSET,
+ SBREAD_DEFAULT);
if (ret) {
error("cannot scan %s: %s", path, strerror(-ret));
close (fd);
int btrfs_scan_one_device(int fd, const char *path,
struct btrfs_fs_devices **fs_devices_ret,
- u64 *total_devs, u64 super_offset, int super_recover)
+ u64 *total_devs, u64 super_offset, unsigned sbflags)
{
struct btrfs_super_block *disk_super;
char buf[BTRFS_SUPER_INFO_SIZE];
u64 devid;
disk_super = (struct btrfs_super_block *)buf;
- ret = btrfs_read_dev_super(fd, disk_super, super_offset, super_recover);
+ ret = btrfs_read_dev_super(fd, disk_super, super_offset, sbflags);
if (ret < 0)
return -EIO;
devid = btrfs_stack_device_id(&disk_super->dev_item);
struct btrfs_device *device);
int btrfs_scan_one_device(int fd, const char *path,
struct btrfs_fs_devices **fs_devices_ret,
- u64 *total_devs, u64 super_offset, int super_recover);
+ u64 *total_devs, u64 super_offset, unsigned sbflags);
int btrfs_num_copies(struct btrfs_mapping_tree *map_tree, u64 logical, u64 len);
struct list_head *btrfs_scanned_uuids(void);
int btrfs_add_system_chunk(struct btrfs_trans_handle *trans,