RepoMirrors/btrfs-progs
1
0
Fork 0
mirror of https://github.com/kdave/btrfs-progs synced 2025-02-20 03:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

btrfs-progs: remove temporary buffer for super block

Browse Source 
There are a lot of call sites where we use the following code snippet:

	u8 super_block_data[BTRFS_SUPER_INFO_SIZE];
	struct btrfs_super_block *sb;
	u64 ret;

	sb = (struct btrfs_super_block *)super_block_data;

The reason for this is, structure btrfs_super_block was smaller than
BTRFS_SUPER_INFO_SIZE.

Thus for anything with csum involved, we have to use a proper 4K buffer.

Since the recent unification of sizeof(struct btrfs_super_block), we no
longer need such workaround, and can use struct btrfs_super_block
directly to do any operation.

Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Qu Wenruo 2021-10-21 09:40:19 +08:00 committed by David Sterba
parent 76f1a2ed57
commit 636b2e6027
12 changed files with 112 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
cmds/filesystem-usage.c
View File

@ -668,8 +668,7 @@ static int cmp_device_info(const void *a, const void *b)
int dev_to_fsid(const char *dev, u8 *fsid)
{
struct btrfs_super_block *disk_super;
char buf[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block disk_super;
int ret;
int fd;
@ -679,13 +678,12 @@ int dev_to_fsid(const char *dev, u8 *fsid)
return ret;
}
disk_super = (struct btrfs_super_block *)buf;
ret = btrfs_read_dev_super(fd, disk_super,
ret = btrfs_read_dev_super(fd, &disk_super,
BTRFS_SUPER_INFO_OFFSET, SBREAD_DEFAULT);
if (ret)
goto out;
memcpy(fsid, disk_super->fsid, BTRFS_FSID_SIZE);
memcpy(fsid, disk_super.fsid, BTRFS_FSID_SIZE);
ret = 0;
out:

11
cmds/inspect-dump-super.c
View File

@ -33,13 +33,10 @@
static int load_and_dump_sb(char *filename, int fd, u64 sb_bytenr, int full,
int force)
{
u8 super_block_data[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block *sb;
struct btrfs_super_block sb;
u64 ret;
sb = (struct btrfs_super_block *)super_block_data;
ret = sbread(fd, super_block_data, sb_bytenr);
ret = sbread(fd, &sb, sb_bytenr);
if (ret != BTRFS_SUPER_INFO_SIZE) {
/* check if the disk if too short for further superblock */
if (ret == 0 && errno == 0)
@ -52,11 +49,11 @@ static int load_and_dump_sb(char *filename, int fd, u64 sb_bytenr, int full,
}
printf("superblock: bytenr=%llu, device=%s\n", sb_bytenr, filename);
printf("---------------------------------------------------------\n");
if (btrfs_super_magic(sb) != BTRFS_MAGIC && !force) {
if (btrfs_super_magic(&sb) != BTRFS_MAGIC && !force) {
error("bad magic on superblock on %s at %llu",
filename, (unsigned long long)sb_bytenr);
} else {
btrfs_print_superblock(sb, full);
btrfs_print_superblock(&sb, full);
}
return 0;
}

20
cmds/rescue-chunk-recover.c
View File

@ -1506,8 +1506,7 @@ static int recover_prepare(struct recover_control *rc, const char *path)
{
int ret;
int fd;
struct btrfs_super_block *sb;
char buf[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block sb;
struct btrfs_fs_devices *fs_devices;
ret = 0;
@ -1517,23 +1516,22 @@ static int recover_prepare(struct recover_control *rc, const char *path)
return -1;
}
sb = (struct btrfs_super_block*)buf;
ret = btrfs_read_dev_super(fd, sb, BTRFS_SUPER_INFO_OFFSET,
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;
}
rc->sectorsize = btrfs_super_sectorsize(sb);
rc->nodesize = btrfs_super_nodesize(sb);
rc->generation = btrfs_super_generation(sb);
rc->chunk_root_generation = btrfs_super_chunk_root_generation(sb);
rc->csum_size = btrfs_super_csum_size(sb);
rc->csum_type = btrfs_super_csum_type(sb);
rc->sectorsize = btrfs_super_sectorsize(&sb);
rc->nodesize = btrfs_super_nodesize(&sb);
rc->generation = btrfs_super_generation(&sb);
rc->chunk_root_generation = btrfs_super_chunk_root_generation(&sb);
rc->csum_size = btrfs_super_csum_size(&sb);
rc->csum_type = btrfs_super_csum_type(&sb);
/* if seed, the result of scanning below will be partial */
if (btrfs_super_flags(sb) & BTRFS_SUPER_FLAG_SEEDING) {
if (btrfs_super_flags(&sb) & BTRFS_SUPER_FLAG_SEEDING) {
fprintf(stderr, "this device is seed device\n");
ret = -1;
goto out_close_fd;

11
cmds/rescue-super-recover.c
View File

@ -114,9 +114,8 @@ static int
read_dev_supers(char *filename, struct btrfs_recover_superblock *recover)
{
int i, ret, fd;
u8 buf[BTRFS_SUPER_INFO_SIZE];
u64 max_gen, bytenr;
struct btrfs_super_block *sb = (struct btrfs_super_block *)buf;
struct btrfs_super_block sb;
/* just ignore errno that were set in btrfs_scan_fs_devices() */
errno = 0;
@ -128,13 +127,13 @@ read_dev_supers(char *filename, struct btrfs_recover_superblock *recover)
for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
bytenr = btrfs_sb_offset(i);
ret = btrfs_read_dev_super(fd, sb, bytenr, SBREAD_DEFAULT);
ret = btrfs_read_dev_super(fd, &sb, bytenr, SBREAD_DEFAULT);
if (!ret) {
ret = add_superblock_record(sb, filename, bytenr,
ret = add_superblock_record(&sb, filename, bytenr,
&recover->good_supers);
if (ret)
goto out;
max_gen = btrfs_super_generation(sb);
max_gen = btrfs_super_generation(&sb);
if (max_gen > recover->max_generation)
recover->max_generation = max_gen;
} else if (ret != -ENOENT){
@ -142,7 +141,7 @@ read_dev_supers(char *filename, struct btrfs_recover_superblock *recover)
* Skip superblock which doesn't exist, only adds
* really corrupted superblock
*/
ret = add_superblock_record(sb, filename, bytenr,
ret = add_superblock_record(&sb, filename, bytenr,
&recover->bad_supers);
if (ret)
goto out;

23
common/device-scan.c
View File

@ -269,34 +269,25 @@ int btrfs_register_all_devices(void)
int btrfs_device_already_in_root(struct btrfs_root *root, int fd,
int super_offset)
{
struct btrfs_super_block *disk_super;
char *buf;
struct btrfs_super_block disk_super;
int ret = 0;
buf = malloc(BTRFS_SUPER_INFO_SIZE);
if (!buf) {
ret = -ENOMEM;
goto out;
}
ret = sbread(fd, buf, super_offset);
ret = sbread(fd, &disk_super, super_offset);
if (ret != BTRFS_SUPER_INFO_SIZE)
goto brelse;
goto out;
ret = 0;
disk_super = (struct btrfs_super_block *)buf;
/*
* Accept devices from the same filesystem, allow partially created
* structures.
*/
if (btrfs_super_magic(disk_super) != BTRFS_MAGIC &&
btrfs_super_magic(disk_super) != BTRFS_MAGIC_TEMPORARY)
goto brelse;
if (btrfs_super_magic(&disk_super) != BTRFS_MAGIC &&
btrfs_super_magic(&disk_super) != BTRFS_MAGIC_TEMPORARY)
goto out;
if (!memcmp(disk_super->fsid, root->fs_info->super_copy->fsid,
if (!memcmp(disk_super.fsid, root->fs_info->super_copy->fsid,
BTRFS_FSID_SIZE))
ret = 1;
brelse:
free(buf);
out:
return ret;
}

8
common/utils.c
View File

@ -438,8 +438,7 @@ int get_fs_info(const char *path, struct btrfs_ioctl_fs_info_args *fi_args,
memset(fi_args, 0, sizeof(*fi_args));
if (path_is_block_device(path) == 1) {
struct btrfs_super_block *disk_super;
char buf[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block disk_super;
/* Ensure it's mounted, then set path to the mountpoint */
fd = open(path, O_RDONLY);
@ -460,14 +459,13 @@ int get_fs_info(const char *path, struct btrfs_ioctl_fs_info_args *fi_args,
/* Only fill in this one device */
fi_args->num_devices = 1;
disk_super = (struct btrfs_super_block *)buf;
ret = btrfs_read_dev_super(fd, disk_super,
ret = btrfs_read_dev_super(fd, &disk_super,
BTRFS_SUPER_INFO_OFFSET, 0);
if (ret < 0) {
ret = -EIO;
goto out;
}
last_devid = btrfs_stack_device_id(&disk_super->dev_item);
last_devid = btrfs_stack_device_id(&disk_super.dev_item);
fi_args->max_id = last_devid;
memcpy(fi_args->fsid, fs_devices_mnt->fsid, BTRFS_FSID_SIZE);

79
convert/common.c
View File

@ -91,15 +91,13 @@ static int setup_temp_super(int fd, struct btrfs_mkfs_config *cfg,
u64 root_bytenr, u64 chunk_bytenr)
{
unsigned char chunk_uuid[BTRFS_UUID_SIZE];
char super_buf[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block *super = (struct btrfs_super_block *)super_buf;
struct btrfs_super_block super = {};
int ret;
memset(super_buf, 0, BTRFS_SUPER_INFO_SIZE);
cfg->num_bytes = round_down(cfg->num_bytes, cfg->sectorsize);
if (*cfg->fs_uuid) {
if (uuid_parse(cfg->fs_uuid, super->fsid) != 0) {
if (uuid_parse(cfg->fs_uuid, super.fsid) != 0) {
error("could not parse UUID: %s", cfg->fs_uuid);
ret = -EINVAL;
goto out;
@ -108,43 +106,43 @@ static int setup_temp_super(int fd, struct btrfs_mkfs_config *cfg,
* Caller should make sure the uuid is either unique or OK to
* be duplicate in case it's copied from the source filesystem.
*/
uuid_copy(super->metadata_uuid, super->fsid);
uuid_copy(super.metadata_uuid, super.fsid);
} else {
uuid_generate(super->fsid);
uuid_unparse(super->fsid, cfg->fs_uuid);
uuid_copy(super->metadata_uuid, super->fsid);
uuid_generate(super.fsid);
uuid_unparse(super.fsid, cfg->fs_uuid);
uuid_copy(super.metadata_uuid, super.fsid);
}
uuid_generate(chunk_uuid);
uuid_unparse(chunk_uuid, cfg->chunk_uuid);
btrfs_set_super_bytenr(super, cfg->super_bytenr);
btrfs_set_super_num_devices(super, 1);
btrfs_set_super_magic(super, BTRFS_MAGIC_TEMPORARY);
btrfs_set_super_generation(super, 1);
btrfs_set_super_root(super, root_bytenr);
btrfs_set_super_chunk_root(super, chunk_bytenr);
btrfs_set_super_total_bytes(super, cfg->num_bytes);
btrfs_set_super_bytenr(&super, cfg->super_bytenr);
btrfs_set_super_num_devices(&super, 1);
btrfs_set_super_magic(&super, BTRFS_MAGIC_TEMPORARY);
btrfs_set_super_generation(&super, 1);
btrfs_set_super_root(&super, root_bytenr);
btrfs_set_super_chunk_root(&super, chunk_bytenr);
btrfs_set_super_total_bytes(&super, cfg->num_bytes);
/*
* Temporary filesystem will only have 6 tree roots:
* chunk tree, root tree, extent_tree, device tree, fs tree
* and csum tree.
*/
btrfs_set_super_bytes_used(super, 6 * cfg->nodesize);
btrfs_set_super_sectorsize(super, cfg->sectorsize);
super->__unused_leafsize = cpu_to_le32(cfg->nodesize);
btrfs_set_super_nodesize(super, cfg->nodesize);
btrfs_set_super_stripesize(super, cfg->stripesize);
btrfs_set_super_csum_type(super, cfg->csum_type);
btrfs_set_super_chunk_root(super, chunk_bytenr);
btrfs_set_super_cache_generation(super, -1);
btrfs_set_super_incompat_flags(super, cfg->features);
btrfs_set_super_bytes_used(&super, 6 * cfg->nodesize);
btrfs_set_super_sectorsize(&super, cfg->sectorsize);
super.__unused_leafsize = cpu_to_le32(cfg->nodesize);
btrfs_set_super_nodesize(&super, cfg->nodesize);
btrfs_set_super_stripesize(&super, cfg->stripesize);
btrfs_set_super_csum_type(&super, cfg->csum_type);
btrfs_set_super_chunk_root(&super, chunk_bytenr);
btrfs_set_super_cache_generation(&super, -1);
btrfs_set_super_incompat_flags(&super, cfg->features);
if (cfg->label)
__strncpy_null(super->label, cfg->label, BTRFS_LABEL_SIZE - 1);
__strncpy_null(super.label, cfg->label, BTRFS_LABEL_SIZE - 1);
/* Sys chunk array will be re-initialized at chunk tree init time */
super->sys_chunk_array_size = 0;
super.sys_chunk_array_size = 0;
ret = write_temp_super(fd, super, cfg->super_bytenr);
ret = write_temp_super(fd, &super, cfg->super_bytenr);
out:
return ret;
}
@ -295,13 +293,12 @@ static int insert_temp_dev_item(int fd, struct extent_buffer *buf,
{
struct btrfs_disk_key disk_key;
struct btrfs_dev_item *dev_item;
char super_buf[BTRFS_SUPER_INFO_SIZE];
unsigned char dev_uuid[BTRFS_UUID_SIZE];
unsigned char fsid[BTRFS_FSID_SIZE];
struct btrfs_super_block *super = (struct btrfs_super_block *)super_buf;
struct btrfs_super_block super;
int ret;
ret = pread(fd, super_buf, BTRFS_SUPER_INFO_SIZE, cfg->super_bytenr);
ret = pread(fd, &super, BTRFS_SUPER_INFO_SIZE, cfg->super_bytenr);
if (ret < BTRFS_SUPER_INFO_SIZE) {
ret = (ret < 0 ? -errno : -EIO);
goto out;
@ -342,9 +339,9 @@ static int insert_temp_dev_item(int fd, struct extent_buffer *buf,
btrfs_set_device_type(buf, dev_item, 0);
/* Super dev_item is not complete, copy the complete one to sb */
read_extent_buffer(buf, &super->dev_item, (unsigned long)dev_item,
read_extent_buffer(buf, &super.dev_item, (unsigned long)dev_item,
sizeof(*dev_item));
ret = write_temp_super(fd, super, cfg->super_bytenr);
ret = write_temp_super(fd, &super, cfg->super_bytenr);
(*slot)++;
out:
return ret;
@ -357,12 +354,10 @@ static int insert_temp_chunk_item(int fd, struct extent_buffer *buf,
{
struct btrfs_chunk *chunk;
struct btrfs_disk_key disk_key;
char super_buf[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block *sb = (struct btrfs_super_block *)super_buf;
struct btrfs_super_block sb;
int ret = 0;
ret = pread(fd, super_buf, BTRFS_SUPER_INFO_SIZE,
cfg->super_bytenr);
ret = pread(fd, &sb, BTRFS_SUPER_INFO_SIZE, cfg->super_bytenr);
if (ret < BTRFS_SUPER_INFO_SIZE) {
ret = (ret < 0 ? ret : -EIO);
return ret;
@ -391,7 +386,7 @@ static int insert_temp_chunk_item(int fd, struct extent_buffer *buf,
btrfs_set_stripe_devid_nr(buf, chunk, 0, 1);
/* We are doing 1:1 mapping, so start is its dev offset */
btrfs_set_stripe_offset_nr(buf, chunk, 0, start);
write_extent_buffer(buf, &sb->dev_item.uuid,
write_extent_buffer(buf, sb.dev_item.uuid,
(unsigned long)btrfs_stripe_dev_uuid_nr(chunk, 0),
BTRFS_UUID_SIZE);
(*slot)++;
@ -403,18 +398,18 @@ static int insert_temp_chunk_item(int fd, struct extent_buffer *buf,
char *cur;
u32 array_size;
cur = (char *)sb->sys_chunk_array
+ btrfs_super_sys_array_size(sb);
cur = (char *)sb.sys_chunk_array
+ btrfs_super_sys_array_size(&sb);
memcpy(cur, &disk_key, sizeof(disk_key));
cur += sizeof(disk_key);
read_extent_buffer(buf, cur, (unsigned long int)chunk,
btrfs_chunk_item_size(1));
array_size = btrfs_super_sys_array_size(sb);
array_size = btrfs_super_sys_array_size(&sb);
array_size += btrfs_chunk_item_size(1) +
sizeof(disk_key);
btrfs_set_super_sys_array_size(sb, array_size);
btrfs_set_super_sys_array_size(&sb, array_size);
ret = write_temp_super(fd, sb, cfg->super_bytenr);
ret = write_temp_super(fd, &sb, cfg->super_bytenr);
}
return ret;
}

29
convert/main.c
View File

@ -1066,27 +1066,23 @@ err:
static int migrate_super_block(int fd, u64 old_bytenr)
{
int ret;
struct extent_buffer *buf;
struct btrfs_super_block *super;
struct btrfs_super_block super;
u8 result[BTRFS_CSUM_SIZE] = {};
u32 len;
u32 bytenr;
buf = malloc(sizeof(*buf) + BTRFS_SUPER_INFO_SIZE);
if (!buf)
return -ENOMEM;
buf->len = BTRFS_SUPER_INFO_SIZE;
ret = pread(fd, buf->data, BTRFS_SUPER_INFO_SIZE, old_bytenr);
ret = pread(fd, &super, BTRFS_SUPER_INFO_SIZE, old_bytenr);
if (ret != BTRFS_SUPER_INFO_SIZE)
goto fail;
super = (struct btrfs_super_block *)buf->data;
BUG_ON(btrfs_super_bytenr(super) != old_bytenr);
btrfs_set_super_bytenr(super, BTRFS_SUPER_INFO_OFFSET);
BUG_ON(btrfs_super_bytenr(&super) != old_bytenr);
btrfs_set_super_bytenr(&super, BTRFS_SUPER_INFO_OFFSET);
csum_tree_block_size(buf, btrfs_super_csum_size(super),
0, btrfs_super_csum_type(super));
ret = pwrite(fd, buf->data, BTRFS_SUPER_INFO_SIZE,
btrfs_csum_data(NULL, btrfs_super_csum_type(&super),
(u8 *)&super + BTRFS_CSUM_SIZE, result,
BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
memcpy(&super.csum[0], result, BTRFS_CSUM_SIZE);
ret = pwrite(fd, &super , BTRFS_SUPER_INFO_SIZE,
BTRFS_SUPER_INFO_OFFSET);
if (ret != BTRFS_SUPER_INFO_SIZE)
goto fail;
@ -1095,12 +1091,12 @@ static int migrate_super_block(int fd, u64 old_bytenr)
if (ret)
goto fail;
memset(buf->data, 0, BTRFS_SUPER_INFO_SIZE);
memset(&super, 0, BTRFS_SUPER_INFO_SIZE);
for (bytenr = 0; bytenr < BTRFS_SUPER_INFO_OFFSET; ) {
len = BTRFS_SUPER_INFO_OFFSET - bytenr;
if (len > BTRFS_SUPER_INFO_SIZE)
len = BTRFS_SUPER_INFO_SIZE;
ret = pwrite(fd, buf->data, len, bytenr);
ret = pwrite(fd, &super, len, bytenr);
if (ret != len) {
fprintf(stderr, "unable to zero fill device\n");
break;
@ -1110,7 +1106,6 @@ static int migrate_super_block(int fd, u64 old_bytenr)
ret = 0;
fsync(fd);
fail:
free(buf);
if (ret > 0)
ret = -1;
return ret;

14
image/main.c
View File

@ -2927,12 +2927,11 @@ static int update_disk_super_on_device(struct btrfs_fs_info *info,
struct extent_buffer *leaf;
struct btrfs_path path;
struct btrfs_dev_item *dev_item;
struct btrfs_super_block *disk_super;
struct btrfs_super_block disk_super;
char dev_uuid[BTRFS_UUID_SIZE];
char fs_uuid[BTRFS_UUID_SIZE];
u64 devid, type, io_align, io_width;
u64 sector_size, total_bytes, bytes_used;
char buf[BTRFS_SUPER_INFO_SIZE];
int fp = -1;
int ret;
@ -2982,10 +2981,9 @@ static int update_disk_super_on_device(struct btrfs_fs_info *info,
goto out;
}
memcpy(buf, info->super_copy, BTRFS_SUPER_INFO_SIZE);
memcpy(&disk_super, info->super_copy, BTRFS_SUPER_INFO_SIZE);
disk_super = (struct btrfs_super_block *)buf;
dev_item = &disk_super->dev_item;
dev_item = &disk_super.dev_item;
btrfs_set_stack_device_type(dev_item, type);
btrfs_set_stack_device_id(dev_item, devid);
@ -2996,9 +2994,9 @@ static int update_disk_super_on_device(struct btrfs_fs_info *info,
btrfs_set_stack_device_sector_size(dev_item, sector_size);
memcpy(dev_item->uuid, dev_uuid, BTRFS_UUID_SIZE);
memcpy(dev_item->fsid, fs_uuid, BTRFS_UUID_SIZE);
csum_block((u8 *)buf, BTRFS_SUPER_INFO_SIZE);
csum_block((u8 *)&disk_super, BTRFS_SUPER_INFO_SIZE);
ret = pwrite64(fp, buf, BTRFS_SUPER_INFO_SIZE, BTRFS_SUPER_INFO_OFFSET);
ret = pwrite64(fp, &disk_super, BTRFS_SUPER_INFO_SIZE, BTRFS_SUPER_INFO_OFFSET);
if (ret != BTRFS_SUPER_INFO_SIZE) {
if (ret < 0) {
errno = ret;
@ -3010,7 +3008,7 @@ static int update_disk_super_on_device(struct btrfs_fs_info *info,
goto out;
}
write_backup_supers(fp, (u8 *)buf);
write_backup_supers(fp, (u8 *)&disk_super);
out:
if (fp != -1)

35
kernel-shared/disk-io.c
View File

@ -1619,8 +1619,7 @@ int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr,
u8 fsid[BTRFS_FSID_SIZE];
u8 metadata_uuid[BTRFS_FSID_SIZE];
int fsid_is_initialized = 0;
char tmp[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block *buf = (struct btrfs_super_block *)tmp;
struct btrfs_super_block buf;
int i;
int ret;
int max_super = sbflags & SBREAD_RECOVER ? BTRFS_SUPER_MIRROR_MAX : 1;
@ -1629,7 +1628,7 @@ int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr,
u64 bytenr;
if (sb_bytenr != BTRFS_SUPER_INFO_OFFSET) {
ret = sbread(fd, buf, sb_bytenr);
ret = sbread(fd, &buf, sb_bytenr);
/* real error */
if (ret < 0)
return -errno;
@ -1638,13 +1637,13 @@ int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr,
if (ret < BTRFS_SUPER_INFO_SIZE)
return -ENOENT;
if (btrfs_super_bytenr(buf) != sb_bytenr)
if (btrfs_super_bytenr(&buf) != sb_bytenr)
return -EIO;
ret = btrfs_check_super(buf, sbflags);
ret = btrfs_check_super(&buf, sbflags);
if (ret < 0)
return ret;
memcpy(sb, buf, BTRFS_SUPER_INFO_SIZE);
memcpy(sb, &buf, BTRFS_SUPER_INFO_SIZE);
return 0;
}
@ -1657,31 +1656,31 @@ int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr,
for (i = 0; i < max_super; i++) {
bytenr = btrfs_sb_offset(i);
ret = sbread(fd, buf, bytenr);
ret = sbread(fd, &buf, bytenr);
if (ret < BTRFS_SUPER_INFO_SIZE)
break;
if (btrfs_super_bytenr(buf) != bytenr )
if (btrfs_super_bytenr(&buf) != bytenr )
continue;
/* if magic is NULL, the device was removed */
if (btrfs_super_magic(buf) == 0 && i == 0)
if (btrfs_super_magic(&buf) == 0 && i == 0)
break;
if (btrfs_check_super(buf, sbflags))
if (btrfs_check_super(&buf, sbflags))
continue;
if (!fsid_is_initialized) {
if (btrfs_super_incompat_flags(buf) &
if (btrfs_super_incompat_flags(&buf) &
BTRFS_FEATURE_INCOMPAT_METADATA_UUID) {
metadata_uuid_set = true;
memcpy(metadata_uuid, buf->metadata_uuid,
memcpy(metadata_uuid, buf.metadata_uuid,
sizeof(metadata_uuid));
}
memcpy(fsid, buf->fsid, sizeof(fsid));
memcpy(fsid, buf.fsid, sizeof(fsid));
fsid_is_initialized = 1;
} else if (memcmp(fsid, buf->fsid, sizeof(fsid)) ||
} else if (memcmp(fsid, buf.fsid, sizeof(fsid)) ||
(metadata_uuid_set && memcmp(metadata_uuid,
buf->metadata_uuid,
buf.metadata_uuid,
sizeof(metadata_uuid)))) {
/*
* the superblocks (the original one and
@ -1691,9 +1690,9 @@ int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr,
continue;
}
if (btrfs_super_generation(buf) > transid) {
memcpy(sb, buf, BTRFS_SUPER_INFO_SIZE);
transid = btrfs_super_generation(buf);
if (btrfs_super_generation(&buf) > transid) {
memcpy(sb, &buf, BTRFS_SUPER_INFO_SIZE);
transid = btrfs_super_generation(&buf);
}
}

14
kernel-shared/volumes.c
View File

@ -541,22 +541,20 @@ int btrfs_scan_one_device(int fd, const char *path,
struct btrfs_fs_devices **fs_devices_ret,
u64 *total_devs, u64 super_offset, unsigned sbflags)
{
struct btrfs_super_block *disk_super;
char buf[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block disk_super;
int ret;
u64 devid;
disk_super = (struct btrfs_super_block *)buf;
ret = btrfs_read_dev_super(fd, disk_super, super_offset, sbflags);
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);
if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_METADUMP)
devid = btrfs_stack_device_id(&disk_super.dev_item);
if (btrfs_super_flags(&disk_super) & BTRFS_SUPER_FLAG_METADUMP)
*total_devs = 1;
else
*total_devs = btrfs_super_num_devices(disk_super);
*total_devs = btrfs_super_num_devices(&disk_super);
ret = device_list_add(path, disk_super, devid, fs_devices_ret);
ret = device_list_add(path, &disk_super, devid, fs_devices_ret);
return ret;
}

8
mkfs/common.c
View File

@ -805,19 +805,17 @@ static int check_btrfs_signature_zoned(const char *device)
{
int fd;
int ret;
char buf[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block *sb;
struct btrfs_super_block sb;
fd = open(device, O_RDONLY);
if (fd < 0)
return -1;
ret = pread(fd, buf, BTRFS_SUPER_INFO_SIZE, 0);
ret = pread(fd, &sb, BTRFS_SUPER_INFO_SIZE, 0);
if (ret < 0) {
ret = -1;
goto out;
}
sb = (struct btrfs_super_block *)buf;
if (btrfs_super_magic(sb) == BTRFS_MAGIC)
if (btrfs_super_magic(&sb) == BTRFS_MAGIC)
ret = 1;
else
ret = 0;