kill bd_buffered_fd

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>

diff --git a/cmd_counters.c b/cmd_counters.c
index 7605e2d70a69f5426a4b5cba5520f07a9f97e068..9adde2422b425fb40b37e60896bb3da65e12d663 100644 (file)
--- a/cmd_counters.c
+++ b/cmd_counters.c
@@ -45,7 +45,7 @@ int cmd_reset_counters(int argc, char *argv[])
 
        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);
        return 0;
 }

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

diff --git a/cmd_dump.c b/cmd_dump.c
index ffdbcf49921c43ed065df683ba41783d92286b21..3123ba2526281e8a449731cd9caf4675b84538fd 100644 (file)
--- a/cmd_dump.c
+++ b/cmd_dump.c
@@ -98,7 +98,7 @@ static void dump_one_device(struct bch_fs *c, struct bch_dev *ca, int fd,
                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)));
        darray_exit(&data);
 }

diff --git a/cmd_migrate.c b/cmd_migrate.c
index 07fc145290034ae9eed9706d86caada62c116202..60e779e5d005b74123ded3f99d8bc31159177fa6 100644 (file)
--- a/cmd_migrate.c
+++ b/cmd_migrate.c
@@ -678,13 +678,13 @@ static int migrate_fs(const char          *fs_path,
        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);
 
-       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);
        printf("Creating new filesystem on %s in space reserved at %s\n",
               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.nbuckets    = dev.size / dev.bucket_size;
 
@@ -693,7 +693,7 @@ static int migrate_fs(const char            *fs_path,
        u64 bcachefs_inum;
        ranges extents = reserve_new_fs_space(file_path,
                                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);
 
        find_superblock_space(extents, format_opts, &dev);

diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 5c6d7b720dffc7646dabfb2a1c5b1ef1332d44ff..80560ab6cc75b4c93c82e1577e96a7793c8cde31 100644 (file)
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -39,7 +39,6 @@ struct block_device {
        struct gendisk *        bd_disk;
        struct gendisk          __bd_disk;
        int                     bd_fd;
-       int                     bd_buffered_fd;
 };
 
 #define bdev_kobj(_bdev) (&((_bdev)->kobj))

diff --git a/libbcachefs.c b/libbcachefs.c
index 36707654dc761113e21c54d8a51d1827a7ba3b71..ceb6027016c32d21595b265f9e34555fac6aedd6 100644 (file)
--- a/libbcachefs.c
+++ b/libbcachefs.c
@@ -156,7 +156,7 @@ struct bch_sb *bch2_format(struct bch_opt_strs      fs_opt_strs,
        u64 min_bucket_size = U64_MAX;
 
        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: */
        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: */
        for (i = devs; i < devs + nr_devs; i++)
                if (!i->size)
-                       i->size = get_size(i->bdev->bd_buffered_fd);
+                       i->size = get_size(i->bdev->bd_fd);
 
        /* calculate bucket sizes: */
        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 */
                        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");
                }
 
-               bch2_super_write(i->bdev->bd_buffered_fd, sb.sb);
-               close(i->bdev->bd_buffered_fd);
+               bch2_super_write(i->bdev->bd_fd, sb.sb);
+               close(i->bdev->bd_fd);
        }
 
        return sb.sb;

diff --git a/linux/blkdev.c b/linux/blkdev.c
index 611c821eaf933bf55d8d61016bb3cf0892d6630c..61f23362d016375330c312a854a85f69aac03598 100644 (file)
--- a/linux/blkdev.c
+++ b/linux/blkdev.c
@@ -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)
 {
        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))
                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))
                flags |= O_DIRECT;
 
-#if 0
-       /* using O_EXCL doesn't work with opening twice for an O_SYNC fd: */
        if (mode & BLK_OPEN_EXCL)
                flags |= O_EXCL;
-#endif
-       buffered_fd = open(path, flags & ~O_DIRECT);
-       if (buffered_fd < 0)
-               return ERR_PTR(-errno);
 
        fd = open(path, flags);
        if (fd < 0)
-               fd = dup(buffered_fd);
-       if (fd < 0) {
-               close(buffered_fd);
                return ERR_PTR(-errno);
-       }
 
        bdev = malloc(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_fd             = fd;
-       bdev->bd_buffered_fd    = buffered_fd;
        bdev->bd_holder         = holder;
        bdev->bd_disk           = &bdev->__bd_disk;
        bdev->bd_disk->bdi      = &bdev->bd_disk->__bdi;

diff --git a/tools-util.c b/tools-util.c
index 5f0b9ba4fd5f7c279763c3f7df9a9da1d0ca0f59..a1bcd8eba550ded5df147dd5bfef012e8267502c 100644 (file)
--- a/tools-util.c
+++ b/tools-util.c
@@ -189,15 +189,16 @@ int open_for_format(struct dev_opts *dev, bool force)
        const char *fs_type = NULL, *fs_label = NULL;
        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, NULL);
+       dev->bdev = blkdev_get_by_path(dev->path,
+                               BLK_OPEN_READ|BLK_OPEN_WRITE|BLK_OPEN_EXCL|BLK_OPEN_BUFFERED,
+                               dev, NULL);
        int ret = PTR_ERR_OR_ZERO(dev->bdev);
        if (ret < 0)
                die("Error opening device to format %s: %s", dev->path, strerror(-ret));
 
        if (!(pr = blkid_new_probe()))
                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");
        if (blkid_probe_enable_partitions(pr, true) ||
            blkid_probe_enable_superblocks(pr, true) ||