alex/bcachefs-tools
1
0
Fork 0
mirror of https://github.com/koverstreet/bcachefs-tools.git synced 2025-02-22 00:00:03 +03:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

kill bd_buffered_fd

Browse Source 
this gets us back down to a single fd for opening block devices, which
means we can use O_EXCL.

Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
This commit is contained in:
Kent Overstreet 2024-01-06 17:54:06 -05:00
parent 226bade565
commit f6bdf31843
8 changed files with 17 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmd_counters.c
View File

@ -45,7 +45,7 @@ int cmd_reset_counters(int argc, char *argv[])
bch2_sb_field_resize(&sb, counters, 0); bch2_sb_field_resize(&sb, counters, 0);
bch2_super_write(sb.bdev->bd_buffered_fd, sb.sb); bch2_super_write(sb.bdev->bd_fd, sb.sb);
bch2_free_super(&sb); bch2_free_super(&sb);
return 0; return 0;
} }

7
cmd_device.c
View File

@ -132,9 +132,6 @@ int cmd_device_add(int argc, char *argv[])
format_opts, format_opts,
&dev_opts, 1); &dev_opts, 1);
free(sb); free(sb);
fsync(dev_opts.bdev->bd_buffered_fd);
close(dev_opts.bdev->bd_buffered_fd);
bchu_disk_add(fs, dev_opts.path); bchu_disk_add(fs, dev_opts.path);
return 0; return 0;
} }
@ -424,8 +421,8 @@ int cmd_device_set_state(int argc, char *argv[])
le64_add_cpu(&sb.sb->seq, 1); le64_add_cpu(&sb.sb->seq, 1);
bch2_super_write(sb.bdev->bd_buffered_fd, sb.sb); bch2_super_write(sb.bdev->bd_fd, sb.sb);
ret = fsync(sb.bdev->bd_buffered_fd); ret = fsync(sb.bdev->bd_fd);
if (ret) if (ret)
fprintf(stderr, "error writing superblock: fsync error (%m)"); fprintf(stderr, "error writing superblock: fsync error (%m)");
bch2_free_super(&sb); bch2_free_super(&sb);

2
cmd_dump.c
View File

@ -98,7 +98,7 @@ static void dump_one_device(struct bch_fs *c, struct bch_dev *ca, int fd,
bch2_trans_put(trans); bch2_trans_put(trans);
} }
qcow2_write_image(ca->disk_sb.bdev->bd_buffered_fd, fd, &data, qcow2_write_image(ca->disk_sb.bdev->bd_fd, fd, &data,
max_t(unsigned, btree_bytes(c) / 8, block_bytes(c))); max_t(unsigned, btree_bytes(c) / 8, block_bytes(c)));
darray_exit(&data); darray_exit(&data);
} }

6
cmd_migrate.c
View File

@ -678,13 +678,13 @@ static int migrate_fs(const char *fs_path,
dev.path = dev_t_to_path(stat.st_dev); dev.path = dev_t_to_path(stat.st_dev);
dev.bdev = blkdev_get_by_path(dev.path, BLK_OPEN_READ|BLK_OPEN_WRITE, &dev, NULL); dev.bdev = blkdev_get_by_path(dev.path, BLK_OPEN_READ|BLK_OPEN_WRITE, &dev, NULL);
opt_set(fs_opts, block_size, get_blocksize(dev.bdev->bd_buffered_fd)); opt_set(fs_opts, block_size, get_blocksize(dev.bdev->bd_fd));
char *file_path = mprintf("%s/bcachefs", fs_path); char *file_path = mprintf("%s/bcachefs", fs_path);
printf("Creating new filesystem on %s in space reserved at %s\n", printf("Creating new filesystem on %s in space reserved at %s\n",
dev.path, file_path); dev.path, file_path);
dev.size = get_size(dev.bdev->bd_buffered_fd); dev.size = get_size(dev.bdev->bd_fd);
dev.bucket_size = bch2_pick_bucket_size(fs_opts, &dev); dev.bucket_size = bch2_pick_bucket_size(fs_opts, &dev);
dev.nbuckets = dev.size / dev.bucket_size; dev.nbuckets = dev.size / dev.bucket_size;
@ -693,7 +693,7 @@ static int migrate_fs(const char *fs_path,
u64 bcachefs_inum; u64 bcachefs_inum;
ranges extents = reserve_new_fs_space(file_path, ranges extents = reserve_new_fs_space(file_path,
fs_opts.block_size >> 9, fs_opts.block_size >> 9,
get_size(dev.bdev->bd_buffered_fd) / 5, get_size(dev.bdev->bd_fd) / 5,
&bcachefs_inum, stat.st_dev, force); &bcachefs_inum, stat.st_dev, force);
find_superblock_space(extents, format_opts, &dev); find_superblock_space(extents, format_opts, &dev);

1
include/linux/blk_types.h
View File

@ -39,7 +39,6 @@ struct block_device {
struct gendisk * bd_disk; struct gendisk * bd_disk;
struct gendisk __bd_disk; struct gendisk __bd_disk;
int bd_fd; int bd_fd;
int bd_buffered_fd;
}; };
#define bdev_kobj(_bdev) (&((_bdev)->kobj)) #define bdev_kobj(_bdev) (&((_bdev)->kobj))

10
libbcachefs.c
View File

@ -156,7 +156,7 @@ struct bch_sb *bch2_format(struct bch_opt_strs fs_opt_strs,
u64 min_bucket_size = U64_MAX; u64 min_bucket_size = U64_MAX;
for (i = devs; i < devs + nr_devs; i++) for (i = devs; i < devs + nr_devs; i++)
max_dev_block_size = max(max_dev_block_size, get_blocksize(i->bdev->bd_buffered_fd)); max_dev_block_size = max(max_dev_block_size, get_blocksize(i->bdev->bd_fd));
/* calculate block size: */ /* calculate block size: */
if (!opt_defined(fs_opts, block_size)) { if (!opt_defined(fs_opts, block_size)) {
@ -168,7 +168,7 @@ struct bch_sb *bch2_format(struct bch_opt_strs fs_opt_strs,
/* get device size, if it wasn't specified: */ /* get device size, if it wasn't specified: */
for (i = devs; i < devs + nr_devs; i++) for (i = devs; i < devs + nr_devs; i++)
if (!i->size) if (!i->size)
i->size = get_size(i->bdev->bd_buffered_fd); i->size = get_size(i->bdev->bd_fd);
/* calculate bucket sizes: */ /* calculate bucket sizes: */
for (i = devs; i < devs + nr_devs; i++) for (i = devs; i < devs + nr_devs; i++)
@ -328,12 +328,12 @@ struct bch_sb *bch2_format(struct bch_opt_strs fs_opt_strs,
/* Zero start of disk */ /* Zero start of disk */
static const char zeroes[BCH_SB_SECTOR << 9]; static const char zeroes[BCH_SB_SECTOR << 9];
xpwrite(i->bdev->bd_buffered_fd, zeroes, BCH_SB_SECTOR << 9, 0, xpwrite(i->bdev->bd_fd, zeroes, BCH_SB_SECTOR << 9, 0,
"zeroing start of disk"); "zeroing start of disk");
} }
bch2_super_write(i->bdev->bd_buffered_fd, sb.sb); bch2_super_write(i->bdev->bd_fd, sb.sb);
close(i->bdev->bd_buffered_fd); close(i->bdev->bd_fd);
} }
return sb.sb; return sb.sb;

13
linux/blkdev.c
View File

@ -173,7 +173,7 @@ struct block_device *blkdev_get_by_path(const char *path, blk_mode_t mode,
void *holder, const struct blk_holder_ops *hop) void *holder, const struct blk_holder_ops *hop)
{ {
struct block_device *bdev; struct block_device *bdev;
int fd, buffered_fd, flags = 0; int fd, flags = 0;
if ((mode & (BLK_OPEN_READ|BLK_OPEN_WRITE)) == (BLK_OPEN_READ|BLK_OPEN_WRITE)) if ((mode & (BLK_OPEN_READ|BLK_OPEN_WRITE)) == (BLK_OPEN_READ|BLK_OPEN_WRITE))
flags = O_RDWR; flags = O_RDWR;
@ -185,22 +185,12 @@ struct block_device *blkdev_get_by_path(const char *path, blk_mode_t mode,
if (!(mode & BLK_OPEN_BUFFERED)) if (!(mode & BLK_OPEN_BUFFERED))
flags |= O_DIRECT; flags |= O_DIRECT;
#if 0
/* using O_EXCL doesn't work with opening twice for an O_SYNC fd: */
if (mode & BLK_OPEN_EXCL) if (mode & BLK_OPEN_EXCL)
flags |= O_EXCL; flags |= O_EXCL;
#endif
buffered_fd = open(path, flags & ~O_DIRECT);
if (buffered_fd < 0)
return ERR_PTR(-errno);
fd = open(path, flags); fd = open(path, flags);
if (fd < 0) if (fd < 0)
fd = dup(buffered_fd);
if (fd < 0) {
close(buffered_fd);
return ERR_PTR(-errno); return ERR_PTR(-errno);
}
bdev = malloc(sizeof(*bdev)); bdev = malloc(sizeof(*bdev));
memset(bdev, 0, sizeof(*bdev)); memset(bdev, 0, sizeof(*bdev));
@ -210,7 +200,6 @@ struct block_device *blkdev_get_by_path(const char *path, blk_mode_t mode,
bdev->bd_dev = xfstat(fd).st_rdev; bdev->bd_dev = xfstat(fd).st_rdev;
bdev->bd_fd = fd; bdev->bd_fd = fd;
bdev->bd_buffered_fd = buffered_fd;
bdev->bd_holder = holder; bdev->bd_holder = holder;
bdev->bd_disk = &bdev->__bd_disk; bdev->bd_disk = &bdev->__bd_disk;
bdev->bd_disk->bdi = &bdev->bd_disk->__bdi; bdev->bd_disk->bdi = &bdev->bd_disk->__bdi;

7
tools-util.c
View File

@ -189,15 +189,16 @@ int open_for_format(struct dev_opts *dev, bool force)
const char *fs_type = NULL, *fs_label = NULL; const char *fs_type = NULL, *fs_label = NULL;
size_t fs_type_len, fs_label_len; size_t fs_type_len, fs_label_len;
dev->bdev = blkdev_get_by_path(dev->path, BLK_OPEN_READ|BLK_OPEN_WRITE|BLK_OPEN_EXCL, dev->bdev = blkdev_get_by_path(dev->path,
dev, NULL); BLK_OPEN_READ|BLK_OPEN_WRITE|BLK_OPEN_EXCL|BLK_OPEN_BUFFERED,
dev, NULL);
int ret = PTR_ERR_OR_ZERO(dev->bdev); int ret = PTR_ERR_OR_ZERO(dev->bdev);
if (ret < 0) if (ret < 0)
die("Error opening device to format %s: %s", dev->path, strerror(-ret)); die("Error opening device to format %s: %s", dev->path, strerror(-ret));
if (!(pr = blkid_new_probe())) if (!(pr = blkid_new_probe()))
die("blkid error 1"); die("blkid error 1");
if (blkid_probe_set_device(pr, dev->bdev->bd_buffered_fd, 0, 0)) if (blkid_probe_set_device(pr, dev->bdev->bd_fd, 0, 0))
die("blkid error 2"); die("blkid error 2");
if (blkid_probe_enable_partitions(pr, true) || if (blkid_probe_enable_partitions(pr, true) ||
blkid_probe_enable_superblocks(pr, true) || blkid_probe_enable_superblocks(pr, true) ||