* [PATCH 2/3] btrfs-progs: remove temporary buffer for super block
2021-10-21 1:40 [PATCH 0/3] btrfs-progs: cleanup related to btrfs super block Qu Wenruo
2021-10-21 1:40 ` [PATCH 1/3] btrfs-progs: unify sizeof(struct btrfs_super_block) and BTRFS_SUPER_INFO_SIZE Qu Wenruo
@ 2021-10-21 1:40 ` Qu Wenruo
2021-10-21 1:40 ` [PATCH 3/3] btrfs-progs: cache csum_size and csum_type in btrfs_fs_info Qu Wenruo
2021-11-04 19:10 ` [PATCH 0/3] btrfs-progs: cleanup related to btrfs super block David Sterba
3 siblings, 0 replies; 7+ messages in thread
From: Qu Wenruo @ 2021-10-21 1:40 UTC (permalink / raw)
To: linux-btrfs
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 needs such workaround, and can use struct btrfs_super_block
directly to do any operation.
Signed-off-by: Qu Wenruo <wqu@suse.com>
---
cmds/filesystem-usage.c | 8 ++--
cmds/inspect-dump-super.c | 11 ++----
cmds/rescue-chunk-recover.c | 20 +++++-----
cmds/rescue-super-recover.c | 11 +++---
common/device-scan.c | 23 ++++-------
common/utils.c | 8 ++--
convert/common.c | 79 +++++++++++++++++--------------------
convert/main.c | 29 ++++++--------
image/main.c | 14 +++----
kernel-shared/disk-io.c | 35 ++++++++--------
kernel-shared/volumes.c | 14 +++----
mkfs/common.c | 8 ++--
12 files changed, 112 insertions(+), 148 deletions(-)
diff --git a/cmds/filesystem-usage.c b/cmds/filesystem-usage.c
index 7f810cd0c5ac..1ba48fafce0d 100644
--- a/cmds/filesystem-usage.c
+++ b/cmds/filesystem-usage.c
@@ -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:
diff --git a/cmds/inspect-dump-super.c b/cmds/inspect-dump-super.c
index 04e81d8c3b60..d8435624df90 100644
--- a/cmds/inspect-dump-super.c
+++ b/cmds/inspect-dump-super.c
@@ -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;
}
diff --git a/cmds/rescue-chunk-recover.c b/cmds/rescue-chunk-recover.c
index cdf0fe1864cd..35c6f66548fd 100644
--- a/cmds/rescue-chunk-recover.c
+++ b/cmds/rescue-chunk-recover.c
@@ -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;
diff --git a/cmds/rescue-super-recover.c b/cmds/rescue-super-recover.c
index 1eaa87298b2e..d78f5052f076 100644
--- a/cmds/rescue-super-recover.c
+++ b/cmds/rescue-super-recover.c
@@ -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;
diff --git a/common/device-scan.c b/common/device-scan.c
index 4c54ee3b7254..39b12c0e02c4 100644
--- a/common/device-scan.c
+++ b/common/device-scan.c
@@ -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;
}
diff --git a/common/utils.c b/common/utils.c
index aee0eedc15fc..d81e79144790 100644
--- a/common/utils.c
+++ b/common/utils.c
@@ -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);
diff --git a/convert/common.c b/convert/common.c
index 5e7a1d6bea5a..00a7e55361b8 100644
--- a/convert/common.c
+++ b/convert/common.c
@@ -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;
}
diff --git a/convert/main.c b/convert/main.c
index 223eebad2e72..ccfa826ed0d5 100644
--- a/convert/main.c
+++ b/convert/main.c
@@ -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;
diff --git a/image/main.c b/image/main.c
index b40e0e5550f8..8929e94cb6e6 100644
--- a/image/main.c
+++ b/image/main.c
@@ -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)
diff --git a/kernel-shared/disk-io.c b/kernel-shared/disk-io.c
index 3b3c4523e65e..30f16f4da126 100644
--- a/kernel-shared/disk-io.c
+++ b/kernel-shared/disk-io.c
@@ -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);
}
}
diff --git a/kernel-shared/volumes.c b/kernel-shared/volumes.c
index 6c1e6f1018a3..de3a95d0c2e5 100644
--- a/kernel-shared/volumes.c
+++ b/kernel-shared/volumes.c
@@ -528,22 +528,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;
}
diff --git a/mkfs/common.c b/mkfs/common.c
index 5c8d6ac13a3b..0a1fda2ac72e 100644
--- a/mkfs/common.c
+++ b/mkfs/common.c
@@ -804,19 +804,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;
--
2.33.0
^ permalink raw reply related [flat|nested] 7+ messages in thread