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>

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;
 }

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);

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);
 }

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);

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))

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;

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;

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) ||