Open block devices as files
Subsystems (44)
Christian Brauner
maintainerv2 cover Open block devices as files
Hey Christoph,
Hey Jan,
Hey Jens,
This opens block devices as files. Instead of introducing a separate indirection into bdev_open_by_*() vis struct bdev_handle we can just make bdev_file_open_by_*() return a struct file. Opening and closing a block device from setup_bdev_super() and in all other places just becomes equivalent to opening and closing a file.
This has held up in xfstests and in blktests so far and it seems stable and clean. The equivalence of opening and closing block devices to regular files is a win in and of itself imho. Added to that is the ability to do away with struct bdev_handle completely and make various low-level helpers private to the block layer.
All places were we currently stash a struct bdev_handle we just stash a file and use an accessor such as file_bdev() akin to I_BDEV() to get to the block device.
It's now also possible to use file->f_mapping as a replacement for bdev->bd_inode->i_mapping and file->f_inode or file->f_mapping->host as an alternative to bdev->bd_inode allowing us to significantly reduce or even fully remove bdev->bd_inode in follow-up patches.
In addition, we could get rid of sb->s_bdev and various other places that stash the block device directly and instead stash the block device file. Again, this is follow-up work.
Thanks!
Christian
---
Changes in v2:
- This is not an RFC anymore.
- The patches to convert all of fs/buffer.c and associated helpers to
struct file have been split out of the core infrastructure.
- Various renaming of helpers in response to v1.
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Christian Brauner (34):
bdev: open block device as files
block/ioctl: port blkdev_bszset() to file block/genhd: port disk_scan_partitions() to file
md: port block device access to file
swap: port block device usage to file
power: port block device access to file
xfs: port block device access to files
drbd: port block device access to file
pktcdvd: port block device access to file
rnbd: port block device access to file
xen: port block device access to file
zram: port block device access to file
bcache: port block device access to files
block2mtd: port device access to files
nvme: port block device access to file
s390: port block device access to file
target: port block device access to file
bcachefs: port block device access to file
btrfs: port device access to file
erofs: port device access to file
ext4: port block device access to file
f2fs: port block device access to files
jfs: port block device access to file
nfs: port block device access to files
ocfs2: port block device access to file
reiserfs: port block device access to file
bdev: remove bdev_open_by_path()
bdev: make bdev_release() private to block layer
bdev: make struct bdev_handle private to the block layer
bdev: remove bdev pointer from struct bdev_handle
block: use file->f_op to indicate restricted writes
block: remove bdev_handle completely
block: expose bdev_file_inode()
ext4: rely on sb->f_bdev only
block/bdev.c | 249 ++++++++++++++++++++++-------------- block/blk.h | 6 + block/fops.c | 48 ++++--- block/genhd.c | 12 +- block/ioctl.c | 9 +- drivers/block/drbd/drbd_int.h | 4 +- drivers/block/drbd/drbd_nl.c | 58 ++++----- drivers/block/pktcdvd.c | 68 +++++----- drivers/block/rnbd/rnbd-srv.c | 28 ++-- drivers/block/rnbd/rnbd-srv.h | 2 +- drivers/block/xen-blkback/blkback.c | 4 +- drivers/block/xen-blkback/common.h | 4 +- drivers/block/xen-blkback/xenbus.c | 37 +++--- drivers/block/zram/zram_drv.c | 26 ++-- drivers/block/zram/zram_drv.h | 2 +- drivers/md/bcache/bcache.h | 4 +- drivers/md/bcache/super.c | 74 +++++------ drivers/md/dm.c | 23 ++-- drivers/md/md.c | 12 +- drivers/md/md.h | 2 +- drivers/mtd/devices/block2mtd.c | 46 +++---- drivers/nvme/target/io-cmd-bdev.c | 16 +-- drivers/nvme/target/nvmet.h | 2 +- drivers/s390/block/dasd.c | 10 +- drivers/s390/block/dasd_genhd.c | 36 +++--- drivers/s390/block/dasd_int.h | 2 +- drivers/s390/block/dasd_ioctl.c | 2 +- drivers/target/target_core_iblock.c | 18 +-- drivers/target/target_core_iblock.h | 2 +- drivers/target/target_core_pscsi.c | 22 ++-- drivers/target/target_core_pscsi.h | 2 +- fs/bcachefs/super-io.c | 20 +-- fs/bcachefs/super_types.h | 2 +- fs/btrfs/dev-replace.c | 14 +- fs/btrfs/ioctl.c | 16 +-- fs/btrfs/volumes.c | 92 ++++++------- fs/btrfs/volumes.h | 4 +- fs/cramfs/inode.c | 2 +- fs/erofs/data.c | 6 +- fs/erofs/internal.h | 2 +- fs/erofs/super.c | 16 +-- fs/ext4/dir.c | 2 +- fs/ext4/ext4.h | 2 +- fs/ext4/ext4_jbd2.c | 2 +- fs/ext4/fast_commit.c | 2 +- fs/ext4/fsmap.c | 8 +- fs/ext4/super.c | 87 ++++++------- fs/f2fs/f2fs.h | 2 +- fs/f2fs/super.c | 12 +- fs/file_table.c | 36 +++++- fs/jfs/jfs_logmgr.c | 26 ++-- fs/jfs/jfs_logmgr.h | 2 +- fs/jfs/jfs_mount.c | 2 +- fs/nfs/blocklayout/blocklayout.h | 2 +- fs/nfs/blocklayout/dev.c | 68 +++++----- fs/ocfs2/cluster/heartbeat.c | 32 ++--- fs/reiserfs/journal.c | 38 +++--- fs/reiserfs/procfs.c | 2 +- fs/reiserfs/reiserfs.h | 8 +- fs/romfs/super.c | 2 +- fs/super.c | 18 +-- fs/xfs/xfs_buf.c | 10 +- fs/xfs/xfs_buf.h | 4 +- fs/xfs/xfs_super.c | 43 +++---- include/linux/blkdev.h | 18 +-- include/linux/device-mapper.h | 2 +- include/linux/file.h | 2 + include/linux/fs.h | 4 +- include/linux/pktcdvd.h | 4 +- include/linux/swap.h | 2 +- kernel/power/swap.c | 28 ++-- mm/swapfile.c | 22 ++-- 72 files changed, 791 insertions(+), 705 deletions(-)
---
base-commit: 6613476e225e090cc9aad49be7fa504e290dd33d
change-id: 20240103-vfs-bdev-file-1208da73d7ea
Christian Brauner
maintainerPATCH v2 1/34 bdev: open block device as files
Add two new helpers to allow opening block devices as files. This is not the final infrastructure. This still opens the block device before opening a struct a file. Until we have removed all references to struct bdev_handle we can't switch the order:
* Introduce blk_to_file_flags() to translate from block specific to flags usable to pen a new file.
* Introduce bdev_file_open_by_{dev,path}().
* Introduce temporary sb_bdev_handle() helper to retrieve a struct bdev_handle from a block device file and update places that directly reference struct bdev_handle to rely on it.
* Don't count block device openes against the number of open files. A bdev_file_open_by_{dev,path}() file is never installed into any file descriptor table.
One idea that came to mind was to use kernel_tmpfile_open() which would require us to pass a path and it would then call do_dentry_open() going through the regular fops->open::blkdev_open() path. But that has drawbacks that I consider fatal. We're back to the problem of routing block specific flags such as BLK_OPEN_RESTRICT_WRITES through the open path and would have to waste FMODE_* flags every time we add a new one. Second, it would prohibit us from later using custom fops to indicate that this is a restricted write operation as well. Overall, we can avoid using an fmode flag and we have way more leeway in how we open block devices from bdev_open_by_{dev,path}().
--- block/bdev.c | 104 +++++++++++++++++++++++++++++++++++++++++++++++-- fs/cramfs/inode.c | 2 +- fs/f2fs/super.c | 2 +- fs/file_table.c | 36 +++++++++++++---- fs/jfs/jfs_logmgr.c | 2 +- fs/romfs/super.c | 2 +- fs/super.c | 18 ++++----- fs/xfs/xfs_super.c | 2 +- include/linux/blkdev.h | 7 ++++ include/linux/file.h | 2 + include/linux/fs.h | 10 ++++- 11 files changed, 160 insertions(+), 27 deletions(-)
block/bdev.c +100 -4
@@ -49,6 +49,13 @@ struct block_device *I_BDEV(struct inode *inode) }EXPORT_SYMBOL (I_BDEV ); +struct block_device *file_bdev (struct file *bdev_file) +{ +struct bdev_handle *handle = bdev_file->private_data; +return handle->bdev; +} +EXPORT_SYMBOL (file_bdev); +static void bdev_write_inode (struct block_device *bdev) {struct inode *inode = bdev->bd_inode;
@@ -368,12 +375,12 @@ static struct file_system_type bd_type = { };struct super_block *blockdev_superblock__ro_after_init ; +struct vfsmount *blockdev_mnt__ro_after_init ;EXPORT_SYMBOL_GPL (blockdev_superblock);void __init bdev_cache_init (void ) {int err; -static struct vfsmount *bd_mnt__ro_after_init ; bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode), 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
@@ -382,10 +389,10 @@ void __init bdev_cache_init(void) err =register_filesystem (&bd_type);if (err)panic ("Cannot register bdev pseudo-fs" ); - bd_mnt =kern_mount (&bd_type); -if (IS_ERR (bd_mnt)) + blockdev_mnt =kern_mount (&bd_type); +if (IS_ERR (blockdev_mnt))panic ("Cannot create bdev pseudo-fs" ); - blockdev_superblock = bd_mnt->mnt_sb;/* For writeback */ + blockdev_superblock = blockdev_mnt->mnt_sb;/* For writeback */ }struct block_device *bdev_alloc (struct gendisk *disk,u8 partno)
@@ -911,6 +918,95 @@ struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, }EXPORT_SYMBOL (bdev_open_by_dev); +static unsigned blk_to_file_flags (blk_mode_t mode) +{ +unsigned int flags =0 ; + +if ((mode & (BLK_OPEN_READ |BLK_OPEN_WRITE )) == + (BLK_OPEN_READ |BLK_OPEN_WRITE )) + flags |=O_RDWR ; +else if (mode &BLK_OPEN_WRITE ) + flags |=O_WRONLY ; +else if (mode &BLK_OPEN_READ ) + flags |=O_RDONLY ; +else /* Neither read nor write for a block device requested? */ +WARN_ON_ONCE (true); + +/* +* O_EXCL is one of those flags that the VFS clears once it's done with +* the operation. So don't raise it here either. +*/ +if (mode &BLK_OPEN_NDELAY ) + flags |=O_NDELAY ; + +/* +* If BLK_OPEN_WRITE_IOCTL is set then this is a historical quirk +* associated with the floppy driver where it has allowed ioctls if the +* file was opened for writing, but does not allow reads or writes. +* Make sure that this quirk is reflected in @f_flags. +*/ +if (mode &BLK_OPEN_WRITE_IOCTL ) + flags |=O_RDWR |O_WRONLY ; + +return flags; +} + +struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, +const struct blk_holder_ops *hops) +{ +struct file *bdev_file; +struct bdev_handle *handle; +unsigned int flags; + + handle =bdev_open_by_dev (dev, mode, holder, hops); +if (IS_ERR (handle)) +return ERR_CAST (handle); + + flags =blk_to_file_flags (mode); + bdev_file =alloc_file_pseudo_noaccount (handle->bdev->bd_inode, + blockdev_mnt,"" , flags |O_LARGEFILE , &def_blk_fops); +if (IS_ERR (bdev_file)) { +bdev_release (handle); +return bdev_file; + } +ihold (handle->bdev->bd_inode); + + bdev_file->f_mode |=FMODE_BUF_RASYNC |FMODE_CAN_ODIRECT ; +if (bdev_nowait (handle->bdev)) + bdev_file->f_mode |=FMODE_NOWAIT ; + + bdev_file->f_mapping = handle->bdev->bd_inode->i_mapping; + bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); + bdev_file->private_data = handle; +return bdev_file; +} +EXPORT_SYMBOL (bdev_file_open_by_dev); + +struct file *bdev_file_open_by_path (const char *path,blk_mode_t mode, +void *holder, +const struct blk_holder_ops *hops) +{ +struct file *bdev_file; +dev_t dev; +int error; + + error =lookup_bdev (path, &dev); +if (error) +return ERR_PTR (error); + + bdev_file =bdev_file_open_by_dev (dev, mode, holder, hops); +if (!IS_ERR (bdev_file) && (mode &BLK_OPEN_WRITE )) { +struct bdev_handle *handle = bdev_file->private_data; +if (bdev_read_only (handle->bdev)) { +fput (bdev_file); + bdev_file =ERR_PTR (-EACCES ); + } + } + +return bdev_file; +} +EXPORT_SYMBOL (bdev_file_open_by_path); +/** * bdev_open_by_path - open a block device by name * @path: path to the block device to open
fs/cramfs/inode.c +1 -1
@@ -495,7 +495,7 @@ static void cramfs_kill_sb(struct super_block *sb) sb->s_mtd =NULL ; }else if (IS_ENABLED (CONFIG_CRAMFS_BLOCKDEV ) && sb->s_bdev) {sync_blockdev (sb->s_bdev); -bdev_release (sb->s_bdev_handle); +fput (sb->s_bdev_file); }kfree (sbi); }
fs/f2fs/super.c +1 -1
@@ -4247,7 +4247,7 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)for (i =0 ; i < max_devices; i++) {if (i ==0 ) -FDEV (0 ).bdev_handle = sbi->sb->s_bdev_handle; +FDEV (0 ).bdev_handle =sb_bdev_handle (sbi->sb);else if (!RDEV (i).path[0 ])break ;
fs/file_table.c +29 -7
@@ -281,13 +281,17 @@ struct file *alloc_empty_backing_file(int flags, const struct cred *cred)* @path: the (dentry, vfsmount) pair for the new file * @flags: O_... flags with which the new file will be opened * @fop: the 'struct file_operations' for the new file +* @noaccount: whether this is an internal open that shouldn't be counted */ static struct file *alloc_file (const struct path *path,int flags, -const struct file_operations *fop) +const struct file_operations *fop,bool noaccount) {struct file *file; - file =alloc_empty_file (flags,current_cred ()); +if (noaccount) + file =alloc_empty_file_noaccount (flags,current_cred ()); +else + file =alloc_empty_file (flags,current_cred ());if (IS_ERR (file))return file;
@@ -312,9 +316,11 @@ static struct file *alloc_file(const struct path *path, int flags,return file; } -struct file *alloc_file_pseudo (struct inode *inode,struct vfsmount *mnt, -const char *name,int flags, -const struct file_operations *fops) +static struct file *__alloc_file_pseudo (struct inode *inode, +struct vfsmount *mnt,const char *name, +int flags, +const struct file_operations *fops, +bool noaccount) {struct qstr this =QSTR_INIT (name,strlen (name));struct path path;
@@ -325,19 +331,35 @@ struct file *alloc_file_pseudo(struct inode *inode, struct vfsmount *mnt,return ERR_PTR (-ENOMEM ); path.mnt =mntget (mnt);d_instantiate (path.dentry, inode); - file =alloc_file (&path, flags, fops); + file =alloc_file (&path, flags, fops, noaccount);if (IS_ERR (file)) {ihold (inode);path_put (&path); }return file; } + +struct file *alloc_file_pseudo (struct inode *inode,struct vfsmount *mnt, +const char *name,int flags, +const struct file_operations *fops) +{ +return __alloc_file_pseudo (inode, mnt, name, flags, fops, false); +}EXPORT_SYMBOL (alloc_file_pseudo); +struct file *alloc_file_pseudo_noaccount (struct inode *inode, +struct vfsmount *mnt,const char *name, +int flags, +const struct file_operations *fops) +{ +return __alloc_file_pseudo (inode, mnt, name, flags, fops, true); +} +EXPORT_SYMBOL_GPL (alloc_file_pseudo_noaccount); +struct file *alloc_file_clone (struct file *base,int flags,const struct file_operations *fops) { -struct file *f =alloc_file (&base->f_path, flags, fops); +struct file *f =alloc_file (&base->f_path, flags, fops, false);if (!IS_ERR (f)) {path_get (&f->f_path); f->f_mapping = base->f_mapping;
fs/jfs/jfs_logmgr.c +1 -1
@@ -1162,7 +1162,7 @@ static int open_inline_log(struct super_block *sb)init_waitqueue_head (&log->syncwait);set_bit (log_INLINELOG, &log->flag); - log->bdev_handle = sb->s_bdev_handle; + log->bdev_handle =sb_bdev_handle (sb); log->base =addressPXD (&JFS_SBI (sb)->logpxd); log->size =lengthPXD (&JFS_SBI (sb)->logpxd) >> (L2LOGPSIZE - sb->s_blocksize_bits);
fs/romfs/super.c +1 -1
@@ -594,7 +594,7 @@ static void romfs_kill_sb(struct super_block *sb)#ifdef CONFIG_ROMFS_ON_BLOCK if (sb->s_bdev) {sync_blockdev (sb->s_bdev); -bdev_release (sb->s_bdev_handle); +fput (sb->s_bdev_file); }#endif }
fs/super.c +9 -9
@@ -1532,16 +1532,16 @@ int setup_bdev_super(struct super_block *sb, int sb_flags, struct fs_context *fc) {blk_mode_t mode =sb_open_mode (sb_flags); -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev; - bdev_handle =bdev_open_by_dev (sb->s_dev, mode, sb, &fs_holder_ops); -if (IS_ERR (bdev_handle)) { + bdev_file =bdev_file_open_by_dev (sb->s_dev, mode, sb, &fs_holder_ops); +if (IS_ERR (bdev_file)) {if (fc)errorf (fc,"%s: Can't open blockdev" , fc->source); -return PTR_ERR (bdev_handle); +return PTR_ERR (bdev_file); } - bdev = bdev_handle->bdev; + bdev =file_bdev (bdev_file);/* * This really should be in blkdev_get_by_dev, but right now can't due
@@ -1549,7 +1549,7 @@ int setup_bdev_super(struct super_block *sb, int sb_flags,* writable from userspace even for a read-only block device. */ if ((mode &BLK_OPEN_WRITE ) &&bdev_read_only (bdev)) { -bdev_release (bdev_handle); +fput (bdev_file);return -EACCES ; }
@@ -1560,11 +1560,11 @@ int setup_bdev_super(struct super_block *sb, int sb_flags,if (atomic_read (&bdev->bd_fsfreeze_count) >0 ) {if (fc)warnf (fc,"%pg: Can't mount, blockdev is frozen" , bdev); -bdev_release (bdev_handle); +fput (bdev_file);return -EBUSY ; }spin_lock (&sb_lock); - sb->s_bdev_handle = bdev_handle; + sb->s_bdev_file = bdev_file; sb->s_bdev = bdev; sb->s_bdi =bdi_get (bdev->bd_disk->bdi);if (bdev_stable_writes (bdev))
@@ -1680,7 +1680,7 @@ void kill_block_super(struct super_block *sb)generic_shutdown_super (sb);if (bdev) {sync_blockdev (bdev); -bdev_release (sb->s_bdev_handle); +fput (sb->s_bdev_file); } }
fs/xfs/xfs_super.c +1 -1
@@ -467,7 +467,7 @@ xfs_open_devices(* Setup xfs_mount buffer target pointers */ error = -ENOMEM ; - mp->m_ddev_targp =xfs_alloc_buftarg (mp, sb->s_bdev_handle); + mp->m_ddev_targp =xfs_alloc_buftarg (mp,sb_bdev_handle (sb));if (!mp->m_ddev_targp) goto out_close_rtdev;
include/linux/blkdev.h +7 -0
@@ -24,6 +24,7 @@#include <linux/sbitmap.h> #include <linux/uuid.h> #include <linux/xarray.h> +#include <linux/file.h> struct module ;struct request_queue ;
@@ -1474,6 +1475,7 @@ extern const struct blk_holder_ops fs_holder_ops; (BLK_OPEN_READ |BLK_OPEN_RESTRICT_WRITES | \ (((flags) &SB_RDONLY ) ?0 :BLK_OPEN_WRITE )) +/* @bdev_handle will be removed soon. */struct bdev_handle {struct block_device *bdev;void *holder;
@@ -1484,6 +1486,10 @@ struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, const struct blk_holder_ops *hops);struct bdev_handle *bdev_open_by_path (const char *path,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops); +struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, +const struct blk_holder_ops *hops); +struct file *bdev_file_open_by_path (const char *path,blk_mode_t mode, +void *holder,const struct blk_holder_ops *hops);int bd_prepare_to_claim (struct block_device *bdev,void *holder,const struct blk_holder_ops *hops);void bd_abort_claiming (struct block_device *bdev,void *holder);
@@ -1494,6 +1500,7 @@ struct block_device *blkdev_get_no_open(dev_t dev);void blkdev_put_no_open (struct block_device *bdev);struct block_device *I_BDEV (struct inode *inode); +struct block_device *file_bdev (struct file *bdev_file);#ifdef CONFIG_BLOCK void invalidate_bdev (struct block_device *bdev);
include/linux/file.h +2 -0
@@ -24,6 +24,8 @@ struct inode;struct path ;extern struct file *alloc_file_pseudo (struct inode *,struct vfsmount *,const char *,int flags,const struct file_operations *); +extern struct file *alloc_file_pseudo_noaccount (struct inode *,struct vfsmount *, +const char *,int flags,const struct file_operations *);extern struct file *alloc_file_clone (struct file *,int flags,const struct file_operations *);
include/linux/fs.h +8 -2
@@ -1228,8 +1228,8 @@ struct super_block {#endif struct hlist_bl_head s_roots;/* alternate root dentries for NFS */ struct list_head s_mounts;/* list of mounts; _not_ for fs use */ -struct block_device *s_bdev; -struct bdev_handle *s_bdev_handle; +struct block_device *s_bdev;/* can go away once we use an accessor for @s_bdev_file */ +struct file *s_bdev_file;struct backing_dev_info *s_bdi;struct mtd_info *s_mtd;struct hlist_node s_instances;
@@ -1327,6 +1327,12 @@ struct super_block {struct list_head s_inodes_wb;/* writeback inodes */ } __randomize_layout; +/* Temporary helper that will go away. */ +static inline struct bdev_handle *sb_bdev_handle (struct super_block *sb) +{ +return sb->s_bdev_file->private_data; +} +static inline struct user_namespace *i_user_ns (const struct inode *inode) {return inode->i_sb->s_user_ns;
Signature · 1 line
2.43.0
Christoph Hellwig
maintainerRe: [PATCH v2 01/34] bdev: open block device as files
Quoted 4 lines
block/bdev.c +4
-0+static unsigned blk_to_file_flags (blk_mode_t mode) +{ +unsigned int flags =0 ; +
...
block/bdev.c struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 940
Quoted 6 lines
block/bdev.c +6
-0+/* +* O_EXCL is one of those flags that the VFS clears once it's done with +* the operation. So don't raise it here either. +*/ +if (mode &BLK_OPEN_NDELAY ) + flags |=O_NDELAY ;
O_EXCL isn't dealt with in this helper at all.
block/bdev.c struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 949
Quoted 8 lines
block/bdev.c +8
-0+/* +* If BLK_OPEN_WRITE_IOCTL is set then this is a historical quirk +* associated with the floppy driver where it has allowed ioctls if the +* file was opened for writing, but does not allow reads or writes. +* Make sure that this quirk is reflected in @f_flags. +*/ +if (mode &BLK_OPEN_WRITE_IOCTL ) + flags |=O_RDWR |O_WRONLY ;
.. and BLK_OPEN_WRITE_IOCTL will never be passed to it. It only comes from open block devices nodes.
That being said, passing BLK_OPEN_* to bdev_file_open_by_* actually feels wrong. They deal with files and should just take normal O_* flags instead of translating from BLK_OPEN_* to O_* back to BLK_OPEN_* for the driver (where they make sense as the driver flags are pretty different from what is passed to open).
Now of course changing that would make a mess of the whole series, so maybe that can go into a new patch at the end?
fs/file_table.c struct file *alloc_empty_backing_file(int flags, const struct cred *cred) · line 287
Quoted 5 lines
+ * @noaccount: whether this is an internal open that shouldn't be counted */
static struct file *alloc_file(const struct path *path, int flags,fs/file_table.c +1
-1- const struct file_operations *fop) + const struct file_operations *fop, bool noaccount)
Just a suggestion as you are the maintainer here, but I always find it hard to follow when infrastructure in subsystem A is changed in a patch primarily changing subsystem B. Can the file_table.c changes go into a separate patch or patches with commit logs documenting their semantics?
And while we're at the semantics I find this area already a bit of a a mess and this doesn't make it any better..
How about the following:
- alloc_file loses the actual file allocation and gets a new name (unfortunatel init_file is already taken), callers call alloc_empty_file_noaccount or alloc_empty_file plus the new helper.
- similarly __alloc_file_pseudo is split into a helper creating a path for mnt and inode, and callers call that plus the file allocation
?
Quoted 1 line
+extern struct file *alloc_file_pseudo_noaccount(struct inode *, struct vfsmount *,
no need for the extern here.
include/linux/fs.h struct super_block { · line 1231
Quoted 1 line
include/linux/fs.h +1
-0+struct block_device *s_bdev;/* can go away once we use an accessor for @s_bdev_file */
can you put the comment into a separate line to make it readable.
But I'm not even sure it should go away. s_bdev is used all over the data and metadata I/O path, so caching it and avoiding multiple levels of pointer chasing would seem useful.
Christian Brauner
maintainerRe: [PATCH v2 01/34] bdev: open block device as files
Quoted 7 lines · Christoph Hellwig
Quoted 4 lines
block/bdev.c +4
-0+static unsigned blk_to_file_flags (blk_mode_t mode) +{ +unsigned int flags =0 ; +...
Quoted 8 lines
block/bdev.c struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 940
Quoted 6 lines
block/bdev.c +6
-0+/* +* O_EXCL is one of those flags that the VFS clears once it's done with +* the operation. So don't raise it here either. +*/ +if (mode &BLK_OPEN_NDELAY ) + flags |=O_NDELAY ;
O_EXCLisn't dealt with in this helper at all.
Yeah, on purpose was my point bc we can just rely on @holder and passing _EXCL without holder is invalid. But I could add it.
Quoted 13 lines
block/bdev.c struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 949
Quoted 9 lines
block/bdev.c +8
-0+/* +* If BLK_OPEN_WRITE_IOCTL is set then this is a historical quirk +* associated with the floppy driver where it has allowed ioctls if the +* file was opened for writing, but does not allow reads or writes. +* Make sure that this quirk is reflected in @f_flags. +*/ +if (mode &BLK_OPEN_WRITE_IOCTL ) + flags |=O_RDWR |O_WRONLY ;.. and
BLK_OPEN_WRITE_IOCTLwill never be passed to it. It only comes from open block devices nodes.
Quoted 8 lines
That being said, passing BLK_OPEN_* to bdev_file_open_by_* actually feels wrong. They deal with files and should just take normal O_* flags instead of translating from BLK_OPEN_* to O_* back to BLK_OPEN_* for the driver (where they make sense as the driver flags are pretty different from what is passed to open).
Now of course changing that would make a mess of the whole series, so maybe that can go into a new patch at the end?
Yes, I had considered that and it would work but there's the issue that we need to figure out how to handle BLK_OPEN_RESTRICT_WRITES. It has no corresponding O_* flag that would let us indicate this. So I had considered:
1/ Expose bdev_file_open_excl() so callers don't need to pass any
specific flags. Nearly all filesystems would effectively use this helper as sb_open_mode() adds it implicitly. That would have the side-effect of introducing another open helper ofc; possibly two if we take _by_dev() and _by_path() into account.
2/ Abuse an O_* flag to mean BLK_OPEN_RESTRICT_WRITES. For example,
O_TRUNC or O_NOCTTY which is pretty yucky.
3/ Introduce an internal O_* flag which is also ugly. Vomitorious and my
co-maintainers would likely chop off my hands so I can't go near a computer again.
3/ Make O_EXCL when passed together with bdev_file_open_by_*() always
imply BLK_OPEN_RESTRICT_WRITES.
The 3/ option would probably be the cleanest one and I think that all filesystems now pass at least a holder and holder ops so this _should_ work.
Thoughts?
Quoted 26 lines
fs/file_table.c struct file *alloc_empty_backing_file(int flags, const struct cred *cred) · line 287
Quoted 6 lines
+ * @noaccount: whether this is an internal open that shouldn't be counted */
static struct file *alloc_file(const struct path *path, int flags,fs/file_table.c +1
-1- const struct file_operations *fop) + const struct file_operations *fop, bool noaccount)Just a suggestion as you are the maintainer here, but I always find it hard to follow when infrastructure in subsystem A is changed in a patch primarily changing subsystem B. Can the
file_table.cchanges go into a separate patch or patches with commit logs documenting their semantics?And while we're at the semantics I find this area already a bit of a a mess and this doesn't make it any better..
How about the following:
-
alloc_fileloses the actual file allocation and gets a new name (unfortunatelinit_fileis already taken), callers callalloc_empty_file_noaccountoralloc_empty_fileplus the new helper.
- similarly__alloc_file_pseudois split into a helper creating a path for mnt and inode, and callers call that plus the file allocation
Quoted 1 line
?
Ok, let me see how far I get.
Quoted 5 lines
Quoted 2 lines
+extern struct file *alloc_file_pseudo_noaccount(struct inode *, struct vfsmount *,
no need for the extern here.
Quoted 7 lines
include/linux/fs.h struct super_block { · line 1231
Quoted 1 line
include/linux/fs.h +1
-0+struct block_device *s_bdev;/* can go away once we use an accessor for @s_bdev_file */ can you put the comment into a separate line to make it readable.
But I'm not even sure it should go away.
s_bdevis used all over the data and metadata I/O path, so caching it and avoiding multiple levels of pointer chasing would seem useful.
Fair.
Christoph Hellwig
maintainerRe: [PATCH v2 01/34] bdev: open block device as files
Quoted 11 lines · Christian Brauner
Quoted 8 lines
block/bdev.c struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 940
Quoted 6 lines
block/bdev.c +6
-0+/* +* O_EXCL is one of those flags that the VFS clears once it's done with +* the operation. So don't raise it here either. +*/ +if (mode &BLK_OPEN_NDELAY ) + flags |=O_NDELAY ;
O_EXCLisn't dealt with in this helper at all.Yeah, on purpose was my point bc we can just rely on @holder and passing
_EXCLwithout holder is invalid. But I could add it.
Ok. I found it weird to have the comment next to BLK_OPEN_NDELAY as it looked like it sneaked through. Especially as BLK_OPEN_EXCL has literally nothing to do with O_EXCL at all as the latter is a namespace operation flag. So even if the comment was intentional I think we're probably better off without it.
Quoted 3 lines
Yes, I had considered that and it would work but there's the issue that we need to figure out how to handle
BLK_OPEN_RESTRICT_WRITES. It has no corresponding O_* flag that would let us indicate this.
Oh, indeed.
Quoted 17 lines
So I had
considered:1/ Expose
bdev_file_open_excl()so callers don't need to pass any
specific flags. Nearly all filesystems would effectively use this helper assb_open_mode()adds it implicitly. That would have the side-effect of introducing another open helper ofc; possibly two if we take_by_dev()and_by_path()into account.2/ Abuse an O_* flag to mean
BLK_OPEN_RESTRICT_WRITES. For example,
O_TRUNCorO_NOCTTYwhich is pretty yucky.3/ Introduce an internal O_* flag which is also ugly. Vomitorious and my
co-maintainers would likely chop off my hands so I can't go near a computer again.
Quoted 6 lines
3/ Make
O_EXCLwhen passed together with bdev_file_open_by_*() always
implyBLK_OPEN_RESTRICT_WRITES.The 3/ option would probably be the cleanest one and I think that all filesystems now pass at least a holder and holder ops so this _should_ work.
2 and 3 sound pretty horrible. 3 would work and look clean for the block side, but O_ flags are mess so I wouldn't go there.
Maybe variant of 1 that allows for a non-exclusive open and clearly marks that?
Or just leave it as-is for now and look into that later.
Christian Brauner
maintainerRe: [PATCH v2 01/34] bdev: open block device as files
Quoted 45 lines · Christoph Hellwig
Quoted 11 lines · Christian Brauner
Quoted 8 lines
block/bdev.c struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 940
Quoted 6 lines
block/bdev.c +6
-0+/* +* O_EXCL is one of those flags that the VFS clears once it's done with +* the operation. So don't raise it here either. +*/ +if (mode &BLK_OPEN_NDELAY ) + flags |=O_NDELAY ;
O_EXCLisn't dealt with in this helper at all.Yeah, on purpose was my point bc we can just rely on @holder and passing
_EXCLwithout holder is invalid. But I could add it.Ok. I found it weird to have the comment next to
BLK_OPEN_NDELAYas it looked like it sneaked through. Especially asBLK_OPEN_EXCLhas literally nothing to do withO_EXCLat all as the latter is a namespace operation flag. So even if the comment was intentional I think we're probably better off without it.Quoted 3 lines
Yes, I had considered that and it would work but there's the issue that we need to figure out how to handle
BLK_OPEN_RESTRICT_WRITES. It has no corresponding O_* flag that would let us indicate this.Oh, indeed.
Quoted 20 lines
So I had
considered:1/ Expose
bdev_file_open_excl()so callers don't need to pass any
specific flags. Nearly all filesystems would effectively use this helper assb_open_mode()adds it implicitly. That would have the side-effect of introducing another open helper ofc; possibly two if we take_by_dev()and_by_path()into account.2/ Abuse an O_* flag to mean
BLK_OPEN_RESTRICT_WRITES. For example,
O_TRUNCorO_NOCTTYwhich is pretty yucky.3/ Introduce an internal O_* flag which is also ugly. Vomitorious and my
co-maintainers would likely chop off my hands so I can't go near a computer again.3/ Make
O_EXCLwhen passed together with bdev_file_open_by_*() always
implyBLK_OPEN_RESTRICT_WRITES.
Quoted 6 lines
Quoted 3 lines
The 3/ option would probably be the cleanest one and I think that all filesystems now pass at least a holder and holder ops so this _should_ work.
2 and 3 sound pretty horrible. 3 would work and look clean for the block side, but O_ flags are mess so I wouldn't go there.
My numbering is obviously wrong btw. That last point should obviously be 4/
Quoted 5 lines
Maybe variant of 1 that allows for a non-exclusive open and clearly marks that?
Or just leave it as-is for now and look into that later.
Ok.
Christian Brauner
maintainerRe: [PATCH v2 01/34] bdev: open block device as files
In reply to Christian BraunerQuoted 10 lines
Quoted 10 lines
How about the following:
-
alloc_fileloses the actual file allocation and gets a new name (unfortunatelinit_fileis already taken), callers callalloc_empty_file_noaccountoralloc_empty_fileplus the new helper.
- similarly__alloc_file_pseudois split into a helper creating a path for mnt and inode, and callers call that plus the file allocation
Quoted 3 lines
Quoted 1 line
?
Ok, let me see how far I get.
Ok, it's in vfs.super.
Re: [PATCH v2 01/34] bdev: open block device as files
In reply to Christian BraunerNow that this is in mainline it seems to cause blktests to crash nbd/003 with a rather non-obvious oops for me:
nbd/003 (mount/unmount concurrently with NBD_CLEAR_SOCK) runtime 8.139s ...
[ 802.941685] run blktests nbd/003 at 2024-03-12 14:51:20 [ 803.171958] nbd0: detected capacity change from 0 to 20971520 [ 803.183725] block nbd0: shutting down sockets [ 803.184645] I/O error, dev nbd0, sector 2 op 0x0:(READ) flags 0x1000 phys_seg 1 prio class 0 [ 803.185156] EXT4-fs (nbd0): unable to read superblock [ 803.186214] I/O error, dev nbd0, sector 20968432 op 0x0:(READ) flags 0x80700 phys_seg 1 prio clas0 [ 803.186770] I/O error, dev nbd0, sector 20968432 op 0x0:(READ) flags 0x0 phys_seg 1 prio class 0 [ 803.187026] Buffer I/O error on dev nbd0, logical block 10484216, async page read [ 803.187335] I/O error, dev nbd0, sector 20968434 op 0x0:(READ) flags 0x0 phys_seg 3 prio class 0 [ 803.187593] Buffer I/O error on dev nbd0, logical block 10484217, async page read [ 803.187809] Buffer I/O error on dev nbd0, logical block 10484218, async page read [ 803.188027] Buffer I/O error on dev nbd0, logical block 10484219, async page read [ 803.194147] I/O error, dev nbd0, sector 0 op 0x0:(READ) flags 0x0 phys_seg 1 prio class 0 [ 803.194400] Buffer I/O error on dev nbd0, logical block 0, async page read [ 803.194634] I/O error, dev nbd0, sector 2 op 0x0:(READ) flags 0x0 phys_seg 1 prio class 0 [ 803.194880] Buffer I/O error on dev nbd0, logical block 1, async page read [ 803.195296] I/O error, dev nbd0, sector 4 op 0x0:(READ) flags 0x0 phys_seg 1 prio class 0 [ 803.195548] Buffer I/O error on dev nbd0, logical block 2, async page read [ 803.195781] I/O error, dev nbd0, sector 6 op 0x0:(READ) flags 0x0 phys_seg 1 prio class 0 [ 803.196015] Buffer I/O error on dev nbd0, logical block 3, async page read [ 803.196246] Buffer I/O error on dev nbd0, logical block 0, async page read [ 803.196743] ldm_validate_partition_table(): Disk read failed. [ 803.197375] Dev nbd0: unable to read RDB block 0 [ 803.198007] nbd0: unable to read partition table [ 803.198467] EXT4-fs (nbd0): unable to read superblock [ 803.199444] ldm_validate_partition_table(): Disk read failed. [ 803.200487] Dev nbd0: unable to read RDB block 0 [ 803.201046] nbd0: unable to read partition table [ 803.207369] (udev-worker): attempt to access beyond end of device [ 803.207369] nbd0: rw=0, sector=2, nr_sectors = 2 limit=0 [ 803.208100] (udev-worker): attempt to access beyond end of device [ 803.208100] nbd0: rw=0, sector=4, nr_sectors = 2 limit=0 [ 803.208807] (udev-worker): attempt to access beyond end of device [ 803.208807] nbd0: rw=0, sector=6, nr_sectors = 2 limit=0 [ 803.209197] ldm_validate_partition_table(): Disk read failed. [ 803.209365] Dev nbd0: unable to read RDB block 0 [ 803.209506] nbd0: unable to read partition table [ 803.209679] nbd0: partition table beyond EOD, truncated [ 803.210132] mount_clear_soc: attempt to access beyond end of device [ 803.210132] nbd0: rw=4096, sector=2, nr_sectors = 2 limit=0 [ 803.210896] EXT4-fs (nbd0): unable to read superblock [ 803.212990] mount_clear_soc: attempt to access beyond end of device [ 803.212990] nbd0: rw=4096, sector=2, nr_sectors = 2 limit=0 [ 803.213374] EXT4-fs (nbd0): unable to read superblock [ 803.221502] mount_clear_soc: attempt to access beyond end of device [ 803.221502] nbd0: rw=4096, sector=2, nr_sectors = 2 limit=0 [ 803.221868] EXT4-fs (nbd0): unable to read superblock [ 803.223990] mount_clear_soc: attempt to access beyond end of device [ 803.223990] nbd0: rw=4096, sector=2, nr_sectors = 2 limit=0 [ 803.224334] EXT4-fs (nbd0): unable to read superblock [ 803.229317] mount_clear_soc: attempt to access beyond end of device [ 803.229317] nbd0: rw=4096, sector=2, nr_sectors = 2 limit=0 [ 803.229665] EXT4-fs (nbd0): unable to read superblock [ 803.231698] mount_clear_soc: attempt to access beyond end of device [ 803.231698] nbd0: rw=4096, sector=2, nr_sectors = 2 limit=0 [ 803.232068] EXT4-fs (nbd0): unable to read superblock [ 803.233702] mount_clear_soc: attempt to access beyond end of device [ 803.233702] nbd0: rw=4096, sector=2, nr_sectors = 2 limit=0 [ 803.234049] EXT4-fs (nbd0): unable to read superblock [ 803.235263] general protection fault, maybe for address 0x0: 0000 [#1] PREEMPT SMP NOPTI [ 803.235505] CPU: 1 PID: 53579 Comm: mount_clear_soc Not tainted 6.8.0+ #2288 [ 803.235712] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.16.2-debian-1.16.2-1 04/014 [ 803.235973] RIP: 0010:srso_alias_safe_ret+0x5/0x7 [ 803.236118] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc [ 803.236637] RSP: 0018:ffffc900000d4ef8 EFLAGS: 00010202 [ 803.236789] RAX: 0000000000000000 RBX: 0000000000000001 RCX: 0000000000000001 [ 803.236991] RDX: 6b6b6b6b6b6b6b6b RSI: ffffffff833adc6a RDI: ffff888112581870 [ 803.237200] RBP: ffffffff8124ae64 R08: 00000000ffffffff R09: 00000000ffffffff [ 803.237402] R10: 0000000000000002 R11: ffff8881130cb458 R12: ffff8881130caa40 [ 803.237605] R13: 0000000000000000 R14: 0000000000031688 R15: ffffffff8124adde [ 803.237811] FS: 0000000000000000(0000) GS:ffff8881f9d00000(0000) knlGS:0000000000000000 [ 803.238038] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 803.238206] CR2: 00007f2bb5507740 CR3: 0000000110dd2000 CR4: 0000000000750ef0 [ 803.238412] PKRU: 55555554 [ 803.238496] Call Trace: [ 803.238571] <IRQ> [ 803.238634] ? die_addr+0x31/0x80 [ 803.238740] ? exc_general_protection+0x24a/0x480 [ 803.238886] ? asm_exc_general_protection+0x26/0x30 [ 803.239028] ? rcu_core+0x34e/0xae0 [ 803.239141] ? rcu_core+0x3d4/0xae0 [ 803.239255] ? srso_alias_safe_ret+0x5/0x7 [ 803.239379] ? srso_alias_return_thunk+0x5/0xfbef5 [ 803.239523] ? rcu_core+0x3d9/0xae0 [ 803.239636] ? __do_softirq+0xec/0x481 [ 803.239757] ? __irq_exit_rcu+0x89/0xe0 [ 803.239874] ? irq_exit_rcu+0x9/0x30 [ 803.239982] ? sysvec_apic_timer_interrupt+0xa1/0xd0 [ 803.240130] </IRQ> [ 803.240197] <TASK> [ 803.240265] ? asm_sysvec_apic_timer_interrupt+0x1a/0x20 [ 803.240423] ? __memcg_slab_free_hook+0x11e/0x230 [ 803.240566] ? __memcg_slab_free_hook+0x68/0x230 [ 803.240705] ? unlink_anon_vmas+0x78/0x200 [ 803.240833] ? kmem_cache_free+0x2ca/0x310 [ 803.240960] ? unlink_anon_vmas+0x78/0x200 [ 803.241086] ? free_pgtables+0x141/0x260 [ 803.241218] ? exit_mmap+0x194/0x440 [ 803.241337] ? __mmput+0x3a/0x110 [ 803.241445] ? do_exit+0x2bf/0xb10 [ 803.241553] ? do_group_exit+0x31/0x90 [ 803.241669] ? __x64_sys_exit_group+0x13/0x20 [ 803.241801] ? do_syscall_64+0x75/0x150 [ 803.241921] ? entry_SYSCALL_64_after_hwframe+0x6c/0x74
Christian Brauner
maintainerRe: [PATCH v2 01/34] bdev: open block device as files
Quoted 2 lines · Christoph Hellwig
Now that this is in mainline it seems to cause blktests to crash nbd/003 with a rather non-obvious oops for me:
Ok, will be looking into that next.
Christian Brauner
maintainerRe: [PATCH v2 01/34] bdev: open block device as files
Quoted 5 lines · Christian Brauner
Quoted 2 lines · Christoph Hellwig
Now that this is in mainline it seems to cause blktests to crash nbd/003 with a rather non-obvious oops for me:
Ok, will be looking into that next.
Ok, I know what's going on. Basically, fput() on the block device runs asynchronously which means that bdev->bd_holder can still be set to @sb after it has already been freed. Let me illustrate what I mean:
P1 P2
mount(sb) fd = open("/dev/nbd", ...)
-> file = bdev_file_open_by_dev(..., sb, ...)
bdev->bd_holder = sb;
// Later on:
umount(sb)
->kill_block_super(sb)
|----> [fput() -> deferred via task work]
-> put_super(sb) -> frees the sb via rcu
| | nbd_ioctl(NBD_CLEAR_SOCK) | -> disk_force_media_change() | -> bdev_mark_dead() | -> fs_mark_dead() | // Finds bdev->bd_holder == sb |-> file->release::bdev_release() // Tries to get reference to it but it's freed; frees it again
bdev->bd_holder = NULL;
Two solutions that come to my mind:
[1] Indicate to fput() that this is an internal block devices open and thus just close it synchronously. This is fine. First, because the block device superblock is never unmounted or anything so there's no risk from hanging there for any reason. Second, bdev_release() also ran synchronously so any issue that we'd see from calling file->f_op->release::bdev_release() we would have seen from bdev_release() itself. See [1.1] for a patch.
(2) Take a temporary reference to the holder when opening the block device. This is also fine afaict because we differentiate between passive and active references on superblocks and what we already do in fs_bdev_mark_dead() and friends. This mean we don't have to mess around with fput(). See [1.2] for a patch.
(3) Revert and cry. No patch.
Personally, I think (2) is more desirable because we don't lose the async property of fput() and we don't need to have a new FMODE_* flag. I'd like to do some more testing with this. Thoughts?
[1.1]:
--- block/bdev.c | 1 + fs/file_table.c | 5 +++++ include/linux/fs.h | 3 +++ 3 files changed, 9 insertions(+)
block/bdev.c +1 -0
@@ -969,6 +969,7 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,return bdev_file; }ihold (bdev->bd_inode); + bdev_file->f_mode |=FMODE_BLOCKDEV ; ret =bdev_open (bdev, mode, holder, hops, bdev_file);if (ret) {
fs/file_table.c +5 -0
@@ -473,6 +473,11 @@ void fput(struct file *file)if (atomic_long_dec_and_test (&file->f_count)) {struct task_struct *task = current; +if (unlikely ((file->f_mode &FMODE_BLOCKDEV ))) { +__fput (file); +return ; + } +if (unlikely (!(file->f_mode & (FMODE_BACKING |FMODE_OPENED )))) {file_free (file);return ;
include/linux/fs.h +3 -0
@@ -121,6 +121,9 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,#define FMODE_PWRITE ((__force fmode_t)0x10)/* File is opened for execution with sys_execve / sys_uselib */ #define FMODE_EXEC ((__force fmode_t)0x20) + +/* File is opened as block device. */ +#define FMODE_BLOCKDEV ((__force fmode_t)0x100)/* 32bit hashes as llseek() offset (for directories) */ #define FMODE_32BITHASH ((__force fmode_t)0x200)/* 64bit hashes as llseek() offset (for directories) */
Signature · 9 lines
2.43.0 [1.2]: Sketched-by: Christian Brauner <[email protected]> --- block/bdev.c | 4 ++++ fs/super.c | 17 +++++++++++++++++ include/linux/blkdev.h | 3 +++ 3 files changed, 24 insertions(+)
block/bdev.c +4 -0
@@ -627,6 +627,8 @@ static void bd_end_claim(struct block_device *bdev, void *holder) whole->bd_holder =NULL ;mutex_unlock (&bdev_lock); +if (bdev->bd_holder_ops && bdev->bd_holder_ops->put_holder) + bdev->bd_holder_ops->put_holder (holder);/* * If this was the last claim, remove holder link and unblock evpoll if * it was a write holder.
@@ -902,6 +904,8 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder, bdev_file->f_mode |=FMODE_NOWAIT ; bdev_file->f_mapping = bdev->bd_inode->i_mapping; bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); +if (hops && hops->get_holder) + hops->get_holder (holder); bdev_file->private_data = holder;return 0 ;
fs/super.c +17 -0
@@ -1515,11 +1515,28 @@ static int fs_bdev_thaw(struct block_device *bdev)return error; } +static void fs_bdev_super_get (void *data) +{ +struct super_block *sb = data; + +spin_lock (&sb_lock); + sb->s_count++; +spin_unlock (&sb_lock); +} + +static void fs_bdev_super_put (void *data) +{ +struct super_block *sb = data; +put_super (sb); +} +const struct blk_holder_ops fs_holder_ops = { .mark_dead = fs_bdev_mark_dead, .sync = fs_bdev_sync, .freeze = fs_bdev_freeze, .thaw = fs_bdev_thaw, + .get_holder = fs_bdev_super_get, + .put_holder = fs_bdev_super_put, };EXPORT_SYMBOL_GPL (fs_holder_ops);
include/linux/blkdev.h +3 -0
@@ -1505,6 +1505,9 @@ struct blk_holder_ops {* Thaw the file system mounted on the block device. */ int (*thaw)(struct block_device *bdev); + +void (*get_holder)(void *holder); +void (*put_holder)(void *holder); };/*
Signature · 1 line
2.43.0
Christian Brauner
maintainerRe: [PATCH v2 01/34] bdev: open block device as files
Quoted 119 lines · Christian Brauner
Quoted 5 lines · Christian Brauner
Quoted 2 lines · Christoph Hellwig
Now that this is in mainline it seems to cause blktests to crash nbd/003 with a rather non-obvious oops for me:
Ok, will be looking into that next.
Ok, I know what's going on. Basically,
fput()on the block device runs asynchronously which means thatbdev->bd_holdercan still be set to @sb after it has already been freed. Let me illustrate what I mean:P1 P2
mount(sb) fd =open("/dev/nbd", ...)
-> file =bdev_file_open_by_dev(..., sb, ...)
bdev->bd_holder= sb;// Later on:
umount(sb)
->kill_block_super(sb)
|----> [fput()-> deferred via task work]
->put_super(sb)-> frees the sb via rcu| | nbd_ioctl(NBD_CLEAR_SOCK) | -> disk_force_media_change() | -> bdev_mark_dead() | -> fs_mark_dead() | // Finds bdev->bd_holder == sb |-> file->release::bdev_release() // Tries to get reference to it but it's freed; frees it again
bdev->bd_holder= NULL;Two solutions that come to my mind:
[1] Indicate to
fput()that this is an internal block devices open and thus just close it synchronously. This is fine. First, because the block device superblock is never unmounted or anything so there's no risk from hanging there for any reason. Second,bdev_release()also ran synchronously so any issue that we'd see from callingfile->f_op->release::bdev_release()we would have seen frombdev_release()itself. See [1.1] for a patch.(2) Take a temporary reference to the holder when opening the block device. This is also fine afaict because we differentiate between passive and active references on superblocks and what we already do in
fs_bdev_mark_dead()and friends. This mean we don't have to mess around withfput(). See [1.2] for a patch.(3) Revert and cry. No patch.
Personally, I think (2) is more desirable because we don't lose the async property of
fput()and we don't need to have a new FMODE_* flag. I'd like to do some more testing with this. Thoughts?[1.1]:
Signed-off-by Christian Brauner <[email protected]>--- block/bdev.c | 1 + fs/file_table.c | 5 +++++ include/linux/fs.h | 3 +++ 3 files changed, 9 insertions(+)block/bdev.c +1
-0@@ -969,6 +969,7 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,return bdev_file; }ihold (bdev->bd_inode); + bdev_file->f_mode |=FMODE_BLOCKDEV ; ret =bdev_open (bdev, mode, holder, hops, bdev_file);if (ret) {fs/file_table.c +5
-0@@ -473,6 +473,11 @@ void fput(struct file *file)if (atomic_long_dec_and_test (&file->f_count)) {struct task_struct *task = current; +if (unlikely ((file->f_mode &FMODE_BLOCKDEV ))) { +__fput (file); +return ; + } +if (unlikely (!(file->f_mode & (FMODE_BACKING |FMODE_OPENED )))) {file_free (file);return ;include/linux/fs.h +3
-0@@ -121,6 +121,9 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,#define FMODE_PWRITE ((__force fmode_t)0x10)/* File is opened for execution with sys_execve / sys_uselib */ #define FMODE_EXEC ((__force fmode_t)0x20) + +/* File is opened as block device. */ +#define FMODE_BLOCKDEV ((__force fmode_t)0x100)/* 32bit hashes as llseek() offset (for directories) */ #define FMODE_32BITHASH ((__force fmode_t)0x200)/* 64bit hashes as llseek() offset (for directories) */ Signature · 9 lines
2.43.0 [1.2]: Sketched-by: Christian Brauner <[email protected]> --- block/bdev.c | 4 ++++ fs/super.c | 17 +++++++++++++++++ include/linux/blkdev.h | 3 +++ 3 files changed, 24 insertions(+)block/bdev.c +0
-0
block/bdev.c static void bd_end_claim(struct block_device *bdev, void *holder) · line 631
Quoted 5 lines
block/bdev.c +2
-0@@ -627,6 +627,8 @@ static void bd_end_claim(struct block_device *bdev, void *holder) whole->bd_holder =NULL ;mutex_unlock (&bdev_lock); +if (bdev->bd_holder_ops && bdev->bd_holder_ops->put_holder) + bdev->bd_holder_ops->put_holder (holder);
That should move into bdev_release() obviously so it mirrors bdev_open(). Plus, currently it's a nop because we just NULLed bdev->bd_holder_ops above. But you get the idea, I hope.
Quoted 62 lines
block/bdev.c +2
-0/* * If this was the last claim, remove holder link and unblock evpoll if * it was a write holder. @@ -902,6 +904,8 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder, bdev_file->f_mode |=FMODE_NOWAIT ; bdev_file->f_mapping = bdev->bd_inode->i_mapping; bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); +if (hops && hops->get_holder) + hops->get_holder (holder); bdev_file->private_data = holder;return 0 ;fs/super.c +17
-0@@ -1515,11 +1515,28 @@ static int fs_bdev_thaw(struct block_device *bdev)return error; } +static void fs_bdev_super_get (void *data) +{ +struct super_block *sb = data; + +spin_lock (&sb_lock); + sb->s_count++; +spin_unlock (&sb_lock); +} + +static void fs_bdev_super_put (void *data) +{ +struct super_block *sb = data; +put_super (sb); +} +const struct blk_holder_ops fs_holder_ops = { .mark_dead = fs_bdev_mark_dead, .sync = fs_bdev_sync, .freeze = fs_bdev_freeze, .thaw = fs_bdev_thaw, + .get_holder = fs_bdev_super_get, + .put_holder = fs_bdev_super_put, };EXPORT_SYMBOL_GPL (fs_holder_ops);include/linux/blkdev.h +3
-0@@ -1505,6 +1505,9 @@ struct blk_holder_ops {* Thaw the file system mounted on the block device. */ int (*thaw)(struct block_device *bdev); + +void (*get_holder)(void *holder); +void (*put_holder)(void *holder); };/* Signature · 1 line
2.43.0
Jan Kara
reviewerRe: [PATCH v2 01/34] bdev: open block device as files
In reply to Christian BraunerQuoted 47 lines · Christian Brauner
Quoted 5 lines · Christian Brauner
Quoted 2 lines · Christoph Hellwig
Now that this is in mainline it seems to cause blktests to crash nbd/003 with a rather non-obvious oops for me:
Ok, will be looking into that next.
Ok, I know what's going on. Basically,
fput()on the block device runs asynchronously which means thatbdev->bd_holdercan still be set to @sb after it has already been freed. Let me illustrate what I mean:P1 P2
mount(sb) fd =open("/dev/nbd", ...)
-> file =bdev_file_open_by_dev(..., sb, ...)
bdev->bd_holder= sb;// Later on:
umount(sb)
->kill_block_super(sb)
|----> [fput()-> deferred via task work]
->put_super(sb)-> frees the sb via rcu| | nbd_ioctl(NBD_CLEAR_SOCK) | -> disk_force_media_change() | -> bdev_mark_dead() | -> fs_mark_dead() | // Finds bdev->bd_holder == sb |-> file->release::bdev_release() // Tries to get reference to it but it's freed; frees it again
bdev->bd_holder= NULL;Two solutions that come to my mind:
[1] Indicate to
fput()that this is an internal block devices open and thus just close it synchronously. This is fine. First, because the block device superblock is never unmounted or anything so there's no risk from hanging there for any reason. Second,bdev_release()also ran synchronously so any issue that we'd see from callingfile->f_op->release::bdev_release()we would have seen frombdev_release()itself. See [1.1] for a patch.(2) Take a temporary reference to the holder when opening the block device. This is also fine afaict because we differentiate between passive and active references on superblocks and what we already do in
fs_bdev_mark_dead()and friends. This mean we don't have to mess around withfput(). See [1.2] for a patch.
Quoted 5 lines
(3) Revert and cry. No patch.
Personally, I think (2) is more desirable because we don't lose the async property of
fput()and we don't need to have a new FMODE_* flag. I'd like to do some more testing with this. Thoughts?
Yeah, 2) looks like the least painful solution to me as well.
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH 1/1 fs,block: get holder during claim
Now that we open block devices as files we need to deal with the realities that closing is a deferred operation. An operation on the block device such as e.g., freeze, thaw, or removal that runs concurrently with umount, tries to acquire a stable reference on the holder. The holder might already be gone though. Make that reliable by grabbing a passive reference to the holder during bdev_open() and releasing it during bdev_release().
---
Hey all,
I ran blktests with nbd enabled which contains a reliable repro for the issue. Thanks to Christoph for pointing in that direction. The underlying issue is not reproducible anymore with this patch applied. xfstests and blktests pass.
Thanks!
Christian
--- block/bdev.c | 7 +++++++ fs/super.c | 18 ++++++++++++++++++ include/linux/blkdev.h | 10 ++++++++++ 3 files changed, 35 insertions(+)
block/bdev.c +7 -0
@@ -583,6 +583,9 @@ static void bd_finish_claiming(struct block_device *bdev, void *holder,mutex_unlock (&bdev->bd_holder_lock);bd_clear_claiming (whole, holder);mutex_unlock (&bdev_lock); + +if (hops && hops->get_holder) + hops->get_holder (holder); }/**
@@ -605,6 +608,7 @@ EXPORT_SYMBOL(bd_abort_claiming);static void bd_end_claim (struct block_device *bdev,void *holder) {struct block_device *whole =bdev_whole (bdev); +const struct blk_holder_ops *hops = bdev->bd_holder_ops;bool unblock = false;/*
@@ -627,6 +631,9 @@ static void bd_end_claim(struct block_device *bdev, void *holder) whole->bd_holder =NULL ;mutex_unlock (&bdev_lock); +if (hops && hops->put_holder) + hops->put_holder (holder); +/* * If this was the last claim, remove holder link and unblock evpoll if * it was a write holder.
fs/super.c +18 -0
@@ -1515,11 +1515,29 @@ static int fs_bdev_thaw(struct block_device *bdev)return error; } +static void fs_bdev_super_get (void *data) +{ +struct super_block *sb = data; + +spin_lock (&sb_lock); + sb->s_count++; +spin_unlock (&sb_lock); +} + +static void fs_bdev_super_put (void *data) +{ +struct super_block *sb = data; + +put_super (sb); +} +const struct blk_holder_ops fs_holder_ops = { .mark_dead = fs_bdev_mark_dead, .sync = fs_bdev_sync, .freeze = fs_bdev_freeze, .thaw = fs_bdev_thaw, + .get_holder = fs_bdev_super_get, + .put_holder = fs_bdev_super_put, };EXPORT_SYMBOL_GPL (fs_holder_ops);
include/linux/blkdev.h +10 -0
@@ -1505,6 +1505,16 @@ struct blk_holder_ops {* Thaw the file system mounted on the block device. */ int (*thaw)(struct block_device *bdev); + +/* +* If needed, get a reference to the holder. +*/ +void (*get_holder)(void *holder); + +/* +* Release the holder. +*/ +void (*put_holder)(void *holder); };/*
Signature · 1 line
2.43.0
Re: [PATCH] fs,block: get holder during claim
Quoted 12 lines · Christian Brauner
Now that we open block devices as files we need to deal with the realities that closing is a deferred operation. An operation on the block device such as e.g., freeze, thaw, or removal that runs concurrently with umount, tries to acquire a stable reference on the holder. The holder might already be gone though. Make that reliable by grabbing a passive reference to the holder during
bdev_open()and releasing it duringbdev_release().Fixes f3a608827d1f ("bdev: open block device as files") # mainline onlyReported-by Christoph Hellwig <[email protected]>Signed-off-by Christian Brauner <[email protected]>
Quoted 7 lines
---
Hey all,I ran blktests with nbd enabled which contains a reliable repro for the issue. Thanks to Christoph for pointing in that direction. The underlying issue is not reproducible anymore with this patch applied. xfstests and blktests pass.
Thanks for the fix! It looks good to me. Feel free to add:
Honza
Quoted 90 lines
block/bdev.c +7
-0@@ -583,6 +583,9 @@ static void bd_finish_claiming(struct block_device *bdev, void *holder,mutex_unlock (&bdev->bd_holder_lock);bd_clear_claiming (whole, holder);mutex_unlock (&bdev_lock); + +if (hops && hops->get_holder) + hops->get_holder (holder); }/** @@ -605,6 +608,7 @@ EXPORT_SYMBOL(bd_abort_claiming);static void bd_end_claim (struct block_device *bdev,void *holder) {struct block_device *whole =bdev_whole (bdev); +const struct blk_holder_ops *hops = bdev->bd_holder_ops;bool unblock = false;/* @@ -627,6 +631,9 @@ static void bd_end_claim(struct block_device *bdev, void *holder) whole->bd_holder =NULL ;mutex_unlock (&bdev_lock); +if (hops && hops->put_holder) + hops->put_holder (holder); +/* * If this was the last claim, remove holder link and unblock evpoll if * it was a write holder. fs/super.c +18
-0@@ -1515,11 +1515,29 @@ static int fs_bdev_thaw(struct block_device *bdev)return error; } +static void fs_bdev_super_get (void *data) +{ +struct super_block *sb = data; + +spin_lock (&sb_lock); + sb->s_count++; +spin_unlock (&sb_lock); +} + +static void fs_bdev_super_put (void *data) +{ +struct super_block *sb = data; + +put_super (sb); +} +const struct blk_holder_ops fs_holder_ops = { .mark_dead = fs_bdev_mark_dead, .sync = fs_bdev_sync, .freeze = fs_bdev_freeze, .thaw = fs_bdev_thaw, + .get_holder = fs_bdev_super_get, + .put_holder = fs_bdev_super_put, };EXPORT_SYMBOL_GPL (fs_holder_ops);include/linux/blkdev.h +10
-0@@ -1505,6 +1505,16 @@ struct blk_holder_ops {* Thaw the file system mounted on the block device. */ int (*thaw)(struct block_device *bdev); + +/* +* If needed, get a reference to the holder. +*/ +void (*get_holder)(void *holder); + +/* +* Release the holder. +*/ +void (*put_holder)(void *holder); };/* Signature · 1 line
2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerRe: remove holder ops
Quoted 6 lines
Quoted 4 lines
I ran blktests with nbd enabled which contains a reliable repro for the issue. Thanks to Christoph for pointing in that direction. The underlying issue is not reproducible anymore with this patch applied. xfstests and blktests pass.
Thanks for the fix! It looks good to me. Feel free to add:
So Linus complained about the fact that we have holder ops when really it currently isn't needed by anything apart from filesytems. And I think that he's right and we should consider removing the holder ops and just calling helpers directly. If there's users outside of filesystems we can always reintroduce that. So I went ahead and drafted a patch series. I think it ends up simplifying things and it ends up easier to follow and we can handle lifetime of the superblock cleaner with relying on callbacks. Appending the patch series here and pushed to vfs.bdev.holder. Want to gauge your thoughts before sending it out.
https://gitlab.com/brauner/linux/-/commits/vfs.bdev.holder
From 5a2a2d554a1ba069469ea3e58473a734a60b1f4d Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Tue, 19 Mar 2024 10:40:56 +0100
Subject: [PATCH 1/5] [RFC] block: add bdev_fsopen*()
Use a dedicated helper instead of open-coding bdev_file_open_by_*() everywhere with NULL arguments apart from a few places. This is in preparation of removing holder ops.
--- block/bdev.c | 12 ++++++++++++ fs/ext4/super.c | 4 +--- fs/super.c | 3 +-- fs/xfs/xfs_super.c | 4 ++-- include/linux/blkdev.h | 3 +++ 5 files changed, 19 insertions(+), 7 deletions(-)
block/bdev.c +12 -0
@@ -1012,6 +1012,18 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode, }EXPORT_SYMBOL (bdev_file_open_by_path); +struct file *bdev_fsopen (dev_t dev,blk_mode_t mode,struct super_block *sb) +{ +return bdev_file_open_by_dev (dev, mode, sb, &fs_holder_ops); +} +EXPORT_SYMBOL (bdev_fsopen); + +struct file *bdev_fsopen_path (const char *path,blk_mode_t mode,struct super_block *sb) +{ +return bdev_file_open_by_path (path, mode, sb, &fs_holder_ops); +} +EXPORT_SYMBOL (bdev_fsopen_path); +void bdev_release (struct file *bdev_file) {struct block_device *bdev =file_bdev (bdev_file);
fs/ext4/super.c +1 -3
@@ -5851,9 +5851,7 @@ static struct file *ext4_get_journal_blkdev(struct super_block *sb,struct ext4_super_block *es;int errno; - bdev_file =bdev_file_open_by_dev (j_dev, -BLK_OPEN_READ |BLK_OPEN_WRITE |BLK_OPEN_RESTRICT_WRITES , - sb, &fs_holder_ops); + bdev_file =bdev_fsopen (j_dev,BLK_OPEN_READ |BLK_OPEN_WRITE |BLK_OPEN_RESTRICT_WRITES , sb);if (IS_ERR (bdev_file)) { ext4_msg(sb, KERN_ERR, "failed to open journal device unknown-block(%u,%u) %ld",
fs/super.c +1 -2
@@ -1539,7 +1539,6 @@ const struct blk_holder_ops fs_holder_ops = { .get_holder = fs_bdev_super_get, .put_holder = fs_bdev_super_put, }; -EXPORT_SYMBOL_GPL (fs_holder_ops);int setup_bdev_super (struct super_block *sb,int sb_flags,struct fs_context *fc)
@@ -1548,7 +1547,7 @@ int setup_bdev_super(struct super_block *sb, int sb_flags,struct file *bdev_file;struct block_device *bdev; - bdev_file =bdev_file_open_by_dev (sb->s_dev, mode, sb, &fs_holder_ops); + bdev_file =bdev_fsopen (sb->s_dev, mode, sb);if (IS_ERR (bdev_file)) {if (fc)errorf (fc,"%s: Can't open blockdev" , fc->source);
fs/xfs/xfs_super.c +2 -2
@@ -366,9 +366,9 @@ xfs_blkdev_get( {int error =0 ; - *bdev_filep =bdev_file_open_by_path (name, + *bdev_filep =bdev_fsopen_path (name,BLK_OPEN_READ |BLK_OPEN_WRITE |BLK_OPEN_RESTRICT_WRITES , - mp->m_super, &fs_holder_ops); + mp->m_super);if (IS_ERR (*bdev_filep)) { error =PTR_ERR (*bdev_filep); *bdev_filep =NULL ;
include/linux/blkdev.h +3 -0
@@ -1536,6 +1536,9 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, const struct blk_holder_ops *hops);struct file *bdev_file_open_by_path (const char *path,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops); +struct file *bdev_fsopen (dev_t dev,blk_mode_t mode,struct super_block *sb); +struct file *bdev_fsopen_path (const char *path,blk_mode_t mode, +struct super_block *sb);int bd_prepare_to_claim (struct block_device *bdev,void *holder,const struct blk_holder_ops *hops);void bd_abort_claiming (struct block_device *bdev,void *holder);
Signature · 1 line
2.43.0
From e21591ed892657ab2b601f398b3273f93be035ce Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Tue, 19 Mar 2024 10:59:45 +0100
Subject: [PATCH 2/5] [RFC] fs,block: remove holder_ops argument *_by_path()
--- block/bdev.c | 53 ++++++++++++++++++++++++----- drivers/block/drbd/drbd_nl.c | 2 +- drivers/block/rnbd/rnbd-srv.c | 2 +- drivers/md/bcache/super.c | 2 +- drivers/mtd/devices/block2mtd.c | 2 +- drivers/nvme/target/io-cmd-bdev.c | 2 +- drivers/target/target_core_iblock.c | 3 +- drivers/target/target_core_pscsi.c | 2 +- fs/bcachefs/super-io.c | 7 ++-- fs/btrfs/dev-replace.c | 2 +- fs/btrfs/volumes.c | 6 ++-- fs/erofs/super.c | 2 +- fs/f2fs/super.c | 2 +- fs/nfs/blocklayout/dev.c | 2 +- fs/reiserfs/journal.c | 2 +- include/linux/blkdev.h | 8 ++++- 16 files changed, 68 insertions(+), 31 deletions(-)
block/bdev.c +44 -9
90 lines not on this page · raw message
drivers/block/drbd/drbd_nl.c +1 -1
@@ -1634,7 +1634,7 @@ static struct file *open_backing_dev(struct drbd_device *device,int err =0 ; file =bdev_file_open_by_path (bdev_path,BLK_OPEN_READ |BLK_OPEN_WRITE , - claim_ptr,NULL ); + claim_ptr);if (IS_ERR (file)) {drbd_err (device,"open(\"%s\") failed with %ld\n" , bdev_path,PTR_ERR (file));
drivers/block/rnbd/rnbd-srv.c +1 -1
@@ -716,7 +716,7 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess, goto reject; } - bdev_file =bdev_file_open_by_path (full_path, open_flags,NULL ,NULL ); + bdev_file =bdev_file_open_by_path (full_path, open_flags,NULL );if (IS_ERR (bdev_file)) { ret =PTR_ERR (bdev_file); pr_err("Opening device '%s' on session %s failed, failed to open the block device, err: %pe\n",
drivers/md/bcache/super.c +1 -1
@@ -2550,7 +2550,7 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr, ret = -EINVAL ; err ="failed to open device" ; - bdev_file =bdev_file_open_by_path (strim (path),BLK_OPEN_READ ,NULL ,NULL ); + bdev_file =bdev_file_open_by_path (strim (path),BLK_OPEN_READ ,NULL );if (IS_ERR (bdev_file)) goto out_free_sb;
drivers/mtd/devices/block2mtd.c +1 -1
@@ -275,7 +275,7 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size,return NULL ;/* Get a handle on the device */ - bdev_file =bdev_file_open_by_path (devname, mode, dev,NULL ); + bdev_file =bdev_file_open_by_path (devname, mode, dev);if (IS_ERR (bdev_file)) bdev_file =mdtblock_early_get_bdev (devname, mode, timeout, dev);
drivers/nvme/target/io-cmd-bdev.c +1 -1
@@ -86,7 +86,7 @@ int nvmet_bdev_ns_enable(struct nvmet_ns *ns)return -ENOTBLK ; ns->bdev_file =bdev_file_open_by_path (ns->device_path, -BLK_OPEN_READ |BLK_OPEN_WRITE ,NULL ,NULL ); +BLK_OPEN_READ |BLK_OPEN_WRITE ,NULL );if (IS_ERR (ns->bdev_file)) { ret =PTR_ERR (ns->bdev_file);if (ret != -ENOTBLK ) {
drivers/target/target_core_iblock.c +1 -2
@@ -117,8 +117,7 @@ static int iblock_configure_device(struct se_device *dev)else dev->dev_flags |=DF_READ_ONLY ; - bdev_file =bdev_file_open_by_path (ib_dev->ibd_udev_path, mode, ib_dev, -NULL ); + bdev_file =bdev_file_open_by_path (ib_dev->ibd_udev_path, mode, ib_dev);if (IS_ERR (bdev_file)) { ret =PTR_ERR (bdev_file); goto out_free_bioset;
drivers/target/target_core_pscsi.c +1 -1
@@ -367,7 +367,7 @@ static int pscsi_create_type_disk(struct se_device *dev, struct scsi_device *sd)* for TYPE_DISK and TYPE_ZBC using supplied udev_path */ bdev_file =bdev_file_open_by_path (dev->udev_path, -BLK_OPEN_WRITE |BLK_OPEN_READ , pdv,NULL ); +BLK_OPEN_WRITE |BLK_OPEN_READ , pdv);if (IS_ERR (bdev_file)) {pr_err ("pSCSI: bdev_open_by_path() failed\n" );scsi_device_put (sd);
fs/bcachefs/super-io.c +2 -5
@@ -24,9 +24,6 @@#include <linux/backing-dev.h> #include <linux/sort.h> -static const struct blk_holder_ops bch2_sb_handle_bdev_ops = { -}; -struct bch2_metadata_version {u16 version;const char *name;
@@ -712,13 +709,13 @@ static int __bch2_read_super(const char *path, struct bch_opts *opts,if (!opt_get (*opts, nochanges)) sb->mode |=BLK_OPEN_WRITE ; - sb->s_bdev_file =bdev_file_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); + sb->s_bdev_file =bdev_file_open_by_path (path, sb->mode, sb->holder);if (IS_ERR (sb->s_bdev_file) &&PTR_ERR (sb->s_bdev_file) == -EACCES &&opt_get (*opts, read_only)) { sb->mode &= ~BLK_OPEN_WRITE ; - sb->s_bdev_file =bdev_file_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); + sb->s_bdev_file =bdev_file_open_by_path (path, sb->mode, sb->holder);if (!IS_ERR (sb->s_bdev_file))opt_set (*opts, nochanges, true); }
fs/btrfs/dev-replace.c +1 -1
@@ -256,7 +256,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info, } bdev_file =bdev_file_open_by_path (device_path,BLK_OPEN_WRITE , - fs_info->bdev_holder,NULL ); + fs_info->bdev_holder);if (IS_ERR (bdev_file)) {btrfs_err (fs_info,"target device %s is invalid!" , device_path);return PTR_ERR (bdev_file);
fs/btrfs/volumes.c +3 -3
@@ -472,7 +472,7 @@ btrfs_get_bdev_and_sb(const char *device_path, blk_mode_t flags, void *holder,struct block_device *bdev;int ret; - *bdev_file =bdev_file_open_by_path (device_path, flags, holder,NULL ); + *bdev_file =bdev_file_open_by_path (device_path, flags, holder);if (IS_ERR (*bdev_file)) { ret =PTR_ERR (*bdev_file);
@@ -1341,7 +1341,7 @@ struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags,* values temporarily, as the device paths of the fsid are the only * required information for assembling the volume. */ - bdev_file =bdev_file_open_by_path (path, flags,NULL ,NULL ); + bdev_file =bdev_file_open_by_path (path, flags,NULL );if (IS_ERR (bdev_file))return ERR_CAST (bdev_file);
@@ -2597,7 +2597,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_pathreturn -EROFS ; bdev_file =bdev_file_open_by_path (device_path,BLK_OPEN_WRITE , - fs_info->bdev_holder,NULL ); + fs_info->bdev_holder);if (IS_ERR (bdev_file))return PTR_ERR (bdev_file);
fs/erofs/super.c +1 -1
@@ -202,7 +202,7 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb, dif->fscache = fscache; }else if (!sbi->devs->flatdev) { bdev_file =bdev_file_open_by_path (dif->path,BLK_OPEN_READ , - sb->s_type,NULL ); + sb->s_type);if (IS_ERR (bdev_file))return PTR_ERR (bdev_file); dif->bdev_file = bdev_file;
fs/f2fs/super.c +1 -1
@@ -4204,7 +4204,7 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)SEGS_TO_BLKS (sbi,FDEV (i).total_segments) -1 ;FDEV (i).bdev_file =bdev_file_open_by_path ( -FDEV (i).path, mode, sbi->sb,NULL ); +FDEV (i).path, mode, sbi->sb); } }if (IS_ERR (FDEV (i).bdev_file))
fs/nfs/blocklayout/dev.c +1 -1
@@ -312,7 +312,7 @@ bl_open_path(struct pnfs_block_volume *v, const char *prefix)return ERR_PTR (-ENOMEM ); bdev_file =bdev_file_open_by_path (devname,BLK_OPEN_READ |BLK_OPEN_WRITE , -NULL ,NULL ); +NULL );if (IS_ERR (bdev_file)) {pr_warn ("pNFS: failed to open device %s (%ld)\n" , devname,PTR_ERR (bdev_file));
fs/reiserfs/journal.c +1 -1
@@ -2633,7 +2633,7 @@ static int journal_init_dev(struct super_block *super, } journal->j_bdev_file =bdev_file_open_by_path (jdev_name, blkdev_mode, - holder,NULL ); + holder);if (IS_ERR (journal->j_bdev_file)) { result =PTR_ERR (journal->j_bdev_file); journal->j_bdev_file =NULL ;
include/linux/blkdev.h +7 -1
@@ -128,6 +128,12 @@ typedef unsigned int __bitwise blk_mode_t;#define BLK_OPEN_WRITE_IOCTL ((__force blk_mode_t)(1 << 4))/* open is exclusive wrt all other BLK_OPEN_WRITE opens to the device */ #define BLK_OPEN_RESTRICT_WRITES ((__force blk_mode_t)(1 << 5)) +/* open is for filesystem */ +#define BLK_OPEN_MOUNTED ((__force blk_mode_t)(1 << 6)) + +#define BLK_OPEN_VALID_FLAGS \ + (BLK_OPEN_READ | BLK_OPEN_WRITE | BLK_OPEN_EXCL | BLK_OPEN_NDELAY | \ + BLK_OPEN_WRITE_IOCTL | BLK_OPEN_RESTRICT_WRITES)struct gendisk {/*
@@ -1535,7 +1541,7 @@ extern const struct blk_holder_ops fs_holder_ops;struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops);struct file *bdev_file_open_by_path (const char *path,blk_mode_t mode, -void *holder,const struct blk_holder_ops *hops); +void *holder);struct file *bdev_fsopen (dev_t dev,blk_mode_t mode,struct super_block *sb);struct file *bdev_fsopen_path (const char *path,blk_mode_t mode,struct super_block *sb);
Signature · 1 line
2.43.0
From 232edeaf0d2abecb0b949bf8e106a4c81c094245 Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Tue, 19 Mar 2024 11:02:19 +0100
Subject: [PATCH 3/5] [RFC] fs,block: remove holder_ops argument from
*_by_dev()
--- block/bdev.c | 5 ++--- block/genhd.c | 2 +- block/ioctl.c | 2 +- drivers/block/pktcdvd.c | 4 ++-- drivers/block/xen-blkback/xenbus.c | 2 +- drivers/block/zram/zram_drv.c | 2 +- drivers/md/bcache/super.c | 2 +- drivers/md/dm.c | 2 +- drivers/md/md.c | 2 +- drivers/mtd/devices/block2mtd.c | 2 +- drivers/s390/block/dasd_genhd.c | 2 +- fs/jfs/jfs_logmgr.c | 2 +- fs/nfs/blocklayout/dev.c | 2 +- fs/ocfs2/cluster/heartbeat.c | 2 +- fs/reiserfs/journal.c | 2 +- include/linux/blkdev.h | 3 +-- kernel/power/swap.c | 4 ++-- mm/swapfile.c | 2 +- 18 files changed, 21 insertions(+), 23 deletions(-)
block/bdev.c +2 -3
@@ -989,8 +989,7 @@ static struct file *bdev_file_open(dev_t dev, blk_mode_t mode, void *holder)return bdev_file; } -struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, -const struct blk_holder_ops *hops) +struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder) {if (mode & ~BLK_OPEN_VALID_FLAGS )return ERR_PTR (-EINVAL );
@@ -1010,7 +1009,7 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,if (error)return ERR_PTR (error); - file =bdev_file_open_by_dev (dev, mode, holder,NULL ); + file =bdev_file_open_by_dev (dev, mode, holder);if (!IS_ERR (file) && (mode &BLK_OPEN_WRITE )) {if (bdev_read_only (file_bdev (file))) {fput (file);
block/genhd.c +1 -1
@@ -367,7 +367,7 @@ int disk_scan_partitions(struct gendisk *disk, blk_mode_t mode)set_bit (GD_NEED_PART_SCAN , &disk->state); file =bdev_file_open_by_dev (disk_devt (disk), mode & ~BLK_OPEN_EXCL , -NULL ,NULL ); +NULL );if (IS_ERR (file)) ret =PTR_ERR (file);else
block/ioctl.c +1 -1
@@ -488,7 +488,7 @@ static int blkdev_bszset(struct block_device *bdev, blk_mode_t mode,if (mode &BLK_OPEN_EXCL )return set_blocksize (bdev, n); - file =bdev_file_open_by_dev (bdev->bd_dev, mode, &bdev,NULL ); + file =bdev_file_open_by_dev (bdev->bd_dev, mode, &bdev);if (IS_ERR (file))return -EBUSY ; ret =set_blocksize (bdev, n);
drivers/block/pktcdvd.c +2 -2
@@ -2176,7 +2176,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write)* so open should not fail. */ bdev_file =bdev_file_open_by_dev (file_bdev (pd->bdev_file)->bd_dev, -BLK_OPEN_READ , pd,NULL ); +BLK_OPEN_READ , pd);if (IS_ERR (bdev_file)) { ret =PTR_ERR (bdev_file); goto out;
@@ -2512,7 +2512,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) } bdev_file =bdev_file_open_by_dev (dev,BLK_OPEN_READ |BLK_OPEN_NDELAY , -NULL ,NULL ); +NULL );if (IS_ERR (bdev_file))return PTR_ERR (bdev_file); sdev =scsi_device_from_queue (file_bdev (bdev_file)->bd_disk->queue);
drivers/block/xen-blkback/xenbus.c +1 -1
@@ -492,7 +492,7 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, vbd->pdevice =MKDEV (major, minor); bdev_file =bdev_file_open_by_dev (vbd->pdevice, vbd->readonly ? -BLK_OPEN_READ :BLK_OPEN_WRITE ,NULL ,NULL ); +BLK_OPEN_READ :BLK_OPEN_WRITE ,NULL );if (IS_ERR (bdev_file)) { pr_warn("xen_vbd_create: device %08x could not be opened\n",
drivers/block/zram/zram_drv.c +1 -1
@@ -514,7 +514,7 @@ static ssize_t backing_dev_store(struct device *dev, } bdev_file =bdev_file_open_by_dev (inode->i_rdev, -BLK_OPEN_READ |BLK_OPEN_WRITE , zram,NULL ); +BLK_OPEN_READ |BLK_OPEN_WRITE , zram);if (IS_ERR (bdev_file)) { err =PTR_ERR (bdev_file); bdev_file =NULL ;
drivers/md/bcache/super.c +1 -1
@@ -2571,7 +2571,7 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,/* Now reopen in exclusive mode with proper holder */ bdev_file2 =bdev_file_open_by_dev (file_bdev (bdev_file)->bd_dev, -BLK_OPEN_READ |BLK_OPEN_WRITE , holder,NULL ); +BLK_OPEN_READ |BLK_OPEN_WRITE , holder);fput (bdev_file); bdev_file = bdev_file2;if (IS_ERR (bdev_file)) {
drivers/md/dm.c +1 -1
@@ -736,7 +736,7 @@ static struct table_device *open_table_device(struct mapped_device *md,return ERR_PTR (-ENOMEM );refcount_set (&td->count,1 ); - bdev_file =bdev_file_open_by_dev (dev, mode, _dm_claim_ptr,NULL ); + bdev_file =bdev_file_open_by_dev (dev, mode, _dm_claim_ptr);if (IS_ERR (bdev_file)) { r =PTR_ERR (bdev_file); goto out_free_td;
drivers/md/md.c +1 -1
@@ -3780,7 +3780,7 @@ static struct md_rdev *md_import_device(dev_t newdev, int super_format, int supe rdev->bdev_file =bdev_file_open_by_dev (newdev,BLK_OPEN_READ |BLK_OPEN_WRITE , - super_format ==-2 ? &claim_rdev : rdev,NULL ); + super_format ==-2 ? &claim_rdev : rdev);if (IS_ERR (rdev->bdev_file)) {pr_warn ("md: could not open device unknown-block(%u,%u).\n" ,MAJOR (newdev),MINOR (newdev));
drivers/mtd/devices/block2mtd.c +1 -1
@@ -249,7 +249,7 @@ static struct file __ref *mdtblock_early_get_bdev(const char *devname,wait_for_device_probe ();if (!early_lookup_bdev (devname, &devt)) { - bdev_file =bdev_file_open_by_dev (devt, mode, dev,NULL ); + bdev_file =bdev_file_open_by_dev (devt, mode, dev);if (!IS_ERR (bdev_file))break ; }
drivers/s390/block/dasd_genhd.c +1 -1
@@ -137,7 +137,7 @@ int dasd_scan_partitions(struct dasd_block *block)int rc; bdev_file =bdev_file_open_by_dev (disk_devt (block->gdp),BLK_OPEN_READ , -NULL ,NULL ); +NULL );if (IS_ERR (bdev_file)) { DBF_DEV_EVENT(DBF_ERR, block->base, "scan partitions error, blkdev_get returned %ld",
fs/jfs/jfs_logmgr.c +1 -1
@@ -1101,7 +1101,7 @@ int lmLogOpen(struct super_block *sb)*/ bdev_file =bdev_file_open_by_dev (sbi->logdev, -BLK_OPEN_READ |BLK_OPEN_WRITE , log,NULL ); +BLK_OPEN_READ |BLK_OPEN_WRITE , log);if (IS_ERR (bdev_file)) { rc =PTR_ERR (bdev_file); goto free;
fs/nfs/blocklayout/dev.c +1 -1
@@ -244,7 +244,7 @@ bl_parse_simple(struct nfs_server *server, struct pnfs_block_dev *d,return -EIO ; bdev_file =bdev_file_open_by_dev (dev,BLK_OPEN_READ |BLK_OPEN_WRITE , -NULL ,NULL ); +NULL );if (IS_ERR (bdev_file)) {printk (KERN_WARNING "pNFS: failed to open device %d:%d (%ld)\n" ,MAJOR (dev),MINOR (dev),PTR_ERR (bdev_file));
fs/ocfs2/cluster/heartbeat.c +1 -1
@@ -1796,7 +1796,7 @@ static ssize_t o2hb_region_dev_store(struct config_item *item, goto out2; reg->hr_bdev_file =bdev_file_open_by_dev (f.file->f_mapping->host->i_rdev, -BLK_OPEN_WRITE |BLK_OPEN_READ ,NULL ,NULL ); +BLK_OPEN_WRITE |BLK_OPEN_READ ,NULL );if (IS_ERR (reg->hr_bdev_file)) { ret =PTR_ERR (reg->hr_bdev_file); reg->hr_bdev_file =NULL ;
fs/reiserfs/journal.c +1 -1
@@ -2617,7 +2617,7 @@ static int journal_init_dev(struct super_block *super,if (jdev == super->s_dev) holder =NULL ; journal->j_bdev_file =bdev_file_open_by_dev (jdev, blkdev_mode, - holder,NULL ); + holder);if (IS_ERR (journal->j_bdev_file)) { result =PTR_ERR (journal->j_bdev_file); journal->j_bdev_file =NULL ;
include/linux/blkdev.h +1 -2
@@ -1538,8 +1538,7 @@ extern const struct blk_holder_ops fs_holder_ops; (BLK_OPEN_READ |BLK_OPEN_RESTRICT_WRITES | \ (((flags) & SB_RDONLY) ? 0 : BLK_OPEN_WRITE)) -struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, -const struct blk_holder_ops *hops); +struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder);struct file *bdev_file_open_by_path (const char *path,blk_mode_t mode,void *holder);struct file *bdev_fsopen (dev_t dev,blk_mode_t mode,struct super_block *sb);
kernel/power/swap.c +2 -2
@@ -364,7 +364,7 @@ static int swsusp_swap_check(void) root_swap = res; hib_resume_bdev_file =bdev_file_open_by_dev (swsusp_resume_device, -BLK_OPEN_WRITE ,NULL ,NULL ); +BLK_OPEN_WRITE ,NULL );if (IS_ERR (hib_resume_bdev_file))return PTR_ERR (hib_resume_bdev_file);
@@ -1572,7 +1572,7 @@ int swsusp_check(bool exclusive)int error; hib_resume_bdev_file =bdev_file_open_by_dev (swsusp_resume_device, -BLK_OPEN_READ , holder,NULL ); +BLK_OPEN_READ , holder);if (!IS_ERR (hib_resume_bdev_file)) {set_blocksize (file_bdev (hib_resume_bdev_file),PAGE_SIZE );clear_page (swsusp_header);
mm/swapfile.c +1 -1
@@ -2786,7 +2786,7 @@ static int claim_swapfile(struct swap_info_struct *p, struct inode *inode)if (S_ISBLK (inode->i_mode)) { p->bdev_file =bdev_file_open_by_dev (inode->i_rdev, -BLK_OPEN_READ |BLK_OPEN_WRITE , p,NULL ); +BLK_OPEN_READ |BLK_OPEN_WRITE , p);if (IS_ERR (p->bdev_file)) { error =PTR_ERR (p->bdev_file); p->bdev_file =NULL ;
Signature · 1 line
2.43.0
From bac19560ff52cf7140051ca8c477b6e1ba783f23 Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Tue, 19 Mar 2024 11:27:28 +0100
Subject: [PATCH 4/5] [RFC] fs,block: call helpers in block layer directly
block: pass mode to bd_finish_claiming()
--- block/bdev.c | 34 +++++++++++++++++----------------- block/ioctl.c | 5 +++-- fs/internal.h | 7 +++++++ fs/super.c | 12 ++++++------ include/linux/blk_types.h | 1 + 5 files changed, 34 insertions(+), 25 deletions(-)
block/bdev.c +17 -17
@@ -241,8 +241,8 @@ int bdev_freeze(struct block_device *bdev) }mutex_lock (&bdev->bd_holder_lock); -if (bdev->bd_holder_ops && bdev->bd_holder_ops->freeze) { - error = bdev->bd_holder_ops->freeze (bdev); +if (bdev->bd_mounted) { + error =fs_bdev_freeze (bdev);lockdep_assert_not_held (&bdev->bd_holder_lock); }else {mutex_unlock (&bdev->bd_holder_lock);
@@ -284,8 +284,8 @@ int bdev_thaw(struct block_device *bdev) goto out;mutex_lock (&bdev->bd_holder_lock); -if (bdev->bd_holder_ops && bdev->bd_holder_ops->thaw) { - error = bdev->bd_holder_ops->thaw (bdev); +if (bdev->bd_mounted) { + error =fs_bdev_thaw (bdev);lockdep_assert_not_held (&bdev->bd_holder_lock); }else {mutex_unlock (&bdev->bd_holder_lock);
@@ -564,7 +564,7 @@ static void bd_clear_claiming(struct block_device *whole, void *holder)* open by the holder and wake up all waiters for exclusive open to finish. */ static void bd_finish_claiming (struct block_device *bdev,void *holder, -const struct blk_holder_ops *hops) +const struct blk_holder_ops *hops,blk_mode_t mode) {struct block_device *whole =bdev_whole (bdev);
@@ -579,13 +579,12 @@ static void bd_finish_claiming(struct block_device *bdev, void *holder, bdev->bd_holders++;mutex_lock (&bdev->bd_holder_lock); bdev->bd_holder = holder; +if (mode &BLK_OPEN_MOUNTED ) + bdev->bd_mounted = true; bdev->bd_holder_ops = hops;mutex_unlock (&bdev->bd_holder_lock);bd_clear_claiming (whole, holder);mutex_unlock (&bdev_lock); - -if (hops && hops->get_holder) - hops->get_holder (holder); }/**
@@ -608,8 +607,7 @@ EXPORT_SYMBOL(bd_abort_claiming);static void bd_end_claim (struct block_device *bdev,void *holder) {struct block_device *whole =bdev_whole (bdev); -const struct blk_holder_ops *hops = bdev->bd_holder_ops; -bool unblock = false; +bool unblock = false, mounted = false;/* * Release a claim on the device. The holder fields are protected with
@@ -619,10 +617,12 @@ static void bd_end_claim(struct block_device *bdev, void *holder)WARN_ON_ONCE (bdev->bd_holder != holder);WARN_ON_ONCE (--bdev->bd_holders <0 );WARN_ON_ONCE (--whole->bd_holders <0 ); + mounted = bdev->bd_mounted;if (!bdev->bd_holders) {mutex_lock (&bdev->bd_holder_lock); bdev->bd_holder =NULL ; bdev->bd_holder_ops =NULL ; + bdev->bd_mounted = false;mutex_unlock (&bdev->bd_holder_lock);if (bdev->bd_write_holder) unblock = true;
@@ -631,8 +631,8 @@ static void bd_end_claim(struct block_device *bdev, void *holder) whole->bd_holder =NULL ;mutex_unlock (&bdev_lock); -if (hops && hops->put_holder) - hops->put_holder (holder); +if (mounted) +fs_bdev_super_put (holder);/* * If this was the last claim, remove holder link and unblock evpoll if
@@ -883,7 +883,7 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder, goto put_module;bdev_claim_write_access (bdev, mode);if (holder) { -bd_finish_claiming (bdev, holder, hops); +bd_finish_claiming (bdev, holder, hops, mode);/* * Block event polling for write claims if requested. Any write
@@ -1030,7 +1030,7 @@ struct file *bdev_fsopen(dev_t dev, blk_mode_t mode, struct super_block *sb) bdev_file =bdev_file_open (dev, mode |BLK_OPEN_MOUNTED , sb);if (!IS_ERR (bdev_file)) -return bdev_file; +fs_bdev_super_get (sb);return bdev_file; }EXPORT_SYMBOL (bdev_fsopen);
@@ -1158,9 +1158,9 @@ EXPORT_SYMBOL(lookup_bdev);void bdev_mark_dead (struct block_device *bdev,bool surprise) {mutex_lock (&bdev->bd_holder_lock); -if (bdev->bd_holder_ops && bdev->bd_holder_ops->mark_dead) - bdev->bd_holder_ops->mark_dead (bdev, surprise); -else { +if (bdev->bd_mounted) { +fs_bdev_mark_dead (bdev, surprise); + }else {mutex_unlock (&bdev->bd_holder_lock);sync_blockdev (bdev); }
block/ioctl.c +3 -2
@@ -11,6 +11,7 @@#include <linux/blktrace_api.h> #include <linux/pr.h> #include <linux/uaccess.h> +#include "../fs/internal.h" #include "blk.h" static int blkpg_do_ioctl(struct block_device *bdev,
@@ -376,8 +377,8 @@ static int blkdev_flushbuf(struct block_device *bdev, unsigned cmd,return -EACCES ;mutex_lock (&bdev->bd_holder_lock); -if (bdev->bd_holder_ops && bdev->bd_holder_ops->sync) - bdev->bd_holder_ops->sync (bdev); +if (bdev->bd_mounted) +fs_bdev_sync (bdev);else {mutex_unlock (&bdev->bd_holder_lock);sync_blockdev (bdev);
fs/internal.h +7 -0
@@ -318,3 +318,10 @@ struct stashed_operations {int path_from_stashed (struct dentry **stashed,struct vfsmount *mnt,void *data,struct path *path);void stashed_dentry_prune (struct dentry *dentry); + +int fs_bdev_freeze (struct block_device *bdev); +int fs_bdev_thaw (struct block_device *bdev); +void fs_bdev_mark_dead (struct block_device *bdev,bool surprise); +void fs_bdev_sync (struct block_device *bdev); +void fs_bdev_super_get (void *); +void fs_bdev_super_put (void *);
fs/super.c +6 -6
@@ -1394,7 +1394,7 @@ static struct super_block *bdev_super_lock(struct block_device *bdev, bool excl)return sb; } -static void fs_bdev_mark_dead (struct block_device *bdev,bool surprise) +void fs_bdev_mark_dead (struct block_device *bdev,bool surprise) {struct super_block *sb;
@@ -1412,7 +1412,7 @@ static void fs_bdev_mark_dead(struct block_device *bdev, bool surprise)super_unlock_shared (sb); } -static void fs_bdev_sync (struct block_device *bdev) +void fs_bdev_sync (struct block_device *bdev) {struct super_block *sb;
@@ -1454,7 +1454,7 @@ static struct super_block *get_bdev_super(struct block_device *bdev)* Return: If the freeze was successful zero is returned. If the freeze * failed a negative error code is returned. */ -static int fs_bdev_freeze (struct block_device *bdev) +int fs_bdev_freeze (struct block_device *bdev) {struct super_block *sb;int error =0 ;
@@ -1494,7 +1494,7 @@ static int fs_bdev_freeze(struct block_device *bdev)* as it may have been frozen multiple times (kernel may hold a * freeze or might be frozen from other block devices). */ -static int fs_bdev_thaw (struct block_device *bdev) +int fs_bdev_thaw (struct block_device *bdev) {struct super_block *sb;int error;
@@ -1515,7 +1515,7 @@ static int fs_bdev_thaw(struct block_device *bdev)return error; } -static void fs_bdev_super_get (void *data) +void fs_bdev_super_get (void *data) {struct super_block *sb = data;
@@ -1524,7 +1524,7 @@ static void fs_bdev_super_get(void *data)spin_unlock (&sb_lock); } -static void fs_bdev_super_put (void *data) +void fs_bdev_super_put (void *data) {struct super_block *sb = data;
include/linux/blk_types.h +1 -0
@@ -57,6 +57,7 @@ struct block_device {void * bd_claiming;void * bd_holder;const struct blk_holder_ops *bd_holder_ops; +bool bd_mounted;struct mutex bd_holder_lock;int bd_holders;struct kobject *bd_holder_dir;
Signature · 1 line
2.43.0
From 463ee9ed2668963f2edd2b4d7dcc4669c76c4e4b Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Tue, 19 Mar 2024 11:32:48 +0100
Subject: [PATCH 5/5] [RFC] fs,block: remove holder ops
--- block/bdev.c | 46 ++++++++++++--------------------------- block/blk.h | 2 +- block/fops.c | 2 +- block/genhd.c | 3 +-- block/partitions/core.c | 4 ++-- drivers/block/loop.c | 2 +- fs/internal.h | 4 ++-- fs/super.c | 17 ++------------- include/linux/blk_types.h | 1 - include/linux/blkdev.h | 39 +-------------------------------- 10 files changed, 25 insertions(+), 95 deletions(-)
block/bdev.c +14 -32
150 lines not on this page · raw message
block/blk.h +1 -1
@@ -598,7 +598,7 @@ static inline void bio_issue_init(struct bio_issue *issue,void bdev_release (struct file *bdev_file);int bdev_open (struct block_device *bdev,blk_mode_t mode,void *holder, -const struct blk_holder_ops *hops,struct file *bdev_file); +struct file *bdev_file);int bdev_permission (dev_t dev,blk_mode_t mode,void *holder);#endif /* BLK_INTERNAL_H */
block/fops.c +1 -1
@@ -617,7 +617,7 @@ static int blkdev_open(struct inode *inode, struct file *filp)if (!bdev)return -ENXIO ; - ret =bdev_open (bdev, mode, filp->private_data,NULL , filp); + ret =bdev_open (bdev, mode, filp->private_data, filp);if (ret)blkdev_put_no_open (bdev);return ret;
block/genhd.c +1 -2
@@ -359,8 +359,7 @@ int disk_scan_partitions(struct gendisk *disk, blk_mode_t mode)* scanners. */ if (!(mode &BLK_OPEN_EXCL )) { - ret =bd_prepare_to_claim (disk->part0, disk_scan_partitions, -NULL ); + ret =bd_prepare_to_claim (disk->part0, disk_scan_partitions);if (ret)return ret; }
block/partitions/core.c +2 -2
@@ -462,10 +462,10 @@ int bdev_del_partition(struct gendisk *disk, int partno)/* * We verified that @part->bd_openers is zero above and so -* @part->bd_holder{_ops} can't be set. And since we hold +* @part->bd_mounted can't be set. And since we hold * @disk->open_mutex the device can't be claimed by anyone. * -* So no need to call @part->bd_holder_ops->mark_dead() here. +* So no need to call fs_bdev_mark_dead() here. * Just delete the partition and invalidate it. */
drivers/block/loop.c +1 -1
@@ -1014,7 +1014,7 @@ static int loop_configure(struct loop_device *lo, blk_mode_t mode,* here to avoid changing device under exclusive owner. */ if (!(mode &BLK_OPEN_EXCL )) { - error =bd_prepare_to_claim (bdev, loop_configure,NULL ); + error =bd_prepare_to_claim (bdev, loop_configure);if (error) goto out_putf; }
fs/internal.h +2 -2
@@ -323,5 +323,5 @@ int fs_bdev_freeze(struct block_device *bdev);int fs_bdev_thaw (struct block_device *bdev);void fs_bdev_mark_dead (struct block_device *bdev,bool surprise);void fs_bdev_sync (struct block_device *bdev); -void fs_bdev_super_get (void *); -void fs_bdev_super_put (void *); +void fs_bdev_super_get (struct super_block *sb); +void fs_bdev_super_put (struct super_block *sb);
fs/super.c +2 -15
@@ -1515,31 +1515,18 @@ int fs_bdev_thaw(struct block_device *bdev)return error; } -void fs_bdev_super_get (void *data) +void fs_bdev_super_get (struct super_block *sb) { -struct super_block *sb = data; -spin_lock (&sb_lock); sb->s_count++;spin_unlock (&sb_lock); } -void fs_bdev_super_put (void *data) +void fs_bdev_super_put (struct super_block *sb) { -struct super_block *sb = data; -put_super (sb); } -const struct blk_holder_ops fs_holder_ops = { - .mark_dead = fs_bdev_mark_dead, - .sync = fs_bdev_sync, - .freeze = fs_bdev_freeze, - .thaw = fs_bdev_thaw, - .get_holder = fs_bdev_super_get, - .put_holder = fs_bdev_super_put, -}; -int setup_bdev_super (struct super_block *sb,int sb_flags,struct fs_context *fc) {
include/linux/blk_types.h +0 -1
@@ -56,7 +56,6 @@ struct block_device {spinlock_t bd_size_lock;/* for bd_inode->i_size updates */ void * bd_claiming;void * bd_holder; -const struct blk_holder_ops *bd_holder_ops;bool bd_mounted;struct mutex bd_holder_lock;int bd_holders;
include/linux/blkdev.h +1 -38
@@ -1494,42 +1494,6 @@ void blkdev_show(struct seq_file *seqf, off_t offset);#define BLKDEV_MAJOR_MAX 0#endif -struct blk_holder_ops { -void (*mark_dead)(struct block_device *bdev,bool surprise); - -/* -* Sync the file system mounted on the block device. -*/ -void (*sync)(struct block_device *bdev); - -/* -* Freeze the file system mounted on the block device. -*/ -int (*freeze)(struct block_device *bdev); - -/* -* Thaw the file system mounted on the block device. -*/ -int (*thaw)(struct block_device *bdev); - -/* -* If needed, get a reference to the holder. -*/ -void (*get_holder)(void *holder); - -/* -* Release the holder. -*/ -void (*put_holder)(void *holder); -}; - -/* -* For filesystems using @fs_holder_ops, the @holder argument passed to -* helpers used to open and claim block devices via -* bd_prepare_to_claim() must point to a superblock. -*/ -extern const struct blk_holder_ops fs_holder_ops; -/* * Return the correct open flags for blkdev_get_by_* for super block flags * as stored in sb->s_flags.
@@ -1544,8 +1508,7 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,struct file *bdev_fsopen (dev_t dev,blk_mode_t mode,struct super_block *sb);struct file *bdev_fsopen_path (const char *path,blk_mode_t mode,struct super_block *sb); -int bd_prepare_to_claim (struct block_device *bdev,void *holder, -const struct blk_holder_ops *hops); +int bd_prepare_to_claim (struct block_device *bdev,void *holder);void bd_abort_claiming (struct block_device *bdev,void *holder);/* just for blk-cgroup, don't use elsewhere */
Signature · 1 line
2.43.0
Re: remove holder ops
block/bdev.c static void bd_end_claim(struct block_device *bdev, void *holder) · line 635
Quoted 8 lines · Christian Brauner
block/bdev.c +2
-2@@ -631,8 +631,8 @@ static void bd_end_claim(struct block_device *bdev, void *holder) whole->bd_holder =NULL ;mutex_unlock (&bdev_lock); -if (hops && hops->put_holder) - hops->put_holder (holder); +if (mounted) +fs_bdev_super_put (holder);
I think you haven't gone quite far enough here. Call super_put() directly and make bd_end_claim() take a super_block pointer.
Re: remove holder ops
In reply to Christian BraunerQuoted 2 lines · Christian Brauner
So Linus complained about the fact that we have holder ops when really it currently isn't needed by anything apart from filesytems.
Err, that's jut because we haven't gotten to it. The whole point of the ops is that we do want device removal (and in the future resize) notification for others users as well. In fact what drove me is to have proper notifications for a removed devices in md parity raid, I've just not gotten to that quite yet as I've been busy with other things.
Vut even if that wasn't the case, calling straight from block layer code into file systems is just wrong.
Re: [PATCH] fs,block: get holder during claim
In reply to Christian BraunerQuoted 7 lines · Christian Brauner
Now that we open block devices as files we need to deal with the realities that closing is a deferred operation. An operation on the block device such as e.g., freeze, thaw, or removal that runs concurrently with umount, tries to acquire a stable reference on the holder. The holder might already be gone though. Make that reliable by grabbing a passive reference to the holder during
bdev_open()and releasing it duringbdev_release().
Looks good:
does bcachefs also need a fix for it's holder ops? Or does it get to keep the pieces as it has it's own NULL holder_ops and obviously doens't care about getting any of this right?
Christian Brauner
maintainerRe: [PATCH] fs,block: get holder during claim
Quoted 9 lines · Christoph Hellwig
Quoted 7 lines · Christian Brauner
Now that we open block devices as files we need to deal with the realities that closing is a deferred operation. An operation on the block device such as e.g., freeze, thaw, or removal that runs concurrently with umount, tries to acquire a stable reference on the holder. The holder might already be gone though. Make that reliable by grabbing a passive reference to the holder during
bdev_open()and releasing it duringbdev_release().
Quoted 7 lines
Looks good:
Reviewed-by Christoph Hellwig <[email protected]>does bcachefs also need a fix for it's holder ops? Or does it get to keep the pieces as it has it's own NULL
holder_opsand obviously doens't care about getting any of this right?
It has empty holder ops and so is behaving equivalent too having NULL holder ops. IOW, the block layer cannot access the holder.
Re: [PATCH] fs,block: get holder during claim
In reply to Christian BraunerQuoted 9 lines · Christian Brauner
Now that we open block devices as files we need to deal with the realities that closing is a deferred operation. An operation on the block device such as e.g., freeze, thaw, or removal that runs concurrently with umount, tries to acquire a stable reference on the holder. The holder might already be gone though. Make that reliable by grabbing a passive reference to the holder during
bdev_open()and releasing it duringbdev_release().
Quoted 4 lines
Fixes f3a608827d1f ("bdev: open block device as files") # mainline onlyReported-by Christoph Hellwig <[email protected]>Signed-off-by Christian Brauner <[email protected]>
Verified the blktests ndb/003 panic issue was fixed by this patch, feel free to add:
Quoted 104 lines
---
Hey all,I ran blktests with nbd enabled which contains a reliable repro for the issue. Thanks to Christoph for pointing in that direction. The underlying issue is not reproducible anymore with this patch applied. xfstests and blktests pass.
Thanks!
Christian--- block/bdev.c | 7 +++++++ fs/super.c | 18 ++++++++++++++++++ include/linux/blkdev.h | 10 ++++++++++ 3 files changed, 35 insertions(+)block/bdev.c +7
-0@@ -583,6 +583,9 @@ static void bd_finish_claiming(struct block_device *bdev, void *holder,mutex_unlock (&bdev->bd_holder_lock);bd_clear_claiming (whole, holder);mutex_unlock (&bdev_lock); + +if (hops && hops->get_holder) + hops->get_holder (holder); }/** @@ -605,6 +608,7 @@ EXPORT_SYMBOL(bd_abort_claiming);static void bd_end_claim (struct block_device *bdev,void *holder) {struct block_device *whole =bdev_whole (bdev); +const struct blk_holder_ops *hops = bdev->bd_holder_ops;bool unblock = false;/* @@ -627,6 +631,9 @@ static void bd_end_claim(struct block_device *bdev, void *holder) whole->bd_holder =NULL ;mutex_unlock (&bdev_lock); +if (hops && hops->put_holder) + hops->put_holder (holder); +/* * If this was the last claim, remove holder link and unblock evpoll if * it was a write holder. fs/super.c +18
-0@@ -1515,11 +1515,29 @@ static int fs_bdev_thaw(struct block_device *bdev)return error; } +static void fs_bdev_super_get (void *data) +{ +struct super_block *sb = data; + +spin_lock (&sb_lock); + sb->s_count++; +spin_unlock (&sb_lock); +} + +static void fs_bdev_super_put (void *data) +{ +struct super_block *sb = data; + +put_super (sb); +} +const struct blk_holder_ops fs_holder_ops = { .mark_dead = fs_bdev_mark_dead, .sync = fs_bdev_sync, .freeze = fs_bdev_freeze, .thaw = fs_bdev_thaw, + .get_holder = fs_bdev_super_get, + .put_holder = fs_bdev_super_put, };EXPORT_SYMBOL_GPL (fs_holder_ops);include/linux/blkdev.h +10
-1@@ -1505,6 +1505,16 @@ struct blk_holder_ops {* Thaw the file system mounted on the block device. */ int (*thaw)(struct block_device *bdev); + +/* +* If needed, get a reference to the holder. +*/ +void (*get_holder)(void *holder); + +/* +* Release the holder. +*/ +void (*put_holder)(void *holder); };/* --
Quoted 3 lines
2.43.0
--
Best Regards,
Yi Zhang
Christian Brauner
maintainerPATCH v2 2/34 block/ioctl: port blkdev_bszset() to file
In reply to Christian Brauner--- block/ioctl.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
block/ioctl.c +4 -5
@@ -471,7 +471,7 @@ static int blkdev_bszset(struct block_device *bdev, blk_mode_t mode, int __user *argp) {int ret, n; -struct bdev_handle *handle; +struct file *file;if (!capable (CAP_SYS_ADMIN ))return -EACCES ;
@@ -483,12 +483,11 @@ static int blkdev_bszset(struct block_device *bdev, blk_mode_t mode,if (mode &BLK_OPEN_EXCL )return set_blocksize (bdev, n); - handle =bdev_open_by_dev (bdev->bd_dev, mode, &bdev,NULL ); -if (IS_ERR (handle)) + file =bdev_file_open_by_dev (bdev->bd_dev, mode, &bdev,NULL ); +if (IS_ERR (file))return -EBUSY ; ret =set_blocksize (bdev, n); -bdev_release (handle); - +fput (file);return ret; }
Signature · 1 line
2.43.0
Re: [PATCH v2 02/34] block/ioctl: port blkdev_bszset() to file
Looks good:
Re: [PATCH v2 02/34] block/ioctl: port blkdev_bszset() to file
In reply to Christian BraunerQuoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 37 lines
--- block/ioctl.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)block/ioctl.c +4
-5@@ -471,7 +471,7 @@ static int blkdev_bszset(struct block_device *bdev, blk_mode_t mode, int __user *argp) {int ret, n; -struct bdev_handle *handle; +struct file *file;if (!capable (CAP_SYS_ADMIN ))return -EACCES ;@@ -483,12 +483,11 @@ static int blkdev_bszset(struct block_device *bdev, blk_mode_t mode,if (mode &BLK_OPEN_EXCL )return set_blocksize (bdev, n); - handle =bdev_open_by_dev (bdev->bd_dev, mode, &bdev,NULL ); -if (IS_ERR (handle)) + file =bdev_file_open_by_dev (bdev->bd_dev, mode, &bdev,NULL ); +if (IS_ERR (file))return -EBUSY ; ret =set_blocksize (bdev, n); -bdev_release (handle); - +fput (file);return ret; }Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 3/34 block/genhd: port disk_scan_partitions() to file
In reply to Christian BraunerThis may run from a kernel thread via device_add_disk(). So this could also use __fput_sync() if we were worried about EBUSY. But when it is called from a kernel thread it's always BLK_OPEN_READ so EBUSY can't really happen even if we do BLK_OPEN_RESTRICT_WRITES or BLK_OPEN_EXCL.
Otherwise it's called from an ioctl on the block device which is only called from userspace and can rely on task work.
--- block/genhd.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
block/genhd.c +6 -6
@@ -342,7 +342,7 @@ EXPORT_SYMBOL_GPL(disk_uevent);int disk_scan_partitions (struct gendisk *disk,blk_mode_t mode) { -struct bdev_handle *handle; +struct file *file;int ret =0 ;if (disk->flags & (GENHD_FL_NO_PART |GENHD_FL_HIDDEN ))
@@ -366,12 +366,12 @@ int disk_scan_partitions(struct gendisk *disk, blk_mode_t mode) }set_bit (GD_NEED_PART_SCAN , &disk->state); - handle =bdev_open_by_dev (disk_devt (disk), mode & ~BLK_OPEN_EXCL ,NULL , -NULL ); -if (IS_ERR (handle)) - ret =PTR_ERR (handle); + file =bdev_file_open_by_dev (disk_devt (disk), mode & ~BLK_OPEN_EXCL , +NULL ,NULL ); +if (IS_ERR (file)) + ret =PTR_ERR (file);else -bdev_release (handle); +fput (file);/* * If blkdev_get_by_dev() failed early, GD_NEED_PART_SCAN is still set,
Signature · 1 line
2.43.0
Re: [PATCH v2 03/34] block/genhd: port disk_scan_partitions() to file
Looks good:
Re: [PATCH v2 03/34] block/genhd: port disk_scan_partitions() to file
In reply to Christian BraunerQuoted 9 lines · Christian Brauner
This may run from a kernel thread via
device_add_disk(). So this could also use__fput_sync()if we were worried about EBUSY. But when it is called from a kernel thread it's alwaysBLK_OPEN_READso EBUSY can't really happen even if we doBLK_OPEN_RESTRICT_WRITESorBLK_OPEN_EXCL.Otherwise it's called from an ioctl on the block device which is only called from userspace and can rely on task work.
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 39 lines
--- block/genhd.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)block/genhd.c +6
-6@@ -342,7 +342,7 @@ EXPORT_SYMBOL_GPL(disk_uevent);int disk_scan_partitions (struct gendisk *disk,blk_mode_t mode) { -struct bdev_handle *handle; +struct file *file;int ret =0 ;if (disk->flags & (GENHD_FL_NO_PART |GENHD_FL_HIDDEN ))@@ -366,12 +366,12 @@ int disk_scan_partitions(struct gendisk *disk, blk_mode_t mode) }set_bit (GD_NEED_PART_SCAN , &disk->state); - handle =bdev_open_by_dev (disk_devt (disk), mode & ~BLK_OPEN_EXCL ,NULL , -NULL ); -if (IS_ERR (handle)) - ret =PTR_ERR (handle); + file =bdev_file_open_by_dev (disk_devt (disk), mode & ~BLK_OPEN_EXCL , +NULL ,NULL ); +if (IS_ERR (file)) + ret =PTR_ERR (file);else -bdev_release (handle); +fput (file);/* * If blkdev_get_by_dev() failed early, GD_NEED_PART_SCAN is still set, Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 4/34 md: port block device access to file
In reply to Christian Brauner--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)
drivers/md/dm.c +13 -10
@@ -726,7 +726,8 @@ static struct table_device *open_table_device(struct mapped_device *md, dev_t dev, blk_mode_t mode) {struct table_device *td; -struct bdev_handle *bdev_handle; +struct file *bdev_file; +struct block_device *bdev;u64 part_off;int r;
@@ -735,34 +736,36 @@ static struct table_device *open_table_device(struct mapped_device *md,return ERR_PTR (-ENOMEM );refcount_set (&td->count,1 ); - bdev_handle =bdev_open_by_dev (dev, mode, _dm_claim_ptr,NULL ); -if (IS_ERR (bdev_handle)) { - r =PTR_ERR (bdev_handle); + bdev_file =bdev_file_open_by_dev (dev, mode, _dm_claim_ptr,NULL ); +if (IS_ERR (bdev_file)) { + r =PTR_ERR (bdev_file); goto out_free_td; } + bdev =file_bdev (bdev_file); +/* * We can be called before the dm disk is added. In that case we can't * register the holder relation here. It will be done once add_disk was * called. */ if (md->disk->slave_dir) { - r =bd_link_disk_holder (bdev_handle->bdev, md->disk); + r =bd_link_disk_holder (bdev, md->disk);if (r) goto out_blkdev_put; } td->dm_dev.mode = mode; - td->dm_dev.bdev = bdev_handle->bdev; - td->dm_dev.bdev_handle = bdev_handle; - td->dm_dev.dax_dev =fs_dax_get_by_bdev (bdev_handle->bdev, &part_off, + td->dm_dev.bdev = bdev; + td->dm_dev.bdev_file = bdev_file; + td->dm_dev.dax_dev =fs_dax_get_by_bdev (bdev, &part_off,NULL ,NULL );format_dev_t (td->dm_dev.name, dev);list_add (&td->list, &md->table_devices);return td; out_blkdev_put: -bdev_release (bdev_handle); +fput (bdev_file); out_free_td:kfree (td);return ERR_PTR (r);
@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);put_dax (td->dm_dev.dax_dev);list_del (&td->list);kfree (td);
drivers/md/md.c +6 -6
@@ -2578,7 +2578,7 @@ static void export_rdev(struct md_rdev *rdev, struct mddev *mddev)if (test_bit (AutoDetected, &rdev->flags))md_autodetect_dev (rdev->bdev->bd_dev);#endif -bdev_release (rdev->bdev_handle); +fput (rdev->bdev_file); rdev->bdev =NULL ;kobject_put (&rdev->kobj); }
@@ -3773,16 +3773,16 @@ static struct md_rdev *md_import_device(dev_t newdev, int super_format, int supeif (err) goto out_clear_rdev; - rdev->bdev_handle =bdev_open_by_dev (newdev, + rdev->bdev_file =bdev_file_open_by_dev (newdev,BLK_OPEN_READ |BLK_OPEN_WRITE , super_format ==-2 ? &claim_rdev : rdev,NULL ); -if (IS_ERR (rdev->bdev_handle)) { +if (IS_ERR (rdev->bdev_file)) {pr_warn ("md: could not open device unknown-block(%u,%u).\n" ,MAJOR (newdev),MINOR (newdev)); - err =PTR_ERR (rdev->bdev_handle); + err =PTR_ERR (rdev->bdev_file); goto out_clear_rdev; } - rdev->bdev = rdev->bdev_handle->bdev; + rdev->bdev =file_bdev (rdev->bdev_file);kobject_init (&rdev->kobj, &rdev_ktype);
@@ -3813,7 +3813,7 @@ static struct md_rdev *md_import_device(dev_t newdev, int super_format, int supereturn rdev; out_blkdev_put: -bdev_release (rdev->bdev_handle); +fput (rdev->bdev_file); out_clear_rdev:md_rdev_clear (rdev); out_free_rdev:
drivers/md/md.h +1 -1
@@ -59,7 +59,7 @@ struct md_rdev {*/ struct block_device *meta_bdev;struct block_device *bdev;/* block device handle */ -struct bdev_handle *bdev_handle;/* Handle from open for bdev */ +struct file *bdev_file;/* Handle from open for bdev */ struct page *sb_page, *bb_page;int sb_loaded;
include/linux/device-mapper.h +1 -1
@@ -165,7 +165,7 @@ void dm_error(const char *message);struct dm_dev {struct block_device *bdev; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct dax_device *dax_dev;blk_mode_t mode;char name[16 ];
Signature · 1 line
2.43.0
Re: [PATCH v2 04/34] md: port block device access to file
Looks good:
Re: [PATCH v2 04/34] md: port block device access to file
In reply to Christian BraunerQuoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 148 lines
--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +13
-10@@ -726,7 +726,8 @@ static struct table_device *open_table_device(struct mapped_device *md, dev_t dev, blk_mode_t mode) {struct table_device *td; -struct bdev_handle *bdev_handle; +struct file *bdev_file; +struct block_device *bdev;u64 part_off;int r;@@ -735,34 +736,36 @@ static struct table_device *open_table_device(struct mapped_device *md,return ERR_PTR (-ENOMEM );refcount_set (&td->count,1 ); - bdev_handle =bdev_open_by_dev (dev, mode, _dm_claim_ptr,NULL ); -if (IS_ERR (bdev_handle)) { - r =PTR_ERR (bdev_handle); + bdev_file =bdev_file_open_by_dev (dev, mode, _dm_claim_ptr,NULL ); +if (IS_ERR (bdev_file)) { + r =PTR_ERR (bdev_file); goto out_free_td; } + bdev =file_bdev (bdev_file); +/* * We can be called before the dm disk is added. In that case we can't * register the holder relation here. It will be done once add_disk was * called. */ if (md->disk->slave_dir) { - r =bd_link_disk_holder (bdev_handle->bdev, md->disk); + r =bd_link_disk_holder (bdev, md->disk);if (r) goto out_blkdev_put; } td->dm_dev.mode = mode; - td->dm_dev.bdev = bdev_handle->bdev; - td->dm_dev.bdev_handle = bdev_handle; - td->dm_dev.dax_dev =fs_dax_get_by_bdev (bdev_handle->bdev, &part_off, + td->dm_dev.bdev = bdev; + td->dm_dev.bdev_file = bdev_file; + td->dm_dev.dax_dev =fs_dax_get_by_bdev (bdev, &part_off,NULL ,NULL );format_dev_t (td->dm_dev.name, dev);list_add (&td->list, &md->table_devices);return td; out_blkdev_put: -bdev_release (bdev_handle); +fput (bdev_file); out_free_td:kfree (td);return ERR_PTR (r);@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);put_dax (td->dm_dev.dax_dev);list_del (&td->list);kfree (td);drivers/md/md.c +6
-6@@ -2578,7 +2578,7 @@ static void export_rdev(struct md_rdev *rdev, struct mddev *mddev)if (test_bit (AutoDetected, &rdev->flags))md_autodetect_dev (rdev->bdev->bd_dev);#endif -bdev_release (rdev->bdev_handle); +fput (rdev->bdev_file); rdev->bdev =NULL ;kobject_put (&rdev->kobj); }@@ -3773,16 +3773,16 @@ static struct md_rdev *md_import_device(dev_t newdev, int super_format, int supeif (err) goto out_clear_rdev; - rdev->bdev_handle =bdev_open_by_dev (newdev, + rdev->bdev_file =bdev_file_open_by_dev (newdev,BLK_OPEN_READ |BLK_OPEN_WRITE , super_format ==-2 ? &claim_rdev : rdev,NULL ); -if (IS_ERR (rdev->bdev_handle)) { +if (IS_ERR (rdev->bdev_file)) {pr_warn ("md: could not open device unknown-block(%u,%u).\n" ,MAJOR (newdev),MINOR (newdev)); - err =PTR_ERR (rdev->bdev_handle); + err =PTR_ERR (rdev->bdev_file); goto out_clear_rdev; } - rdev->bdev = rdev->bdev_handle->bdev; + rdev->bdev =file_bdev (rdev->bdev_file);kobject_init (&rdev->kobj, &rdev_ktype);@@ -3813,7 +3813,7 @@ static struct md_rdev *md_import_device(dev_t newdev, int super_format, int supereturn rdev; out_blkdev_put: -bdev_release (rdev->bdev_handle); +fput (rdev->bdev_file); out_clear_rdev:md_rdev_clear (rdev); out_free_rdev:drivers/md/md.h +1
-1@@ -59,7 +59,7 @@ struct md_rdev {*/ struct block_device *meta_bdev;struct block_device *bdev;/* block device handle */ -struct bdev_handle *bdev_handle;/* Handle from open for bdev */ +struct file *bdev_file;/* Handle from open for bdev */ struct page *sb_page, *bb_page;int sb_loaded;include/linux/device-mapper.h +1
-1@@ -165,7 +165,7 @@ void dm_error(const char *message);struct dm_dev {struct block_device *bdev; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct dax_device *dax_dev;blk_mode_t mode;char name[16 ];Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCH v2 04/34] md: port block device access to file
In reply to Christian BraunerHello,
Quoted 12 lines · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +0
-0
...
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 781
Quoted 6 lines
drivers/md/dm.c +1
-1@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);
The above change caused regression on 'dmsetup remove_all'.
blkdev_release() is delayed because of fput(), so dm_lock_for_deletion returns -EBUSY, then this dm disk is skipped in remove_all().
Force to mark DMF_DEFERRED_REMOVE might solve it, but need our device mapper guys to check if it is safe.
Or other better solution?
thanks,
Ming
Christian Brauner
maintainerRe: [PATCH v2 04/34] md: port block device access to file
Quoted 27 lines · Ming Lei
Hello,
Quoted 12 lines · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +0
-0...
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 781
Quoted 6 lines
drivers/md/dm.c +1
-1@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);The above change caused regression on 'dmsetup
remove_all'.
Quoted 7 lines
blkdev_release()is delayed because offput(), sodm_lock_for_deletionreturns-EBUSY, then this dm disk is skipped inremove_all().Force to mark
DMF_DEFERRED_REMOVEmight solve it, but need our device mapper guys to check if it is safe.Or other better solution?
Yeah, I think there is. You can just switch all fput() instances in device mapper to bdev_fput() which is mainline now. This will yield the device and make it able to be reclaimed. Should be as simple as the patch below. Could you test this and send a patch based on this (I'm on a prolonged vacation so I don't have time right now.):
drivers/md/dm.c +2 -2
@@ -765,7 +765,7 @@ static struct table_device *open_table_device(struct mapped_device *md,return td; out_blkdev_put: -fput (bdev_file); +bdev_fput (bdev_file); out_free_td:kfree (td);return ERR_PTR (r);
@@ -778,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -fput (td->dm_dev.bdev_file); +bdev_fput (td->dm_dev.bdev_file);put_dax (td->dm_dev.dax_dev);list_del (&td->list);kfree (td);
Mike Snitzer
maintainerRe: [PATCH v2 04/34] md: port block device access to file
Quoted 58 lines · Christian Brauner
Quoted 27 lines · Ming Lei
Hello,
Quoted 12 lines · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +0
-0...
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 781
Quoted 6 lines
drivers/md/dm.c +1
-1@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);The above change caused regression on 'dmsetup
remove_all'.Quoted 7 lines
blkdev_release()is delayed because offput(), sodm_lock_for_deletionreturns-EBUSY, then this dm disk is skipped inremove_all().Force to mark
DMF_DEFERRED_REMOVEmight solve it, but need our device mapper guys to check if it is safe.Or other better solution?
Yeah, I think there is. You can just switch all
fput()instances in device mapper tobdev_fput()which is mainline now. This will yield the device and make it able to be reclaimed. Should be as simple as the patch below. Could you test this and send a patch based on this (I'm on a prolonged vacation so I don't have time right now.):drivers/md/dm.c +1
-1@@ -765,7 +765,7 @@ static struct table_device *open_table_device(struct mapped_device *md,return td; out_blkdev_put: -fput (bdev_file); +bdev_fput (bdev_file); out_free_td:kfree (td);return ERR_PTR (r);
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 784
Quoted 8 lines
drivers/md/dm.c +1
-1@@ -778,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -fput (td->dm_dev.bdev_file); +bdev_fput (td->dm_dev.bdev_file);put_dax (td->dm_dev.dax_dev);list_del (&td->list);kfree (td);
Thanks. I'll work with Ming and others to take care of it. Have a great vacation!
Re: [PATCH v2 04/34] md: port block device access to file
In reply to Christian BraunerQuoted 34 lines · Christian Brauner
Quoted 33 lines · Ming Lei
Hello,
Quoted 12 lines · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +0
-0...
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 781
Quoted 6 lines
drivers/md/dm.c +1
-1@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);The above change caused regression on 'dmsetup
remove_all'.
blkdev_release()is delayed because offput(), sodm_lock_for_deletionreturns-EBUSY, then this dm disk is skipped inremove_all().Force to mark
DMF_DEFERRED_REMOVEmight solve it, but need our device mapper guys to check if it is safe.
Quoted 7 lines
Quoted 1 line
Or other better solution?
Yeah, I think there is. You can just switch all
fput()instances in device mapper tobdev_fput()which is mainline now. This will yield the device and make it able to be reclaimed. Should be as simple as the patch below. Could you test this and send a patch based on this (I'm on a prolonged vacation so I don't have time right now.):
Unfortunately it doesn't work.
Here the problem is that blkdev_release() is delayed, which changes 'dmsetup remove_all' behavior, and causes that some of dm disks aren't removed.
Please see dm_lock_for_deletion() and dm_blk_open()/dm_blk_close().
Thanks,
Ming
Christian Brauner
maintainerRe: [PATCH v2 04/34] md: port block device access to file
Quoted 43 lines · Ming Lei
Quoted 34 lines · Christian Brauner
Quoted 33 lines · Ming Lei
Hello,
Quoted 12 lines · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +0
-0...
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 781
Quoted 6 lines
drivers/md/dm.c +1
-1@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);The above change caused regression on 'dmsetup
remove_all'.
blkdev_release()is delayed because offput(), sodm_lock_for_deletionreturns-EBUSY, then this dm disk is skipped inremove_all().Force to mark
DMF_DEFERRED_REMOVEmight solve it, but need our device mapper guys to check if it is safe.Quoted 7 lines
Quoted 1 line
Or other better solution?
Yeah, I think there is. You can just switch all
fput()instances in device mapper tobdev_fput()which is mainline now. This will yield the device and make it able to be reclaimed. Should be as simple as the patch below. Could you test this and send a patch based on this (I'm on a prolonged vacation so I don't have time right now.):
Quoted 7 lines
Unfortunately it doesn't work.
Here the problem is that
blkdev_release()is delayed, which changes 'dmsetupremove_all' behavior, and causes that some of dm disks aren't removed.Please see
dm_lock_for_deletion()and dm_blk_open()/dm_blk_close().
So you really need blkdev_release() itself to be synchronous? Groan, in that case use __fput_sync() instead of fput() which ensures that this file is closed synchronously.
Re: [PATCH v2 04/34] md: port block device access to file
Quoted 46 lines · Christian Brauner
Quoted 45 lines · Ming Lei
Quoted 34 lines · Christian Brauner
Quoted 33 lines · Ming Lei
Hello,
Quoted 12 lines · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +0
-0...
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 781
Quoted 6 lines
drivers/md/dm.c +1
-1@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);The above change caused regression on 'dmsetup
remove_all'.
blkdev_release()is delayed because offput(), sodm_lock_for_deletionreturns-EBUSY, then this dm disk is skipped inremove_all().Force to mark
DMF_DEFERRED_REMOVEmight solve it, but need our device mapper guys to check if it is safe.Quoted 7 lines
Quoted 1 line
Or other better solution?
Yeah, I think there is. You can just switch all
fput()instances in device mapper tobdev_fput()which is mainline now. This will yield the device and make it able to be reclaimed. Should be as simple as the patch below. Could you test this and send a patch based on this (I'm on a prolonged vacation so I don't have time right now.):Unfortunately it doesn't work.
Quoted 7 lines
Quoted 5 lines
Here the problem is that
blkdev_release()is delayed, which changes 'dmsetupremove_all' behavior, and causes that some of dm disks aren't removed.Please see
dm_lock_for_deletion()and dm_blk_open()/dm_blk_close().So you really need
blkdev_release()itself to be synchronous? Groan, in
At least the current dm implementation relies on this way sort of, and it could be addressed by forcing to mark DMF_DEFERRED_REMOVE in remove_all().
Quoted 2 lines
that case use
__fput_sync()instead offput()which ensures that this file is closed synchronously.
I tried __fput_sync(), but the following panic is caused:
[ 113.486522] ------------[ cut here ]------------ [ 113.486524] kernel BUG at fs/file_table.c:453! [ 113.486531] invalid opcode: 0000 [#1] PREEMPT SMP NOPTI [ 113.488878] CPU: 6 PID: 1919 Comm: dmsetup Kdump: loaded Not tainted 5.14.0+ #23 [ 113.490114] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.16.2-1.fc37 04/01/2014 [ 113.491661] RIP: 0010:__fput_sync+0x25/0x30 [ 113.492562] Code: 90 90 90 90 90 0f 1f 44 00 00 f0 48 ff 4f 38 75 14 65 48 8b 04 25 40 25 03 00 f6 40 36 20 74 0a e9 20 fd ff ff c3 cc cc cc cc <0f0 [ 113.493926] RSP: 0018:ffffb76581003c20 EFLAGS: 00010246 [ 113.494220] RAX: ffff92eca6ef8000 RBX: ffff92ed176c3c18 RCX: 000000008080007c [ 113.494632] RDX: 0000000000000000 RSI: 0000000000000001 RDI: ffff92ec844cac00 [ 113.495033] RBP: ffff92ed176c3c00 R08: 0000000000000001 R09: 0000000000000000 [ 113.495378] R10: ffffb76581003b00 R11: ffffb76581003b68 R12: ffff92ec8fccec20 [ 113.495723] R13: ffff92ec8431b400 R14: ffff92ec8431b508 R15: ffff92ec8fccec00 [ 113.496108] FS: 00007f5be5638840(0000) GS:ffff92f0ebb80000(0000) knlGS:0000000000000000 [ 113.496581] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 113.496907] CR2: 00007f5be54694b0 CR3: 0000000108e54003 CR4: 0000000000770ef0 [ 113.497308] PKRU: 55555554 [ 113.497469] Call Trace: [ 113.497613] <TASK> [ 113.497741] ? show_trace_log_lvl+0x1c4/0x2df [ 113.497997] ? show_trace_log_lvl+0x1c4/0x2df [ 113.498251] ? dm_put_table_device+0x64/0xd0 [dm_mod] [ 113.498553] ? __die_body.cold+0x8/0xd [ 113.498768] ? die+0x2b/0x50 [ 113.498937] ? do_trap+0xce/0x120 [ 113.499129] ? __fput_sync+0x25/0x30 [ 113.499337] ? do_error_trap+0x65/0x80 [ 113.499577] ? __fput_sync+0x25/0x30 [ 113.499787] ? exc_invalid_op+0x4e/0x70 [ 113.500011] ? __fput_sync+0x25/0x30 [ 113.500239] ? asm_exc_invalid_op+0x16/0x20 [ 113.500842] ? __fput_sync+0x25/0x30 [ 113.501387] dm_put_table_device+0x64/0xd0 [dm_mod] [ 113.502047] dm_put_device+0x80/0x110 [dm_mod] [ 113.502650] stripe_dtr+0x2f/0x50 [dm_mod] [ 113.503218] dm_table_destroy+0x59/0x120 [dm_mod] [ 113.503842] __dm_destroy+0x114/0x1e0 [dm_mod] [ 113.504402] dm_hash_remove_all+0x63/0x160 [dm_mod] [ 113.505028] remove_all+0x1e/0x30 [dm_mod] [ 113.505602] ctl_ioctl+0x19f/0x290 [dm_mod] [ 113.506146] dm_ctl_ioctl+0xa/0x20 [dm_mod] [ 113.506717] __x64_sys_ioctl+0x87/0xc0 [ 113.507230] do_syscall_64+0x5c/0xf0 [ 113.507755] ? exc_page_fault+0x62/0x150 [ 113.508309] entry_SYSCALL_64_after_hwframe+0x6e/0x76 [ 113.508945] RIP: 0033:0x7f5be543ec6b
Thanks.
Ming
Mike Snitzer
maintainerRe: [PATCH v2 04/34] md: port block device access to file
Quoted 51 lines · Ming Lei
Quoted 50 lines · Christian Brauner
Quoted 49 lines · Ming Lei
Quoted 34 lines · Christian Brauner
Quoted 33 lines · Ming Lei
Hello,
Quoted 12 lines · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +0
-0...
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 781
Quoted 6 lines
drivers/md/dm.c +1
-1@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);The above change caused regression on 'dmsetup
remove_all'.
blkdev_release()is delayed because offput(), sodm_lock_for_deletionreturns-EBUSY, then this dm disk is skipped inremove_all().Force to mark
DMF_DEFERRED_REMOVEmight solve it, but need our device mapper guys to check if it is safe.Quoted 7 lines
Quoted 1 line
Or other better solution?
Yeah, I think there is. You can just switch all
fput()instances in device mapper tobdev_fput()which is mainline now. This will yield the device and make it able to be reclaimed. Should be as simple as the patch below. Could you test this and send a patch based on this (I'm on a prolonged vacation so I don't have time right now.):Unfortunately it doesn't work.
Here the problem is that
blkdev_release()is delayed, which changes 'dmsetupremove_all' behavior, and causes that some of dm disks aren't removed.
Quoted 7 lines
Quoted 3 lines
Quoted 1 line
Please see
dm_lock_for_deletion()and dm_blk_open()/dm_blk_close().So you really need
blkdev_release()itself to be synchronous? Groan, inAt least the current dm implementation relies on this way sort of, and it could be addressed by forcing to mark
DMF_DEFERRED_REMOVEinremove_all().
You floated that earlier in this thread, etc: no, that would change the interface. DMF_DEFERRED_REMOVE gives people options to allow for async device closes, etc. But I don't want to impose it as some faux equivalent to the sync model remove_all has always provided.
And what about simple 'dmsetup remove'? remove_all just loops doing remove... so isn't 'dmsetup remove' also being forced to be async as of commit a28d893eb3270 ("md: port block device access to file")?
dm.c:dm_put_device -> dm_put_table_device -> close_table_device
Quoted 4 lines
Quoted 2 lines
that case use
__fput_sync()instead offput()which ensures that this file is closed synchronously.I tried
__fput_sync(), but the following panic is caused:
Ok, so more work needed. But we need to preserve the existing sync interface for DM device removal.
Mike
Jan Kara
reviewerRe: [PATCH v2 04/34] md: port block device access to file
In reply to Ming LeiQuoted 62 lines · Ming Lei
Quoted 46 lines · Christian Brauner
Quoted 45 lines · Ming Lei
Quoted 34 lines · Christian Brauner
Quoted 33 lines · Ming Lei
Hello,
Quoted 12 lines · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +0
-0...
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 781
Quoted 6 lines
drivers/md/dm.c +1
-1@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);The above change caused regression on 'dmsetup
remove_all'.
blkdev_release()is delayed because offput(), sodm_lock_for_deletionreturns-EBUSY, then this dm disk is skipped inremove_all().Force to mark
DMF_DEFERRED_REMOVEmight solve it, but need our device mapper guys to check if it is safe.Quoted 7 lines
Quoted 1 line
Or other better solution?
Yeah, I think there is. You can just switch all
fput()instances in device mapper tobdev_fput()which is mainline now. This will yield the device and make it able to be reclaimed. Should be as simple as the patch below. Could you test this and send a patch based on this (I'm on a prolonged vacation so I don't have time right now.):Unfortunately it doesn't work.
Quoted 7 lines
Quoted 5 lines
Here the problem is that
blkdev_release()is delayed, which changes 'dmsetupremove_all' behavior, and causes that some of dm disks aren't removed.Please see
dm_lock_for_deletion()and dm_blk_open()/dm_blk_close().So you really need
blkdev_release()itself to be synchronous? Groan, inAt least the current dm implementation relies on this way sort of, and it could be addressed by forcing to mark
DMF_DEFERRED_REMOVEinremove_all().Quoted 2 lines
that case use
__fput_sync()instead offput()which ensures that this file is closed synchronously.
Quoted 6 lines
I tried
__fput_sync(), but the following panic is caused:[ 113.486522] ------------[ cut here ]------------ [ 113.486524] kernel BUG at fs/file_table.c:453! [ 113.486531] invalid opcode: 0000 [#1] PREEMPT SMP NOPTI [ 113.488878] CPU: 6 PID: 1919 Comm: dmsetup Kdump: loaded Not tainted 5.14.0+ #23
Wait, how come this is 5.14 kernel? Apparently you're crashing on:
BUG_ON(!(task->flags & PF_KTHREAD));
but that is not present in current upstream (BUG_ON was removed in 6.6-rc1 by commit 021a160abf62c).
Honza
Quoted 48 lines
[ 113.490114] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.16.2-1.fc37 04/01/2014 [ 113.491661] RIP: 0010:__fput_sync+0x25/0x30 [ 113.492562] Code: 90 90 90 90 90 0f 1f 44 00 00 f0 48 ff 4f 38 75 14 65 48 8b 04 25 40 25 03 00 f6 40 36 20 74 0a e9 20 fd ff ff c3 cc cc cc cc <0f0 [ 113.493926] RSP: 0018:ffffb76581003c20 EFLAGS: 00010246 [ 113.494220] RAX: ffff92eca6ef8000 RBX: ffff92ed176c3c18 RCX: 000000008080007c [ 113.494632] RDX: 0000000000000000 RSI: 0000000000000001 RDI: ffff92ec844cac00 [ 113.495033] RBP: ffff92ed176c3c00 R08: 0000000000000001 R09: 0000000000000000 [ 113.495378] R10: ffffb76581003b00 R11: ffffb76581003b68 R12: ffff92ec8fccec20 [ 113.495723] R13: ffff92ec8431b400 R14: ffff92ec8431b508 R15: ffff92ec8fccec00 [ 113.496108] FS: 00007f5be5638840(0000) GS:ffff92f0ebb80000(0000) knlGS:0000000000000000 [ 113.496581] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 113.496907] CR2: 00007f5be54694b0 CR3: 0000000108e54003 CR4: 0000000000770ef0 [ 113.497308] PKRU: 55555554 [ 113.497469] Call Trace: [ 113.497613] <TASK> [ 113.497741] ? show_trace_log_lvl+0x1c4/0x2df [ 113.497997] ? show_trace_log_lvl+0x1c4/0x2df [ 113.498251] ? dm_put_table_device+0x64/0xd0 [dm_mod] [ 113.498553] ? __die_body.cold+0x8/0xd [ 113.498768] ? die+0x2b/0x50 [ 113.498937] ? do_trap+0xce/0x120 [ 113.499129] ? __fput_sync+0x25/0x30 [ 113.499337] ? do_error_trap+0x65/0x80 [ 113.499577] ? __fput_sync+0x25/0x30 [ 113.499787] ? exc_invalid_op+0x4e/0x70 [ 113.500011] ? __fput_sync+0x25/0x30 [ 113.500239] ? asm_exc_invalid_op+0x16/0x20 [ 113.500842] ? __fput_sync+0x25/0x30 [ 113.501387] dm_put_table_device+0x64/0xd0 [dm_mod] [ 113.502047] dm_put_device+0x80/0x110 [dm_mod] [ 113.502650] stripe_dtr+0x2f/0x50 [dm_mod] [ 113.503218] dm_table_destroy+0x59/0x120 [dm_mod] [ 113.503842] __dm_destroy+0x114/0x1e0 [dm_mod] [ 113.504402] dm_hash_remove_all+0x63/0x160 [dm_mod] [ 113.505028] remove_all+0x1e/0x30 [dm_mod] [ 113.505602] ctl_ioctl+0x19f/0x290 [dm_mod] [ 113.506146] dm_ctl_ioctl+0xa/0x20 [dm_mod] [ 113.506717] __x64_sys_ioctl+0x87/0xc0 [ 113.507230] do_syscall_64+0x5c/0xf0 [ 113.507755] ? exc_page_fault+0x62/0x150 [ 113.508309] entry_SYSCALL_64_after_hwframe+0x6e/0x76 [ 113.508945] RIP: 0033:0x7f5be543ec6bThanks.
Ming
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCH v2 04/34] md: port block device access to file
Quoted 70 lines · Jan Kara
Quoted 62 lines · Ming Lei
Quoted 46 lines · Christian Brauner
Quoted 45 lines · Ming Lei
Quoted 34 lines · Christian Brauner
Quoted 33 lines · Ming Lei
Hello,
Quoted 12 lines · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>--- drivers/md/dm.c | 23 +++++++++++++---------- drivers/md/md.c | 12 ++++++------ drivers/md/md.h | 2 +- include/linux/device-mapper.h | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-)drivers/md/dm.c +0
-0...
drivers/md/dm.c static void close_table_device(struct table_device *td, struct mapped_device *md · line 781
Quoted 6 lines
drivers/md/dm.c +1
-1@@ -775,7 +778,7 @@ static void close_table_device(struct table_device *td, struct mapped_device *md {if (md->disk->slave_dir)bd_unlink_disk_holder (td->dm_dev.bdev, md->disk); -bdev_release (td->dm_dev.bdev_handle); +fput (td->dm_dev.bdev_file);The above change caused regression on 'dmsetup
remove_all'.
blkdev_release()is delayed because offput(), sodm_lock_for_deletionreturns-EBUSY, then this dm disk is skipped inremove_all().Force to mark
DMF_DEFERRED_REMOVEmight solve it, but need our device mapper guys to check if it is safe.Quoted 7 lines
Quoted 1 line
Or other better solution?
Yeah, I think there is. You can just switch all
fput()instances in device mapper tobdev_fput()which is mainline now. This will yield the device and make it able to be reclaimed. Should be as simple as the patch below. Could you test this and send a patch based on this (I'm on a prolonged vacation so I don't have time right now.):Unfortunately it doesn't work.
Quoted 7 lines
Quoted 5 lines
Here the problem is that
blkdev_release()is delayed, which changes 'dmsetupremove_all' behavior, and causes that some of dm disks aren't removed.Please see
dm_lock_for_deletion()and dm_blk_open()/dm_blk_close().So you really need
blkdev_release()itself to be synchronous? Groan, inAt least the current dm implementation relies on this way sort of, and it could be addressed by forcing to mark
DMF_DEFERRED_REMOVEinremove_all().Quoted 2 lines
that case use
__fput_sync()instead offput()which ensures that this file is closed synchronously.Quoted 6 lines
I tried
__fput_sync(), but the following panic is caused:[ 113.486522] ------------[ cut here ]------------ [ 113.486524] kernel BUG at fs/file_table.c:453! [ 113.486531] invalid opcode: 0000 [#1] PREEMPT SMP NOPTI [ 113.488878] CPU: 6 PID: 1919 Comm: dmsetup Kdump: loaded Not tainted 5.14.0+ #23
Quoted 6 lines
Wait, how come this is 5.14 kernel? Apparently you're crashing on:
BUG_ON(!(task->flags & PF_KTHREAD));but that is not present in current upstream (
BUG_ONwas removed in 6.6-rc1 by commit021a160abf62c).
Indeed, just tried the change on v6.9-rc3, looks it does work.
Thanks,
Ming
Christian Brauner
maintainerPATCH v2 5/34 swap: port block device usage to file
In reply to Christian Brauner--- include/linux/swap.h | 2 +- mm/swapfile.c | 22 +++++++++++----------- 2 files changed, 12 insertions(+), 12 deletions(-)
include/linux/swap.h +1 -1
@@ -298,7 +298,7 @@ struct swap_info_struct {unsigned int __percpu *cluster_next_cpu;/*percpu index for next allocation */ struct percpu_cluster __percpu *percpu_cluster;/* per cpu's swap location */ struct rb_root swap_extent_root;/* root of the swap extent rbtree */ -struct bdev_handle *bdev_handle;/* open handle of the bdev */ +struct file *bdev_file;/* open handle of the bdev */ struct block_device *bdev;/* swap device or bdev of swap file */ struct file *swap_file;/* seldom referenced */ unsigned int old_block_size;/* seldom referenced */
mm/swapfile.c +11 -11
@@ -2532,10 +2532,10 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)exit_swap_address_space (p->type); inode = mapping->host; -if (p->bdev_handle) { +if (p->bdev_file) {set_blocksize (p->bdev, old_block_size); -bdev_release (p->bdev_handle); - p->bdev_handle =NULL ; +fput (p->bdev_file); + p->bdev_file =NULL ; }inode_lock (inode);
@@ -2765,14 +2765,14 @@ static int claim_swapfile(struct swap_info_struct *p, struct inode *inode)int error;if (S_ISBLK (inode->i_mode)) { - p->bdev_handle =bdev_open_by_dev (inode->i_rdev, + p->bdev_file =bdev_file_open_by_dev (inode->i_rdev,BLK_OPEN_READ |BLK_OPEN_WRITE , p,NULL ); -if (IS_ERR (p->bdev_handle)) { - error =PTR_ERR (p->bdev_handle); - p->bdev_handle =NULL ; +if (IS_ERR (p->bdev_file)) { + error =PTR_ERR (p->bdev_file); + p->bdev_file =NULL ;return error; } - p->bdev = p->bdev_handle->bdev; + p->bdev =file_bdev (p->bdev_file); p->old_block_size =block_size (p->bdev); error =set_blocksize (p->bdev,PAGE_SIZE );if (error <0 )
@@ -3208,10 +3208,10 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) p->percpu_cluster =NULL ;free_percpu (p->cluster_next_cpu); p->cluster_next_cpu =NULL ; -if (p->bdev_handle) { +if (p->bdev_file) {set_blocksize (p->bdev, p->old_block_size); -bdev_release (p->bdev_handle); - p->bdev_handle =NULL ; +fput (p->bdev_file); + p->bdev_file =NULL ; } inode =NULL ;destroy_swap_extents (p);
Signature · 1 line
2.43.0
Re: [PATCH v2 05/34] swap: port block device usage to file
Looks good:
Re: [PATCH v2 05/34] swap: port block device usage to file
In reply to Christian BraunerQuoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 74 lines
--- include/linux/swap.h | 2 +- mm/swapfile.c | 22 +++++++++++----------- 2 files changed, 12 insertions(+), 12 deletions(-)include/linux/swap.h +1
-1@@ -298,7 +298,7 @@ struct swap_info_struct {unsigned int __percpu *cluster_next_cpu;/*percpu index for next allocation */ struct percpu_cluster __percpu *percpu_cluster;/* per cpu's swap location */ struct rb_root swap_extent_root;/* root of the swap extent rbtree */ -struct bdev_handle *bdev_handle;/* open handle of the bdev */ +struct file *bdev_file;/* open handle of the bdev */ struct block_device *bdev;/* swap device or bdev of swap file */ struct file *swap_file;/* seldom referenced */ unsigned int old_block_size;/* seldom referenced */ mm/swapfile.c +11
-11@@ -2532,10 +2532,10 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)exit_swap_address_space (p->type); inode = mapping->host; -if (p->bdev_handle) { +if (p->bdev_file) {set_blocksize (p->bdev, old_block_size); -bdev_release (p->bdev_handle); - p->bdev_handle =NULL ; +fput (p->bdev_file); + p->bdev_file =NULL ; }inode_lock (inode);@@ -2765,14 +2765,14 @@ static int claim_swapfile(struct swap_info_struct *p, struct inode *inode)int error;if (S_ISBLK (inode->i_mode)) { - p->bdev_handle =bdev_open_by_dev (inode->i_rdev, + p->bdev_file =bdev_file_open_by_dev (inode->i_rdev,BLK_OPEN_READ |BLK_OPEN_WRITE , p,NULL ); -if (IS_ERR (p->bdev_handle)) { - error =PTR_ERR (p->bdev_handle); - p->bdev_handle =NULL ; +if (IS_ERR (p->bdev_file)) { + error =PTR_ERR (p->bdev_file); + p->bdev_file =NULL ;return error; } - p->bdev = p->bdev_handle->bdev; + p->bdev =file_bdev (p->bdev_file); p->old_block_size =block_size (p->bdev); error =set_blocksize (p->bdev,PAGE_SIZE );if (error <0 )@@ -3208,10 +3208,10 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) p->percpu_cluster =NULL ;free_percpu (p->cluster_next_cpu); p->cluster_next_cpu =NULL ; -if (p->bdev_handle) { +if (p->bdev_file) {set_blocksize (p->bdev, p->old_block_size); -bdev_release (p->bdev_handle); - p->bdev_handle =NULL ; +fput (p->bdev_file); + p->bdev_file =NULL ; } inode =NULL ;destroy_swap_extents (p);Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 6/34 power: port block device access to file
In reply to Christian Brauner--- kernel/power/swap.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-)
kernel/power/swap.c +14 -14
@@ -222,7 +222,7 @@ int swsusp_swap_in_use(void)*/ static unsigned short root_swap =0xffff ; -static struct bdev_handle *hib_resume_bdev_handle; +static struct file *hib_resume_bdev_file;struct hib_bio_batch {atomic_t count;
@@ -276,7 +276,7 @@ static int hib_submit_io(blk_opf_t opf, pgoff_t page_off, void *addr,struct bio *bio;int error =0 ; - bio =bio_alloc (hib_resume_bdev_handle->bdev,1 , opf, + bio =bio_alloc (file_bdev (hib_resume_bdev_file),1 , opf,GFP_NOIO | __GFP_HIGH); bio->bi_iter.bi_sector = page_off * (PAGE_SIZE >>9 );
@@ -357,14 +357,14 @@ static int swsusp_swap_check(void)return res; root_swap = res; - hib_resume_bdev_handle =bdev_open_by_dev (swsusp_resume_device, + hib_resume_bdev_file =bdev_file_open_by_dev (swsusp_resume_device,BLK_OPEN_WRITE ,NULL ,NULL ); -if (IS_ERR (hib_resume_bdev_handle)) -return PTR_ERR (hib_resume_bdev_handle); +if (IS_ERR (hib_resume_bdev_file)) +return PTR_ERR (hib_resume_bdev_file); - res =set_blocksize (hib_resume_bdev_handle->bdev,PAGE_SIZE ); + res =set_blocksize (file_bdev (hib_resume_bdev_file),PAGE_SIZE );if (res <0 ) -bdev_release (hib_resume_bdev_handle); +fput (hib_resume_bdev_file);return res; }
@@ -1523,10 +1523,10 @@ int swsusp_check(bool exclusive)void *holder = exclusive ? &swsusp_holder :NULL ;int error; - hib_resume_bdev_handle =bdev_open_by_dev (swsusp_resume_device, + hib_resume_bdev_file =bdev_file_open_by_dev (swsusp_resume_device,BLK_OPEN_READ , holder,NULL ); -if (!IS_ERR (hib_resume_bdev_handle)) { -set_blocksize (hib_resume_bdev_handle->bdev,PAGE_SIZE ); +if (!IS_ERR (hib_resume_bdev_file)) { +set_blocksize (file_bdev (hib_resume_bdev_file),PAGE_SIZE );clear_page (swsusp_header); error =hib_submit_io (REQ_OP_READ , swsusp_resume_block, swsusp_header,NULL );
@@ -1551,11 +1551,11 @@ int swsusp_check(bool exclusive) put:if (error) -bdev_release (hib_resume_bdev_handle); +fput (hib_resume_bdev_file);else pr_debug ("Image signature found, resuming\n" ); }else { - error =PTR_ERR (hib_resume_bdev_handle); + error =PTR_ERR (hib_resume_bdev_file); }if (error)
@@ -1570,12 +1570,12 @@ int swsusp_check(bool exclusive)void swsusp_close (void ) { -if (IS_ERR (hib_resume_bdev_handle)) { +if (IS_ERR (hib_resume_bdev_file)) {pr_debug ("Image device not initialised\n" );return ; } -bdev_release (hib_resume_bdev_handle); +fput (hib_resume_bdev_file); }/**
Signature · 1 line
2.43.0
Re: [PATCH v2 06/34] power: port block device access to file
Looks good:
Re: [PATCH v2 06/34] power: port block device access to file
In reply to Christian BraunerQuoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 93 lines
--- kernel/power/swap.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-)kernel/power/swap.c +14
-14@@ -222,7 +222,7 @@ int swsusp_swap_in_use(void)*/ static unsigned short root_swap =0xffff ; -static struct bdev_handle *hib_resume_bdev_handle; +static struct file *hib_resume_bdev_file;struct hib_bio_batch {atomic_t count;@@ -276,7 +276,7 @@ static int hib_submit_io(blk_opf_t opf, pgoff_t page_off, void *addr,struct bio *bio;int error =0 ; - bio =bio_alloc (hib_resume_bdev_handle->bdev,1 , opf, + bio =bio_alloc (file_bdev (hib_resume_bdev_file),1 , opf,GFP_NOIO | __GFP_HIGH); bio->bi_iter.bi_sector = page_off * (PAGE_SIZE >>9 );@@ -357,14 +357,14 @@ static int swsusp_swap_check(void)return res; root_swap = res; - hib_resume_bdev_handle =bdev_open_by_dev (swsusp_resume_device, + hib_resume_bdev_file =bdev_file_open_by_dev (swsusp_resume_device,BLK_OPEN_WRITE ,NULL ,NULL ); -if (IS_ERR (hib_resume_bdev_handle)) -return PTR_ERR (hib_resume_bdev_handle); +if (IS_ERR (hib_resume_bdev_file)) +return PTR_ERR (hib_resume_bdev_file); - res =set_blocksize (hib_resume_bdev_handle->bdev,PAGE_SIZE ); + res =set_blocksize (file_bdev (hib_resume_bdev_file),PAGE_SIZE );if (res <0 ) -bdev_release (hib_resume_bdev_handle); +fput (hib_resume_bdev_file);return res; }@@ -1523,10 +1523,10 @@ int swsusp_check(bool exclusive)void *holder = exclusive ? &swsusp_holder :NULL ;int error; - hib_resume_bdev_handle =bdev_open_by_dev (swsusp_resume_device, + hib_resume_bdev_file =bdev_file_open_by_dev (swsusp_resume_device,BLK_OPEN_READ , holder,NULL ); -if (!IS_ERR (hib_resume_bdev_handle)) { -set_blocksize (hib_resume_bdev_handle->bdev,PAGE_SIZE ); +if (!IS_ERR (hib_resume_bdev_file)) { +set_blocksize (file_bdev (hib_resume_bdev_file),PAGE_SIZE );clear_page (swsusp_header); error =hib_submit_io (REQ_OP_READ , swsusp_resume_block, swsusp_header,NULL );@@ -1551,11 +1551,11 @@ int swsusp_check(bool exclusive) put:if (error) -bdev_release (hib_resume_bdev_handle); +fput (hib_resume_bdev_file);else pr_debug ("Image signature found, resuming\n" ); }else { - error =PTR_ERR (hib_resume_bdev_handle); + error =PTR_ERR (hib_resume_bdev_file); }if (error)@@ -1570,12 +1570,12 @@ int swsusp_check(bool exclusive)void swsusp_close (void ) { -if (IS_ERR (hib_resume_bdev_handle)) { +if (IS_ERR (hib_resume_bdev_file)) {pr_debug ("Image device not initialised\n" );return ; } -bdev_release (hib_resume_bdev_handle); +fput (hib_resume_bdev_file); }/** Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 7/34 xfs: port block device access to files
In reply to Christian Brauner--- fs/xfs/xfs_buf.c | 10 +++++----- fs/xfs/xfs_buf.h | 4 ++-- fs/xfs/xfs_super.c | 43 +++++++++++++++++++++---------------------- 3 files changed, 28 insertions(+), 29 deletions(-)
fs/xfs/xfs_buf.c +5 -5
@@ -1951,7 +1951,7 @@ xfs_free_buftarg(fs_put_dax (btp->bt_daxdev, btp->bt_mount);/* the main block device is closed by kill_block_super */ if (btp->bt_bdev != btp->bt_mount->m_super->s_bdev) -bdev_release (btp->bt_bdev_handle); +fput (btp->bt_bdev_file);kmem_free (btp); }
@@ -1994,7 +1994,7 @@ xfs_setsize_buftarg_early(struct xfs_buftarg *xfs_alloc_buftarg (struct xfs_mount *mp, -struct bdev_handle *bdev_handle) +struct file *bdev_file) {xfs_buftarg_t *btp;const struct dax_holder_operations *ops =NULL ;
@@ -2005,9 +2005,9 @@ xfs_alloc_buftarg( btp =kmem_zalloc (sizeof (*btp),KM_NOFS ); btp->bt_mount = mp; - btp->bt_bdev_handle = bdev_handle; - btp->bt_dev = bdev_handle->bdev->bd_dev; - btp->bt_bdev = bdev_handle->bdev; + btp->bt_bdev_file = bdev_file; + btp->bt_bdev =file_bdev (bdev_file); + btp->bt_dev = btp->bt_bdev->bd_dev; btp->bt_daxdev =fs_dax_get_by_bdev (btp->bt_bdev, &btp->bt_dax_part_off, mp, ops);
fs/xfs/xfs_buf.h +2 -2
@@ -98,7 +98,7 @@ typedef unsigned int xfs_buf_flags_t;*/ typedef struct xfs_buftarg { dev_t bt_dev; - struct bdev_handle *bt_bdev_handle; + struct file *bt_bdev_file; struct block_device *bt_bdev; struct dax_device *bt_daxdev; u64 bt_dax_part_off;
@@ -366,7 +366,7 @@ xfs_buf_update_cksum(struct xfs_buf *bp, unsigned long cksum_offset)* Handling of buftargs. */ struct xfs_buftarg *xfs_alloc_buftarg (struct xfs_mount *mp, -struct bdev_handle *bdev_handle); +struct file *bdev_file);extern void xfs_free_buftarg (struct xfs_buftarg *);extern void xfs_buftarg_wait (struct xfs_buftarg *);extern void xfs_buftarg_drain (struct xfs_buftarg *);
fs/xfs/xfs_super.c +21 -22
99 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH v2 07/34] xfs: port block device access to files
fs/xfs/xfs_super.c xfs_open_devices( · line 457
Quoted 11 lines
fs/xfs/xfs_super.c +3
-4if (mp->m_rtname) { - error =xfs_blkdev_get (mp, mp->m_rtname, &rtdev_handle); + error =xfs_blkdev_get (mp, mp->m_rtname, &rtdev_file);if (error) goto out_close_logdev; -if (rtdev_handle->bdev == ddev || - (logdev_handle && - rtdev_handle->bdev == logdev_handle->bdev)) { +if (file_bdev (rtdev_file) == ddev || + (logdev_file &&file_bdev (rtdev_file) ==file_bdev (logdev_file))) {
Please avoid the overly long line here.
Otherwise looks good:
(note that this will probably have some not too bad merge conflict with in-flight xfs work)
Christian Brauner
maintainerRe: [PATCH v2 07/34] xfs: port block device access to files
Quoted 1 line
Please avoid the overly long line here.
Done.
Re: [PATCH v2 07/34] xfs: port block device access to files
In reply to Christian BraunerQuoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 174 lines
--- fs/xfs/xfs_buf.c | 10 +++++----- fs/xfs/xfs_buf.h | 4 ++-- fs/xfs/xfs_super.c | 43 +++++++++++++++++++++---------------------- 3 files changed, 28 insertions(+), 29 deletions(-)fs/xfs/xfs_buf.c +5
-5@@ -1951,7 +1951,7 @@ xfs_free_buftarg(fs_put_dax (btp->bt_daxdev, btp->bt_mount);/* the main block device is closed by kill_block_super */ if (btp->bt_bdev != btp->bt_mount->m_super->s_bdev) -bdev_release (btp->bt_bdev_handle); +fput (btp->bt_bdev_file);kmem_free (btp); }@@ -1994,7 +1994,7 @@ xfs_setsize_buftarg_early(struct xfs_buftarg *xfs_alloc_buftarg (struct xfs_mount *mp, -struct bdev_handle *bdev_handle) +struct file *bdev_file) {xfs_buftarg_t *btp;const struct dax_holder_operations *ops =NULL ;@@ -2005,9 +2005,9 @@ xfs_alloc_buftarg( btp =kmem_zalloc (sizeof (*btp),KM_NOFS ); btp->bt_mount = mp; - btp->bt_bdev_handle = bdev_handle; - btp->bt_dev = bdev_handle->bdev->bd_dev; - btp->bt_bdev = bdev_handle->bdev; + btp->bt_bdev_file = bdev_file; + btp->bt_bdev =file_bdev (bdev_file); + btp->bt_dev = btp->bt_bdev->bd_dev; btp->bt_daxdev =fs_dax_get_by_bdev (btp->bt_bdev, &btp->bt_dax_part_off, mp, ops);fs/xfs/xfs_buf.h +2
-2@@ -98,7 +98,7 @@ typedef unsigned int xfs_buf_flags_t;*/ typedef struct xfs_buftarg { dev_t bt_dev; - struct bdev_handle *bt_bdev_handle; + struct file *bt_bdev_file; struct block_device *bt_bdev; struct dax_device *bt_daxdev; u64 bt_dax_part_off;@@ -366,7 +366,7 @@ xfs_buf_update_cksum(struct xfs_buf *bp, unsigned long cksum_offset)* Handling of buftargs. */ struct xfs_buftarg *xfs_alloc_buftarg (struct xfs_mount *mp, -struct bdev_handle *bdev_handle); +struct file *bdev_file);extern void xfs_free_buftarg (struct xfs_buftarg *);extern void xfs_buftarg_wait (struct xfs_buftarg *);extern void xfs_buftarg_drain (struct xfs_buftarg *);fs/xfs/xfs_super.c +21
-22@@ -362,16 +362,16 @@ STATIC intxfs_blkdev_get ( xfs_mount_t *mp, const char *name, - struct bdev_handle **handlep) + struct file **bdev_filep) {int error =0 ; - *handlep =bdev_open_by_path (name, + *bdev_filep =bdev_file_open_by_path (name,BLK_OPEN_READ |BLK_OPEN_WRITE |BLK_OPEN_RESTRICT_WRITES , mp->m_super, &fs_holder_ops); -if (IS_ERR (*handlep)) { - error =PTR_ERR (*handlep); - *handlep =NULL ; +if (IS_ERR (*bdev_filep)) { + error =PTR_ERR (*bdev_filep); + *bdev_filep =NULL ;xfs_warn (mp,"Invalid device [%s], error=%d" , name, error); }@@ -436,26 +436,25 @@ xfs_open_devices( {struct super_block *sb = mp->m_super;struct block_device *ddev = sb->s_bdev; -struct bdev_handle *logdev_handle =NULL , *rtdev_handle =NULL ; +struct file *logdev_file =NULL , *rtdev_file =NULL ;int error;/* * Open real time and log devices - order is important. */ if (mp->m_logname) { - error =xfs_blkdev_get (mp, mp->m_logname, &logdev_handle); + error =xfs_blkdev_get (mp, mp->m_logname, &logdev_file);if (error)return error; }if (mp->m_rtname) { - error =xfs_blkdev_get (mp, mp->m_rtname, &rtdev_handle); + error =xfs_blkdev_get (mp, mp->m_rtname, &rtdev_file);if (error) goto out_close_logdev; -if (rtdev_handle->bdev == ddev || - (logdev_handle && - rtdev_handle->bdev == logdev_handle->bdev)) { +if (file_bdev (rtdev_file) == ddev || + (logdev_file &&file_bdev (rtdev_file) ==file_bdev (logdev_file))) {xfs_warn (mp,"Cannot mount filesystem with identical rtdev and ddev/logdev." ); error = -EINVAL ;@@ -467,25 +466,25 @@ xfs_open_devices(* Setup xfs_mount buffer target pointers */ error = -ENOMEM ; - mp->m_ddev_targp =xfs_alloc_buftarg (mp,sb_bdev_handle (sb)); + mp->m_ddev_targp =xfs_alloc_buftarg (mp, sb->s_bdev_file);if (!mp->m_ddev_targp) goto out_close_rtdev; -if (rtdev_handle) { - mp->m_rtdev_targp =xfs_alloc_buftarg (mp, rtdev_handle); +if (rtdev_file) { + mp->m_rtdev_targp =xfs_alloc_buftarg (mp, rtdev_file);if (!mp->m_rtdev_targp) goto out_free_ddev_targ; } -if (logdev_handle && logdev_handle->bdev != ddev) { - mp->m_logdev_targp =xfs_alloc_buftarg (mp, logdev_handle); +if (logdev_file &&file_bdev (logdev_file) != ddev) { + mp->m_logdev_targp =xfs_alloc_buftarg (mp, logdev_file);if (!mp->m_logdev_targp) goto out_free_rtdev_targ; }else { mp->m_logdev_targp = mp->m_ddev_targp;/* Handle won't be used, drop it */ -if (logdev_handle) -bdev_release (logdev_handle); +if (logdev_file) +fput (logdev_file); }return 0 ;@@ -496,11 +495,11 @@ xfs_open_devices( out_free_ddev_targ:xfs_free_buftarg (mp->m_ddev_targp); out_close_rtdev: -if (rtdev_handle) -bdev_release (rtdev_handle); +if (rtdev_file) +fput (rtdev_file); out_close_logdev: -if (logdev_handle) -bdev_release (logdev_handle); +if (logdev_file) +fput (logdev_file);return error; }Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 8/34 drbd: port block device access to file
In reply to Christian Brauner--- drivers/block/drbd/drbd_int.h | 4 +-- drivers/block/drbd/drbd_nl.c | 58 +++++++++++++++++++++---------------------- 2 files changed, 31 insertions(+), 31 deletions(-)
drivers/block/drbd/drbd_int.h +2 -2
@@ -524,9 +524,9 @@ struct drbd_md {struct drbd_backing_dev {struct block_device *backing_bdev; -struct bdev_handle *backing_bdev_handle; +struct file *backing_bdev_file;struct block_device *md_bdev; -struct bdev_handle *md_bdev_handle; +struct file *f_md_bdev;struct drbd_md md;struct disk_conf *disk_conf;/* RCU, for updates: resource->conf_update */ sector_t known_size;/* last known size of that backing device */
drivers/block/drbd/drbd_nl.c +29 -29
120 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH v2 08/34] drbd: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 154 lines
--- drivers/block/drbd/drbd_int.h | 4 +-- drivers/block/drbd/drbd_nl.c | 58 +++++++++++++++++++++---------------------- 2 files changed, 31 insertions(+), 31 deletions(-)drivers/block/drbd/drbd_int.h +2
-2@@ -524,9 +524,9 @@ struct drbd_md {struct drbd_backing_dev {struct block_device *backing_bdev; -struct bdev_handle *backing_bdev_handle; +struct file *backing_bdev_file;struct block_device *md_bdev; -struct bdev_handle *md_bdev_handle; +struct file *f_md_bdev;struct drbd_md md;struct disk_conf *disk_conf;/* RCU, for updates: resource->conf_update */ sector_t known_size;/* last known size of that backing device */ drivers/block/drbd/drbd_nl.c +29
-29@@ -1635,45 +1635,45 @@ int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info)return 0 ; } -static struct bdev_handle *open_backing_dev (struct drbd_device *device, +static struct file *open_backing_dev (struct drbd_device *device,const char *bdev_path,void *claim_ptr,bool do_bd_link) { -struct bdev_handle *handle; +struct file *file;int err =0 ; - handle =bdev_open_by_path (bdev_path,BLK_OPEN_READ |BLK_OPEN_WRITE , - claim_ptr,NULL ); -if (IS_ERR (handle)) { + file =bdev_file_open_by_path (bdev_path,BLK_OPEN_READ |BLK_OPEN_WRITE , + claim_ptr,NULL ); +if (IS_ERR (file)) {drbd_err (device,"open(\"%s\") failed with %ld\n" , - bdev_path,PTR_ERR (handle)); -return handle; + bdev_path,PTR_ERR (file)); +return file; }if (!do_bd_link) -return handle; +return file; - err =bd_link_disk_holder (handle->bdev, device->vdisk); + err =bd_link_disk_holder (file_bdev (file), device->vdisk);if (err) { -bdev_release (handle); +fput (file);drbd_err (device,"bd_link_disk_holder(\"%s\", ...) failed with %d\n" , bdev_path, err); - handle =ERR_PTR (err); + file =ERR_PTR (err); } -return handle; +return file; }static int open_backing_devices (struct drbd_device *device,struct disk_conf *new_disk_conf,struct drbd_backing_dev *nbc) { -struct bdev_handle *handle; +struct file *file; - handle =open_backing_dev (device, new_disk_conf->backing_dev, device, + file =open_backing_dev (device, new_disk_conf->backing_dev, device, true); -if (IS_ERR (handle)) +if (IS_ERR (file))return ERR_OPEN_DISK ; - nbc->backing_bdev = handle->bdev; - nbc->backing_bdev_handle = handle; + nbc->backing_bdev =file_bdev (file); + nbc->backing_bdev_file = file;/* * meta_dev_idx >= 0: external fixed size, possibly multiple @@ -1683,7 +1683,7 @@ static int open_backing_devices(struct drbd_device *device,* should check it for you already; but if you don't, or * someone fooled it, we need to double check here) */ - handle = open_backing_dev(device, new_disk_conf->meta_dev, + file = open_backing_dev(device, new_disk_conf->meta_dev, /* claim ptr: device, if claimed exclusively; shared drbd_m_holder, * if potentially shared with other drbd minors */ (new_disk_conf->meta_dev_idx < 0) ? (void*)device : (void*)drbd_m_holder,@@ -1691,21 +1691,21 @@ static int open_backing_devices(struct drbd_device *device,* as would happen with internal metadata. */ (new_disk_conf->meta_dev_idx !=DRBD_MD_INDEX_FLEX_INT && new_disk_conf->meta_dev_idx != DRBD_MD_INDEX_INTERNAL)); -if (IS_ERR (handle)) +if (IS_ERR (file))return ERR_OPEN_MD_DISK ; - nbc->md_bdev = handle->bdev; - nbc->md_bdev_handle = handle; + nbc->md_bdev =file_bdev (file); + nbc->f_md_bdev = file;return NO_ERROR ; }static void close_backing_dev (struct drbd_device *device, -struct bdev_handle *handle,bool do_bd_unlink) +struct file *bdev_file,bool do_bd_unlink) { -if (!handle) +if (!bdev_file)return ;if (do_bd_unlink) -bd_unlink_disk_holder (handle->bdev, device->vdisk); -bdev_release (handle); +bd_unlink_disk_holder (file_bdev (bdev_file), device->vdisk); +fput (bdev_file); }void drbd_backing_dev_free (struct drbd_device *device,struct drbd_backing_dev *ldev)@@ -1713,9 +1713,9 @@ void drbd_backing_dev_free(struct drbd_device *device, struct drbd_backing_dev *if (ldev ==NULL )return ; -close_backing_dev (device, ldev->md_bdev_handle, +close_backing_dev (device, ldev->f_md_bdev, ldev->md_bdev != ldev->backing_bdev); -close_backing_dev (device, ldev->backing_bdev_handle, true); +close_backing_dev (device, ldev->backing_bdev_file, true);kfree (ldev->disk_conf);kfree (ldev);@@ -2131,9 +2131,9 @@ int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info) fail:conn_reconfig_done (connection);if (nbc) { -close_backing_dev (device, nbc->md_bdev_handle, +close_backing_dev (device, nbc->f_md_bdev, nbc->md_bdev != nbc->backing_bdev); -close_backing_dev (device, nbc->backing_bdev_handle, true); +close_backing_dev (device, nbc->backing_bdev_file, true);kfree (nbc); }kfree (new_disk_conf);Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 9/34 pktcdvd: port block device access to file
In reply to Christian Brauner--- drivers/block/pktcdvd.c | 68 ++++++++++++++++++++++++------------------------- include/linux/pktcdvd.h | 4 +-- 2 files changed, 36 insertions(+), 36 deletions(-)
drivers/block/pktcdvd.c +34 -34
@@ -340,8 +340,8 @@ static ssize_t device_map_show(const struct class *c, const struct class_attribu n +=sysfs_emit_at (data, n,"%s %u:%u %u:%u\n" , pd->disk->disk_name,MAJOR (pd->pkt_dev),MINOR (pd->pkt_dev), -MAJOR (pd->bdev_handle->bdev->bd_dev), -MINOR (pd->bdev_handle->bdev->bd_dev)); +MAJOR (file_bdev (pd->bdev_file)->bd_dev), +MINOR (file_bdev (pd->bdev_file)->bd_dev)); }mutex_unlock (&ctl_mutex);return n;
@@ -438,7 +438,7 @@ static int pkt_seq_show(struct seq_file *m, void *p)int states[PACKET_NUM_STATES ];seq_printf (m,"Writer %s mapped to %pg:\n" , pd->disk->disk_name, - pd->bdev_handle->bdev); +file_bdev (pd->bdev_file));seq_printf (m,"\nSettings:\n" );seq_printf (m,"\tpacket size:\t\t%dkB\n" , pd->settings.size /2 );
@@ -715,7 +715,7 @@ static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *nod*/ static int pkt_generic_packet (struct pktcdvd_device *pd,struct packet_command *cgc) { -struct request_queue *q =bdev_get_queue (pd->bdev_handle->bdev); +struct request_queue *q =bdev_get_queue (file_bdev (pd->bdev_file));struct scsi_cmnd *scmd;struct request *rq;int ret =0 ;
@@ -1048,7 +1048,7 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)continue ; bio = pkt->r_bios[f]; -bio_init (bio, pd->bdev_handle->bdev, bio->bi_inline_vecs,1 , +bio_init (bio,file_bdev (pd->bdev_file), bio->bi_inline_vecs,1 ,REQ_OP_READ ); bio->bi_iter.bi_sector = pkt->sector + f * (CD_FRAMESIZE >>9 ); bio->bi_end_io = pkt_end_io_read;
@@ -1264,7 +1264,7 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)struct device *ddev =disk_to_dev (pd->disk);int f; -bio_init (pkt->w_bio, pd->bdev_handle->bdev, pkt->w_bio->bi_inline_vecs, +bio_init (pkt->w_bio,file_bdev (pd->bdev_file), pkt->w_bio->bi_inline_vecs, pkt->frames,REQ_OP_WRITE ); pkt->w_bio->bi_iter.bi_sector = pkt->sector; pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
@@ -2162,20 +2162,20 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write)int ret;long lba;struct request_queue *q; -struct bdev_handle *bdev_handle; +struct file *bdev_file;/* * We need to re-open the cdrom device without O_NONBLOCK to be able * to read/write from/to it. It is already opened in O_NONBLOCK mode * so open should not fail. */ - bdev_handle =bdev_open_by_dev (pd->bdev_handle->bdev->bd_dev, + bdev_file =bdev_file_open_by_dev (file_bdev (pd->bdev_file)->bd_dev,BLK_OPEN_READ , pd,NULL ); -if (IS_ERR (bdev_handle)) { - ret =PTR_ERR (bdev_handle); +if (IS_ERR (bdev_file)) { + ret =PTR_ERR (bdev_file); goto out; } - pd->open_bdev_handle = bdev_handle; + pd->f_open_bdev = bdev_file; ret =pkt_get_last_written (pd, &lba);if (ret) {
@@ -2184,9 +2184,9 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write) }set_capacity (pd->disk, lba <<2 ); -set_capacity_and_notify (pd->bdev_handle->bdev->bd_disk, lba <<2 ); +set_capacity_and_notify (file_bdev (pd->bdev_file)->bd_disk, lba <<2 ); - q =bdev_get_queue (pd->bdev_handle->bdev); + q =bdev_get_queue (file_bdev (pd->bdev_file));if (write) { ret =pkt_open_write (pd);if (ret)
@@ -2218,7 +2218,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write)return 0 ; out_putdev: -bdev_release (bdev_handle); +fput (bdev_file); out:return ret; }
@@ -2237,8 +2237,8 @@ static void pkt_release_dev(struct pktcdvd_device *pd, int flush)pkt_lock_door (pd,0 );pkt_set_speed (pd,MAX_SPEED ,MAX_SPEED ); -bdev_release (pd->open_bdev_handle); - pd->open_bdev_handle =NULL ; +fput (pd->f_open_bdev); + pd->f_open_bdev =NULL ;pkt_shrink_pktlist (pd); }
@@ -2326,7 +2326,7 @@ static void pkt_end_io_read_cloned(struct bio *bio)static void pkt_make_request_read (struct pktcdvd_device *pd,struct bio *bio) { -struct bio *cloned_bio =bio_alloc_clone (pd->bdev_handle->bdev, bio, +struct bio *cloned_bio =bio_alloc_clone (file_bdev (pd->bdev_file), bio,GFP_NOIO , &pkt_bio_set);struct packet_stacked_data *psd =mempool_alloc (&psd_pool,GFP_NOIO );
@@ -2497,7 +2497,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) {struct device *ddev =disk_to_dev (pd->disk);int i; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct scsi_device *sdev;if (pd->pkt_dev == dev) {
@@ -2508,9 +2508,9 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)struct pktcdvd_device *pd2 = pkt_devs[i];if (!pd2)continue ; -if (pd2->bdev_handle->bdev->bd_dev == dev) { +if (file_bdev (pd2->bdev_file)->bd_dev == dev) {dev_err (ddev,"%pg already setup\n" , - pd2->bdev_handle->bdev); +file_bdev (pd2->bdev_file));return -EBUSY ; }if (pd2->pkt_dev == dev) {
@@ -2519,13 +2519,13 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) } } - bdev_handle =bdev_open_by_dev (dev,BLK_OPEN_READ |BLK_OPEN_NDELAY , + bdev_file =bdev_file_open_by_dev (dev,BLK_OPEN_READ |BLK_OPEN_NDELAY ,NULL ,NULL ); -if (IS_ERR (bdev_handle)) -return PTR_ERR (bdev_handle); - sdev =scsi_device_from_queue (bdev_handle->bdev->bd_disk->queue); +if (IS_ERR (bdev_file)) +return PTR_ERR (bdev_file); + sdev =scsi_device_from_queue (file_bdev (bdev_file)->bd_disk->queue);if (!sdev) { -bdev_release (bdev_handle); +fput (bdev_file);return -EINVAL ; }put_device (&sdev->sdev_gendev);
@@ -2533,8 +2533,8 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)/* This is safe, since we have a reference from open(). */ __module_get (THIS_MODULE ); - pd->bdev_handle = bdev_handle; -set_blocksize (bdev_handle->bdev,CD_FRAMESIZE ); + pd->bdev_file = bdev_file; +set_blocksize (file_bdev (bdev_file),CD_FRAMESIZE );pkt_init_queue (pd);
@@ -2546,11 +2546,11 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) }proc_create_single_data (pd->disk->disk_name,0 , pkt_proc, pkt_seq_show, pd); -dev_notice (ddev,"writer mapped to %pg\n" , bdev_handle->bdev); +dev_notice (ddev,"writer mapped to %pg\n" ,file_bdev (bdev_file));return 0 ; out_mem: -bdev_release (bdev_handle); +fput (bdev_file);/* This is safe: open() is still holding a reference. */ module_put (THIS_MODULE );return -ENOMEM ;
@@ -2605,9 +2605,9 @@ static unsigned int pkt_check_events(struct gendisk *disk,if (!pd)return 0 ; -if (!pd->bdev_handle) +if (!pd->bdev_file)return 0 ; - attached_disk = pd->bdev_handle->bdev->bd_disk; + attached_disk =file_bdev (pd->bdev_file)->bd_disk;if (!attached_disk || !attached_disk->fops->check_events)return 0 ;return attached_disk->fops->check_events (attached_disk, clearing);
@@ -2692,7 +2692,7 @@ static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev) goto out_mem2;/* inherit events of the host device */ - disk->events = pd->bdev_handle->bdev->bd_disk->events; + disk->events =file_bdev (pd->bdev_file)->bd_disk->events; ret =add_disk (disk);if (ret)
@@ -2757,7 +2757,7 @@ static int pkt_remove_dev(dev_t pkt_dev)pkt_debugfs_dev_remove (pd);pkt_sysfs_dev_remove (pd); -bdev_release (pd->bdev_handle); +fput (pd->bdev_file);remove_proc_entry (pd->disk->disk_name, pkt_proc);dev_notice (ddev,"writer unmapped\n" );
@@ -2784,7 +2784,7 @@ static void pkt_get_status(struct pkt_ctrl_command *ctrl_cmd) pd =pkt_find_dev_from_minor (ctrl_cmd->dev_index);if (pd) { - ctrl_cmd->dev =new_encode_dev (pd->bdev_handle->bdev->bd_dev); + ctrl_cmd->dev =new_encode_dev (file_bdev (pd->bdev_file)->bd_dev); ctrl_cmd->pkt_dev =new_encode_dev (pd->pkt_dev); }else { ctrl_cmd->dev =0 ;
include/linux/pktcdvd.h +2 -2
@@ -154,9 +154,9 @@ struct packet_stacked_datastruct pktcdvd_device { -struct bdev_handle *bdev_handle;/* dev attached */ +struct file *bdev_file;/* dev attached */ /* handle acquired for bdev during pkt_open_dev() */ -struct bdev_handle *open_bdev_handle; +struct file *f_open_bdev;dev_t pkt_dev;/* our dev */ struct packet_settings settings;struct packet_stats stats;
Signature · 1 line
2.43.0
Re: [PATCH v2 09/34] pktcdvd: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 247 lines
--- drivers/block/pktcdvd.c | 68 ++++++++++++++++++++++++------------------------- include/linux/pktcdvd.h | 4 +-- 2 files changed, 36 insertions(+), 36 deletions(-)drivers/block/pktcdvd.c +34
-34@@ -340,8 +340,8 @@ static ssize_t device_map_show(const struct class *c, const struct class_attribu n +=sysfs_emit_at (data, n,"%s %u:%u %u:%u\n" , pd->disk->disk_name,MAJOR (pd->pkt_dev),MINOR (pd->pkt_dev), -MAJOR (pd->bdev_handle->bdev->bd_dev), -MINOR (pd->bdev_handle->bdev->bd_dev)); +MAJOR (file_bdev (pd->bdev_file)->bd_dev), +MINOR (file_bdev (pd->bdev_file)->bd_dev)); }mutex_unlock (&ctl_mutex);return n;@@ -438,7 +438,7 @@ static int pkt_seq_show(struct seq_file *m, void *p)int states[PACKET_NUM_STATES ];seq_printf (m,"Writer %s mapped to %pg:\n" , pd->disk->disk_name, - pd->bdev_handle->bdev); +file_bdev (pd->bdev_file));seq_printf (m,"\nSettings:\n" );seq_printf (m,"\tpacket size:\t\t%dkB\n" , pd->settings.size /2 );@@ -715,7 +715,7 @@ static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *nod*/ static int pkt_generic_packet (struct pktcdvd_device *pd,struct packet_command *cgc) { -struct request_queue *q =bdev_get_queue (pd->bdev_handle->bdev); +struct request_queue *q =bdev_get_queue (file_bdev (pd->bdev_file));struct scsi_cmnd *scmd;struct request *rq;int ret =0 ;@@ -1048,7 +1048,7 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)continue ; bio = pkt->r_bios[f]; -bio_init (bio, pd->bdev_handle->bdev, bio->bi_inline_vecs,1 , +bio_init (bio,file_bdev (pd->bdev_file), bio->bi_inline_vecs,1 ,REQ_OP_READ ); bio->bi_iter.bi_sector = pkt->sector + f * (CD_FRAMESIZE >>9 ); bio->bi_end_io = pkt_end_io_read;@@ -1264,7 +1264,7 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)struct device *ddev =disk_to_dev (pd->disk);int f; -bio_init (pkt->w_bio, pd->bdev_handle->bdev, pkt->w_bio->bi_inline_vecs, +bio_init (pkt->w_bio,file_bdev (pd->bdev_file), pkt->w_bio->bi_inline_vecs, pkt->frames,REQ_OP_WRITE ); pkt->w_bio->bi_iter.bi_sector = pkt->sector; pkt->w_bio->bi_end_io = pkt_end_io_packet_write;@@ -2162,20 +2162,20 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write)int ret;long lba;struct request_queue *q; -struct bdev_handle *bdev_handle; +struct file *bdev_file;/* * We need to re-open the cdrom device without O_NONBLOCK to be able * to read/write from/to it. It is already opened in O_NONBLOCK mode * so open should not fail. */ - bdev_handle =bdev_open_by_dev (pd->bdev_handle->bdev->bd_dev, + bdev_file =bdev_file_open_by_dev (file_bdev (pd->bdev_file)->bd_dev,BLK_OPEN_READ , pd,NULL ); -if (IS_ERR (bdev_handle)) { - ret =PTR_ERR (bdev_handle); +if (IS_ERR (bdev_file)) { + ret =PTR_ERR (bdev_file); goto out; } - pd->open_bdev_handle = bdev_handle; + pd->f_open_bdev = bdev_file; ret =pkt_get_last_written (pd, &lba);if (ret) {@@ -2184,9 +2184,9 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write) }set_capacity (pd->disk, lba <<2 ); -set_capacity_and_notify (pd->bdev_handle->bdev->bd_disk, lba <<2 ); +set_capacity_and_notify (file_bdev (pd->bdev_file)->bd_disk, lba <<2 ); - q =bdev_get_queue (pd->bdev_handle->bdev); + q =bdev_get_queue (file_bdev (pd->bdev_file));if (write) { ret =pkt_open_write (pd);if (ret)@@ -2218,7 +2218,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write)return 0 ; out_putdev: -bdev_release (bdev_handle); +fput (bdev_file); out:return ret; }@@ -2237,8 +2237,8 @@ static void pkt_release_dev(struct pktcdvd_device *pd, int flush)pkt_lock_door (pd,0 );pkt_set_speed (pd,MAX_SPEED ,MAX_SPEED ); -bdev_release (pd->open_bdev_handle); - pd->open_bdev_handle =NULL ; +fput (pd->f_open_bdev); + pd->f_open_bdev =NULL ;pkt_shrink_pktlist (pd); }@@ -2326,7 +2326,7 @@ static void pkt_end_io_read_cloned(struct bio *bio)static void pkt_make_request_read (struct pktcdvd_device *pd,struct bio *bio) { -struct bio *cloned_bio =bio_alloc_clone (pd->bdev_handle->bdev, bio, +struct bio *cloned_bio =bio_alloc_clone (file_bdev (pd->bdev_file), bio,GFP_NOIO , &pkt_bio_set);struct packet_stacked_data *psd =mempool_alloc (&psd_pool,GFP_NOIO );@@ -2497,7 +2497,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) {struct device *ddev =disk_to_dev (pd->disk);int i; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct scsi_device *sdev;if (pd->pkt_dev == dev) {@@ -2508,9 +2508,9 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)struct pktcdvd_device *pd2 = pkt_devs[i];if (!pd2)continue ; -if (pd2->bdev_handle->bdev->bd_dev == dev) { +if (file_bdev (pd2->bdev_file)->bd_dev == dev) {dev_err (ddev,"%pg already setup\n" , - pd2->bdev_handle->bdev); +file_bdev (pd2->bdev_file));return -EBUSY ; }if (pd2->pkt_dev == dev) {@@ -2519,13 +2519,13 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) } } - bdev_handle =bdev_open_by_dev (dev,BLK_OPEN_READ |BLK_OPEN_NDELAY , + bdev_file =bdev_file_open_by_dev (dev,BLK_OPEN_READ |BLK_OPEN_NDELAY ,NULL ,NULL ); -if (IS_ERR (bdev_handle)) -return PTR_ERR (bdev_handle); - sdev =scsi_device_from_queue (bdev_handle->bdev->bd_disk->queue); +if (IS_ERR (bdev_file)) +return PTR_ERR (bdev_file); + sdev =scsi_device_from_queue (file_bdev (bdev_file)->bd_disk->queue);if (!sdev) { -bdev_release (bdev_handle); +fput (bdev_file);return -EINVAL ; }put_device (&sdev->sdev_gendev);@@ -2533,8 +2533,8 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)/* This is safe, since we have a reference from open(). */ __module_get (THIS_MODULE ); - pd->bdev_handle = bdev_handle; -set_blocksize (bdev_handle->bdev,CD_FRAMESIZE ); + pd->bdev_file = bdev_file; +set_blocksize (file_bdev (bdev_file),CD_FRAMESIZE );pkt_init_queue (pd);@@ -2546,11 +2546,11 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) }proc_create_single_data (pd->disk->disk_name,0 , pkt_proc, pkt_seq_show, pd); -dev_notice (ddev,"writer mapped to %pg\n" , bdev_handle->bdev); +dev_notice (ddev,"writer mapped to %pg\n" ,file_bdev (bdev_file));return 0 ; out_mem: -bdev_release (bdev_handle); +fput (bdev_file);/* This is safe: open() is still holding a reference. */ module_put (THIS_MODULE );return -ENOMEM ;@@ -2605,9 +2605,9 @@ static unsigned int pkt_check_events(struct gendisk *disk,if (!pd)return 0 ; -if (!pd->bdev_handle) +if (!pd->bdev_file)return 0 ; - attached_disk = pd->bdev_handle->bdev->bd_disk; + attached_disk =file_bdev (pd->bdev_file)->bd_disk;if (!attached_disk || !attached_disk->fops->check_events)return 0 ;return attached_disk->fops->check_events (attached_disk, clearing);@@ -2692,7 +2692,7 @@ static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev) goto out_mem2;/* inherit events of the host device */ - disk->events = pd->bdev_handle->bdev->bd_disk->events; + disk->events =file_bdev (pd->bdev_file)->bd_disk->events; ret =add_disk (disk);if (ret)@@ -2757,7 +2757,7 @@ static int pkt_remove_dev(dev_t pkt_dev)pkt_debugfs_dev_remove (pd);pkt_sysfs_dev_remove (pd); -bdev_release (pd->bdev_handle); +fput (pd->bdev_file);remove_proc_entry (pd->disk->disk_name, pkt_proc);dev_notice (ddev,"writer unmapped\n" );@@ -2784,7 +2784,7 @@ static void pkt_get_status(struct pkt_ctrl_command *ctrl_cmd) pd =pkt_find_dev_from_minor (ctrl_cmd->dev_index);if (pd) { - ctrl_cmd->dev =new_encode_dev (pd->bdev_handle->bdev->bd_dev); + ctrl_cmd->dev =new_encode_dev (file_bdev (pd->bdev_file)->bd_dev); ctrl_cmd->pkt_dev =new_encode_dev (pd->pkt_dev); }else { ctrl_cmd->dev =0 ;include/linux/pktcdvd.h +2
-2@@ -154,9 +154,9 @@ struct packet_stacked_datastruct pktcdvd_device { -struct bdev_handle *bdev_handle;/* dev attached */ +struct file *bdev_file;/* dev attached */ /* handle acquired for bdev during pkt_open_dev() */ -struct bdev_handle *open_bdev_handle; +struct file *f_open_bdev;dev_t pkt_dev;/* our dev */ struct packet_settings settings;struct packet_stats stats;Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 10/34 rnbd: port block device access to file
In reply to Christian Brauner--- drivers/block/rnbd/rnbd-srv.c | 28 ++++++++++++++-------------- drivers/block/rnbd/rnbd-srv.h | 2 +- 2 files changed, 15 insertions(+), 15 deletions(-)
drivers/block/rnbd/rnbd-srv.c +14 -14
@@ -145,7 +145,7 @@ static int process_rdma(struct rnbd_srv_session *srv_sess, priv->sess_dev = sess_dev; priv->id = id; - bio =bio_alloc (sess_dev->bdev_handle->bdev,1 , + bio =bio_alloc (file_bdev (sess_dev->bdev_file),1 ,rnbd_to_bio_flags (le32_to_cpu (msg->rw)),GFP_KERNEL );if (bio_add_page (bio,virt_to_page (data), datalen,offset_in_page (data)) != datalen) {
@@ -219,7 +219,7 @@ void rnbd_destroy_sess_dev(struct rnbd_srv_sess_dev *sess_dev, bool keep_id)rnbd_put_sess_dev (sess_dev);wait_for_completion (&dc);/* wait for inflights to drop to zero */ -bdev_release (sess_dev->bdev_handle); +fput (sess_dev->bdev_file);mutex_lock (&sess_dev->dev->lock);list_del (&sess_dev->dev_list);if (!sess_dev->readonly)
@@ -534,7 +534,7 @@ rnbd_srv_get_or_create_srv_dev(struct block_device *bdev,static void rnbd_srv_fill_msg_open_rsp (struct rnbd_msg_open_rsp *rsp,struct rnbd_srv_sess_dev *sess_dev) { -struct block_device *bdev = sess_dev->bdev_handle->bdev; +struct block_device *bdev =file_bdev (sess_dev->bdev_file); rsp->hdr.type =cpu_to_le16 (RNBD_MSG_OPEN_RSP ); rsp->device_id =cpu_to_le32 (sess_dev->device_id);
@@ -560,7 +560,7 @@ static void rnbd_srv_fill_msg_open_rsp(struct rnbd_msg_open_rsp *rsp,static struct rnbd_srv_sess_dev *rnbd_srv_create_set_sess_dev (struct rnbd_srv_session *srv_sess,const struct rnbd_msg_open *open_msg, -struct bdev_handle *handle,bool readonly, +struct file *bdev_file,bool readonly,struct rnbd_srv_dev *srv_dev) {struct rnbd_srv_sess_dev *sdev =rnbd_sess_dev_alloc (srv_sess);
@@ -572,7 +572,7 @@ rnbd_srv_create_set_sess_dev(struct rnbd_srv_session *srv_sess,strscpy (sdev->pathname, open_msg->dev_name,sizeof (sdev->pathname)); - sdev->bdev_handle = handle; + sdev->bdev_file = bdev_file; sdev->sess = srv_sess; sdev->dev = srv_dev; sdev->readonly = readonly;
@@ -678,7 +678,7 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess,struct rnbd_srv_dev *srv_dev;struct rnbd_srv_sess_dev *srv_sess_dev;const struct rnbd_msg_open *open_msg = msg; -struct bdev_handle *bdev_handle; +struct file *bdev_file;blk_mode_t open_flags =BLK_OPEN_READ ;char *full_path;struct rnbd_msg_open_rsp *rsp = data;
@@ -716,15 +716,15 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess, goto reject; } - bdev_handle =bdev_open_by_path (full_path, open_flags,NULL ,NULL ); -if (IS_ERR (bdev_handle)) { - ret =PTR_ERR (bdev_handle); + bdev_file =bdev_file_open_by_path (full_path, open_flags,NULL ,NULL ); +if (IS_ERR (bdev_file)) { + ret =PTR_ERR (bdev_file);pr_err ("Opening device '%s' on session %s failed, failed to open the block device, err: %pe\n" , - full_path, srv_sess->sessname, bdev_handle); + full_path, srv_sess->sessname, bdev_file); goto free_path; } - srv_dev =rnbd_srv_get_or_create_srv_dev (bdev_handle->bdev, srv_sess, + srv_dev =rnbd_srv_get_or_create_srv_dev (file_bdev (bdev_file), srv_sess, open_msg->access_mode);if (IS_ERR (srv_dev)) { pr_err("Opening device '%s' on session %s failed, creating srv_dev failed, err: %pe\n",
@@ -734,7 +734,7 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess, } srv_sess_dev =rnbd_srv_create_set_sess_dev (srv_sess, open_msg, - bdev_handle, + bdev_file, open_msg->access_mode ==RNBD_ACCESS_RO , srv_dev);if (IS_ERR (srv_sess_dev)) {
@@ -750,7 +750,7 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess,*/ mutex_lock (&srv_dev->lock);if (!srv_dev->dev_kobj.state_in_sysfs) { - ret =rnbd_srv_create_dev_sysfs (srv_dev, bdev_handle->bdev); + ret =rnbd_srv_create_dev_sysfs (srv_dev,file_bdev (bdev_file));if (ret) {mutex_unlock (&srv_dev->lock); rnbd_srv_err(srv_sess_dev,
@@ -793,7 +793,7 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess, }rnbd_put_srv_dev (srv_dev); blkdev_put: -bdev_release (bdev_handle); +fput (bdev_file); free_path:kfree (full_path); reject:
drivers/block/rnbd/rnbd-srv.h +1 -1
@@ -46,7 +46,7 @@ struct rnbd_srv_dev {struct rnbd_srv_sess_dev {/* Entry inside rnbd_srv_dev struct */ struct list_head dev_list; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct rnbd_srv_session *sess;struct rnbd_srv_dev *dev;struct kobject kobj;
Signature · 1 line
2.43.0
Re: [PATCH v2 10/34] rnbd: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 128 lines
--- drivers/block/rnbd/rnbd-srv.c | 28 ++++++++++++++-------------- drivers/block/rnbd/rnbd-srv.h | 2 +- 2 files changed, 15 insertions(+), 15 deletions(-)drivers/block/rnbd/rnbd-srv.c +14
-14@@ -145,7 +145,7 @@ static int process_rdma(struct rnbd_srv_session *srv_sess, priv->sess_dev = sess_dev; priv->id = id; - bio =bio_alloc (sess_dev->bdev_handle->bdev,1 , + bio =bio_alloc (file_bdev (sess_dev->bdev_file),1 ,rnbd_to_bio_flags (le32_to_cpu (msg->rw)),GFP_KERNEL );if (bio_add_page (bio,virt_to_page (data), datalen,offset_in_page (data)) != datalen) {@@ -219,7 +219,7 @@ void rnbd_destroy_sess_dev(struct rnbd_srv_sess_dev *sess_dev, bool keep_id)rnbd_put_sess_dev (sess_dev);wait_for_completion (&dc);/* wait for inflights to drop to zero */ -bdev_release (sess_dev->bdev_handle); +fput (sess_dev->bdev_file);mutex_lock (&sess_dev->dev->lock);list_del (&sess_dev->dev_list);if (!sess_dev->readonly)@@ -534,7 +534,7 @@ rnbd_srv_get_or_create_srv_dev(struct block_device *bdev,static void rnbd_srv_fill_msg_open_rsp (struct rnbd_msg_open_rsp *rsp,struct rnbd_srv_sess_dev *sess_dev) { -struct block_device *bdev = sess_dev->bdev_handle->bdev; +struct block_device *bdev =file_bdev (sess_dev->bdev_file); rsp->hdr.type =cpu_to_le16 (RNBD_MSG_OPEN_RSP ); rsp->device_id =cpu_to_le32 (sess_dev->device_id);@@ -560,7 +560,7 @@ static void rnbd_srv_fill_msg_open_rsp(struct rnbd_msg_open_rsp *rsp,static struct rnbd_srv_sess_dev *rnbd_srv_create_set_sess_dev (struct rnbd_srv_session *srv_sess,const struct rnbd_msg_open *open_msg, -struct bdev_handle *handle,bool readonly, +struct file *bdev_file,bool readonly,struct rnbd_srv_dev *srv_dev) {struct rnbd_srv_sess_dev *sdev =rnbd_sess_dev_alloc (srv_sess);@@ -572,7 +572,7 @@ rnbd_srv_create_set_sess_dev(struct rnbd_srv_session *srv_sess,strscpy (sdev->pathname, open_msg->dev_name,sizeof (sdev->pathname)); - sdev->bdev_handle = handle; + sdev->bdev_file = bdev_file; sdev->sess = srv_sess; sdev->dev = srv_dev; sdev->readonly = readonly;@@ -678,7 +678,7 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess,struct rnbd_srv_dev *srv_dev;struct rnbd_srv_sess_dev *srv_sess_dev;const struct rnbd_msg_open *open_msg = msg; -struct bdev_handle *bdev_handle; +struct file *bdev_file;blk_mode_t open_flags =BLK_OPEN_READ ;char *full_path;struct rnbd_msg_open_rsp *rsp = data;@@ -716,15 +716,15 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess, goto reject; } - bdev_handle =bdev_open_by_path (full_path, open_flags,NULL ,NULL ); -if (IS_ERR (bdev_handle)) { - ret =PTR_ERR (bdev_handle); + bdev_file =bdev_file_open_by_path (full_path, open_flags,NULL ,NULL ); +if (IS_ERR (bdev_file)) { + ret =PTR_ERR (bdev_file);pr_err ("Opening device '%s' on session %s failed, failed to open the block device, err: %pe\n" , - full_path, srv_sess->sessname, bdev_handle); + full_path, srv_sess->sessname, bdev_file); goto free_path; } - srv_dev =rnbd_srv_get_or_create_srv_dev (bdev_handle->bdev, srv_sess, + srv_dev =rnbd_srv_get_or_create_srv_dev (file_bdev (bdev_file), srv_sess, open_msg->access_mode);if (IS_ERR (srv_dev)) { pr_err("Opening device '%s' on session %s failed, creating srv_dev failed, err: %pe\n",@@ -734,7 +734,7 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess, } srv_sess_dev =rnbd_srv_create_set_sess_dev (srv_sess, open_msg, - bdev_handle, + bdev_file, open_msg->access_mode ==RNBD_ACCESS_RO , srv_dev);if (IS_ERR (srv_sess_dev)) {@@ -750,7 +750,7 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess,*/ mutex_lock (&srv_dev->lock);if (!srv_dev->dev_kobj.state_in_sysfs) { - ret =rnbd_srv_create_dev_sysfs (srv_dev, bdev_handle->bdev); + ret =rnbd_srv_create_dev_sysfs (srv_dev,file_bdev (bdev_file));if (ret) {mutex_unlock (&srv_dev->lock); rnbd_srv_err(srv_sess_dev,@@ -793,7 +793,7 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess, }rnbd_put_srv_dev (srv_dev); blkdev_put: -bdev_release (bdev_handle); +fput (bdev_file); free_path:kfree (full_path); reject:drivers/block/rnbd/rnbd-srv.h +1
-1@@ -46,7 +46,7 @@ struct rnbd_srv_dev {struct rnbd_srv_sess_dev {/* Entry inside rnbd_srv_dev struct */ struct list_head dev_list; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct rnbd_srv_session *sess;struct rnbd_srv_dev *dev;struct kobject kobj;Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 11/34 xen: port block device access to file
In reply to Christian Brauner--- drivers/block/xen-blkback/blkback.c | 4 ++-- drivers/block/xen-blkback/common.h | 4 ++-- drivers/block/xen-blkback/xenbus.c | 37 ++++++++++++++++++------------------- 3 files changed, 22 insertions(+), 23 deletions(-)
drivers/block/xen-blkback/blkback.c +2 -2
@@ -465,7 +465,7 @@ static int xen_vbd_translate(struct phys_req *req, struct xen_blkif *blkif, } req->dev = vbd->pdevice; - req->bdev = vbd->bdev_handle->bdev; + req->bdev =file_bdev (vbd->bdev_file); rc =0 ; out:
@@ -969,7 +969,7 @@ static int dispatch_discard_io(struct xen_blkif_ring *ring,int err =0 ;int status =BLKIF_RSP_OKAY ;struct xen_blkif *blkif = ring->blkif; -struct block_device *bdev = blkif->vbd.bdev_handle->bdev; +struct block_device *bdev =file_bdev (blkif->vbd.bdev_file);struct phys_req preq;xen_blkif_get (blkif);
drivers/block/xen-blkback/common.h +2 -2
@@ -221,7 +221,7 @@ struct xen_vbd {unsigned char type;/* phys device that this vbd maps to. */ u32 pdevice; -struct bdev_handle *bdev_handle; +struct file *bdev_file;/* Cached size parameter. */ sector_t size; unsigned int flush_support:1;
@@ -360,7 +360,7 @@ struct pending_req { }; -#define vbd_sz (_v) bdev_nr_sectors((_v)->bdev_handle->bdev) +#define vbd_sz (_v) bdev_nr_sectors(file_bdev((_v)->bdev_file))#define xen_blkif_get (_b) (atomic_inc(&(_b)->refcnt))#define xen_blkif_put (_b) \
drivers/block/xen-blkback/xenbus.c +18 -19
@@ -81,7 +81,7 @@ static void xen_update_blkif_status(struct xen_blkif *blkif)int i;/* Not ready to connect? */ -if (!blkif->rings || !blkif->rings[0 ].irq || !blkif->vbd.bdev_handle) +if (!blkif->rings || !blkif->rings[0 ].irq || !blkif->vbd.bdev_file)return ;/* Already connected? */
@@ -99,13 +99,12 @@ static void xen_update_blkif_status(struct xen_blkif *blkif)return ; } - err =sync_blockdev (blkif->vbd.bdev_handle->bdev); + err =sync_blockdev (file_bdev (blkif->vbd.bdev_file));if (err) {xenbus_dev_error (blkif->be->dev, err,"block flush" );return ; } -invalidate_inode_pages2 ( - blkif->vbd.bdev_handle->bdev->bd_inode->i_mapping); +invalidate_inode_pages2 (blkif->vbd.bdev_file->f_mapping);for (i =0 ; i < blkif->nr_rings; i++) { ring = &blkif->rings[i];
@@ -473,9 +472,9 @@ static void xenvbd_sysfs_delif(struct xenbus_device *dev)static void xen_vbd_free (struct xen_vbd *vbd) { -if (vbd->bdev_handle) -bdev_release (vbd->bdev_handle); - vbd->bdev_handle =NULL ; +if (vbd->bdev_file) +fput (vbd->bdev_file); + vbd->bdev_file =NULL ; } static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle,
@@ -483,7 +482,7 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, int cdrom) {struct xen_vbd *vbd; -struct bdev_handle *bdev_handle; +struct file *bdev_file; vbd = &blkif->vbd; vbd->handle = handle;
@@ -492,17 +491,17 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, vbd->pdevice =MKDEV (major, minor); - bdev_handle =bdev_open_by_dev (vbd->pdevice, vbd->readonly ? + bdev_file =bdev_file_open_by_dev (vbd->pdevice, vbd->readonly ?BLK_OPEN_READ :BLK_OPEN_WRITE ,NULL ,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {pr_warn ("xen_vbd_create: device %08x could not be opened\n" , vbd->pdevice);return -ENOENT ; } - vbd->bdev_handle = bdev_handle; -if (vbd->bdev_handle->bdev->bd_disk ==NULL ) { + vbd->bdev_file = bdev_file; +if (file_bdev (vbd->bdev_file)->bd_disk ==NULL ) {pr_warn ("xen_vbd_create: device %08x doesn't exist\n" , vbd->pdevice);xen_vbd_free (vbd);
@@ -510,14 +509,14 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, } vbd->size =vbd_sz (vbd); -if (cdrom ||disk_to_cdi (vbd->bdev_handle->bdev->bd_disk)) +if (cdrom ||disk_to_cdi (file_bdev (vbd->bdev_file)->bd_disk)) vbd->type |=VDISK_CDROM ; -if (vbd->bdev_handle->bdev->bd_disk->flags &GENHD_FL_REMOVABLE ) +if (file_bdev (vbd->bdev_file)->bd_disk->flags &GENHD_FL_REMOVABLE ) vbd->type |=VDISK_REMOVABLE ; -if (bdev_write_cache (bdev_handle->bdev)) +if (bdev_write_cache (file_bdev (bdev_file))) vbd->flush_support = true; -if (bdev_max_secure_erase_sectors (bdev_handle->bdev)) +if (bdev_max_secure_erase_sectors (file_bdev (bdev_file))) vbd->discard_secure = true; pr_debug("Successful creation of handle=%04x (dom=%u)\n",
@@ -570,7 +569,7 @@ static void xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_infostruct xen_blkif *blkif = be->blkif;int err;int state =0 ; -struct block_device *bdev = be->blkif->vbd.bdev_handle->bdev; +struct block_device *bdev =file_bdev (be->blkif->vbd.bdev_file);if (!xenbus_read_unsigned (dev->nodename,"discard-enable" ,1 ))return ;
@@ -932,7 +931,7 @@ static void connect(struct backend_info *be) } err =xenbus_printf (xbt, dev->nodename,"sector-size" ,"%lu" , (unsigned long )bdev_logical_block_size ( - be->blkif->vbd.bdev_handle->bdev)); +file_bdev (be->blkif->vbd.bdev_file)));if (err) {xenbus_dev_fatal (dev, err,"writing %s/sector-size" , dev->nodename);
@@ -940,7 +939,7 @@ static void connect(struct backend_info *be) } err =xenbus_printf (xbt, dev->nodename,"physical-sector-size" ,"%u" ,bdev_physical_block_size ( - be->blkif->vbd.bdev_handle->bdev)); +file_bdev (be->blkif->vbd.bdev_file)));if (err)xenbus_dev_error (dev, err,"writing %s/physical-sector-size" , dev->nodename);
Signature · 1 line
2.43.0
Re: [PATCH v2 11/34] xen: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 173 lines
--- drivers/block/xen-blkback/blkback.c | 4 ++-- drivers/block/xen-blkback/common.h | 4 ++-- drivers/block/xen-blkback/xenbus.c | 37 ++++++++++++++++++------------------- 3 files changed, 22 insertions(+), 23 deletions(-)drivers/block/xen-blkback/blkback.c +2
-2@@ -465,7 +465,7 @@ static int xen_vbd_translate(struct phys_req *req, struct xen_blkif *blkif, } req->dev = vbd->pdevice; - req->bdev = vbd->bdev_handle->bdev; + req->bdev =file_bdev (vbd->bdev_file); rc =0 ; out:@@ -969,7 +969,7 @@ static int dispatch_discard_io(struct xen_blkif_ring *ring,int err =0 ;int status =BLKIF_RSP_OKAY ;struct xen_blkif *blkif = ring->blkif; -struct block_device *bdev = blkif->vbd.bdev_handle->bdev; +struct block_device *bdev =file_bdev (blkif->vbd.bdev_file);struct phys_req preq;xen_blkif_get (blkif);drivers/block/xen-blkback/common.h +2
-2@@ -221,7 +221,7 @@ struct xen_vbd {unsigned char type;/* phys device that this vbd maps to. */ u32 pdevice; -struct bdev_handle *bdev_handle; +struct file *bdev_file;/* Cached size parameter. */ sector_t size; unsigned int flush_support:1;@@ -360,7 +360,7 @@ struct pending_req { }; -#define vbd_sz (_v) bdev_nr_sectors((_v)->bdev_handle->bdev) +#define vbd_sz (_v) bdev_nr_sectors(file_bdev((_v)->bdev_file))#define xen_blkif_get (_b) (atomic_inc(&(_b)->refcnt))#define xen_blkif_put (_b) \drivers/block/xen-blkback/xenbus.c +18
-19@@ -81,7 +81,7 @@ static void xen_update_blkif_status(struct xen_blkif *blkif)int i;/* Not ready to connect? */ -if (!blkif->rings || !blkif->rings[0 ].irq || !blkif->vbd.bdev_handle) +if (!blkif->rings || !blkif->rings[0 ].irq || !blkif->vbd.bdev_file)return ;/* Already connected? */ @@ -99,13 +99,12 @@ static void xen_update_blkif_status(struct xen_blkif *blkif)return ; } - err =sync_blockdev (blkif->vbd.bdev_handle->bdev); + err =sync_blockdev (file_bdev (blkif->vbd.bdev_file));if (err) {xenbus_dev_error (blkif->be->dev, err,"block flush" );return ; } -invalidate_inode_pages2 ( - blkif->vbd.bdev_handle->bdev->bd_inode->i_mapping); +invalidate_inode_pages2 (blkif->vbd.bdev_file->f_mapping);for (i =0 ; i < blkif->nr_rings; i++) { ring = &blkif->rings[i];@@ -473,9 +472,9 @@ static void xenvbd_sysfs_delif(struct xenbus_device *dev)static void xen_vbd_free (struct xen_vbd *vbd) { -if (vbd->bdev_handle) -bdev_release (vbd->bdev_handle); - vbd->bdev_handle =NULL ; +if (vbd->bdev_file) +fput (vbd->bdev_file); + vbd->bdev_file =NULL ; } static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle,@@ -483,7 +482,7 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, int cdrom) {struct xen_vbd *vbd; -struct bdev_handle *bdev_handle; +struct file *bdev_file; vbd = &blkif->vbd; vbd->handle = handle;@@ -492,17 +491,17 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, vbd->pdevice =MKDEV (major, minor); - bdev_handle =bdev_open_by_dev (vbd->pdevice, vbd->readonly ? + bdev_file =bdev_file_open_by_dev (vbd->pdevice, vbd->readonly ?BLK_OPEN_READ :BLK_OPEN_WRITE ,NULL ,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {pr_warn ("xen_vbd_create: device %08x could not be opened\n" , vbd->pdevice);return -ENOENT ; } - vbd->bdev_handle = bdev_handle; -if (vbd->bdev_handle->bdev->bd_disk ==NULL ) { + vbd->bdev_file = bdev_file; +if (file_bdev (vbd->bdev_file)->bd_disk ==NULL ) {pr_warn ("xen_vbd_create: device %08x doesn't exist\n" , vbd->pdevice);xen_vbd_free (vbd);@@ -510,14 +509,14 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, } vbd->size =vbd_sz (vbd); -if (cdrom ||disk_to_cdi (vbd->bdev_handle->bdev->bd_disk)) +if (cdrom ||disk_to_cdi (file_bdev (vbd->bdev_file)->bd_disk)) vbd->type |=VDISK_CDROM ; -if (vbd->bdev_handle->bdev->bd_disk->flags &GENHD_FL_REMOVABLE ) +if (file_bdev (vbd->bdev_file)->bd_disk->flags &GENHD_FL_REMOVABLE ) vbd->type |=VDISK_REMOVABLE ; -if (bdev_write_cache (bdev_handle->bdev)) +if (bdev_write_cache (file_bdev (bdev_file))) vbd->flush_support = true; -if (bdev_max_secure_erase_sectors (bdev_handle->bdev)) +if (bdev_max_secure_erase_sectors (file_bdev (bdev_file))) vbd->discard_secure = true; pr_debug("Successful creation of handle=%04x (dom=%u)\n",@@ -570,7 +569,7 @@ static void xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_infostruct xen_blkif *blkif = be->blkif;int err;int state =0 ; -struct block_device *bdev = be->blkif->vbd.bdev_handle->bdev; +struct block_device *bdev =file_bdev (be->blkif->vbd.bdev_file);if (!xenbus_read_unsigned (dev->nodename,"discard-enable" ,1 ))return ;@@ -932,7 +931,7 @@ static void connect(struct backend_info *be) } err =xenbus_printf (xbt, dev->nodename,"sector-size" ,"%lu" , (unsigned long )bdev_logical_block_size ( - be->blkif->vbd.bdev_handle->bdev)); +file_bdev (be->blkif->vbd.bdev_file)));if (err) {xenbus_dev_fatal (dev, err,"writing %s/sector-size" , dev->nodename);@@ -940,7 +939,7 @@ static void connect(struct backend_info *be) } err =xenbus_printf (xbt, dev->nodename,"physical-sector-size" ,"%u" ,bdev_physical_block_size ( - be->blkif->vbd.bdev_handle->bdev)); +file_bdev (be->blkif->vbd.bdev_file)));if (err)xenbus_dev_error (dev, err,"writing %s/physical-sector-size" , dev->nodename);Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 12/34 zram: port block device access to file
In reply to Christian Brauner--- drivers/block/zram/zram_drv.c | 26 +++++++++++++------------- drivers/block/zram/zram_drv.h | 2 +- 2 files changed, 14 insertions(+), 14 deletions(-)
drivers/block/zram/zram_drv.c +13 -13
@@ -426,11 +426,11 @@ static void reset_bdev(struct zram *zram)if (!zram->backing_dev)return ; -bdev_release (zram->bdev_handle); +fput (zram->bdev_file);/* hope filp_close flush all of IO */ filp_close (zram->backing_dev,NULL ); zram->backing_dev =NULL ; - zram->bdev_handle =NULL ; + zram->bdev_file =NULL ; zram->disk->fops = &zram_devops;kvfree (zram->bitmap); zram->bitmap =NULL ;
@@ -476,7 +476,7 @@ static ssize_t backing_dev_store(struct device *dev,struct address_space *mapping;unsigned int bitmap_sz;unsigned long nr_pages, *bitmap =NULL ; -struct bdev_handle *bdev_handle =NULL ; +struct file *bdev_file =NULL ;int err;struct zram *zram =dev_to_zram (dev);
@@ -513,11 +513,11 @@ static ssize_t backing_dev_store(struct device *dev, goto out; } - bdev_handle =bdev_open_by_dev (inode->i_rdev, + bdev_file =bdev_file_open_by_dev (inode->i_rdev,BLK_OPEN_READ |BLK_OPEN_WRITE , zram,NULL ); -if (IS_ERR (bdev_handle)) { - err =PTR_ERR (bdev_handle); - bdev_handle =NULL ; +if (IS_ERR (bdev_file)) { + err =PTR_ERR (bdev_file); + bdev_file =NULL ; goto out; }
@@ -531,7 +531,7 @@ static ssize_t backing_dev_store(struct device *dev,reset_bdev (zram); - zram->bdev_handle = bdev_handle; + zram->bdev_file = bdev_file; zram->backing_dev = backing_dev; zram->bitmap = bitmap; zram->nr_pages = nr_pages;
@@ -544,8 +544,8 @@ static ssize_t backing_dev_store(struct device *dev, out:kvfree (bitmap); -if (bdev_handle) -bdev_release (bdev_handle); +if (bdev_file) +fput (bdev_file);if (backing_dev)filp_close (backing_dev,NULL );
@@ -587,7 +587,7 @@ static void read_from_bdev_async(struct zram *zram, struct page *page, {struct bio *bio; - bio =bio_alloc (zram->bdev_handle->bdev,1 , parent->bi_opf,GFP_NOIO ); + bio =bio_alloc (file_bdev (zram->bdev_file),1 , parent->bi_opf,GFP_NOIO ); bio->bi_iter.bi_sector = entry * (PAGE_SIZE >>9 );__bio_add_page (bio, page,PAGE_SIZE ,0 );bio_chain (bio, parent);
@@ -703,7 +703,7 @@ static ssize_t writeback_store(struct device *dev,continue ; } -bio_init (&bio, zram->bdev_handle->bdev, &bio_vec,1 , +bio_init (&bio,file_bdev (zram->bdev_file), &bio_vec,1 ,REQ_OP_WRITE |REQ_SYNC ); bio.bi_iter.bi_sector = blk_idx * (PAGE_SIZE >>9 );__bio_add_page (&bio, page,PAGE_SIZE ,0 );
@@ -785,7 +785,7 @@ static void zram_sync_read(struct work_struct *work)struct bio_vec bv;struct bio bio; -bio_init (&bio, zw->zram->bdev_handle->bdev, &bv,1 ,REQ_OP_READ ); +bio_init (&bio,file_bdev (zw->zram->bdev_file), &bv,1 ,REQ_OP_READ ); bio.bi_iter.bi_sector = zw->entry * (PAGE_SIZE >>9 );__bio_add_page (&bio, zw->page,PAGE_SIZE ,0 ); zw->error =submit_bio_wait (&bio);
drivers/block/zram/zram_drv.h +1 -1
@@ -132,7 +132,7 @@ struct zram {spinlock_t wb_limit_lock;bool wb_limit_enable;u64 bd_wb_limit; -struct bdev_handle *bdev_handle; +struct file *bdev_file;unsigned long *bitmap;unsigned long nr_pages;#endif
Signature · 1 line
2.43.0
Re: [PATCH v2 12/34] zram: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 112 lines
--- drivers/block/zram/zram_drv.c | 26 +++++++++++++------------- drivers/block/zram/zram_drv.h | 2 +- 2 files changed, 14 insertions(+), 14 deletions(-)drivers/block/zram/zram_drv.c +13
-13@@ -426,11 +426,11 @@ static void reset_bdev(struct zram *zram)if (!zram->backing_dev)return ; -bdev_release (zram->bdev_handle); +fput (zram->bdev_file);/* hope filp_close flush all of IO */ filp_close (zram->backing_dev,NULL ); zram->backing_dev =NULL ; - zram->bdev_handle =NULL ; + zram->bdev_file =NULL ; zram->disk->fops = &zram_devops;kvfree (zram->bitmap); zram->bitmap =NULL ;@@ -476,7 +476,7 @@ static ssize_t backing_dev_store(struct device *dev,struct address_space *mapping;unsigned int bitmap_sz;unsigned long nr_pages, *bitmap =NULL ; -struct bdev_handle *bdev_handle =NULL ; +struct file *bdev_file =NULL ;int err;struct zram *zram =dev_to_zram (dev);@@ -513,11 +513,11 @@ static ssize_t backing_dev_store(struct device *dev, goto out; } - bdev_handle =bdev_open_by_dev (inode->i_rdev, + bdev_file =bdev_file_open_by_dev (inode->i_rdev,BLK_OPEN_READ |BLK_OPEN_WRITE , zram,NULL ); -if (IS_ERR (bdev_handle)) { - err =PTR_ERR (bdev_handle); - bdev_handle =NULL ; +if (IS_ERR (bdev_file)) { + err =PTR_ERR (bdev_file); + bdev_file =NULL ; goto out; }@@ -531,7 +531,7 @@ static ssize_t backing_dev_store(struct device *dev,reset_bdev (zram); - zram->bdev_handle = bdev_handle; + zram->bdev_file = bdev_file; zram->backing_dev = backing_dev; zram->bitmap = bitmap; zram->nr_pages = nr_pages;@@ -544,8 +544,8 @@ static ssize_t backing_dev_store(struct device *dev, out:kvfree (bitmap); -if (bdev_handle) -bdev_release (bdev_handle); +if (bdev_file) +fput (bdev_file);if (backing_dev)filp_close (backing_dev,NULL );@@ -587,7 +587,7 @@ static void read_from_bdev_async(struct zram *zram, struct page *page, {struct bio *bio; - bio =bio_alloc (zram->bdev_handle->bdev,1 , parent->bi_opf,GFP_NOIO ); + bio =bio_alloc (file_bdev (zram->bdev_file),1 , parent->bi_opf,GFP_NOIO ); bio->bi_iter.bi_sector = entry * (PAGE_SIZE >>9 );__bio_add_page (bio, page,PAGE_SIZE ,0 );bio_chain (bio, parent);@@ -703,7 +703,7 @@ static ssize_t writeback_store(struct device *dev,continue ; } -bio_init (&bio, zram->bdev_handle->bdev, &bio_vec,1 , +bio_init (&bio,file_bdev (zram->bdev_file), &bio_vec,1 ,REQ_OP_WRITE |REQ_SYNC ); bio.bi_iter.bi_sector = blk_idx * (PAGE_SIZE >>9 );__bio_add_page (&bio, page,PAGE_SIZE ,0 );@@ -785,7 +785,7 @@ static void zram_sync_read(struct work_struct *work)struct bio_vec bv;struct bio bio; -bio_init (&bio, zw->zram->bdev_handle->bdev, &bv,1 ,REQ_OP_READ ); +bio_init (&bio,file_bdev (zw->zram->bdev_file), &bv,1 ,REQ_OP_READ ); bio.bi_iter.bi_sector = zw->entry * (PAGE_SIZE >>9 );__bio_add_page (&bio, zw->page,PAGE_SIZE ,0 ); zw->error =submit_bio_wait (&bio);drivers/block/zram/zram_drv.h +1
-1@@ -132,7 +132,7 @@ struct zram {spinlock_t wb_limit_lock;bool wb_limit_enable;u64 bd_wb_limit; -struct bdev_handle *bdev_handle; +struct file *bdev_file;unsigned long *bitmap;unsigned long nr_pages;#endif Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 13/34 bcache: port block device access to files
In reply to Christian Brauner--- drivers/md/bcache/bcache.h | 4 +-- drivers/md/bcache/super.c | 74 +++++++++++++++++++++++----------------------- 2 files changed, 39 insertions(+), 39 deletions(-)
drivers/md/bcache/bcache.h +2 -2
@@ -300,7 +300,7 @@ struct cached_dev {struct list_head list;struct bcache_device disk;struct block_device *bdev; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct cache_sb sb;struct cache_sb_disk *sb_disk;
@@ -423,7 +423,7 @@ struct cache {struct kobject kobj;struct block_device *bdev; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct task_struct *alloc_thread;
drivers/md/bcache/super.c +37 -37
198 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH v2 13/34] bcache: port block device access to files
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 249 lines
--- drivers/md/bcache/bcache.h | 4 +-- drivers/md/bcache/super.c | 74 +++++++++++++++++++++++----------------------- 2 files changed, 39 insertions(+), 39 deletions(-)drivers/md/bcache/bcache.h +2
-2@@ -300,7 +300,7 @@ struct cached_dev {struct list_head list;struct bcache_device disk;struct block_device *bdev; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct cache_sb sb;struct cache_sb_disk *sb_disk;@@ -423,7 +423,7 @@ struct cache {struct kobject kobj;struct block_device *bdev; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct task_struct *alloc_thread;drivers/md/bcache/super.c +37
-37@@ -1369,8 +1369,8 @@ static CLOSURE_CALLBACK(cached_dev_free)if (dc->sb_disk)put_page (virt_to_page (dc->sb_disk)); -if (dc->bdev_handle) -bdev_release (dc->bdev_handle); +if (dc->bdev_file) +fput (dc->bdev_file);wake_up (&unregister_wait);@@ -1445,7 +1445,7 @@ static int cached_dev_init(struct cached_dev *dc, unsigned int block_size)/* Cached device - bcache superblock */ static int register_bdev (struct cache_sb *sb,struct cache_sb_disk *sb_disk, -struct bdev_handle *bdev_handle, +struct file *bdev_file,struct cached_dev *dc) {const char *err ="cannot allocate memory" ;@@ -1453,8 +1453,8 @@ static int register_bdev(struct cache_sb *sb, struct cache_sb_disk *sb_disk,int ret = -ENOMEM ;memcpy (&dc->sb, sb,sizeof (struct cache_sb )); - dc->bdev_handle = bdev_handle; - dc->bdev = bdev_handle->bdev; + dc->bdev_file = bdev_file; + dc->bdev =file_bdev (bdev_file); dc->sb_disk = sb_disk;if (cached_dev_init (dc, sb->block_size <<9 ))@@ -2218,8 +2218,8 @@ void bch_cache_release(struct kobject *kobj)if (ca->sb_disk)put_page (virt_to_page (ca->sb_disk)); -if (ca->bdev_handle) -bdev_release (ca->bdev_handle); +if (ca->bdev_file) +fput (ca->bdev_file);kfree (ca);module_put (THIS_MODULE );@@ -2339,18 +2339,18 @@ static int cache_alloc(struct cache *ca) }static int register_cache (struct cache_sb *sb,struct cache_sb_disk *sb_disk, -struct bdev_handle *bdev_handle, +struct file *bdev_file,struct cache *ca) {const char *err =NULL ;/* must be set for any error case */ int ret =0 ;memcpy (&ca->sb, sb,sizeof (struct cache_sb )); - ca->bdev_handle = bdev_handle; - ca->bdev = bdev_handle->bdev; + ca->bdev_file = bdev_file; + ca->bdev =file_bdev (bdev_file); ca->sb_disk = sb_disk; -if (bdev_max_discard_sectors ((bdev_handle->bdev))) +if (bdev_max_discard_sectors (file_bdev (bdev_file))) ca->discard =CACHE_DISCARD (&ca->sb); ret =cache_alloc (ca);@@ -2361,20 +2361,20 @@ static int register_cache(struct cache_sb *sb, struct cache_sb_disk *sb_disk, err ="cache_alloc(): cache device is too small" ; else err ="cache_alloc(): unknown error" ; -pr_notice ("error %pg: %s\n" , bdev_handle->bdev, err); +pr_notice ("error %pg: %s\n" ,file_bdev (bdev_file), err);/* * If we failed here, it means ca->kobj is not initialized yet, * kobject_put() won't be called and there is no chance to -* call bdev_release() to bdev in bch_cache_release(). So -* we explicitly call bdev_release() here. +* call fput() to bdev in bch_cache_release(). So +* we explicitly call fput() on the block device here. */ -bdev_release (bdev_handle); +fput (bdev_file);return ret; } -if (kobject_add (&ca->kobj,bdev_kobj (bdev_handle->bdev),"bcache" )) { +if (kobject_add (&ca->kobj,bdev_kobj (file_bdev (bdev_file)),"bcache" )) {pr_notice ("error %pg: error calling kobject_add\n" , - bdev_handle->bdev); +file_bdev (bdev_file)); ret = -ENOMEM ; goto out; }@@ -2388,7 +2388,7 @@ static int register_cache(struct cache_sb *sb, struct cache_sb_disk *sb_disk, goto out; } -pr_info ("registered cache device %pg\n" , ca->bdev_handle->bdev); +pr_info ("registered cache device %pg\n" ,file_bdev (ca->bdev_file)); out:kobject_put (&ca->kobj);@@ -2446,7 +2446,7 @@ struct async_reg_args {char *path;struct cache_sb *sb;struct cache_sb_disk *sb_disk; -struct bdev_handle *bdev_handle; +struct file *bdev_file;void *holder; };@@ -2457,7 +2457,7 @@ static void register_bdev_worker(struct work_struct *work) container_of(work, struct async_reg_args, reg_work.work);mutex_lock (&bch_register_lock); -if (register_bdev (args->sb, args->sb_disk, args->bdev_handle, +if (register_bdev (args->sb, args->sb_disk, args->bdev_file, args->holder) <0 ) fail = true;mutex_unlock (&bch_register_lock);@@ -2478,7 +2478,7 @@ static void register_cache_worker(struct work_struct *work) container_of(work, struct async_reg_args, reg_work.work);/* blkdev_put() will be called in bch_cache_release() */ -if (register_cache (args->sb, args->sb_disk, args->bdev_handle, +if (register_cache (args->sb, args->sb_disk, args->bdev_file, args->holder)) fail = true;@@ -2516,7 +2516,7 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,char *path =NULL ;struct cache_sb *sb;struct cache_sb_disk *sb_disk; -struct bdev_handle *bdev_handle, *bdev_handle2; +struct file *bdev_file, *bdev_file2;void *holder =NULL ;ssize_t ret;bool async_registration = false;@@ -2549,15 +2549,15 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr, ret = -EINVAL ; err ="failed to open device" ; - bdev_handle =bdev_open_by_path (strim (path),BLK_OPEN_READ ,NULL ,NULL ); -if (IS_ERR (bdev_handle)) + bdev_file =bdev_file_open_by_path (strim (path),BLK_OPEN_READ ,NULL ,NULL ); +if (IS_ERR (bdev_file)) goto out_free_sb; err ="failed to set blocksize" ; -if (set_blocksize (bdev_handle->bdev,4096 )) +if (set_blocksize (file_bdev (bdev_file),4096 )) goto out_blkdev_put; - err =read_super (sb, bdev_handle->bdev, &sb_disk); + err =read_super (sb,file_bdev (bdev_file), &sb_disk);if (err) goto out_blkdev_put;@@ -2569,13 +2569,13 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr, }/* Now reopen in exclusive mode with proper holder */ - bdev_handle2 =bdev_open_by_dev (bdev_handle->bdev->bd_dev, + bdev_file2 =bdev_file_open_by_dev (file_bdev (bdev_file)->bd_dev,BLK_OPEN_READ |BLK_OPEN_WRITE , holder,NULL ); -bdev_release (bdev_handle); - bdev_handle = bdev_handle2; -if (IS_ERR (bdev_handle)) { - ret =PTR_ERR (bdev_handle); - bdev_handle =NULL ; +fput (bdev_file); + bdev_file = bdev_file2; +if (IS_ERR (bdev_file)) { + ret =PTR_ERR (bdev_file); + bdev_file =NULL ;if (ret == -EBUSY ) {dev_t dev;@@ -2610,7 +2610,7 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr, args->path = path; args->sb = sb; args->sb_disk = sb_disk; - args->bdev_handle = bdev_handle; + args->bdev_file = bdev_file; args->holder = holder;register_device_async (args);/* No wait and returns to user space */ @@ -2619,14 +2619,14 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,if (SB_IS_BDEV (sb)) {mutex_lock (&bch_register_lock); - ret =register_bdev (sb, sb_disk, bdev_handle, holder); + ret =register_bdev (sb, sb_disk, bdev_file, holder);mutex_unlock (&bch_register_lock);/* blkdev_put() will be called in cached_dev_free() */ if (ret <0 ) goto out_free_sb; }else {/* blkdev_put() will be called in bch_cache_release() */ - ret =register_cache (sb, sb_disk, bdev_handle, holder); + ret =register_cache (sb, sb_disk, bdev_file, holder);if (ret) goto out_free_sb; }@@ -2642,8 +2642,8 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr, out_put_sb_page:put_page (virt_to_page (sb_disk)); out_blkdev_put: -if (bdev_handle) -bdev_release (bdev_handle); +if (bdev_file) +fput (bdev_file); out_free_sb:kfree (sb); out_free_path:Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 14/34 block2mtd: port device access to files
In reply to Christian Brauner--- drivers/mtd/devices/block2mtd.c | 46 +++++++++++++++++++---------------------- 1 file changed, 21 insertions(+), 25 deletions(-)
drivers/mtd/devices/block2mtd.c +21 -25
@@ -37,7 +37,7 @@/* Info for the block device */ struct block2mtd_dev {struct list_head list; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct mtd_info mtd;struct mutex write_mutex; };
@@ -55,8 +55,7 @@ static struct page *page_read(struct address_space *mapping, pgoff_t index)/* erase a specified part of the device */ static int _block2mtd_erase (struct block2mtd_dev *dev,loff_t to,size_t len) { -struct address_space *mapping = - dev->bdev_handle->bdev->bd_inode->i_mapping; +struct address_space *mapping = dev->bdev_file->f_mapping;struct page *page;pgoff_t index = to >>PAGE_SHIFT ;// page index int pages = len >>PAGE_SHIFT ;
@@ -106,8 +105,7 @@ static int block2mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf) { struct block2mtd_dev *dev = mtd->priv; -struct address_space *mapping = - dev->bdev_handle->bdev->bd_inode->i_mapping; +struct address_space *mapping = dev->bdev_file->f_mapping;struct page *page;pgoff_t index = from >>PAGE_SHIFT ;int offset = from & (PAGE_SIZE -1 );
@@ -142,8 +140,7 @@ static int _block2mtd_write(struct block2mtd_dev *dev, const u_char *buf, loff_t to, size_t len, size_t *retlen) { struct page *page; -struct address_space *mapping = - dev->bdev_handle->bdev->bd_inode->i_mapping; +struct address_space *mapping = dev->bdev_file->f_mapping;pgoff_t index = to >>PAGE_SHIFT ;// page index int offset = to & ~PAGE_MASK ;// page offset int cpylen;
@@ -198,7 +195,7 @@ static int block2mtd_write(struct mtd_info *mtd, loff_t to, size_t len,static void block2mtd_sync (struct mtd_info *mtd) {struct block2mtd_dev *dev = mtd->priv; -sync_blockdev (dev->bdev_handle->bdev); +sync_blockdev (file_bdev (dev->bdev_file));return ; }
@@ -210,10 +207,9 @@ static void block2mtd_free_device(struct block2mtd_dev *dev)kfree (dev->mtd.name); -if (dev->bdev_handle) { -invalidate_mapping_pages ( - dev->bdev_handle->bdev->bd_inode->i_mapping,0 ,-1 ); -bdev_release (dev->bdev_handle); +if (dev->bdev_file) { +invalidate_mapping_pages (dev->bdev_file->f_mapping,0 ,-1 ); +fput (dev->bdev_file); }kfree (dev);
@@ -223,10 +219,10 @@ static void block2mtd_free_device(struct block2mtd_dev *dev)* This function is marked __ref because it calls the __init marked * early_lookup_bdev when called from the early boot code. */ -static struct bdev_handle __ref *mdtblock_early_get_bdev (const char *devname, +static struct file __ref *mdtblock_early_get_bdev (const char *devname,blk_mode_t mode,int timeout,struct block2mtd_dev *dev) { -struct bdev_handle *bdev_handle =ERR_PTR (-ENODEV ); +struct file *bdev_file =ERR_PTR (-ENODEV );#ifndef MODULE int i;
@@ -234,7 +230,7 @@ static struct bdev_handle __ref *mdtblock_early_get_bdev(const char *devname,* We can't use early_lookup_bdev from a running system. */ if (system_state >=SYSTEM_RUNNING ) -return bdev_handle; +return bdev_file;/* * We might not have the root device mounted at this point.
@@ -253,20 +249,20 @@ static struct bdev_handle __ref *mdtblock_early_get_bdev(const char *devname,wait_for_device_probe ();if (!early_lookup_bdev (devname, &devt)) { - bdev_handle =bdev_open_by_dev (devt, mode, dev,NULL ); -if (!IS_ERR (bdev_handle)) + bdev_file =bdev_file_open_by_dev (devt, mode, dev,NULL ); +if (!IS_ERR (bdev_file))break ; } }#endif -return bdev_handle; +return bdev_file; }static struct block2mtd_dev *add_device (char *devname,int erase_size,char *label,int timeout) {const blk_mode_t mode =BLK_OPEN_READ |BLK_OPEN_WRITE ; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;struct block2mtd_dev *dev;char *name;
@@ -279,16 +275,16 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size,return NULL ;/* Get a handle on the device */ - bdev_handle =bdev_open_by_path (devname, mode, dev,NULL ); -if (IS_ERR (bdev_handle)) - bdev_handle =mdtblock_early_get_bdev (devname, mode, timeout, + bdev_file =bdev_file_open_by_path (devname, mode, dev,NULL ); +if (IS_ERR (bdev_file)) + bdev_file =mdtblock_early_get_bdev (devname, mode, timeout, dev); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {pr_err ("error: cannot open device %s\n" , devname); goto err_free_block2mtd; } - dev->bdev_handle = bdev_handle; - bdev = bdev_handle->bdev; + dev->bdev_file = bdev_file; + bdev =file_bdev (bdev_file);if (MAJOR (bdev->bd_dev) ==MTD_BLOCK_MAJOR ) {pr_err ("attempting to use an MTD device as a block device\n" );
Signature · 1 line
2.43.0
Re: [PATCH v2 14/34] block2mtd: port device access to files
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 144 lines
--- drivers/mtd/devices/block2mtd.c | 46 +++++++++++++++++++---------------------- 1 file changed, 21 insertions(+), 25 deletions(-)drivers/mtd/devices/block2mtd.c +21
-25@@ -37,7 +37,7 @@/* Info for the block device */ struct block2mtd_dev {struct list_head list; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct mtd_info mtd;struct mutex write_mutex; };@@ -55,8 +55,7 @@ static struct page *page_read(struct address_space *mapping, pgoff_t index)/* erase a specified part of the device */ static int _block2mtd_erase (struct block2mtd_dev *dev,loff_t to,size_t len) { -struct address_space *mapping = - dev->bdev_handle->bdev->bd_inode->i_mapping; +struct address_space *mapping = dev->bdev_file->f_mapping;struct page *page;pgoff_t index = to >>PAGE_SHIFT ;// page index int pages = len >>PAGE_SHIFT ;@@ -106,8 +105,7 @@ static int block2mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf) { struct block2mtd_dev *dev = mtd->priv; -struct address_space *mapping = - dev->bdev_handle->bdev->bd_inode->i_mapping; +struct address_space *mapping = dev->bdev_file->f_mapping;struct page *page;pgoff_t index = from >>PAGE_SHIFT ;int offset = from & (PAGE_SIZE -1 );@@ -142,8 +140,7 @@ static int _block2mtd_write(struct block2mtd_dev *dev, const u_char *buf, loff_t to, size_t len, size_t *retlen) { struct page *page; -struct address_space *mapping = - dev->bdev_handle->bdev->bd_inode->i_mapping; +struct address_space *mapping = dev->bdev_file->f_mapping;pgoff_t index = to >>PAGE_SHIFT ;// page index int offset = to & ~PAGE_MASK ;// page offset int cpylen;@@ -198,7 +195,7 @@ static int block2mtd_write(struct mtd_info *mtd, loff_t to, size_t len,static void block2mtd_sync (struct mtd_info *mtd) {struct block2mtd_dev *dev = mtd->priv; -sync_blockdev (dev->bdev_handle->bdev); +sync_blockdev (file_bdev (dev->bdev_file));return ; }@@ -210,10 +207,9 @@ static void block2mtd_free_device(struct block2mtd_dev *dev)kfree (dev->mtd.name); -if (dev->bdev_handle) { -invalidate_mapping_pages ( - dev->bdev_handle->bdev->bd_inode->i_mapping,0 ,-1 ); -bdev_release (dev->bdev_handle); +if (dev->bdev_file) { +invalidate_mapping_pages (dev->bdev_file->f_mapping,0 ,-1 ); +fput (dev->bdev_file); }kfree (dev);@@ -223,10 +219,10 @@ static void block2mtd_free_device(struct block2mtd_dev *dev)* This function is marked __ref because it calls the __init marked * early_lookup_bdev when called from the early boot code. */ -static struct bdev_handle __ref *mdtblock_early_get_bdev (const char *devname, +static struct file __ref *mdtblock_early_get_bdev (const char *devname,blk_mode_t mode,int timeout,struct block2mtd_dev *dev) { -struct bdev_handle *bdev_handle =ERR_PTR (-ENODEV ); +struct file *bdev_file =ERR_PTR (-ENODEV );#ifndef MODULE int i;@@ -234,7 +230,7 @@ static struct bdev_handle __ref *mdtblock_early_get_bdev(const char *devname,* We can't use early_lookup_bdev from a running system. */ if (system_state >=SYSTEM_RUNNING ) -return bdev_handle; +return bdev_file;/* * We might not have the root device mounted at this point. @@ -253,20 +249,20 @@ static struct bdev_handle __ref *mdtblock_early_get_bdev(const char *devname,wait_for_device_probe ();if (!early_lookup_bdev (devname, &devt)) { - bdev_handle =bdev_open_by_dev (devt, mode, dev,NULL ); -if (!IS_ERR (bdev_handle)) + bdev_file =bdev_file_open_by_dev (devt, mode, dev,NULL ); +if (!IS_ERR (bdev_file))break ; } }#endif -return bdev_handle; +return bdev_file; }static struct block2mtd_dev *add_device (char *devname,int erase_size,char *label,int timeout) {const blk_mode_t mode =BLK_OPEN_READ |BLK_OPEN_WRITE ; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;struct block2mtd_dev *dev;char *name;@@ -279,16 +275,16 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size,return NULL ;/* Get a handle on the device */ - bdev_handle =bdev_open_by_path (devname, mode, dev,NULL ); -if (IS_ERR (bdev_handle)) - bdev_handle =mdtblock_early_get_bdev (devname, mode, timeout, + bdev_file =bdev_file_open_by_path (devname, mode, dev,NULL ); +if (IS_ERR (bdev_file)) + bdev_file =mdtblock_early_get_bdev (devname, mode, timeout, dev); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {pr_err ("error: cannot open device %s\n" , devname); goto err_free_block2mtd; } - dev->bdev_handle = bdev_handle; - bdev = bdev_handle->bdev; + dev->bdev_file = bdev_file; + bdev =file_bdev (bdev_file);if (MAJOR (bdev->bd_dev) ==MTD_BLOCK_MAJOR ) {pr_err ("attempting to use an MTD device as a block device\n" );Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 15/34 nvme: port block device access to file
In reply to Christian Brauner--- drivers/nvme/target/io-cmd-bdev.c | 16 ++++++++-------- drivers/nvme/target/nvmet.h | 2 +- 2 files changed, 9 insertions(+), 9 deletions(-)
drivers/nvme/target/io-cmd-bdev.c +8 -8
@@ -50,10 +50,10 @@ void nvmet_bdev_set_limits(struct block_device *bdev, struct nvme_id_ns *id)void nvmet_bdev_ns_disable (struct nvmet_ns *ns) { -if (ns->bdev_handle) { -bdev_release (ns->bdev_handle); +if (ns->bdev_file) { +fput (ns->bdev_file); ns->bdev =NULL ; - ns->bdev_handle =NULL ; + ns->bdev_file =NULL ; } }
@@ -85,18 +85,18 @@ int nvmet_bdev_ns_enable(struct nvmet_ns *ns)if (ns->buffered_io)return -ENOTBLK ; - ns->bdev_handle =bdev_open_by_path (ns->device_path, + ns->bdev_file =bdev_file_open_by_path (ns->device_path,BLK_OPEN_READ |BLK_OPEN_WRITE ,NULL ,NULL ); -if (IS_ERR (ns->bdev_handle)) { - ret =PTR_ERR (ns->bdev_handle); +if (IS_ERR (ns->bdev_file)) { + ret =PTR_ERR (ns->bdev_file);if (ret != -ENOTBLK ) {pr_err ("failed to open block device %s: (%d)\n" , ns->device_path, ret); } - ns->bdev_handle =NULL ; + ns->bdev_file =NULL ;return ret; } - ns->bdev = ns->bdev_handle->bdev; + ns->bdev =file_bdev (ns->bdev_file); ns->size =bdev_nr_bytes (ns->bdev); ns->blksize_shift =blksize_bits (bdev_logical_block_size (ns->bdev));
drivers/nvme/target/nvmet.h +1 -1
@@ -58,7 +58,7 @@struct nvmet_ns {struct percpu_ref ref; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;struct file *file;bool readonly;
Signature · 1 line
2.43.0
Re: [PATCH v2 15/34] nvme: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 64 lines
--- drivers/nvme/target/io-cmd-bdev.c | 16 ++++++++-------- drivers/nvme/target/nvmet.h | 2 +- 2 files changed, 9 insertions(+), 9 deletions(-)drivers/nvme/target/io-cmd-bdev.c +8
-8@@ -50,10 +50,10 @@ void nvmet_bdev_set_limits(struct block_device *bdev, struct nvme_id_ns *id)void nvmet_bdev_ns_disable (struct nvmet_ns *ns) { -if (ns->bdev_handle) { -bdev_release (ns->bdev_handle); +if (ns->bdev_file) { +fput (ns->bdev_file); ns->bdev =NULL ; - ns->bdev_handle =NULL ; + ns->bdev_file =NULL ; } }@@ -85,18 +85,18 @@ int nvmet_bdev_ns_enable(struct nvmet_ns *ns)if (ns->buffered_io)return -ENOTBLK ; - ns->bdev_handle =bdev_open_by_path (ns->device_path, + ns->bdev_file =bdev_file_open_by_path (ns->device_path,BLK_OPEN_READ |BLK_OPEN_WRITE ,NULL ,NULL ); -if (IS_ERR (ns->bdev_handle)) { - ret =PTR_ERR (ns->bdev_handle); +if (IS_ERR (ns->bdev_file)) { + ret =PTR_ERR (ns->bdev_file);if (ret != -ENOTBLK ) {pr_err ("failed to open block device %s: (%d)\n" , ns->device_path, ret); } - ns->bdev_handle =NULL ; + ns->bdev_file =NULL ;return ret; } - ns->bdev = ns->bdev_handle->bdev; + ns->bdev =file_bdev (ns->bdev_file); ns->size =bdev_nr_bytes (ns->bdev); ns->blksize_shift =blksize_bits (bdev_logical_block_size (ns->bdev));drivers/nvme/target/nvmet.h +1
-1@@ -58,7 +58,7 @@struct nvmet_ns {struct percpu_ref ref; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;struct file *file;bool readonly;Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 16/34 s390: port block device access to file
In reply to Christian Brauner--- drivers/s390/block/dasd.c | 10 +++++----- drivers/s390/block/dasd_genhd.c | 36 ++++++++++++++++++------------------ drivers/s390/block/dasd_int.h | 2 +- drivers/s390/block/dasd_ioctl.c | 2 +- 4 files changed, 25 insertions(+), 25 deletions(-)
drivers/s390/block/dasd.c +5 -5
@@ -412,7 +412,7 @@ dasd_state_ready_to_online(struct dasd_device * device) KOBJ_CHANGE);return 0 ; } -disk_uevent (device->block->bdev_handle->bdev->bd_disk, +disk_uevent (file_bdev (device->block->bdev_file)->bd_disk,KOBJ_CHANGE ); }return 0 ;
@@ -433,7 +433,7 @@ static int dasd_state_online_to_ready(struct dasd_device *device) device->state =DASD_STATE_READY ;if (device->block && !(device->features &DASD_FEATURE_USERAW )) -disk_uevent (device->block->bdev_handle->bdev->bd_disk, +disk_uevent (file_bdev (device->block->bdev_file)->bd_disk,KOBJ_CHANGE );return 0 ; }
@@ -3588,7 +3588,7 @@ int dasd_generic_set_offline(struct ccw_device *cdev)* in the other openers. */ if (device->block) { - max_count = device->block->bdev_handle ?0 :-1 ; + max_count = device->block->bdev_file ?0 :-1 ; open_count =atomic_read (&device->block->open_count);if (open_count > max_count) {if (open_count >0 )
@@ -3634,8 +3634,8 @@ int dasd_generic_set_offline(struct ccw_device *cdev)* so sync bdev first and then wait for our queues to become * empty */ -if (device->block && device->block->bdev_handle) -bdev_mark_dead (device->block->bdev_handle->bdev, false); +if (device->block && device->block->bdev_file) +bdev_mark_dead (file_bdev (device->block->bdev_file), false);dasd_schedule_device_bh (device); rc =wait_event_interruptible (shutdown_waitq,_wait_for_empty_queues (device));
drivers/s390/block/dasd_genhd.c +18 -18
@@ -127,15 +127,15 @@ void dasd_gendisk_free(struct dasd_block *block)*/ int dasd_scan_partitions (struct dasd_block *block) { -struct bdev_handle *bdev_handle; +struct file *bdev_file;int rc; - bdev_handle =bdev_open_by_dev (disk_devt (block->gdp),BLK_OPEN_READ , + bdev_file =bdev_file_open_by_dev (disk_devt (block->gdp),BLK_OPEN_READ ,NULL ,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {DBF_DEV_EVENT (DBF_ERR , block->base,"scan partitions error, blkdev_get returned %ld" , -PTR_ERR (bdev_handle)); +PTR_ERR (bdev_file));return -ENODEV ; }
@@ -147,15 +147,15 @@ int dasd_scan_partitions(struct dasd_block *block) "scan partitions error, rc %d", rc);/* -* Since the matching bdev_release() call to the -* bdev_open_by_path() in this function is not called before +* Since the matching fput() call to the +* bdev_file_open_by_path() in this function is not called before * dasd_destroy_partitions the offline open_count limit needs to be -* increased from 0 to 1. This is done by setting device->bdev_handle +* increased from 0 to 1. This is done by setting device->bdev_file * (see dasd_generic_set_offline). As long as the partition detection * is running no offline should be allowed. That is why the assignment -* to block->bdev_handle is done AFTER the BLKRRPART ioctl. +* to block->bdev_file is done AFTER the BLKRRPART ioctl. */ - block->bdev_handle = bdev_handle; + block->bdev_file = bdev_file;return 0 ; }
@@ -165,21 +165,21 @@ int dasd_scan_partitions(struct dasd_block *block)*/ void dasd_destroy_partitions (struct dasd_block *block) { -struct bdev_handle *bdev_handle; +struct file *bdev_file;/* -* Get the bdev_handle pointer from the device structure and clear -* device->bdev_handle to lower the offline open_count limit again. +* Get the bdev_file pointer from the device structure and clear +* device->bdev_file to lower the offline open_count limit again. */ - bdev_handle = block->bdev_handle; - block->bdev_handle =NULL ; + bdev_file = block->bdev_file; + block->bdev_file =NULL ; -mutex_lock (&bdev_handle->bdev->bd_disk->open_mutex); -bdev_disk_changed (bdev_handle->bdev->bd_disk, true); -mutex_unlock (&bdev_handle->bdev->bd_disk->open_mutex); +mutex_lock (&file_bdev (bdev_file)->bd_disk->open_mutex); +bdev_disk_changed (file_bdev (bdev_file)->bd_disk, true); +mutex_unlock (&file_bdev (bdev_file)->bd_disk->open_mutex);/* Matching blkdev_put to the blkdev_get in dasd_scan_partitions. */ -bdev_release (bdev_handle); +fput (bdev_file); }int dasd_gendisk_init (void )
drivers/s390/block/dasd_int.h +1 -1
@@ -650,7 +650,7 @@ struct dasd_block {struct gendisk *gdp;spinlock_t request_queue_lock;struct blk_mq_tag_set tag_set; -struct bdev_handle *bdev_handle; +struct file *bdev_file;atomic_t open_count;unsigned long blocks;/* size of volume in blocks */
drivers/s390/block/dasd_ioctl.c +1 -1
@@ -537,7 +537,7 @@ static int __dasd_ioctl_information(struct dasd_block *block,* This must be hidden from user-space. */ dasd_info->open_count =atomic_read (&block->open_count); -if (!block->bdev_handle) +if (!block->bdev_file) dasd_info->open_count++;/*
Signature · 1 line
2.43.0
Re: [PATCH v2 16/34] s390: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 155 lines
--- drivers/s390/block/dasd.c | 10 +++++----- drivers/s390/block/dasd_genhd.c | 36 ++++++++++++++++++------------------ drivers/s390/block/dasd_int.h | 2 +- drivers/s390/block/dasd_ioctl.c | 2 +- 4 files changed, 25 insertions(+), 25 deletions(-)drivers/s390/block/dasd.c +5
-5@@ -412,7 +412,7 @@ dasd_state_ready_to_online(struct dasd_device * device) KOBJ_CHANGE);return 0 ; } -disk_uevent (device->block->bdev_handle->bdev->bd_disk, +disk_uevent (file_bdev (device->block->bdev_file)->bd_disk,KOBJ_CHANGE ); }return 0 ;@@ -433,7 +433,7 @@ static int dasd_state_online_to_ready(struct dasd_device *device) device->state =DASD_STATE_READY ;if (device->block && !(device->features &DASD_FEATURE_USERAW )) -disk_uevent (device->block->bdev_handle->bdev->bd_disk, +disk_uevent (file_bdev (device->block->bdev_file)->bd_disk,KOBJ_CHANGE );return 0 ; }@@ -3588,7 +3588,7 @@ int dasd_generic_set_offline(struct ccw_device *cdev)* in the other openers. */ if (device->block) { - max_count = device->block->bdev_handle ?0 :-1 ; + max_count = device->block->bdev_file ?0 :-1 ; open_count =atomic_read (&device->block->open_count);if (open_count > max_count) {if (open_count >0 )@@ -3634,8 +3634,8 @@ int dasd_generic_set_offline(struct ccw_device *cdev)* so sync bdev first and then wait for our queues to become * empty */ -if (device->block && device->block->bdev_handle) -bdev_mark_dead (device->block->bdev_handle->bdev, false); +if (device->block && device->block->bdev_file) +bdev_mark_dead (file_bdev (device->block->bdev_file), false);dasd_schedule_device_bh (device); rc =wait_event_interruptible (shutdown_waitq,_wait_for_empty_queues (device));drivers/s390/block/dasd_genhd.c +18
-18@@ -127,15 +127,15 @@ void dasd_gendisk_free(struct dasd_block *block)*/ int dasd_scan_partitions (struct dasd_block *block) { -struct bdev_handle *bdev_handle; +struct file *bdev_file;int rc; - bdev_handle =bdev_open_by_dev (disk_devt (block->gdp),BLK_OPEN_READ , + bdev_file =bdev_file_open_by_dev (disk_devt (block->gdp),BLK_OPEN_READ ,NULL ,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {DBF_DEV_EVENT (DBF_ERR , block->base,"scan partitions error, blkdev_get returned %ld" , -PTR_ERR (bdev_handle)); +PTR_ERR (bdev_file));return -ENODEV ; }@@ -147,15 +147,15 @@ int dasd_scan_partitions(struct dasd_block *block) "scan partitions error, rc %d", rc);/* -* Since the matching bdev_release() call to the -* bdev_open_by_path() in this function is not called before +* Since the matching fput() call to the +* bdev_file_open_by_path() in this function is not called before * dasd_destroy_partitions the offline open_count limit needs to be -* increased from 0 to 1. This is done by setting device->bdev_handle +* increased from 0 to 1. This is done by setting device->bdev_file * (see dasd_generic_set_offline). As long as the partition detection * is running no offline should be allowed. That is why the assignment -* to block->bdev_handle is done AFTER the BLKRRPART ioctl. +* to block->bdev_file is done AFTER the BLKRRPART ioctl. */ - block->bdev_handle = bdev_handle; + block->bdev_file = bdev_file;return 0 ; }@@ -165,21 +165,21 @@ int dasd_scan_partitions(struct dasd_block *block)*/ void dasd_destroy_partitions (struct dasd_block *block) { -struct bdev_handle *bdev_handle; +struct file *bdev_file;/* -* Get the bdev_handle pointer from the device structure and clear -* device->bdev_handle to lower the offline open_count limit again. +* Get the bdev_file pointer from the device structure and clear +* device->bdev_file to lower the offline open_count limit again. */ - bdev_handle = block->bdev_handle; - block->bdev_handle =NULL ; + bdev_file = block->bdev_file; + block->bdev_file =NULL ; -mutex_lock (&bdev_handle->bdev->bd_disk->open_mutex); -bdev_disk_changed (bdev_handle->bdev->bd_disk, true); -mutex_unlock (&bdev_handle->bdev->bd_disk->open_mutex); +mutex_lock (&file_bdev (bdev_file)->bd_disk->open_mutex); +bdev_disk_changed (file_bdev (bdev_file)->bd_disk, true); +mutex_unlock (&file_bdev (bdev_file)->bd_disk->open_mutex);/* Matching blkdev_put to the blkdev_get in dasd_scan_partitions. */ -bdev_release (bdev_handle); +fput (bdev_file); }int dasd_gendisk_init (void )drivers/s390/block/dasd_int.h +1
-1@@ -650,7 +650,7 @@ struct dasd_block {struct gendisk *gdp;spinlock_t request_queue_lock;struct blk_mq_tag_set tag_set; -struct bdev_handle *bdev_handle; +struct file *bdev_file;atomic_t open_count;unsigned long blocks;/* size of volume in blocks */ drivers/s390/block/dasd_ioctl.c +1
-1@@ -537,7 +537,7 @@ static int __dasd_ioctl_information(struct dasd_block *block,* This must be hidden from user-space. */ dasd_info->open_count =atomic_read (&block->open_count); -if (!block->bdev_handle) +if (!block->bdev_file) dasd_info->open_count++;/* Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 17/34 target: port block device access to file
In reply to Christian Brauner--- drivers/target/target_core_iblock.c | 18 +++++++++--------- drivers/target/target_core_iblock.h | 2 +- drivers/target/target_core_pscsi.c | 22 +++++++++++----------- drivers/target/target_core_pscsi.h | 2 +- 4 files changed, 22 insertions(+), 22 deletions(-)
drivers/target/target_core_iblock.c +9 -9
@@ -91,7 +91,7 @@ static int iblock_configure_device(struct se_device *dev) {struct iblock_dev *ib_dev =IBLOCK_DEV (dev);struct request_queue *q; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bd;struct blk_integrity *bi;blk_mode_t mode =BLK_OPEN_READ ;
@@ -117,14 +117,14 @@ static int iblock_configure_device(struct se_device *dev)else dev->dev_flags |=DF_READ_ONLY ; - bdev_handle =bdev_open_by_path (ib_dev->ibd_udev_path, mode, ib_dev, + bdev_file =bdev_file_open_by_path (ib_dev->ibd_udev_path, mode, ib_dev,NULL ); -if (IS_ERR (bdev_handle)) { - ret =PTR_ERR (bdev_handle); +if (IS_ERR (bdev_file)) { + ret =PTR_ERR (bdev_file); goto out_free_bioset; } - ib_dev->ibd_bdev_handle = bdev_handle; - ib_dev->ibd_bd = bd = bdev_handle->bdev; + ib_dev->ibd_bdev_file = bdev_file; + ib_dev->ibd_bd = bd =file_bdev (bdev_file); q =bdev_get_queue (bd);
@@ -180,7 +180,7 @@ static int iblock_configure_device(struct se_device *dev)return 0 ; out_blkdev_put: -bdev_release (ib_dev->ibd_bdev_handle); +fput (ib_dev->ibd_bdev_file); out_free_bioset:bioset_exit (&ib_dev->ibd_bio_set); out:
@@ -205,8 +205,8 @@ static void iblock_destroy_device(struct se_device *dev) {struct iblock_dev *ib_dev =IBLOCK_DEV (dev); -if (ib_dev->ibd_bdev_handle) -bdev_release (ib_dev->ibd_bdev_handle); +if (ib_dev->ibd_bdev_file) +fput (ib_dev->ibd_bdev_file);bioset_exit (&ib_dev->ibd_bio_set); }
drivers/target/target_core_iblock.h +1 -1
@@ -32,7 +32,7 @@ struct iblock_dev {u32 ibd_flags;struct bio_set ibd_bio_set;struct block_device *ibd_bd; -struct bdev_handle *ibd_bdev_handle; +struct file *ibd_bdev_file;bool ibd_readonly;struct iblock_dev_plug *ibd_plug; }____cacheline_aligned ;
drivers/target/target_core_pscsi.c +11 -11
@@ -352,7 +352,7 @@ static int pscsi_create_type_disk(struct se_device *dev, struct scsi_device *sd)struct pscsi_hba_virt *phv = dev->se_hba->hba_ptr;struct pscsi_dev_virt *pdv =PSCSI_DEV (dev);struct Scsi_Host *sh = sd->host; -struct bdev_handle *bdev_handle; +struct file *bdev_file;int ret;if (scsi_device_get (sd)) {
@@ -366,18 +366,18 @@ static int pscsi_create_type_disk(struct se_device *dev, struct scsi_device *sd)* Claim exclusive struct block_device access to struct scsi_device * for TYPE_DISK and TYPE_ZBC using supplied udev_path */ - bdev_handle =bdev_open_by_path (dev->udev_path, + bdev_file =bdev_file_open_by_path (dev->udev_path,BLK_OPEN_WRITE |BLK_OPEN_READ , pdv,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {pr_err ("pSCSI: bdev_open_by_path() failed\n" );scsi_device_put (sd); -return PTR_ERR (bdev_handle); +return PTR_ERR (bdev_file); } - pdv->pdv_bdev_handle = bdev_handle; + pdv->pdv_bdev_file = bdev_file; ret =pscsi_add_device_to_list (dev, sd);if (ret) { -bdev_release (bdev_handle); +fput (bdev_file);scsi_device_put (sd);return ret; }
@@ -564,9 +564,9 @@ static void pscsi_destroy_device(struct se_device *dev)* from pscsi_create_type_disk() */ if ((sd->type ==TYPE_DISK || sd->type ==TYPE_ZBC ) && - pdv->pdv_bdev_handle) { -bdev_release (pdv->pdv_bdev_handle); - pdv->pdv_bdev_handle =NULL ; + pdv->pdv_bdev_file) { +fput (pdv->pdv_bdev_file); + pdv->pdv_bdev_file =NULL ; }/* * For HBA mode PHV_LLD_SCSI_HOST_NO, release the reference
@@ -994,8 +994,8 @@ static sector_t pscsi_get_blocks(struct se_device *dev) {struct pscsi_dev_virt *pdv =PSCSI_DEV (dev); -if (pdv->pdv_bdev_handle) -return bdev_nr_sectors (pdv->pdv_bdev_handle->bdev); +if (pdv->pdv_bdev_file) +return bdev_nr_sectors (file_bdev (pdv->pdv_bdev_file));return 0 ; }
drivers/target/target_core_pscsi.h +1 -1
@@ -37,7 +37,7 @@ struct pscsi_dev_virt {int pdv_channel_id;int pdv_target_id;int pdv_lun_id; -struct bdev_handle *pdv_bdev_handle; +struct file *pdv_bdev_file;struct scsi_device *pdv_sd;struct Scsi_Host *pdv_lld_host; }____cacheline_aligned ;
Signature · 1 line
2.43.0
Re: [PATCH v2 17/34] target: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 151 lines
--- drivers/target/target_core_iblock.c | 18 +++++++++--------- drivers/target/target_core_iblock.h | 2 +- drivers/target/target_core_pscsi.c | 22 +++++++++++----------- drivers/target/target_core_pscsi.h | 2 +- 4 files changed, 22 insertions(+), 22 deletions(-)drivers/target/target_core_iblock.c +9
-9@@ -91,7 +91,7 @@ static int iblock_configure_device(struct se_device *dev) {struct iblock_dev *ib_dev =IBLOCK_DEV (dev);struct request_queue *q; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bd;struct blk_integrity *bi;blk_mode_t mode =BLK_OPEN_READ ;@@ -117,14 +117,14 @@ static int iblock_configure_device(struct se_device *dev)else dev->dev_flags |=DF_READ_ONLY ; - bdev_handle =bdev_open_by_path (ib_dev->ibd_udev_path, mode, ib_dev, + bdev_file =bdev_file_open_by_path (ib_dev->ibd_udev_path, mode, ib_dev,NULL ); -if (IS_ERR (bdev_handle)) { - ret =PTR_ERR (bdev_handle); +if (IS_ERR (bdev_file)) { + ret =PTR_ERR (bdev_file); goto out_free_bioset; } - ib_dev->ibd_bdev_handle = bdev_handle; - ib_dev->ibd_bd = bd = bdev_handle->bdev; + ib_dev->ibd_bdev_file = bdev_file; + ib_dev->ibd_bd = bd =file_bdev (bdev_file); q =bdev_get_queue (bd);@@ -180,7 +180,7 @@ static int iblock_configure_device(struct se_device *dev)return 0 ; out_blkdev_put: -bdev_release (ib_dev->ibd_bdev_handle); +fput (ib_dev->ibd_bdev_file); out_free_bioset:bioset_exit (&ib_dev->ibd_bio_set); out:@@ -205,8 +205,8 @@ static void iblock_destroy_device(struct se_device *dev) {struct iblock_dev *ib_dev =IBLOCK_DEV (dev); -if (ib_dev->ibd_bdev_handle) -bdev_release (ib_dev->ibd_bdev_handle); +if (ib_dev->ibd_bdev_file) +fput (ib_dev->ibd_bdev_file);bioset_exit (&ib_dev->ibd_bio_set); }drivers/target/target_core_iblock.h +1
-1@@ -32,7 +32,7 @@ struct iblock_dev {u32 ibd_flags;struct bio_set ibd_bio_set;struct block_device *ibd_bd; -struct bdev_handle *ibd_bdev_handle; +struct file *ibd_bdev_file;bool ibd_readonly;struct iblock_dev_plug *ibd_plug; }____cacheline_aligned ;drivers/target/target_core_pscsi.c +11
-11@@ -352,7 +352,7 @@ static int pscsi_create_type_disk(struct se_device *dev, struct scsi_device *sd)struct pscsi_hba_virt *phv = dev->se_hba->hba_ptr;struct pscsi_dev_virt *pdv =PSCSI_DEV (dev);struct Scsi_Host *sh = sd->host; -struct bdev_handle *bdev_handle; +struct file *bdev_file;int ret;if (scsi_device_get (sd)) {@@ -366,18 +366,18 @@ static int pscsi_create_type_disk(struct se_device *dev, struct scsi_device *sd)* Claim exclusive struct block_device access to struct scsi_device * for TYPE_DISK and TYPE_ZBC using supplied udev_path */ - bdev_handle =bdev_open_by_path (dev->udev_path, + bdev_file =bdev_file_open_by_path (dev->udev_path,BLK_OPEN_WRITE |BLK_OPEN_READ , pdv,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {pr_err ("pSCSI: bdev_open_by_path() failed\n" );scsi_device_put (sd); -return PTR_ERR (bdev_handle); +return PTR_ERR (bdev_file); } - pdv->pdv_bdev_handle = bdev_handle; + pdv->pdv_bdev_file = bdev_file; ret =pscsi_add_device_to_list (dev, sd);if (ret) { -bdev_release (bdev_handle); +fput (bdev_file);scsi_device_put (sd);return ret; }@@ -564,9 +564,9 @@ static void pscsi_destroy_device(struct se_device *dev)* from pscsi_create_type_disk() */ if ((sd->type ==TYPE_DISK || sd->type ==TYPE_ZBC ) && - pdv->pdv_bdev_handle) { -bdev_release (pdv->pdv_bdev_handle); - pdv->pdv_bdev_handle =NULL ; + pdv->pdv_bdev_file) { +fput (pdv->pdv_bdev_file); + pdv->pdv_bdev_file =NULL ; }/* * For HBA mode PHV_LLD_SCSI_HOST_NO, release the reference @@ -994,8 +994,8 @@ static sector_t pscsi_get_blocks(struct se_device *dev) {struct pscsi_dev_virt *pdv =PSCSI_DEV (dev); -if (pdv->pdv_bdev_handle) -return bdev_nr_sectors (pdv->pdv_bdev_handle->bdev); +if (pdv->pdv_bdev_file) +return bdev_nr_sectors (file_bdev (pdv->pdv_bdev_file));return 0 ; }drivers/target/target_core_pscsi.h +1
-1@@ -37,7 +37,7 @@ struct pscsi_dev_virt {int pdv_channel_id;int pdv_target_id;int pdv_lun_id; -struct bdev_handle *pdv_bdev_handle; +struct file *pdv_bdev_file;struct scsi_device *pdv_sd;struct Scsi_Host *pdv_lld_host; }____cacheline_aligned ;Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 18/34 bcachefs: port block device access to file
In reply to Christian Brauner--- fs/bcachefs/super-io.c | 20 ++++++++++---------- fs/bcachefs/super_types.h | 2 +- 2 files changed, 11 insertions(+), 11 deletions(-)
fs/bcachefs/super-io.c +10 -10
@@ -142,8 +142,8 @@ void bch2_sb_field_delete(struct bch_sb_handle *sb,void bch2_free_super (struct bch_sb_handle *sb) {kfree (sb->bio); -if (!IS_ERR_OR_NULL (sb->bdev_handle)) -bdev_release (sb->bdev_handle); +if (!IS_ERR_OR_NULL (sb->s_bdev_file)) +fput (sb->s_bdev_file);kfree (sb->holder);kfree (sb->sb_name);
@@ -704,22 +704,22 @@ static int __bch2_read_super(const char *path, struct bch_opts *opts,if (!opt_get (*opts, nochanges)) sb->mode |=BLK_OPEN_WRITE ; - sb->bdev_handle =bdev_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); -if (IS_ERR (sb->bdev_handle) && -PTR_ERR (sb->bdev_handle) == -EACCES && + sb->s_bdev_file =bdev_file_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); +if (IS_ERR (sb->s_bdev_file) && +PTR_ERR (sb->s_bdev_file) == -EACCES &&opt_get (*opts, read_only)) { sb->mode &= ~BLK_OPEN_WRITE ; - sb->bdev_handle =bdev_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); -if (!IS_ERR (sb->bdev_handle)) + sb->s_bdev_file =bdev_file_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); +if (!IS_ERR (sb->s_bdev_file))opt_set (*opts, nochanges, true); } -if (IS_ERR (sb->bdev_handle)) { - ret =PTR_ERR (sb->bdev_handle); +if (IS_ERR (sb->s_bdev_file)) { + ret =PTR_ERR (sb->s_bdev_file); goto out; } - sb->bdev = sb->bdev_handle->bdev; + sb->bdev =file_bdev (sb->s_bdev_file); ret =bch2_sb_realloc (sb,0 );if (ret) {
fs/bcachefs/super_types.h +1 -1
@@ -4,7 +4,7 @@struct bch_sb_handle {struct bch_sb *sb; -struct bdev_handle *bdev_handle; +struct file *s_bdev_file;struct block_device *bdev;char *sb_name;struct bio *bio;
Signature · 1 line
2.43.0
Re: [PATCH v2 18/34] bcachefs: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 68 lines
--- fs/bcachefs/super-io.c | 20 ++++++++++---------- fs/bcachefs/super_types.h | 2 +- 2 files changed, 11 insertions(+), 11 deletions(-)fs/bcachefs/super-io.c +10
-10@@ -142,8 +142,8 @@ void bch2_sb_field_delete(struct bch_sb_handle *sb,void bch2_free_super (struct bch_sb_handle *sb) {kfree (sb->bio); -if (!IS_ERR_OR_NULL (sb->bdev_handle)) -bdev_release (sb->bdev_handle); +if (!IS_ERR_OR_NULL (sb->s_bdev_file)) +fput (sb->s_bdev_file);kfree (sb->holder);kfree (sb->sb_name);@@ -704,22 +704,22 @@ static int __bch2_read_super(const char *path, struct bch_opts *opts,if (!opt_get (*opts, nochanges)) sb->mode |=BLK_OPEN_WRITE ; - sb->bdev_handle =bdev_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); -if (IS_ERR (sb->bdev_handle) && -PTR_ERR (sb->bdev_handle) == -EACCES && + sb->s_bdev_file =bdev_file_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); +if (IS_ERR (sb->s_bdev_file) && +PTR_ERR (sb->s_bdev_file) == -EACCES &&opt_get (*opts, read_only)) { sb->mode &= ~BLK_OPEN_WRITE ; - sb->bdev_handle =bdev_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); -if (!IS_ERR (sb->bdev_handle)) + sb->s_bdev_file =bdev_file_open_by_path (path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); +if (!IS_ERR (sb->s_bdev_file))opt_set (*opts, nochanges, true); } -if (IS_ERR (sb->bdev_handle)) { - ret =PTR_ERR (sb->bdev_handle); +if (IS_ERR (sb->s_bdev_file)) { + ret =PTR_ERR (sb->s_bdev_file); goto out; } - sb->bdev = sb->bdev_handle->bdev; + sb->bdev =file_bdev (sb->s_bdev_file); ret =bch2_sb_realloc (sb,0 );if (ret) {fs/bcachefs/super_types.h +1
-1@@ -4,7 +4,7 @@struct bch_sb_handle {struct bch_sb *sb; -struct bdev_handle *bdev_handle; +struct file *s_bdev_file;struct block_device *bdev;char *sb_name;struct bio *bio;Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 19/34 btrfs: port device access to file
In reply to Christian Brauner--- fs/btrfs/dev-replace.c | 14 ++++---- fs/btrfs/ioctl.c | 16 ++++----- fs/btrfs/volumes.c | 92 +++++++++++++++++++++++++------------------------- fs/btrfs/volumes.h | 4 +-- 4 files changed, 63 insertions(+), 63 deletions(-)
fs/btrfs/dev-replace.c +7 -7
@@ -246,7 +246,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info, {struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;struct btrfs_device *device; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;u64 devid =BTRFS_DEV_REPLACE_DEVID ;int ret =0 ;
@@ -257,13 +257,13 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,return -EINVAL ; } - bdev_handle =bdev_open_by_path (device_path,BLK_OPEN_WRITE , + bdev_file =bdev_file_open_by_path (device_path,BLK_OPEN_WRITE , fs_info->bdev_holder,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {btrfs_err (fs_info,"target device %s is invalid!" , device_path); -return PTR_ERR (bdev_handle); +return PTR_ERR (bdev_file); } - bdev = bdev_handle->bdev; + bdev =file_bdev (bdev_file);if (!btrfs_check_device_zone_type (fs_info, bdev)) { btrfs_err(fs_info,
@@ -314,7 +314,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info, device->commit_bytes_used = device->bytes_used; device->fs_info = fs_info; device->bdev = bdev; - device->bdev_handle = bdev_handle; + device->bdev_file = bdev_file;set_bit (BTRFS_DEV_STATE_IN_FS_METADATA , &device->dev_state);set_bit (BTRFS_DEV_STATE_REPLACE_TGT , &device->dev_state); device->dev_stats_valid =1 ;
@@ -335,7 +335,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,return 0 ; error: -bdev_release (bdev_handle); +fput (bdev_file);return ret; }
fs/btrfs/ioctl.c +8 -8
@@ -2691,7 +2691,7 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg)struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_ioctl_vol_args_v2 *vol_args; -struct bdev_handle *bdev_handle =NULL ; +struct file *bdev_file =NULL ;int ret;bool cancel = false;
@@ -2728,7 +2728,7 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg) goto err_drop;/* Exclusive operation is now claimed */ - ret =btrfs_rm_device (fs_info, &args, &bdev_handle); + ret =btrfs_rm_device (fs_info, &args, &bdev_file);btrfs_exclop_finish (fs_info);
@@ -2742,8 +2742,8 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg) } err_drop:mnt_drop_write_file (file); -if (bdev_handle) -bdev_release (bdev_handle); +if (bdev_file) +fput (bdev_file); out:btrfs_put_dev_args_from_path (&args);kfree (vol_args);
@@ -2756,7 +2756,7 @@ static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_ioctl_vol_args *vol_args; -struct bdev_handle *bdev_handle =NULL ; +struct file *bdev_file =NULL ;int ret;bool cancel = false;
@@ -2783,15 +2783,15 @@ static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg) ret =exclop_start_or_cancel_reloc (fs_info,BTRFS_EXCLOP_DEV_REMOVE , cancel);if (ret ==0 ) { - ret =btrfs_rm_device (fs_info, &args, &bdev_handle); + ret =btrfs_rm_device (fs_info, &args, &bdev_file);if (!ret)btrfs_info (fs_info,"disk deleted %s" , vol_args->name);btrfs_exclop_finish (fs_info); }mnt_drop_write_file (file); -if (bdev_handle) -bdev_release (bdev_handle); +if (bdev_file) +fput (bdev_file); out:btrfs_put_dev_args_from_path (&args);kfree (vol_args);
fs/btrfs/volumes.c +46 -46
271 lines not on this page · raw message
fs/btrfs/volumes.h +2 -2
@@ -90,7 +90,7 @@ struct btrfs_device {u64 generation; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;struct btrfs_zoned_device_info *zone_info;
@@ -661,7 +661,7 @@ struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,void btrfs_put_dev_args_from_path (struct btrfs_dev_lookup_args *args);int btrfs_rm_device (struct btrfs_fs_info *fs_info,struct btrfs_dev_lookup_args *args, -struct bdev_handle **bdev_handle); +struct file **bdev_file); void __exit btrfs_cleanup_fs_uuids(void);int btrfs_num_copies (struct btrfs_fs_info *fs_info,u64 logical,u64 len); int btrfs_grow_device(struct btrfs_trans_handle *trans,
Signature · 1 line
2.43.0
Re: [PATCH v2 19/34] btrfs: port device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 440 lines
--- fs/btrfs/dev-replace.c | 14 ++++---- fs/btrfs/ioctl.c | 16 ++++----- fs/btrfs/volumes.c | 92 +++++++++++++++++++++++++------------------------- fs/btrfs/volumes.h | 4 +-- 4 files changed, 63 insertions(+), 63 deletions(-)fs/btrfs/dev-replace.c +7
-7@@ -246,7 +246,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info, {struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;struct btrfs_device *device; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;u64 devid =BTRFS_DEV_REPLACE_DEVID ;int ret =0 ;@@ -257,13 +257,13 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,return -EINVAL ; } - bdev_handle =bdev_open_by_path (device_path,BLK_OPEN_WRITE , + bdev_file =bdev_file_open_by_path (device_path,BLK_OPEN_WRITE , fs_info->bdev_holder,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {btrfs_err (fs_info,"target device %s is invalid!" , device_path); -return PTR_ERR (bdev_handle); +return PTR_ERR (bdev_file); } - bdev = bdev_handle->bdev; + bdev =file_bdev (bdev_file);if (!btrfs_check_device_zone_type (fs_info, bdev)) { btrfs_err(fs_info,@@ -314,7 +314,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info, device->commit_bytes_used = device->bytes_used; device->fs_info = fs_info; device->bdev = bdev; - device->bdev_handle = bdev_handle; + device->bdev_file = bdev_file;set_bit (BTRFS_DEV_STATE_IN_FS_METADATA , &device->dev_state);set_bit (BTRFS_DEV_STATE_REPLACE_TGT , &device->dev_state); device->dev_stats_valid =1 ;@@ -335,7 +335,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,return 0 ; error: -bdev_release (bdev_handle); +fput (bdev_file);return ret; }fs/btrfs/ioctl.c +8
-8@@ -2691,7 +2691,7 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg)struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_ioctl_vol_args_v2 *vol_args; -struct bdev_handle *bdev_handle =NULL ; +struct file *bdev_file =NULL ;int ret;bool cancel = false;@@ -2728,7 +2728,7 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg) goto err_drop;/* Exclusive operation is now claimed */ - ret =btrfs_rm_device (fs_info, &args, &bdev_handle); + ret =btrfs_rm_device (fs_info, &args, &bdev_file);btrfs_exclop_finish (fs_info);@@ -2742,8 +2742,8 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg) } err_drop:mnt_drop_write_file (file); -if (bdev_handle) -bdev_release (bdev_handle); +if (bdev_file) +fput (bdev_file); out:btrfs_put_dev_args_from_path (&args);kfree (vol_args);@@ -2756,7 +2756,7 @@ static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_ioctl_vol_args *vol_args; -struct bdev_handle *bdev_handle =NULL ; +struct file *bdev_file =NULL ;int ret;bool cancel = false;@@ -2783,15 +2783,15 @@ static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg) ret =exclop_start_or_cancel_reloc (fs_info,BTRFS_EXCLOP_DEV_REMOVE , cancel);if (ret ==0 ) { - ret =btrfs_rm_device (fs_info, &args, &bdev_handle); + ret =btrfs_rm_device (fs_info, &args, &bdev_file);if (!ret)btrfs_info (fs_info,"disk deleted %s" , vol_args->name);btrfs_exclop_finish (fs_info); }mnt_drop_write_file (file); -if (bdev_handle) -bdev_release (bdev_handle); +if (bdev_file) +fput (bdev_file); out:btrfs_put_dev_args_from_path (&args);kfree (vol_args);fs/btrfs/volumes.c +46
-46@@ -468,39 +468,39 @@ static noinline struct btrfs_fs_devices *find_fsid(static int btrfs_get_bdev_and_sb (const char *device_path,blk_mode_t flags,void *holder, -int flush,struct bdev_handle **bdev_handle, +int flush,struct file **bdev_file,struct btrfs_super_block **disk_super) {struct block_device *bdev;int ret; - *bdev_handle =bdev_open_by_path (device_path, flags, holder,NULL ); + *bdev_file =bdev_file_open_by_path (device_path, flags, holder,NULL ); -if (IS_ERR (*bdev_handle)) { - ret =PTR_ERR (*bdev_handle); +if (IS_ERR (*bdev_file)) { + ret =PTR_ERR (*bdev_file); goto error; } - bdev = (*bdev_handle)->bdev; + bdev =file_bdev (*bdev_file);if (flush)sync_blockdev (bdev); ret =set_blocksize (bdev,BTRFS_BDEV_BLOCKSIZE );if (ret) { -bdev_release (*bdev_handle); +fput (*bdev_file); goto error; }invalidate_bdev (bdev); *disk_super =btrfs_read_dev_super (bdev);if (IS_ERR (*disk_super)) { ret =PTR_ERR (*disk_super); -bdev_release (*bdev_handle); +fput (*bdev_file); goto error; }return 0 ; error: - *bdev_handle =NULL ; + *bdev_file =NULL ;return ret; }@@ -643,7 +643,7 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices, struct btrfs_device *device, blk_mode_t flags, void *holder) { - struct bdev_handle *bdev_handle; + struct file *bdev_file;struct btrfs_super_block *disk_super;u64 devid;int ret;@@ -654,7 +654,7 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,return -EINVAL ; ret =btrfs_get_bdev_and_sb (device->name->str, flags, holder,1 , - &bdev_handle, &disk_super); + &bdev_file, &disk_super);if (ret)return ret;@@ -678,20 +678,20 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,clear_bit (BTRFS_DEV_STATE_WRITEABLE , &device->dev_state); fs_devices->seeding = true; }else { -if (bdev_read_only (bdev_handle->bdev)) +if (bdev_read_only (file_bdev (bdev_file)))clear_bit (BTRFS_DEV_STATE_WRITEABLE , &device->dev_state);else set_bit (BTRFS_DEV_STATE_WRITEABLE , &device->dev_state); } -if (!bdev_nonrot (bdev_handle->bdev)) +if (!bdev_nonrot (file_bdev (bdev_file))) fs_devices->rotating = true; -if (bdev_max_discard_sectors (bdev_handle->bdev)) +if (bdev_max_discard_sectors (file_bdev (bdev_file))) fs_devices->discardable = true; - device->bdev_handle = bdev_handle; - device->bdev = bdev_handle->bdev; + device->bdev_file = bdev_file; + device->bdev =file_bdev (bdev_file);clear_bit (BTRFS_DEV_STATE_IN_FS_METADATA , &device->dev_state); fs_devices->open_devices++;@@ -706,7 +706,7 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices, error_free_page:btrfs_release_disk_super (disk_super); -bdev_release (bdev_handle); +fput (bdev_file);return -EINVAL ; }@@ -1015,10 +1015,10 @@ static void __btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices,if (device->devid ==BTRFS_DEV_REPLACE_DEVID )continue ; -if (device->bdev_handle) { -bdev_release (device->bdev_handle); +if (device->bdev_file) { +fput (device->bdev_file); device->bdev =NULL ; - device->bdev_handle =NULL ; + device->bdev_file =NULL ; fs_devices->open_devices--; }if (test_bit (BTRFS_DEV_STATE_WRITEABLE , &device->dev_state)) {@@ -1063,7 +1063,7 @@ static void btrfs_close_bdev(struct btrfs_device *device)invalidate_bdev (device->bdev); } -bdev_release (device->bdev_handle); +fput (device->bdev_file); }static void btrfs_close_one_device (struct btrfs_device *device)@@ -1316,7 +1316,7 @@ struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags,struct btrfs_super_block *disk_super;bool new_device_added = false;struct btrfs_device *device =NULL ; -struct bdev_handle *bdev_handle; +struct file *bdev_file;u64 bytenr, bytenr_orig;int ret;@@ -1339,18 +1339,18 @@ struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags,* values temporarily, as the device paths of the fsid are the only * required information for assembling the volume. */ - bdev_handle =bdev_open_by_path (path, flags,NULL ,NULL ); -if (IS_ERR (bdev_handle)) -return ERR_CAST (bdev_handle); + bdev_file =bdev_file_open_by_path (path, flags,NULL ,NULL ); +if (IS_ERR (bdev_file)) +return ERR_CAST (bdev_file); bytenr_orig =btrfs_sb_offset (0 ); - ret =btrfs_sb_log_location_bdev (bdev_handle->bdev,0 ,READ , &bytenr); + ret =btrfs_sb_log_location_bdev (file_bdev (bdev_file),0 ,READ , &bytenr);if (ret) { device =ERR_PTR (ret); goto error_bdev_put; } - disk_super =btrfs_read_disk_super (bdev_handle->bdev, bytenr, + disk_super =btrfs_read_disk_super (file_bdev (bdev_file), bytenr, bytenr_orig);if (IS_ERR (disk_super)) { device =ERR_CAST (disk_super);@@ -1381,7 +1381,7 @@ struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags,btrfs_release_disk_super (disk_super); error_bdev_put: -bdev_release (bdev_handle); +fput (bdev_file);return device; }@@ -2057,7 +2057,7 @@ void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info,int btrfs_rm_device (struct btrfs_fs_info *fs_info,struct btrfs_dev_lookup_args *args, -struct bdev_handle **bdev_handle) +struct file **bdev_file) {struct btrfs_trans_handle *trans;struct btrfs_device *device;@@ -2166,7 +2166,7 @@ int btrfs_rm_device(struct btrfs_fs_info *fs_info,btrfs_assign_next_active_device (device,NULL ); -if (device->bdev_handle) { +if (device->bdev_file) { cur_devices->open_devices--;/* remove sysfs entry */ btrfs_sysfs_remove_device (device);@@ -2182,9 +2182,9 @@ int btrfs_rm_device(struct btrfs_fs_info *fs_info,* free the device. * * We cannot call btrfs_close_bdev() here because we're holding the sb -* write lock, and bdev_release() will pull in the ->open_mutex on -* the block device and it's dependencies. Instead just flush the -* device and let the caller do the final bdev_release. +* write lock, and fput() on the block device will pull in the +* ->open_mutex on the block device and it's dependencies. Instead +* just flush the device and let the caller do the final bdev_release. */ if (test_bit (BTRFS_DEV_STATE_WRITEABLE , &device->dev_state)) { btrfs_scratch_superblocks(fs_info, device->bdev,@@ -2195,7 +2195,7 @@ int btrfs_rm_device(struct btrfs_fs_info *fs_info, } } - *bdev_handle = device->bdev_handle; + *bdev_file = device->bdev_file;synchronize_rcu ();btrfs_free_device (device);@@ -2332,7 +2332,7 @@ int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info, const char *path) {struct btrfs_super_block *disk_super; -struct bdev_handle *bdev_handle; +struct file *bdev_file;int ret;if (!path || !path[0 ])@@ -2350,7 +2350,7 @@ int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info, } ret =btrfs_get_bdev_and_sb (path,BLK_OPEN_READ ,NULL ,0 , - &bdev_handle, &disk_super); + &bdev_file, &disk_super);if (ret) {btrfs_put_dev_args_from_path (args);return ret;@@ -2363,7 +2363,7 @@ int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,else memcpy (args->fsid, disk_super->fsid,BTRFS_FSID_SIZE );btrfs_release_disk_super (disk_super); -bdev_release (bdev_handle); +fput (bdev_file);return 0 ; }@@ -2583,7 +2583,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_pathstruct btrfs_root *root = fs_info->dev_root;struct btrfs_trans_handle *trans;struct btrfs_device *device; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct super_block *sb = fs_info->sb;struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;struct btrfs_fs_devices *seed_devices =NULL ;@@ -2596,12 +2596,12 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_pathif (sb_rdonly (sb) && !fs_devices->seeding)return -EROFS ; - bdev_handle =bdev_open_by_path (device_path,BLK_OPEN_WRITE , + bdev_file =bdev_file_open_by_path (device_path,BLK_OPEN_WRITE , fs_info->bdev_holder,NULL ); -if (IS_ERR (bdev_handle)) -return PTR_ERR (bdev_handle); +if (IS_ERR (bdev_file)) +return PTR_ERR (bdev_file); -if (!btrfs_check_device_zone_type (fs_info, bdev_handle->bdev)) { +if (!btrfs_check_device_zone_type (fs_info,file_bdev (bdev_file))) { ret = -EINVAL ; goto error; }@@ -2613,11 +2613,11 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path locked = true; } -sync_blockdev (bdev_handle->bdev); +sync_blockdev (file_bdev (bdev_file));rcu_read_lock ();list_for_each_entry_rcu (device, &fs_devices->devices, dev_list) { -if (device->bdev == bdev_handle->bdev) { +if (device->bdev ==file_bdev (bdev_file)) { ret = -EEXIST ;rcu_read_unlock (); goto error;@@ -2633,8 +2633,8 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path } device->fs_info = fs_info; - device->bdev_handle = bdev_handle; - device->bdev = bdev_handle->bdev; + device->bdev_file = bdev_file; + device->bdev =file_bdev (bdev_file); ret =lookup_bdev (device_path, &device->devt);if (ret) goto error_free_device;@@ -2817,7 +2817,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path error_free_device:btrfs_free_device (device); error: -bdev_release (bdev_handle); +fput (bdev_file);if (locked) {mutex_unlock (&uuid_mutex);up_write (&sb->s_umount);fs/btrfs/volumes.h +2
-2@@ -90,7 +90,7 @@ struct btrfs_device {u64 generation; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;struct btrfs_zoned_device_info *zone_info;@@ -661,7 +661,7 @@ struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,void btrfs_put_dev_args_from_path (struct btrfs_dev_lookup_args *args);int btrfs_rm_device (struct btrfs_fs_info *fs_info,struct btrfs_dev_lookup_args *args, -struct bdev_handle **bdev_handle); +struct file **bdev_file); void __exit btrfs_cleanup_fs_uuids(void);int btrfs_num_copies (struct btrfs_fs_info *fs_info,u64 logical,u64 len); int btrfs_grow_device(struct btrfs_trans_handle *trans,Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 20/34 erofs: port device access to file
In reply to Christian Brauner--- fs/erofs/data.c | 6 +++--- fs/erofs/internal.h | 2 +- fs/erofs/super.c | 16 ++++++++-------- 3 files changed, 12 insertions(+), 12 deletions(-)
fs/erofs/data.c +3 -3
@@ -220,7 +220,7 @@ int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *map)up_read (&devs->rwsem);return 0 ; } - map->m_bdev = dif->bdev_handle ? dif->bdev_handle->bdev :NULL ; + map->m_bdev = dif->bdev_file ?file_bdev (dif->bdev_file) :NULL ; map->m_daxdev = dif->dax_dev; map->m_dax_part_off = dif->dax_part_off; map->m_fscache = dif->fscache;
@@ -238,8 +238,8 @@ int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *map)if (map->m_pa >= startoff && map->m_pa < startoff + length) { map->m_pa -= startoff; - map->m_bdev = dif->bdev_handle ? - dif->bdev_handle->bdev :NULL ; + map->m_bdev = dif->bdev_file ? +file_bdev (dif->bdev_file) :NULL ; map->m_daxdev = dif->dax_dev; map->m_dax_part_off = dif->dax_part_off; map->m_fscache = dif->fscache;
fs/erofs/internal.h +1 -1
@@ -49,7 +49,7 @@ typedef u32 erofs_blk_t;struct erofs_device_info {char *path;struct erofs_fscache *fscache; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct dax_device *dax_dev;u64 dax_part_off;
fs/erofs/super.c +8 -8
@@ -177,7 +177,7 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb,struct erofs_sb_info *sbi =EROFS_SB (sb);struct erofs_fscache *fscache;struct erofs_deviceslot *dis; -struct bdev_handle *bdev_handle; +struct file *bdev_file;void *ptr; ptr =erofs_read_metabuf (buf, sb,erofs_blknr (sb, *pos),EROFS_KMAP );
@@ -201,12 +201,12 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb,return PTR_ERR (fscache); dif->fscache = fscache; }else if (!sbi->devs->flatdev) { - bdev_handle =bdev_open_by_path (dif->path,BLK_OPEN_READ , + bdev_file =bdev_file_open_by_path (dif->path,BLK_OPEN_READ , sb->s_type,NULL ); -if (IS_ERR (bdev_handle)) -return PTR_ERR (bdev_handle); - dif->bdev_handle = bdev_handle; - dif->dax_dev =fs_dax_get_by_bdev (bdev_handle->bdev, +if (IS_ERR (bdev_file)) +return PTR_ERR (bdev_file); + dif->bdev_file = bdev_file; + dif->dax_dev =fs_dax_get_by_bdev (file_bdev (bdev_file), &dif->dax_part_off,NULL ,NULL ); }
@@ -754,8 +754,8 @@ static int erofs_release_device_info(int id, void *ptr, void *data)struct erofs_device_info *dif = ptr;fs_put_dax (dif->dax_dev,NULL ); -if (dif->bdev_handle) -bdev_release (dif->bdev_handle); +if (dif->bdev_file) +fput (dif->bdev_file);erofs_fscache_unregister_cookie (dif->fscache); dif->fscache =NULL ;kfree (dif->path);
Signature · 1 line
2.43.0
Re: [PATCH v2 20/34] erofs: port device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 89 lines
--- fs/erofs/data.c | 6 +++--- fs/erofs/internal.h | 2 +- fs/erofs/super.c | 16 ++++++++-------- 3 files changed, 12 insertions(+), 12 deletions(-)fs/erofs/data.c +3
-3@@ -220,7 +220,7 @@ int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *map)up_read (&devs->rwsem);return 0 ; } - map->m_bdev = dif->bdev_handle ? dif->bdev_handle->bdev :NULL ; + map->m_bdev = dif->bdev_file ?file_bdev (dif->bdev_file) :NULL ; map->m_daxdev = dif->dax_dev; map->m_dax_part_off = dif->dax_part_off; map->m_fscache = dif->fscache;@@ -238,8 +238,8 @@ int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *map)if (map->m_pa >= startoff && map->m_pa < startoff + length) { map->m_pa -= startoff; - map->m_bdev = dif->bdev_handle ? - dif->bdev_handle->bdev :NULL ; + map->m_bdev = dif->bdev_file ? +file_bdev (dif->bdev_file) :NULL ; map->m_daxdev = dif->dax_dev; map->m_dax_part_off = dif->dax_part_off; map->m_fscache = dif->fscache;fs/erofs/internal.h +1
-1@@ -49,7 +49,7 @@ typedef u32 erofs_blk_t;struct erofs_device_info {char *path;struct erofs_fscache *fscache; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct dax_device *dax_dev;u64 dax_part_off;fs/erofs/super.c +8
-8@@ -177,7 +177,7 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb,struct erofs_sb_info *sbi =EROFS_SB (sb);struct erofs_fscache *fscache;struct erofs_deviceslot *dis; -struct bdev_handle *bdev_handle; +struct file *bdev_file;void *ptr; ptr =erofs_read_metabuf (buf, sb,erofs_blknr (sb, *pos),EROFS_KMAP );@@ -201,12 +201,12 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb,return PTR_ERR (fscache); dif->fscache = fscache; }else if (!sbi->devs->flatdev) { - bdev_handle =bdev_open_by_path (dif->path,BLK_OPEN_READ , + bdev_file =bdev_file_open_by_path (dif->path,BLK_OPEN_READ , sb->s_type,NULL ); -if (IS_ERR (bdev_handle)) -return PTR_ERR (bdev_handle); - dif->bdev_handle = bdev_handle; - dif->dax_dev =fs_dax_get_by_bdev (bdev_handle->bdev, +if (IS_ERR (bdev_file)) +return PTR_ERR (bdev_file); + dif->bdev_file = bdev_file; + dif->dax_dev =fs_dax_get_by_bdev (file_bdev (bdev_file), &dif->dax_part_off,NULL ,NULL ); }@@ -754,8 +754,8 @@ static int erofs_release_device_info(int id, void *ptr, void *data)struct erofs_device_info *dif = ptr;fs_put_dax (dif->dax_dev,NULL ); -if (dif->bdev_handle) -bdev_release (dif->bdev_handle); +if (dif->bdev_file) +fput (dif->bdev_file);erofs_fscache_unregister_cookie (dif->fscache); dif->fscache =NULL ;kfree (dif->path);Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 21/34 ext4: port block device access to file
In reply to Christian Brauner--- fs/ext4/ext4.h | 2 +- fs/ext4/fsmap.c | 8 ++++---- fs/ext4/super.c | 52 ++++++++++++++++++++++++++-------------------------- 3 files changed, 31 insertions(+), 31 deletions(-)
fs/ext4/ext4.h +1 -1
@@ -1548,7 +1548,7 @@ struct ext4_sb_info {unsigned long s_commit_interval;u32 s_max_batch_time;u32 s_min_batch_time; -struct bdev_handle *s_journal_bdev_handle; +struct file *s_journal_bdev_file;#ifdef CONFIG_QUOTA /* Names of quota files with journalled quota */ char __rcu *s_qf_names[EXT4_MAXQUOTAS ];
fs/ext4/fsmap.c +4 -4
@@ -576,9 +576,9 @@ static bool ext4_getfsmap_is_valid_device(struct super_block *sb,if (fm->fmr_device ==0 || fm->fmr_device ==UINT_MAX || fm->fmr_device ==new_encode_dev (sb->s_bdev->bd_dev))return true; -if (EXT4_SB (sb)->s_journal_bdev_handle && +if (EXT4_SB (sb)->s_journal_bdev_file && fm->fmr_device == -new_encode_dev (EXT4_SB (sb)->s_journal_bdev_handle->bdev->bd_dev)) +new_encode_dev (file_bdev (EXT4_SB (sb)->s_journal_bdev_file)->bd_dev))return true;return false; }
@@ -648,9 +648,9 @@ int ext4_getfsmap(struct super_block *sb, struct ext4_fsmap_head *head,memset (handlers,0 ,sizeof (handlers)); handlers[0 ].gfd_dev =new_encode_dev (sb->s_bdev->bd_dev); handlers[0 ].gfd_fn = ext4_getfsmap_datadev; -if (EXT4_SB (sb)->s_journal_bdev_handle) { +if (EXT4_SB (sb)->s_journal_bdev_file) { handlers[1 ].gfd_dev =new_encode_dev ( -EXT4_SB (sb)->s_journal_bdev_handle->bdev->bd_dev); +file_bdev (EXT4_SB (sb)->s_journal_bdev_file)->bd_dev); handlers[1 ].gfd_fn = ext4_getfsmap_logdev; }
fs/ext4/super.c +26 -26
138 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH v2 21/34] ext4: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 201 lines
--- fs/ext4/ext4.h | 2 +- fs/ext4/fsmap.c | 8 ++++---- fs/ext4/super.c | 52 ++++++++++++++++++++++++++-------------------------- 3 files changed, 31 insertions(+), 31 deletions(-)fs/ext4/ext4.h +1
-1@@ -1548,7 +1548,7 @@ struct ext4_sb_info {unsigned long s_commit_interval;u32 s_max_batch_time;u32 s_min_batch_time; -struct bdev_handle *s_journal_bdev_handle; +struct file *s_journal_bdev_file;#ifdef CONFIG_QUOTA /* Names of quota files with journalled quota */ char __rcu *s_qf_names[EXT4_MAXQUOTAS ];fs/ext4/fsmap.c +4
-4@@ -576,9 +576,9 @@ static bool ext4_getfsmap_is_valid_device(struct super_block *sb,if (fm->fmr_device ==0 || fm->fmr_device ==UINT_MAX || fm->fmr_device ==new_encode_dev (sb->s_bdev->bd_dev))return true; -if (EXT4_SB (sb)->s_journal_bdev_handle && +if (EXT4_SB (sb)->s_journal_bdev_file && fm->fmr_device == -new_encode_dev (EXT4_SB (sb)->s_journal_bdev_handle->bdev->bd_dev)) +new_encode_dev (file_bdev (EXT4_SB (sb)->s_journal_bdev_file)->bd_dev))return true;return false; }@@ -648,9 +648,9 @@ int ext4_getfsmap(struct super_block *sb, struct ext4_fsmap_head *head,memset (handlers,0 ,sizeof (handlers)); handlers[0 ].gfd_dev =new_encode_dev (sb->s_bdev->bd_dev); handlers[0 ].gfd_fn = ext4_getfsmap_datadev; -if (EXT4_SB (sb)->s_journal_bdev_handle) { +if (EXT4_SB (sb)->s_journal_bdev_file) { handlers[1 ].gfd_dev =new_encode_dev ( -EXT4_SB (sb)->s_journal_bdev_handle->bdev->bd_dev); +file_bdev (EXT4_SB (sb)->s_journal_bdev_file)->bd_dev); handlers[1 ].gfd_fn = ext4_getfsmap_logdev; }fs/ext4/super.c +26
-26@@ -1359,14 +1359,14 @@ static void ext4_put_super(struct super_block *sb)sync_blockdev (sb->s_bdev);invalidate_bdev (sb->s_bdev); -if (sbi->s_journal_bdev_handle) { +if (sbi->s_journal_bdev_file) {/* * Invalidate the journal device's buffers. We don't want them * floating about in memory - the physical journal device may * hotswapped, and it breaks the `ro-after' testing code. */ -sync_blockdev (sbi->s_journal_bdev_handle->bdev); -invalidate_bdev (sbi->s_journal_bdev_handle->bdev); +sync_blockdev (file_bdev (sbi->s_journal_bdev_file)); +invalidate_bdev (file_bdev (sbi->s_journal_bdev_file)); }ext4_xattr_destroy_cache (sbi->s_ea_inode_cache);@@ -4233,7 +4233,7 @@ int ext4_calculate_overhead(struct super_block *sb)* Add the internal journal blocks whether the journal has been * loaded or not */ -if (sbi->s_journal && !sbi->s_journal_bdev_handle) +if (sbi->s_journal && !sbi->s_journal_bdev_file) overhead +=EXT4_NUM_B2C (sbi, sbi->s_journal->j_total_len);else if (ext4_has_feature_journal (sb) && !sbi->s_journal && j_inum) {/* j_inum for internal journal is non-zero */ @@ -5670,9 +5670,9 @@ failed_mount9: __maybe_unused#endif fscrypt_free_dummy_policy (&sbi->s_dummy_enc_policy);brelse (sbi->s_sbh); -if (sbi->s_journal_bdev_handle) { -invalidate_bdev (sbi->s_journal_bdev_handle->bdev); -bdev_release (sbi->s_journal_bdev_handle); +if (sbi->s_journal_bdev_file) { +invalidate_bdev (file_bdev (sbi->s_journal_bdev_file)); +fput (sbi->s_journal_bdev_file); } out_fail:invalidate_bdev (sb->s_bdev);@@ -5842,30 +5842,30 @@ static journal_t *ext4_open_inode_journal(struct super_block *sb,return journal; } -static struct bdev_handle *ext4_get_journal_blkdev (struct super_block *sb, +static struct file *ext4_get_journal_blkdev (struct super_block *sb,dev_t j_dev,ext4_fsblk_t *j_start,ext4_fsblk_t *j_len) {struct buffer_head *bh;struct block_device *bdev; -struct bdev_handle *bdev_handle; +struct file *bdev_file;int hblock, blocksize;ext4_fsblk_t sb_block;unsigned long offset;struct ext4_super_block *es;int errno; - bdev_handle =bdev_open_by_dev (j_dev, + bdev_file =bdev_file_open_by_dev (j_dev,BLK_OPEN_READ |BLK_OPEN_WRITE |BLK_OPEN_RESTRICT_WRITES , sb, &fs_holder_ops); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {ext4_msg (sb,KERN_ERR ,"failed to open journal device unknown-block(%u,%u) %ld" , -MAJOR (j_dev),MINOR (j_dev),PTR_ERR (bdev_handle)); -return bdev_handle; +MAJOR (j_dev),MINOR (j_dev),PTR_ERR (bdev_file)); +return bdev_file; } - bdev = bdev_handle->bdev; + bdev =file_bdev (bdev_file); blocksize = sb->s_blocksize; hblock =bdev_logical_block_size (bdev);if (blocksize < hblock) {@@ -5912,12 +5912,12 @@ static struct bdev_handle *ext4_get_journal_blkdev(struct super_block *sb, *j_start = sb_block +1 ; *j_len =ext4_blocks_count (es);brelse (bh); -return bdev_handle; +return bdev_file; out_bh:brelse (bh); out_bdev: -bdev_release (bdev_handle); +fput (bdev_file);return ERR_PTR (errno); }@@ -5927,14 +5927,14 @@ static journal_t *ext4_open_dev_journal(struct super_block *sb,journal_t *journal;ext4_fsblk_t j_start;ext4_fsblk_t j_len; -struct bdev_handle *bdev_handle; +struct file *bdev_file;int errno =0 ; - bdev_handle =ext4_get_journal_blkdev (sb, j_dev, &j_start, &j_len); -if (IS_ERR (bdev_handle)) -return ERR_CAST (bdev_handle); + bdev_file =ext4_get_journal_blkdev (sb, j_dev, &j_start, &j_len); +if (IS_ERR (bdev_file)) +return ERR_CAST (bdev_file); - journal =jbd2_journal_init_dev (bdev_handle->bdev, sb->s_bdev, j_start, + journal =jbd2_journal_init_dev (file_bdev (bdev_file), sb->s_bdev, j_start, j_len, sb->s_blocksize);if (IS_ERR (journal)) {ext4_msg (sb,KERN_ERR ,"failed to create device journal" );@@ -5949,14 +5949,14 @@ static journal_t *ext4_open_dev_journal(struct super_block *sb, goto out_journal; } journal->j_private = sb; -EXT4_SB (sb)->s_journal_bdev_handle = bdev_handle; +EXT4_SB (sb)->s_journal_bdev_file = bdev_file;ext4_init_journal_params (sb, journal);return journal; out_journal:jbd2_journal_destroy (journal); out_bdev: -bdev_release (bdev_handle); +fput (bdev_file);return ERR_PTR (errno); }@@ -7314,12 +7314,12 @@ static inline int ext3_feature_set_ok(struct super_block *sb)static void ext4_kill_sb (struct super_block *sb) {struct ext4_sb_info *sbi =EXT4_SB (sb); -struct bdev_handle *handle = sbi ? sbi->s_journal_bdev_handle :NULL ; +struct file *bdev_file = sbi ? sbi->s_journal_bdev_file :NULL ;kill_block_super (sb); -if (handle) -bdev_release (handle); +if (bdev_file) +fput (bdev_file); }static struct file_system_type ext4_fs_type = {Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 22/34 f2fs: port block device access to files
In reply to Christian Brauner--- fs/f2fs/f2fs.h | 2 +- fs/f2fs/super.c | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-)
fs/f2fs/f2fs.h +1 -1
@@ -1239,7 +1239,7 @@ struct f2fs_bio_info {#define FDEV (i) (sbi->devs[i])#define RDEV (i) (raw_super->devs[i])struct f2fs_dev_info { -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;char path[MAX_PATH_LEN ];unsigned int total_segments;
fs/f2fs/super.c +6 -6
@@ -1605,7 +1605,7 @@ static void destroy_device_list(struct f2fs_sb_info *sbi)for (i =0 ; i < sbi->s_ndevs; i++) {if (i >0 ) -bdev_release (FDEV (i).bdev_handle); +fput (FDEV (i).bdev_file);#ifdef CONFIG_BLK_DEV_ZONED kvfree (FDEV (i).blkz_seq);#endif
@@ -4247,7 +4247,7 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)for (i =0 ; i < max_devices; i++) {if (i ==0 ) -FDEV (0 ).bdev_handle =sb_bdev_handle (sbi->sb); +FDEV (0 ).bdev_file = sbi->sb->s_bdev_file;else if (!RDEV (i).path[0 ])break ;
@@ -4267,14 +4267,14 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)FDEV (i).end_blk =FDEV (i).start_blk + (FDEV (i).total_segments << sbi->log_blocks_per_seg) -1 ; -FDEV (i).bdev_handle =bdev_open_by_path ( +FDEV (i).bdev_file =bdev_file_open_by_path (FDEV (i).path, mode, sbi->sb,NULL ); } } -if (IS_ERR (FDEV (i).bdev_handle)) -return PTR_ERR (FDEV (i).bdev_handle); +if (IS_ERR (FDEV (i).bdev_file)) +return PTR_ERR (FDEV (i).bdev_file); -FDEV (i).bdev =FDEV (i).bdev_handle->bdev; +FDEV (i).bdev =file_bdev (FDEV (i).bdev_file);/* to release errored devices */ sbi->s_ndevs = i +1 ;
Signature · 1 line
2.43.0
Re: [PATCH v2 22/34] f2fs: port block device access to files
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 63 lines
--- fs/f2fs/f2fs.h | 2 +- fs/f2fs/super.c | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-)fs/f2fs/f2fs.h +1
-1@@ -1239,7 +1239,7 @@ struct f2fs_bio_info {#define FDEV (i) (sbi->devs[i])#define RDEV (i) (raw_super->devs[i])struct f2fs_dev_info { -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct block_device *bdev;char path[MAX_PATH_LEN ];unsigned int total_segments;fs/f2fs/super.c +6
-6@@ -1605,7 +1605,7 @@ static void destroy_device_list(struct f2fs_sb_info *sbi)for (i =0 ; i < sbi->s_ndevs; i++) {if (i >0 ) -bdev_release (FDEV (i).bdev_handle); +fput (FDEV (i).bdev_file);#ifdef CONFIG_BLK_DEV_ZONED kvfree (FDEV (i).blkz_seq);#endif @@ -4247,7 +4247,7 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)for (i =0 ; i < max_devices; i++) {if (i ==0 ) -FDEV (0 ).bdev_handle =sb_bdev_handle (sbi->sb); +FDEV (0 ).bdev_file = sbi->sb->s_bdev_file;else if (!RDEV (i).path[0 ])break ;@@ -4267,14 +4267,14 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)FDEV (i).end_blk =FDEV (i).start_blk + (FDEV (i).total_segments << sbi->log_blocks_per_seg) -1 ; -FDEV (i).bdev_handle =bdev_open_by_path ( +FDEV (i).bdev_file =bdev_file_open_by_path (FDEV (i).path, mode, sbi->sb,NULL ); } } -if (IS_ERR (FDEV (i).bdev_handle)) -return PTR_ERR (FDEV (i).bdev_handle); +if (IS_ERR (FDEV (i).bdev_file)) +return PTR_ERR (FDEV (i).bdev_file); -FDEV (i).bdev =FDEV (i).bdev_handle->bdev; +FDEV (i).bdev =file_bdev (FDEV (i).bdev_file);/* to release errored devices */ sbi->s_ndevs = i +1 ;Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 23/34 jfs: port block device access to file
In reply to Christian Brauner--- fs/jfs/jfs_logmgr.c | 26 +++++++++++++------------- fs/jfs/jfs_logmgr.h | 2 +- fs/jfs/jfs_mount.c | 2 +- 3 files changed, 15 insertions(+), 15 deletions(-)
fs/jfs/jfs_logmgr.c +13 -13
@@ -1058,7 +1058,7 @@ void jfs_syncpt(struct jfs_log *log, int hard_sync)int lmLogOpen (struct super_block *sb) {int rc; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct jfs_log *log;struct jfs_sb_info *sbi =JFS_SBI (sb);
@@ -1070,7 +1070,7 @@ int lmLogOpen(struct super_block *sb)mutex_lock (&jfs_log_mutex);list_for_each_entry (log, &jfs_external_logs, journal_list) { -if (log->bdev_handle->bdev->bd_dev == sbi->logdev) { +if (file_bdev (log->bdev_file)->bd_dev == sbi->logdev) {if (!uuid_equal (&log->uuid, &sbi->loguuid)) {jfs_warn ("wrong uuid on JFS journal" );mutex_unlock (&jfs_log_mutex);
@@ -1100,14 +1100,14 @@ int lmLogOpen(struct super_block *sb)* file systems to log may have n-to-1 relationship; */ - bdev_handle =bdev_open_by_dev (sbi->logdev, + bdev_file =bdev_file_open_by_dev (sbi->logdev,BLK_OPEN_READ |BLK_OPEN_WRITE , log,NULL ); -if (IS_ERR (bdev_handle)) { - rc =PTR_ERR (bdev_handle); +if (IS_ERR (bdev_file)) { + rc =PTR_ERR (bdev_file); goto free; } - log->bdev_handle = bdev_handle; + log->bdev_file = bdev_file;uuid_copy (&log->uuid, &sbi->loguuid);/*
@@ -1141,7 +1141,7 @@ int lmLogOpen(struct super_block *sb)lbmLogShutdown (log); close:/* close external log device */ -bdev_release (bdev_handle); +fput (bdev_file); free:/* free log descriptor */ mutex_unlock (&jfs_log_mutex);
@@ -1162,7 +1162,7 @@ static int open_inline_log(struct super_block *sb)init_waitqueue_head (&log->syncwait);set_bit (log_INLINELOG, &log->flag); - log->bdev_handle =sb_bdev_handle (sb); + log->bdev_file = sb->s_bdev_file; log->base =addressPXD (&JFS_SBI (sb)->logpxd); log->size =lengthPXD (&JFS_SBI (sb)->logpxd) >> (L2LOGPSIZE - sb->s_blocksize_bits);
@@ -1436,7 +1436,7 @@ int lmLogClose(struct super_block *sb) {struct jfs_sb_info *sbi =JFS_SBI (sb);struct jfs_log *log = sbi->log; -struct bdev_handle *bdev_handle; +struct file *bdev_file;int rc =0 ;jfs_info ("lmLogClose: log:0x%p" , log);
@@ -1482,10 +1482,10 @@ int lmLogClose(struct super_block *sb)* external log as separate logical volume */ list_del (&log->journal_list); - bdev_handle = log->bdev_handle; + bdev_file = log->bdev_file; rc =lmLogShutdown (log); -bdev_release (bdev_handle); +fput (bdev_file);kfree (log);
@@ -1972,7 +1972,7 @@ static int lbmRead(struct jfs_log * log, int pn, struct lbuf ** bpp) bp->l_flag |= lbmREAD; - bio =bio_alloc (log->bdev_handle->bdev,1 ,REQ_OP_READ ,GFP_NOFS ); + bio =bio_alloc (file_bdev (log->bdev_file),1 ,REQ_OP_READ ,GFP_NOFS ); bio->bi_iter.bi_sector = bp->l_blkno << (log->l2bsize -9 );__bio_add_page (bio, bp->l_page,LOGPSIZE , bp->l_offset);BUG_ON (bio->bi_iter.bi_size !=LOGPSIZE );
@@ -2115,7 +2115,7 @@ static void lbmStartIO(struct lbuf * bp)jfs_info ("lbmStartIO" );if (!log->no_integrity) - bdev = log->bdev_handle->bdev; + bdev =file_bdev (log->bdev_file); bio =bio_alloc (bdev,1 ,REQ_OP_WRITE |REQ_SYNC ,GFP_NOFS );
fs/jfs/jfs_logmgr.h +1 -1
@@ -356,7 +356,7 @@ struct jfs_log {* before writing syncpt. */ struct list_head journal_list;/* Global list */ -struct bdev_handle *bdev_handle;/* 4: log lv pointer */ +struct file *bdev_file;/* 4: log lv pointer */ int serial;/* 4: log mount serial number */ s64 base;/* @8: log extent address (inline log ) */
fs/jfs/jfs_mount.c +1 -1
@@ -431,7 +431,7 @@ int updateSuper(struct super_block *sb, uint state)if (state ==FM_MOUNT ) {/* record log's dev_t and mount serial number */ j_sb->s_logdev =cpu_to_le32 ( -new_encode_dev (sbi->log->bdev_handle->bdev->bd_dev)); +new_encode_dev (file_bdev (sbi->log->bdev_file)->bd_dev)); j_sb->s_logserial =cpu_to_le32 (sbi->log->serial); }else if (state ==FM_CLEAN ) {/*
Signature · 1 line
2.43.0
Re: [PATCH v2 23/34] jfs: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 135 lines
--- fs/jfs/jfs_logmgr.c | 26 +++++++++++++------------- fs/jfs/jfs_logmgr.h | 2 +- fs/jfs/jfs_mount.c | 2 +- 3 files changed, 15 insertions(+), 15 deletions(-)fs/jfs/jfs_logmgr.c +13
-13@@ -1058,7 +1058,7 @@ void jfs_syncpt(struct jfs_log *log, int hard_sync)int lmLogOpen (struct super_block *sb) {int rc; -struct bdev_handle *bdev_handle; +struct file *bdev_file;struct jfs_log *log;struct jfs_sb_info *sbi =JFS_SBI (sb);@@ -1070,7 +1070,7 @@ int lmLogOpen(struct super_block *sb)mutex_lock (&jfs_log_mutex);list_for_each_entry (log, &jfs_external_logs, journal_list) { -if (log->bdev_handle->bdev->bd_dev == sbi->logdev) { +if (file_bdev (log->bdev_file)->bd_dev == sbi->logdev) {if (!uuid_equal (&log->uuid, &sbi->loguuid)) {jfs_warn ("wrong uuid on JFS journal" );mutex_unlock (&jfs_log_mutex);@@ -1100,14 +1100,14 @@ int lmLogOpen(struct super_block *sb)* file systems to log may have n-to-1 relationship; */ - bdev_handle =bdev_open_by_dev (sbi->logdev, + bdev_file =bdev_file_open_by_dev (sbi->logdev,BLK_OPEN_READ |BLK_OPEN_WRITE , log,NULL ); -if (IS_ERR (bdev_handle)) { - rc =PTR_ERR (bdev_handle); +if (IS_ERR (bdev_file)) { + rc =PTR_ERR (bdev_file); goto free; } - log->bdev_handle = bdev_handle; + log->bdev_file = bdev_file;uuid_copy (&log->uuid, &sbi->loguuid);/* @@ -1141,7 +1141,7 @@ int lmLogOpen(struct super_block *sb)lbmLogShutdown (log); close:/* close external log device */ -bdev_release (bdev_handle); +fput (bdev_file); free:/* free log descriptor */ mutex_unlock (&jfs_log_mutex);@@ -1162,7 +1162,7 @@ static int open_inline_log(struct super_block *sb)init_waitqueue_head (&log->syncwait);set_bit (log_INLINELOG, &log->flag); - log->bdev_handle =sb_bdev_handle (sb); + log->bdev_file = sb->s_bdev_file; log->base =addressPXD (&JFS_SBI (sb)->logpxd); log->size =lengthPXD (&JFS_SBI (sb)->logpxd) >> (L2LOGPSIZE - sb->s_blocksize_bits);@@ -1436,7 +1436,7 @@ int lmLogClose(struct super_block *sb) {struct jfs_sb_info *sbi =JFS_SBI (sb);struct jfs_log *log = sbi->log; -struct bdev_handle *bdev_handle; +struct file *bdev_file;int rc =0 ;jfs_info ("lmLogClose: log:0x%p" , log);@@ -1482,10 +1482,10 @@ int lmLogClose(struct super_block *sb)* external log as separate logical volume */ list_del (&log->journal_list); - bdev_handle = log->bdev_handle; + bdev_file = log->bdev_file; rc =lmLogShutdown (log); -bdev_release (bdev_handle); +fput (bdev_file);kfree (log);@@ -1972,7 +1972,7 @@ static int lbmRead(struct jfs_log * log, int pn, struct lbuf ** bpp) bp->l_flag |= lbmREAD; - bio =bio_alloc (log->bdev_handle->bdev,1 ,REQ_OP_READ ,GFP_NOFS ); + bio =bio_alloc (file_bdev (log->bdev_file),1 ,REQ_OP_READ ,GFP_NOFS ); bio->bi_iter.bi_sector = bp->l_blkno << (log->l2bsize -9 );__bio_add_page (bio, bp->l_page,LOGPSIZE , bp->l_offset);BUG_ON (bio->bi_iter.bi_size !=LOGPSIZE );@@ -2115,7 +2115,7 @@ static void lbmStartIO(struct lbuf * bp)jfs_info ("lbmStartIO" );if (!log->no_integrity) - bdev = log->bdev_handle->bdev; + bdev =file_bdev (log->bdev_file); bio =bio_alloc (bdev,1 ,REQ_OP_WRITE |REQ_SYNC ,GFP_NOFS );fs/jfs/jfs_logmgr.h +1
-1@@ -356,7 +356,7 @@ struct jfs_log {* before writing syncpt. */ struct list_head journal_list;/* Global list */ -struct bdev_handle *bdev_handle;/* 4: log lv pointer */ +struct file *bdev_file;/* 4: log lv pointer */ int serial;/* 4: log mount serial number */ s64 base;/* @8: log extent address (inline log ) */ fs/jfs/jfs_mount.c +1
-1@@ -431,7 +431,7 @@ int updateSuper(struct super_block *sb, uint state)if (state ==FM_MOUNT ) {/* record log's dev_t and mount serial number */ j_sb->s_logdev =cpu_to_le32 ( -new_encode_dev (sbi->log->bdev_handle->bdev->bd_dev)); +new_encode_dev (file_bdev (sbi->log->bdev_file)->bd_dev)); j_sb->s_logserial =cpu_to_le32 (sbi->log->serial); }else if (state ==FM_CLEAN ) {/* Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 24/34 nfs: port block device access to files
In reply to Christian Brauner--- fs/nfs/blocklayout/blocklayout.h | 2 +- fs/nfs/blocklayout/dev.c | 68 ++++++++++++++++++++-------------------- 2 files changed, 35 insertions(+), 35 deletions(-)
fs/nfs/blocklayout/blocklayout.h +1 -1
@@ -108,7 +108,7 @@ struct pnfs_block_dev {struct pnfs_block_dev *children;u64 chunk_size; -struct bdev_handle *bdev_handle; +struct file *bdev_file;u64 disk_offset;u64 pr_key;
fs/nfs/blocklayout/dev.c +34 -34
157 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH v2 24/34] nfs: port block device access to files
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 192 lines
--- fs/nfs/blocklayout/blocklayout.h | 2 +- fs/nfs/blocklayout/dev.c | 68 ++++++++++++++++++++-------------------- 2 files changed, 35 insertions(+), 35 deletions(-)fs/nfs/blocklayout/blocklayout.h +1
-1@@ -108,7 +108,7 @@ struct pnfs_block_dev {struct pnfs_block_dev *children;u64 chunk_size; -struct bdev_handle *bdev_handle; +struct file *bdev_file;u64 disk_offset;u64 pr_key;fs/nfs/blocklayout/dev.c +34
-34@@ -25,17 +25,17 @@ bl_free_device(struct pnfs_block_dev *dev) }else {if (dev->pr_registered) {const struct pr_ops *ops = - dev->bdev_handle->bdev->bd_disk->fops->pr_ops; +file_bdev (dev->bdev_file)->bd_disk->fops->pr_ops;int error; - error = ops->pr_register (dev->bdev_handle->bdev, + error = ops->pr_register (file_bdev (dev->bdev_file), dev->pr_key,0 , false);if (error)pr_err ("failed to unregister PR key.\n" ); } -if (dev->bdev_handle) -bdev_release (dev->bdev_handle); +if (dev->bdev_file) +fput (dev->bdev_file); } }@@ -169,7 +169,7 @@ static bool bl_map_simple(struct pnfs_block_dev *dev, u64 offset, map->start = dev->start; map->len = dev->len; map->disk_offset = dev->disk_offset; - map->bdev = dev->bdev_handle->bdev; + map->bdev =file_bdev (dev->bdev_file);return true; }@@ -236,26 +236,26 @@ bl_parse_simple(struct nfs_server *server, struct pnfs_block_dev *d, struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask) { struct pnfs_block_volume *v = &volumes[idx]; -struct bdev_handle *bdev_handle; +struct file *bdev_file;dev_t dev; dev =bl_resolve_deviceid (server, v, gfp_mask);if (!dev)return -EIO ; - bdev_handle =bdev_open_by_dev (dev,BLK_OPEN_READ |BLK_OPEN_WRITE , + bdev_file =bdev_file_open_by_dev (dev,BLK_OPEN_READ |BLK_OPEN_WRITE ,NULL ,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {printk (KERN_WARNING "pNFS: failed to open device %d:%d (%ld)\n" , -MAJOR (dev),MINOR (dev),PTR_ERR (bdev_handle)); -return PTR_ERR (bdev_handle); +MAJOR (dev),MINOR (dev),PTR_ERR (bdev_file)); +return PTR_ERR (bdev_file); } - d->bdev_handle = bdev_handle; - d->len =bdev_nr_bytes (bdev_handle->bdev); + d->bdev_file = bdev_file; + d->len =bdev_nr_bytes (file_bdev (bdev_file)); d->map = bl_map_simple;printk (KERN_INFO "pNFS: using block device %s\n" , - bdev_handle->bdev->bd_disk->disk_name); +file_bdev (bdev_file)->bd_disk->disk_name);return 0 ; }@@ -300,10 +300,10 @@ bl_validate_designator(struct pnfs_block_volume *v) } } -static struct bdev_handle * +static struct file *bl_open_path (struct pnfs_block_volume *v,const char *prefix) { -struct bdev_handle *bdev_handle; +struct file *bdev_file;const char *devname; devname = kasprintf(GFP_KERNEL, "/dev/disk/by-id/%s%*phN",@@ -311,15 +311,15 @@ bl_open_path(struct pnfs_block_volume *v, const char *prefix)if (!devname)return ERR_PTR (-ENOMEM ); - bdev_handle =bdev_open_by_path (devname,BLK_OPEN_READ |BLK_OPEN_WRITE , + bdev_file =bdev_file_open_by_path (devname,BLK_OPEN_READ |BLK_OPEN_WRITE ,NULL ,NULL ); -if (IS_ERR (bdev_handle)) { +if (IS_ERR (bdev_file)) {pr_warn ("pNFS: failed to open device %s (%ld)\n" , - devname,PTR_ERR (bdev_handle)); + devname,PTR_ERR (bdev_file)); }kfree (devname); -return bdev_handle; +return bdev_file; } static int@@ -327,7 +327,7 @@ bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d, struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask) { struct pnfs_block_volume *v = &volumes[idx]; -struct bdev_handle *bdev_handle; +struct file *bdev_file;const struct pr_ops *ops;int error;@@ -340,14 +340,14 @@ bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,* On other distributions like Debian, the default SCSI by-id path will * point to the dm-multipath device if one exists. */ - bdev_handle =bl_open_path (v,"dm-uuid-mpath-0x" ); -if (IS_ERR (bdev_handle)) - bdev_handle =bl_open_path (v,"wwn-0x" ); -if (IS_ERR (bdev_handle)) -return PTR_ERR (bdev_handle); - d->bdev_handle = bdev_handle; - - d->len =bdev_nr_bytes (d->bdev_handle->bdev); + bdev_file =bl_open_path (v,"dm-uuid-mpath-0x" ); +if (IS_ERR (bdev_file)) + bdev_file =bl_open_path (v,"wwn-0x" ); +if (IS_ERR (bdev_file)) +return PTR_ERR (bdev_file); + d->bdev_file = bdev_file; + + d->len =bdev_nr_bytes (file_bdev (d->bdev_file)); d->map = bl_map_simple; d->pr_key = v->scsi.pr_key;@@ -355,20 +355,20 @@ bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,return -ENODEV ;pr_info ("pNFS: using block device %s (reservation key 0x%llx)\n" , - d->bdev_handle->bdev->bd_disk->disk_name, d->pr_key); +file_bdev (d->bdev_file)->bd_disk->disk_name, d->pr_key); - ops = d->bdev_handle->bdev->bd_disk->fops->pr_ops; + ops =file_bdev (d->bdev_file)->bd_disk->fops->pr_ops;if (!ops) {pr_err ("pNFS: block device %s does not support reservations." , - d->bdev_handle->bdev->bd_disk->disk_name); +file_bdev (d->bdev_file)->bd_disk->disk_name); error = -EINVAL ; goto out_blkdev_put; } - error = ops->pr_register (d->bdev_handle->bdev,0 , d->pr_key, true); + error = ops->pr_register (file_bdev (d->bdev_file),0 , d->pr_key, true);if (error) {pr_err ("pNFS: failed to register key for block device %s." , - d->bdev_handle->bdev->bd_disk->disk_name); +file_bdev (d->bdev_file)->bd_disk->disk_name); goto out_blkdev_put; }@@ -376,7 +376,7 @@ bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,return 0 ; out_blkdev_put: -bdev_release (d->bdev_handle); +fput (d->bdev_file);return error; }Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 25/34 ocfs2: port block device access to file
In reply to Christian Brauner--- fs/ocfs2/cluster/heartbeat.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-)
fs/ocfs2/cluster/heartbeat.c +16 -16
@@ -213,7 +213,7 @@ struct o2hb_region {unsigned int hr_num_pages;struct page **hr_slot_data; -struct bdev_handle *hr_bdev_handle; +struct file *hr_bdev_file;struct o2hb_disk_slot *hr_slots;/* live node map of this region */
@@ -263,7 +263,7 @@ struct o2hb_region {static inline struct block_device *reg_bdev (struct o2hb_region *reg) { -return reg->hr_bdev_handle ? reg->hr_bdev_handle->bdev :NULL ; +return reg->hr_bdev_file ?file_bdev (reg->hr_bdev_file) :NULL ; }struct o2hb_bio_wait_ctxt {
@@ -1509,8 +1509,8 @@ static void o2hb_region_release(struct config_item *item)kfree (reg->hr_slot_data); } -if (reg->hr_bdev_handle) -bdev_release (reg->hr_bdev_handle); +if (reg->hr_bdev_file) +fput (reg->hr_bdev_file);kfree (reg->hr_slots);
@@ -1569,7 +1569,7 @@ static ssize_t o2hb_region_block_bytes_store(struct config_item *item,unsigned long block_bytes;unsigned int block_bits; -if (reg->hr_bdev_handle) +if (reg->hr_bdev_file)return -EINVAL ; status = o2hb_read_block_input(reg, page, &block_bytes,
@@ -1598,7 +1598,7 @@ static ssize_t o2hb_region_start_block_store(struct config_item *item,char *p = (char *)page;ssize_t ret; -if (reg->hr_bdev_handle) +if (reg->hr_bdev_file)return -EINVAL ; ret =kstrtoull (p,0 , &tmp);
@@ -1623,7 +1623,7 @@ static ssize_t o2hb_region_blocks_store(struct config_item *item,unsigned long tmp;char *p = (char *)page; -if (reg->hr_bdev_handle) +if (reg->hr_bdev_file)return -EINVAL ; tmp =simple_strtoul (p, &p,0 );
@@ -1642,7 +1642,7 @@ static ssize_t o2hb_region_dev_show(struct config_item *item, char *page) {unsigned int ret =0 ; -if (to_o2hb_region (item)->hr_bdev_handle) +if (to_o2hb_region (item)->hr_bdev_file) ret =sprintf (page,"%pg\n" ,reg_bdev (to_o2hb_region (item)));return ret;
@@ -1753,7 +1753,7 @@ static int o2hb_populate_slot_data(struct o2hb_region *reg) }/* -* this is acting as commit; we set up all of hr_bdev_handle and hr_task or +* this is acting as commit; we set up all of hr_bdev_file and hr_task or * nothing */ static ssize_t o2hb_region_dev_store(struct config_item *item,
@@ -1769,7 +1769,7 @@ static ssize_t o2hb_region_dev_store(struct config_item *item,ssize_t ret = -EINVAL ;int live_threshold; -if (reg->hr_bdev_handle) +if (reg->hr_bdev_file) goto out;/* We can't heartbeat without having had our node number
@@ -1795,11 +1795,11 @@ static ssize_t o2hb_region_dev_store(struct config_item *item,if (!S_ISBLK (f.file->f_mapping->host->i_mode)) goto out2; - reg->hr_bdev_handle =bdev_open_by_dev (f.file->f_mapping->host->i_rdev, + reg->hr_bdev_file =bdev_file_open_by_dev (f.file->f_mapping->host->i_rdev,BLK_OPEN_WRITE |BLK_OPEN_READ ,NULL ,NULL ); -if (IS_ERR (reg->hr_bdev_handle)) { - ret =PTR_ERR (reg->hr_bdev_handle); - reg->hr_bdev_handle =NULL ; +if (IS_ERR (reg->hr_bdev_file)) { + ret =PTR_ERR (reg->hr_bdev_file); + reg->hr_bdev_file =NULL ; goto out2; }
@@ -1903,8 +1903,8 @@ static ssize_t o2hb_region_dev_store(struct config_item *item, out3:if (ret <0 ) { -bdev_release (reg->hr_bdev_handle); - reg->hr_bdev_handle =NULL ; +fput (reg->hr_bdev_file); + reg->hr_bdev_file =NULL ; } out2:fdput (f);
Signature · 1 line
2.43.0
Re: [PATCH v2 25/34] ocfs2: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 122 lines
--- fs/ocfs2/cluster/heartbeat.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-)fs/ocfs2/cluster/heartbeat.c +16
-16@@ -213,7 +213,7 @@ struct o2hb_region {unsigned int hr_num_pages;struct page **hr_slot_data; -struct bdev_handle *hr_bdev_handle; +struct file *hr_bdev_file;struct o2hb_disk_slot *hr_slots;/* live node map of this region */ @@ -263,7 +263,7 @@ struct o2hb_region {static inline struct block_device *reg_bdev (struct o2hb_region *reg) { -return reg->hr_bdev_handle ? reg->hr_bdev_handle->bdev :NULL ; +return reg->hr_bdev_file ?file_bdev (reg->hr_bdev_file) :NULL ; }struct o2hb_bio_wait_ctxt {@@ -1509,8 +1509,8 @@ static void o2hb_region_release(struct config_item *item)kfree (reg->hr_slot_data); } -if (reg->hr_bdev_handle) -bdev_release (reg->hr_bdev_handle); +if (reg->hr_bdev_file) +fput (reg->hr_bdev_file);kfree (reg->hr_slots);@@ -1569,7 +1569,7 @@ static ssize_t o2hb_region_block_bytes_store(struct config_item *item,unsigned long block_bytes;unsigned int block_bits; -if (reg->hr_bdev_handle) +if (reg->hr_bdev_file)return -EINVAL ; status = o2hb_read_block_input(reg, page, &block_bytes,@@ -1598,7 +1598,7 @@ static ssize_t o2hb_region_start_block_store(struct config_item *item,char *p = (char *)page;ssize_t ret; -if (reg->hr_bdev_handle) +if (reg->hr_bdev_file)return -EINVAL ; ret =kstrtoull (p,0 , &tmp);@@ -1623,7 +1623,7 @@ static ssize_t o2hb_region_blocks_store(struct config_item *item,unsigned long tmp;char *p = (char *)page; -if (reg->hr_bdev_handle) +if (reg->hr_bdev_file)return -EINVAL ; tmp =simple_strtoul (p, &p,0 );@@ -1642,7 +1642,7 @@ static ssize_t o2hb_region_dev_show(struct config_item *item, char *page) {unsigned int ret =0 ; -if (to_o2hb_region (item)->hr_bdev_handle) +if (to_o2hb_region (item)->hr_bdev_file) ret =sprintf (page,"%pg\n" ,reg_bdev (to_o2hb_region (item)));return ret;@@ -1753,7 +1753,7 @@ static int o2hb_populate_slot_data(struct o2hb_region *reg) }/* -* this is acting as commit; we set up all of hr_bdev_handle and hr_task or +* this is acting as commit; we set up all of hr_bdev_file and hr_task or * nothing */ static ssize_t o2hb_region_dev_store(struct config_item *item,@@ -1769,7 +1769,7 @@ static ssize_t o2hb_region_dev_store(struct config_item *item,ssize_t ret = -EINVAL ;int live_threshold; -if (reg->hr_bdev_handle) +if (reg->hr_bdev_file) goto out;/* We can't heartbeat without having had our node number @@ -1795,11 +1795,11 @@ static ssize_t o2hb_region_dev_store(struct config_item *item,if (!S_ISBLK (f.file->f_mapping->host->i_mode)) goto out2; - reg->hr_bdev_handle =bdev_open_by_dev (f.file->f_mapping->host->i_rdev, + reg->hr_bdev_file =bdev_file_open_by_dev (f.file->f_mapping->host->i_rdev,BLK_OPEN_WRITE |BLK_OPEN_READ ,NULL ,NULL ); -if (IS_ERR (reg->hr_bdev_handle)) { - ret =PTR_ERR (reg->hr_bdev_handle); - reg->hr_bdev_handle =NULL ; +if (IS_ERR (reg->hr_bdev_file)) { + ret =PTR_ERR (reg->hr_bdev_file); + reg->hr_bdev_file =NULL ; goto out2; }@@ -1903,8 +1903,8 @@ static ssize_t o2hb_region_dev_store(struct config_item *item, out3:if (ret <0 ) { -bdev_release (reg->hr_bdev_handle); - reg->hr_bdev_handle =NULL ; +fput (reg->hr_bdev_file); + reg->hr_bdev_file =NULL ; } out2:fdput (f);Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 26/34 reiserfs: port block device access to file
In reply to Christian Brauner--- fs/reiserfs/journal.c | 38 +++++++++++++++++++------------------- fs/reiserfs/procfs.c | 2 +- fs/reiserfs/reiserfs.h | 8 ++++---- 3 files changed, 24 insertions(+), 24 deletions(-)
fs/reiserfs/journal.c +19 -19
@@ -2386,7 +2386,7 @@ static int journal_read(struct super_block *sb) cur_dblock =SB_ONDISK_JOURNAL_1st_BLOCK (sb);reiserfs_info (sb,"checking transaction log (%pg)\n" , - journal->j_bdev_handle->bdev); +file_bdev (journal->j_bdev_file)); start =ktime_get_seconds ();/*
@@ -2447,7 +2447,7 @@ static int journal_read(struct super_block *sb)* device and journal device to be the same */ d_bh = -reiserfs_breada (journal->j_bdev_handle->bdev, cur_dblock, +reiserfs_breada (file_bdev (journal->j_bdev_file), cur_dblock, sb->s_blocksize,SB_ONDISK_JOURNAL_1st_BLOCK (sb) +SB_ONDISK_JOURNAL_SIZE (sb));
@@ -2588,9 +2588,9 @@ static void journal_list_init(struct super_block *sb)static void release_journal_dev (struct reiserfs_journal *journal) { -if (journal->j_bdev_handle) { -bdev_release (journal->j_bdev_handle); - journal->j_bdev_handle =NULL ; +if (journal->j_bdev_file) { +fput (journal->j_bdev_file); + journal->j_bdev_file =NULL ; } }
@@ -2605,7 +2605,7 @@ static int journal_init_dev(struct super_block *super, result =0 ; - journal->j_bdev_handle =NULL ; + journal->j_bdev_file =NULL ; jdev =SB_ONDISK_JOURNAL_DEVICE (super) ?new_decode_dev (SB_ONDISK_JOURNAL_DEVICE (super)) : super->s_dev;
@@ -2616,37 +2616,37 @@ static int journal_init_dev(struct super_block *super,if ((!jdev_name || !jdev_name[0 ])) {if (jdev == super->s_dev) holder =NULL ; - journal->j_bdev_handle =bdev_open_by_dev (jdev, blkdev_mode, + journal->j_bdev_file =bdev_file_open_by_dev (jdev, blkdev_mode, holder,NULL ); -if (IS_ERR (journal->j_bdev_handle)) { - result =PTR_ERR (journal->j_bdev_handle); - journal->j_bdev_handle =NULL ; +if (IS_ERR (journal->j_bdev_file)) { + result =PTR_ERR (journal->j_bdev_file); + journal->j_bdev_file =NULL ;reiserfs_warning (super,"sh-458" ,"cannot init journal device unknown-block(%u,%u): %i" ,MAJOR (jdev),MINOR (jdev), result);return result; }else if (jdev != super->s_dev) -set_blocksize (journal->j_bdev_handle->bdev, +set_blocksize (file_bdev (journal->j_bdev_file), super->s_blocksize);return 0 ; } - journal->j_bdev_handle =bdev_open_by_path (jdev_name, blkdev_mode, + journal->j_bdev_file =bdev_file_open_by_path (jdev_name, blkdev_mode, holder,NULL ); -if (IS_ERR (journal->j_bdev_handle)) { - result =PTR_ERR (journal->j_bdev_handle); - journal->j_bdev_handle =NULL ; +if (IS_ERR (journal->j_bdev_file)) { + result =PTR_ERR (journal->j_bdev_file); + journal->j_bdev_file =NULL ;reiserfs_warning (super,"sh-457" ,"journal_init_dev: Cannot open '%s': %i" , jdev_name, result);return result; } -set_blocksize (journal->j_bdev_handle->bdev, super->s_blocksize); +set_blocksize (file_bdev (journal->j_bdev_file), super->s_blocksize);reiserfs_info (super,"journal_init_dev: journal device: %pg\n" , - journal->j_bdev_handle->bdev); +file_bdev (journal->j_bdev_file));return 0 ; }
@@ -2804,7 +2804,7 @@ int journal_init(struct super_block *sb, const char *j_dev_name,"journal header magic %x (device %pg) does " "not match to magic found in super block %x" , jh->jh_journal.jp_journal_magic, - journal->j_bdev_handle->bdev, +file_bdev (journal->j_bdev_file), sb_jp_journal_magic(rs));brelse (bhjh); goto free_and_return;
@@ -2828,7 +2828,7 @@ int journal_init(struct super_block *sb, const char *j_dev_name, reiserfs_info(sb, "journal params: device %pg, size %u, " "journal first block %u, max trans len %u, max batch %u, " "max commit age %u, max trans age %u\n", - journal->j_bdev_handle->bdev, + file_bdev(journal->j_bdev_file), SB_ONDISK_JOURNAL_SIZE(sb), SB_ONDISK_JOURNAL_1st_BLOCK(sb), journal->j_trans_max,
fs/reiserfs/procfs.c +1 -1
@@ -354,7 +354,7 @@ static int show_journal(struct seq_file *m, void *unused)"prepare: \t%12lu\n" "prepare_retry: \t%12lu\n" ,DJP (jp_journal_1st_block), -SB_JOURNAL (sb)->j_bdev_handle->bdev, +file_bdev (SB_JOURNAL (sb)->j_bdev_file),DJP (jp_journal_dev),DJP (jp_journal_size), DJP(jp_journal_trans_max),
fs/reiserfs/reiserfs.h +4 -4
@@ -299,7 +299,7 @@ struct reiserfs_journal {/* oldest journal block. start here for traverse */ struct reiserfs_journal_cnode *j_first; -struct bdev_handle *j_bdev_handle; +struct file *j_bdev_file;/* first block on s_dev of reserved area journal */ int j_1st_reserved_block;
@@ -2810,10 +2810,10 @@ struct reiserfs_journal_header {/* We need these to make journal.c code more readable */ #define journal_find_get_block (s, block) __find_get_block(\ - SB_JOURNAL(s)->j_bdev_handle->bdev, block, s->s_blocksize) -#define journal_getblk (s, block) __getblk(SB_JOURNAL(s)->j_bdev_handle->bdev,\ + file_bdev(SB_JOURNAL(s)->j_bdev_file), block, s->s_blocksize) +#define journal_getblk (s, block) __getblk(file_bdev(SB_JOURNAL(s)->j_bdev_file),\ block, s->s_blocksize) -#define journal_bread (s, block) __bread(SB_JOURNAL(s)->j_bdev_handle->bdev,\ +#define journal_bread (s, block) __bread(file_bdev(SB_JOURNAL(s)->j_bdev_file),\ block, s->s_blocksize)enum reiserfs_bh_state_bits {
Signature · 1 line
2.43.0
Re: [PATCH v2 26/34] reiserfs: port block device access to file
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 161 lines
--- fs/reiserfs/journal.c | 38 +++++++++++++++++++------------------- fs/reiserfs/procfs.c | 2 +- fs/reiserfs/reiserfs.h | 8 ++++---- 3 files changed, 24 insertions(+), 24 deletions(-)fs/reiserfs/journal.c +19
-19@@ -2386,7 +2386,7 @@ static int journal_read(struct super_block *sb) cur_dblock =SB_ONDISK_JOURNAL_1st_BLOCK (sb);reiserfs_info (sb,"checking transaction log (%pg)\n" , - journal->j_bdev_handle->bdev); +file_bdev (journal->j_bdev_file)); start =ktime_get_seconds ();/* @@ -2447,7 +2447,7 @@ static int journal_read(struct super_block *sb)* device and journal device to be the same */ d_bh = -reiserfs_breada (journal->j_bdev_handle->bdev, cur_dblock, +reiserfs_breada (file_bdev (journal->j_bdev_file), cur_dblock, sb->s_blocksize,SB_ONDISK_JOURNAL_1st_BLOCK (sb) +SB_ONDISK_JOURNAL_SIZE (sb));@@ -2588,9 +2588,9 @@ static void journal_list_init(struct super_block *sb)static void release_journal_dev (struct reiserfs_journal *journal) { -if (journal->j_bdev_handle) { -bdev_release (journal->j_bdev_handle); - journal->j_bdev_handle =NULL ; +if (journal->j_bdev_file) { +fput (journal->j_bdev_file); + journal->j_bdev_file =NULL ; } }@@ -2605,7 +2605,7 @@ static int journal_init_dev(struct super_block *super, result =0 ; - journal->j_bdev_handle =NULL ; + journal->j_bdev_file =NULL ; jdev =SB_ONDISK_JOURNAL_DEVICE (super) ?new_decode_dev (SB_ONDISK_JOURNAL_DEVICE (super)) : super->s_dev;@@ -2616,37 +2616,37 @@ static int journal_init_dev(struct super_block *super,if ((!jdev_name || !jdev_name[0 ])) {if (jdev == super->s_dev) holder =NULL ; - journal->j_bdev_handle =bdev_open_by_dev (jdev, blkdev_mode, + journal->j_bdev_file =bdev_file_open_by_dev (jdev, blkdev_mode, holder,NULL ); -if (IS_ERR (journal->j_bdev_handle)) { - result =PTR_ERR (journal->j_bdev_handle); - journal->j_bdev_handle =NULL ; +if (IS_ERR (journal->j_bdev_file)) { + result =PTR_ERR (journal->j_bdev_file); + journal->j_bdev_file =NULL ;reiserfs_warning (super,"sh-458" ,"cannot init journal device unknown-block(%u,%u): %i" ,MAJOR (jdev),MINOR (jdev), result);return result; }else if (jdev != super->s_dev) -set_blocksize (journal->j_bdev_handle->bdev, +set_blocksize (file_bdev (journal->j_bdev_file), super->s_blocksize);return 0 ; } - journal->j_bdev_handle =bdev_open_by_path (jdev_name, blkdev_mode, + journal->j_bdev_file =bdev_file_open_by_path (jdev_name, blkdev_mode, holder,NULL ); -if (IS_ERR (journal->j_bdev_handle)) { - result =PTR_ERR (journal->j_bdev_handle); - journal->j_bdev_handle =NULL ; +if (IS_ERR (journal->j_bdev_file)) { + result =PTR_ERR (journal->j_bdev_file); + journal->j_bdev_file =NULL ;reiserfs_warning (super,"sh-457" ,"journal_init_dev: Cannot open '%s': %i" , jdev_name, result);return result; } -set_blocksize (journal->j_bdev_handle->bdev, super->s_blocksize); +set_blocksize (file_bdev (journal->j_bdev_file), super->s_blocksize);reiserfs_info (super,"journal_init_dev: journal device: %pg\n" , - journal->j_bdev_handle->bdev); +file_bdev (journal->j_bdev_file));return 0 ; }@@ -2804,7 +2804,7 @@ int journal_init(struct super_block *sb, const char *j_dev_name,"journal header magic %x (device %pg) does " "not match to magic found in super block %x" , jh->jh_journal.jp_journal_magic, - journal->j_bdev_handle->bdev, +file_bdev (journal->j_bdev_file), sb_jp_journal_magic(rs));brelse (bhjh); goto free_and_return;@@ -2828,7 +2828,7 @@ int journal_init(struct super_block *sb, const char *j_dev_name, reiserfs_info(sb, "journal params: device %pg, size %u, " "journal first block %u, max trans len %u, max batch %u, " "max commit age %u, max trans age %u\n", - journal->j_bdev_handle->bdev, + file_bdev(journal->j_bdev_file), SB_ONDISK_JOURNAL_SIZE(sb), SB_ONDISK_JOURNAL_1st_BLOCK(sb), journal->j_trans_max,fs/reiserfs/procfs.c +1
-1@@ -354,7 +354,7 @@ static int show_journal(struct seq_file *m, void *unused)"prepare: \t%12lu\n" "prepare_retry: \t%12lu\n" ,DJP (jp_journal_1st_block), -SB_JOURNAL (sb)->j_bdev_handle->bdev, +file_bdev (SB_JOURNAL (sb)->j_bdev_file),DJP (jp_journal_dev),DJP (jp_journal_size), DJP(jp_journal_trans_max),fs/reiserfs/reiserfs.h +4
-4@@ -299,7 +299,7 @@ struct reiserfs_journal {/* oldest journal block. start here for traverse */ struct reiserfs_journal_cnode *j_first; -struct bdev_handle *j_bdev_handle; +struct file *j_bdev_file;/* first block on s_dev of reserved area journal */ int j_1st_reserved_block;@@ -2810,10 +2810,10 @@ struct reiserfs_journal_header {/* We need these to make journal.c code more readable */ #define journal_find_get_block (s, block) __find_get_block(\ - SB_JOURNAL(s)->j_bdev_handle->bdev, block, s->s_blocksize) -#define journal_getblk (s, block) __getblk(SB_JOURNAL(s)->j_bdev_handle->bdev,\ + file_bdev(SB_JOURNAL(s)->j_bdev_file), block, s->s_blocksize) +#define journal_getblk (s, block) __getblk(file_bdev(SB_JOURNAL(s)->j_bdev_file),\ block, s->s_blocksize) -#define journal_bread (s, block) __bread(SB_JOURNAL(s)->j_bdev_handle->bdev,\ +#define journal_bread (s, block) __bread(file_bdev(SB_JOURNAL(s)->j_bdev_file),\ block, s->s_blocksize)enum reiserfs_bh_state_bits {Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 27/34 bdev: remove bdev_open_by_path()
In reply to Christian Brauner--- block/bdev.c | 40 ---------------------------------------- include/linux/blkdev.h | 2 -- 2 files changed, 42 deletions(-)
block/bdev.c +0 -40
@@ -1007,46 +1007,6 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode, }EXPORT_SYMBOL (bdev_file_open_by_path); -/** -* bdev_open_by_path - open a block device by name -* @path: path to the block device to open -* @mode: open mode (BLK_OPEN_*) -* @holder: exclusive holder identifier -* @hops: holder operations -* -* Open the block device described by the device file at @path. If @holder is -* not %NULL, the block device is opened with exclusive access. Exclusive opens -* may nest for the same @holder. -* -* CONTEXT: -* Might sleep. -* -* RETURNS: -* Handle with a reference to the block_device on success, ERR_PTR(-errno) on -* failure. -*/ -struct bdev_handle *bdev_open_by_path (const char *path,blk_mode_t mode, -void *holder,const struct blk_holder_ops *hops) -{ -struct bdev_handle *handle; -dev_t dev; -int error; - - error =lookup_bdev (path, &dev); -if (error) -return ERR_PTR (error); - - handle =bdev_open_by_dev (dev, mode, holder, hops); -if (!IS_ERR (handle) && (mode &BLK_OPEN_WRITE ) && -bdev_read_only (handle->bdev)) { -bdev_release (handle); -return ERR_PTR (-EACCES ); - } - -return handle; -} -EXPORT_SYMBOL (bdev_open_by_path); -void bdev_release (struct bdev_handle *handle) {struct block_device *bdev = handle->bdev;
include/linux/blkdev.h +0 -2
@@ -1484,8 +1484,6 @@ struct bdev_handle {struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops); -struct bdev_handle *bdev_open_by_path (const char *path,blk_mode_t mode, -void *holder,const struct blk_holder_ops *hops);struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops); struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,
Signature · 1 line
2.43.0
Re: [PATCH v2 27/34] bdev: remove bdev_open_by_path()
Looks good:
Re: [PATCH v2 27/34] bdev: remove bdev_open_by_path()
In reply to Christian BraunerQuoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Sure. Feel free to add:
Honza
Quoted 73 lines
--- block/bdev.c | 40 ---------------------------------------- include/linux/blkdev.h | 2 -- 2 files changed, 42 deletions(-)block/bdev.c +0
-40@@ -1007,46 +1007,6 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode, }EXPORT_SYMBOL (bdev_file_open_by_path); -/** -* bdev_open_by_path - open a block device by name -* @path: path to the block device to open -* @mode: open mode (BLK_OPEN_*) -* @holder: exclusive holder identifier -* @hops: holder operations -* -* Open the block device described by the device file at @path. If @holder is -* not %NULL, the block device is opened with exclusive access. Exclusive opens -* may nest for the same @holder. -* -* CONTEXT: -* Might sleep. -* -* RETURNS: -* Handle with a reference to the block_device on success, ERR_PTR(-errno) on -* failure. -*/ -struct bdev_handle *bdev_open_by_path (const char *path,blk_mode_t mode, -void *holder,const struct blk_holder_ops *hops) -{ -struct bdev_handle *handle; -dev_t dev; -int error; - - error =lookup_bdev (path, &dev); -if (error) -return ERR_PTR (error); - - handle =bdev_open_by_dev (dev, mode, holder, hops); -if (!IS_ERR (handle) && (mode &BLK_OPEN_WRITE ) && -bdev_read_only (handle->bdev)) { -bdev_release (handle); -return ERR_PTR (-EACCES ); - } - -return handle; -} -EXPORT_SYMBOL (bdev_open_by_path); -void bdev_release (struct bdev_handle *handle) {struct block_device *bdev = handle->bdev;include/linux/blkdev.h +0
-2@@ -1484,8 +1484,6 @@ struct bdev_handle {struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops); -struct bdev_handle *bdev_open_by_path (const char *path,blk_mode_t mode, -void *holder,const struct blk_holder_ops *hops);struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops); struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 28/34 bdev: make bdev_release() private to block layer
In reply to Christian Braunerand move both of them to the private block header. There's no caller in the tree anymore that uses them directly.
--- block/bdev.c | 2 -- block/blk.h | 4 ++++ include/linux/blkdev.h | 3 --- 3 files changed, 4 insertions(+), 5 deletions(-)
block/bdev.c +0 -2
@@ -916,7 +916,6 @@ struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,kfree (handle);return ERR_PTR (ret); } -EXPORT_SYMBOL (bdev_open_by_dev);static unsigned blk_to_file_flags (blk_mode_t mode) {
@@ -1045,7 +1044,6 @@ void bdev_release(struct bdev_handle *handle)blkdev_put_no_open (bdev);kfree (handle); } -EXPORT_SYMBOL (bdev_release);/** * lookup_bdev() - Look up a struct block_device by name.
block/blk.h +4 -0
@@ -516,4 +516,8 @@ static inline int req_ref_read(struct request *req) return atomic_read(&req->ref); } +void bdev_release (struct bdev_handle *handle); +struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, +const struct blk_holder_ops *hops); +#endif /* BLK_INTERNAL_H */
include/linux/blkdev.h +0 -3
@@ -1482,8 +1482,6 @@ struct bdev_handle {blk_mode_t mode; }; -struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, -const struct blk_holder_ops *hops);struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops); struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,
@@ -1491,7 +1489,6 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,int bd_prepare_to_claim (struct block_device *bdev,void *holder,const struct blk_holder_ops *hops);void bd_abort_claiming (struct block_device *bdev,void *holder); -void bdev_release (struct bdev_handle *handle);/* just for blk-cgroup, don't use elsewhere */ struct block_device *blkdev_get_no_open (dev_t dev);
Signature · 1 line
2.43.0
Re: [PATCH v2 28/34] bdev: make bdev_release() private to block layer
Quoted 2 lines · Christian Brauner
and move both of them to the private block header. There's no caller in the tree anymore that uses them directly.
the subject only takes about a single helper, but then the commit message mentions "both". Seems like the subject is missing a "bdev_open_by_dev and".
Otherwise looks good:
Christian Brauner
maintainerRe: [PATCH v2 28/34] bdev: make bdev_release() private to block layer
Quoted 7 lines · Christoph Hellwig
Quoted 2 lines · Christian Brauner
and move both of them to the private block header. There's no caller in the tree anymore that uses them directly.
the subject only takes about a single helper, but then the commit message mentions "both". Seems like the subject is missing a "
bdev_open_by_devand".
Quoted 7 lines · Jan Kara
Quoted 4 lines · Christian Brauner
and move both of them to the private block header. There's no caller in the tree anymore that uses them directly.
Signed-off-by Christian Brauner <[email protected]>As Christoph noticed, the changelog needs a bit of work but otherwise feel
Fixed, thanks!
Re: [PATCH v2 28/34] bdev: make bdev_release() private to block layer
In reply to Christian BraunerQuoted 4 lines · Christian Brauner
and move both of them to the private block header. There's no caller in the tree anymore that uses them directly.
Signed-off-by Christian Brauner <[email protected]>
As Christoph noticed, the changelog needs a bit of work but otherwise feel free to add:
Honza
Quoted 64 lines
--- block/bdev.c | 2 -- block/blk.h | 4 ++++ include/linux/blkdev.h | 3 --- 3 files changed, 4 insertions(+), 5 deletions(-)block/bdev.c +0
-2@@ -916,7 +916,6 @@ struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,kfree (handle);return ERR_PTR (ret); } -EXPORT_SYMBOL (bdev_open_by_dev);static unsigned blk_to_file_flags (blk_mode_t mode) {@@ -1045,7 +1044,6 @@ void bdev_release(struct bdev_handle *handle)blkdev_put_no_open (bdev);kfree (handle); } -EXPORT_SYMBOL (bdev_release);/** * lookup_bdev() - Look up a struct block_device by name. block/blk.h +4
-0@@ -516,4 +516,8 @@ static inline int req_ref_read(struct request *req) return atomic_read(&req->ref); } +void bdev_release (struct bdev_handle *handle); +struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, +const struct blk_holder_ops *hops); +#endif /* BLK_INTERNAL_H */ include/linux/blkdev.h +0
-3@@ -1482,8 +1482,6 @@ struct bdev_handle {blk_mode_t mode; }; -struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, -const struct blk_holder_ops *hops);struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops); struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,@@ -1491,7 +1489,6 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,int bd_prepare_to_claim (struct block_device *bdev,void *holder,const struct blk_holder_ops *hops);void bd_abort_claiming (struct block_device *bdev,void *holder); -void bdev_release (struct bdev_handle *handle);/* just for blk-cgroup, don't use elsewhere */ struct block_device *blkdev_get_no_open (dev_t dev);Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 29/34 bdev: make struct bdev_handle private to the block layer
In reply to Christian Brauner--- block/bdev.c | 125 +++++++++++++++++++++++++++---------------------- block/blk.h | 12 +++-- block/fops.c | 34 ++++++-------- include/linux/blkdev.h | 7 --- include/linux/fs.h | 6 --- 5 files changed, 92 insertions(+), 92 deletions(-)
block/bdev.c +69 -56
@@ -703,6 +703,24 @@ static int blkdev_get_part(struct block_device *part, blk_mode_t mode)return ret; } +int bdev_permission (dev_t dev,blk_mode_t mode,void *holder) +{ +int ret; + + ret =devcgroup_check_permission ( +DEVCG_DEV_BLOCK ,MAJOR (dev),MINOR (dev), + ((mode &BLK_OPEN_READ ) ?DEVCG_ACC_READ :0 ) | + ((mode &BLK_OPEN_WRITE ) ?DEVCG_ACC_WRITE :0 )); +if (ret) +return ret; + +/* Blocking writes requires exclusive opener */ +if (mode &BLK_OPEN_RESTRICT_WRITES && !holder) +return -EINVAL ; + +return 0 ; +} +static void blkdev_put_part (struct block_device *part) {struct block_device *whole =bdev_whole (part);
@@ -795,15 +813,15 @@ static void bdev_yield_write_access(struct block_device *bdev, blk_mode_t mode) }/** -* bdev_open_by_dev - open a block device by device number -* @dev: device number of block device to open +* bdev_open - open a block device +* @bdev: block device to open * @mode: open mode (BLK_OPEN_*) * @holder: exclusive holder identifier * @hops: holder operations +* @bdev_file: file for the block device * -* Open the block device described by device number @dev. If @holder is not -* %NULL, the block device is opened with exclusive access. Exclusive opens may -* nest for the same @holder. +* Open the block device. If @holder is not %NULL, the block device is opened +* with exclusive access. Exclusive opens may nest for the same @holder. * * Use this interface ONLY if you really do not have anything better - i.e. when * you are behind a truly sucky interface and all you are given is a device
@@ -813,52 +831,29 @@ static void bdev_yield_write_access(struct block_device *bdev, blk_mode_t mode)* Might sleep. * * RETURNS: -* Handle with a reference to the block_device on success, ERR_PTR(-errno) on -* failure. +* zero on success, -errno on failure. */ -struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, -const struct blk_holder_ops *hops) +int bdev_open (struct block_device *bdev,blk_mode_t mode,void *holder, +const struct blk_holder_ops *hops,struct file *bdev_file) {struct bdev_handle *handle =kmalloc (sizeof (struct bdev_handle ),GFP_KERNEL ); -struct block_device *bdev;bool unblock_events = true; -struct gendisk *disk; +struct gendisk *disk = bdev->bd_disk;int ret; + handle =kmalloc (sizeof (struct bdev_handle ),GFP_KERNEL );if (!handle) -return ERR_PTR (-ENOMEM ); - - ret =devcgroup_check_permission (DEVCG_DEV_BLOCK , -MAJOR (dev),MINOR (dev), - ((mode &BLK_OPEN_READ ) ?DEVCG_ACC_READ :0 ) | - ((mode &BLK_OPEN_WRITE ) ?DEVCG_ACC_WRITE :0 )); -if (ret) - goto free_handle; - -/* Blocking writes requires exclusive opener */ -if (mode &BLK_OPEN_RESTRICT_WRITES && !holder) { - ret = -EINVAL ; - goto free_handle; - } - - bdev =blkdev_get_no_open (dev); -if (!bdev) { - ret = -ENXIO ; - goto free_handle; - } - disk = bdev->bd_disk; +return -ENOMEM ;if (holder) { mode |=BLK_OPEN_EXCL ; ret =bd_prepare_to_claim (bdev, holder, hops);if (ret) - goto put_blkdev; +return ret; }else { -if (WARN_ON_ONCE (mode &BLK_OPEN_EXCL )) { - ret = -EIO ; - goto put_blkdev; - } +if (WARN_ON_ONCE (mode &BLK_OPEN_EXCL )) +return -EIO ; }disk_block_events (disk);
@@ -902,7 +897,22 @@ struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, handle->bdev = bdev; handle->holder = holder; handle->mode = mode; -return handle; + +/* +* Preserve backwards compatibility and allow large file access +* even if userspace doesn't ask for it explicitly. Some mkfs +* binary needs it. We might want to drop this workaround +* during an unstable branch. +*/ + bdev_file->f_flags |=O_LARGEFILE ; + bdev_file->f_mode |=FMODE_BUF_RASYNC |FMODE_CAN_ODIRECT ; +if (bdev_nowait (bdev)) + bdev_file->f_mode |=FMODE_NOWAIT ; + bdev_file->f_mapping = handle->bdev->bd_inode->i_mapping; + bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); + bdev_file->private_data = handle; + +return 0 ; put_module:module_put (disk->fops->owner); abort_claiming:
@@ -910,11 +920,8 @@ struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,bd_abort_claiming (bdev, holder);mutex_unlock (&disk->open_mutex);disk_unblock_events (disk); -put_blkdev: -blkdev_put_no_open (bdev); -free_handle:kfree (handle); -return ERR_PTR (ret); +return ret; }static unsigned blk_to_file_flags (blk_mode_t mode)
@@ -954,29 +961,35 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, const struct blk_holder_ops *hops) {struct file *bdev_file; -struct bdev_handle *handle; +struct block_device *bdev;unsigned int flags; +int ret; - handle =bdev_open_by_dev (dev, mode, holder, hops); -if (IS_ERR (handle)) -return ERR_CAST (handle); + ret =bdev_permission (dev,0 , holder); +if (ret) +return ERR_PTR (ret); + + bdev =blkdev_get_no_open (dev); +if (!bdev) +return ERR_PTR (-ENXIO ); flags =blk_to_file_flags (mode); - bdev_file =alloc_file_pseudo_noaccount (handle->bdev->bd_inode, + bdev_file =alloc_file_pseudo_noaccount (bdev->bd_inode, blockdev_mnt,"" , flags |O_LARGEFILE , &def_blk_fops);if (IS_ERR (bdev_file)) { -bdev_release (handle); +blkdev_put_no_open (bdev);return bdev_file; } -ihold (handle->bdev->bd_inode); + bdev_file->f_mode &= ~FMODE_OPENED ; - bdev_file->f_mode |=FMODE_BUF_RASYNC |FMODE_CAN_ODIRECT ; -if (bdev_nowait (handle->bdev)) - bdev_file->f_mode |=FMODE_NOWAIT ; - - bdev_file->f_mapping = handle->bdev->bd_inode->i_mapping; - bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); - bdev_file->private_data = handle; +ihold (bdev->bd_inode); + ret =bdev_open (bdev, mode, holder, hops, bdev_file); +if (ret) { +fput (bdev_file); +return ERR_PTR (ret); + } +/* Now that thing is opened. */ + bdev_file->f_mode |=FMODE_OPENED ;return bdev_file; }EXPORT_SYMBOL (bdev_file_open_by_dev);
block/blk.h +9 -3
@@ -25,6 +25,12 @@ struct blk_flush_queue {struct request *flush_rq; }; +struct bdev_handle { +struct block_device *bdev; +void *holder; +blk_mode_t mode; +}; +bool is_flush_rq (struct request *req); struct blk_flush_queue *blk_alloc_flush_queue(int node, int cmd_size,
@@ -517,7 +523,7 @@ static inline int req_ref_read(struct request *req) }void bdev_release (struct bdev_handle *handle); -struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, -const struct blk_holder_ops *hops); - +int bdev_open (struct block_device *bdev,blk_mode_t mode,void *holder, +const struct blk_holder_ops *hops,struct file *bdev_file); +int bdev_permission (dev_t dev,blk_mode_t mode,void *holder);#endif /* BLK_INTERNAL_H */
block/fops.c +14 -20
@@ -599,31 +599,25 @@ blk_mode_t file_to_blk_mode(struct file *file)static int blkdev_open (struct inode *inode,struct file *filp) { -struct bdev_handle *handle; +struct block_device *bdev;blk_mode_t mode; - -/* -* Preserve backwards compatibility and allow large file access -* even if userspace doesn't ask for it explicitly. Some mkfs -* binary needs it. We might want to drop this workaround -* during an unstable branch. -*/ - filp->f_flags |=O_LARGEFILE ; - filp->f_mode |=FMODE_BUF_RASYNC |FMODE_CAN_ODIRECT ; +void *holder; +int ret; mode =file_to_blk_mode (filp); - handle =bdev_open_by_dev (inode->i_rdev, mode, - mode &BLK_OPEN_EXCL ? filp :NULL ,NULL ); -if (IS_ERR (handle)) -return PTR_ERR (handle); + holder = mode &BLK_OPEN_EXCL ? filp :NULL ; + ret =bdev_permission (inode->i_rdev, mode, holder); +if (ret) +return ret; -if (bdev_nowait (handle->bdev)) - filp->f_mode |=FMODE_NOWAIT ; + bdev =blkdev_get_no_open (inode->i_rdev); +if (!bdev) +return -ENXIO ; - filp->f_mapping = handle->bdev->bd_inode->i_mapping; - filp->f_wb_err =filemap_sample_wb_err (filp->f_mapping); - filp->private_data = handle; -return 0 ; + ret =bdev_open (bdev, mode, holder,NULL , filp); +if (ret) +blkdev_put_no_open (bdev); +return ret; }static int blkdev_release (struct inode *inode,struct file *filp)
include/linux/blkdev.h +0 -7
@@ -1475,13 +1475,6 @@ extern const struct blk_holder_ops fs_holder_ops; (BLK_OPEN_READ |BLK_OPEN_RESTRICT_WRITES | \ (((flags) & SB_RDONLY) ? 0 : BLK_OPEN_WRITE)) -/* @bdev_handle will be removed soon. */ -struct bdev_handle { -struct block_device *bdev; -void *holder; -blk_mode_t mode; -}; -struct file *bdev_file_open_by_dev (dev_t dev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops); struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,
include/linux/fs.h +0 -6
@@ -1327,12 +1327,6 @@ struct super_block {struct list_head s_inodes_wb;/* writeback inodes */ } __randomize_layout; -/* Temporary helper that will go away. */ -static inline struct bdev_handle *sb_bdev_handle (struct super_block *sb) -{ -return sb->s_bdev_file->private_data; -} -static inline struct user_namespace *i_user_ns (const struct inode *inode) {return inode->i_sb->s_user_ns;
Signature · 1 line
2.43.0
Re: [PATCH v2 29/34] bdev: make struct bdev_handle private to the block layer
block/bdev.c static int blkdev_get_part(struct block_device *part, blk_mode_t mode) · line 713
Quoted 4 lines
block/bdev.c +4
-0+ ret =devcgroup_check_permission ( +DEVCG_DEV_BLOCK ,MAJOR (dev),MINOR (dev), + ((mode &BLK_OPEN_READ ) ?DEVCG_ACC_READ :0 ) | + ((mode &BLK_OPEN_WRITE ) ?DEVCG_ACC_WRITE :0 ));
Somewhat weird formatting here with DEVCG_DEV_BLOCK not on the same line as the opening brace and the extra indentation after the |. I would have expected something like:
ret = devcgroup_check_permission(DEVCG_DEV_BLOCK, MAJOR(dev), MINOR(dev), ((mode & BLK_OPEN_READ) ? DEVCG_ACC_READ : 0) | ((mode & BLK_OPEN_WRITE) ? DEVCG_ACC_WRITE : 0));
Otherwise looks good:
Christian Brauner
maintainerRe: [PATCH v2 29/34] bdev: make struct bdev_handle private to the block layer
Quoted 9 lines · Christoph Hellwig
block/bdev.c static int blkdev_get_part(struct block_device *part, blk_mode_t mode) · line 713
Quoted 4 lines
block/bdev.c +4
-0+ ret =devcgroup_check_permission ( +DEVCG_DEV_BLOCK ,MAJOR (dev),MINOR (dev), + ((mode &BLK_OPEN_READ ) ?DEVCG_ACC_READ :0 ) | + ((mode &BLK_OPEN_WRITE ) ?DEVCG_ACC_WRITE :0 ));Somewhat weird formatting here with
DEVCG_DEV_BLOCKnot on the same line as the opening brace and the extra indentation after the |. I would have expected something like:
Quoted 4 lines
ret = devcgroup_check_permission(DEVCG_DEV_BLOCK, MAJOR(dev), MINOR(dev), ((mode & BLK_OPEN_READ) ? DEVCG_ACC_READ : 0) | ((mode & BLK_OPEN_WRITE) ? DEVCG_ACC_WRITE : 0));
Fixed. (Fwiw, this is due to clang-format.)
Jan Kara
reviewerRe: [PATCH v2 29/34] bdev: make struct bdev_handle private to the block layer
In reply to Christian BraunerQuoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
Some comments below...
Quoted 11 lines
block/bdev.c +2
-2@@ -795,15 +813,15 @@ static void bdev_yield_write_access(struct block_device *bdev, blk_mode_t mode) }/** -* bdev_open_by_dev - open a block device by device number -* @dev: device number of block device to open +* bdev_open - open a block device +* @bdev: block device to open * @mode: open mode (BLK_OPEN_*) * @holder: exclusive holder identifier * @hops: holder operations
block/bdev.c static void bdev_yield_write_access(struct block_device *bdev, blk_mode_t mode) · line 827
Quoted 10 lines
block/bdev.c +3
-3+* @bdev_file: file for the block device * -* Open the block device described by device number @dev. If @holder is not -* %NULL, the block device is opened with exclusive access. Exclusive opens may -* nest for the same @holder. +* Open the block device. If @holder is not %NULL, the block device is opened +* with exclusive access. Exclusive opens may nest for the same @holder. * * Use this interface ONLY if you really do not have anything better - i.e. when * you are behind a truly sucky interface and all you are given is a device
^^^
I guess this part of comment is stale now?
block/bdev.c struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 906
Quoted 12 lines
block/bdev.c +7
-1@@ -902,7 +897,22 @@ struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, handle->bdev = bdev; handle->holder = holder; handle->mode = mode; -return handle; + +/* +* Preserve backwards compatibility and allow large file access +* even if userspace doesn't ask for it explicitly. Some mkfs +* binary needs it. We might want to drop this workaround +* during an unstable branch. +*/
Heh, I think the sentense "We might want to drop this workaround during an unstable branch." does not need to be moved as well :)
Quoted 28 lines
block/bdev.c +10
-4+ bdev_file->f_flags |=O_LARGEFILE ; + bdev_file->f_mode |=FMODE_BUF_RASYNC |FMODE_CAN_ODIRECT ; +if (bdev_nowait (bdev)) + bdev_file->f_mode |=FMODE_NOWAIT ; + bdev_file->f_mapping = handle->bdev->bd_inode->i_mapping; + bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); + bdev_file->private_data = handle; + +return 0 ; put_module:module_put (disk->fops->owner); abort_claiming:@@ -910,11 +920,8 @@ struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,bd_abort_claiming (bdev, holder);mutex_unlock (&disk->open_mutex);disk_unblock_events (disk); -put_blkdev: -blkdev_put_no_open (bdev); -free_handle:kfree (handle); -return ERR_PTR (ret); +return ret; }static unsigned blk_to_file_flags (blk_mode_t mode)@@ -954,29 +961,35 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, const struct blk_holder_ops *hops) {
block/bdev.c struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 968
Quoted 10 lines
block/bdev.c +3
-4struct file *bdev_file; -struct bdev_handle *handle; +struct block_device *bdev;unsigned int flags; +int ret; - handle =bdev_open_by_dev (dev, mode, holder, hops); -if (IS_ERR (handle)) -return ERR_CAST (handle); + ret =bdev_permission (dev,0 , holder);
^^ Maybe I'm missing something but why
do you pass 0 mode here?
Quoted 8 lines
block/bdev.c +6
-0+if (ret) +return ERR_PTR (ret); + + bdev =blkdev_get_no_open (dev); +if (!bdev) +return ERR_PTR (-ENXIO ); flags =blk_to_file_flags (mode);
block/bdev.c struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 983
Quoted 10 lines
block/bdev.c +3
-3- bdev_file =alloc_file_pseudo_noaccount (handle->bdev->bd_inode, + bdev_file =alloc_file_pseudo_noaccount (bdev->bd_inode, blockdev_mnt,"" , flags |O_LARGEFILE , &def_blk_fops);if (IS_ERR (bdev_file)) { -bdev_release (handle); +blkdev_put_no_open (bdev);return bdev_file; } -ihold (handle->bdev->bd_inode); + bdev_file->f_mode &= ~FMODE_OPENED ;
Hum, why do you need these games with FMODE_OPENED? I suspect you want to influence fput() behavior but then AFAICT we will leak dentry, mnt, etc. on error? If this is indeed needed, it deserves a comment...
Quoted 8 lines
block/bdev.c +1
-7- bdev_file->f_mode |=FMODE_BUF_RASYNC |FMODE_CAN_ODIRECT ; -if (bdev_nowait (handle->bdev)) - bdev_file->f_mode |=FMODE_NOWAIT ; - - bdev_file->f_mapping = handle->bdev->bd_inode->i_mapping; - bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); - bdev_file->private_data = handle; +ihold (bdev->bd_inode);
block/bdev.c struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 995
Quoted 10 lines
block/bdev.c +7
-0+ ret =bdev_open (bdev, mode, holder, hops, bdev_file); +if (ret) { +fput (bdev_file); +return ERR_PTR (ret); + } +/* Now that thing is opened. */ + bdev_file->f_mode |=FMODE_OPENED ;return bdev_file; }EXPORT_SYMBOL (bdev_file_open_by_dev);
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerRe: [PATCH v2 29/34] bdev: make struct bdev_handle private to the block layer
Quoted 4 lines
Quoted 2 lines
* Use this interface ONLY if you really do not have anything better - i.e. when
* you are behind a truly sucky interface and all you are given is a device^^^I guess this part of comment is stale now?
Indeed, I removed that.
Quoted 16 lines
Review struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 906
Quoted 13 lines
(quoted diff) +7
-1@@ -902,7 +897,22 @@ struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, handle->bdev = bdev; handle->holder = holder; handle->mode = mode; - return handle; + + /* + * Preserve backwards compatibility and allow large file access + * even if userspace doesn't ask for it explicitly. Some mkfs + * binary needs it. We might want to drop this workaround + * during an unstable branch. + */Heh, I think the sentense "We might want to drop this workaround during an unstable branch." does not need to be moved as well :)
Dropped.
Quoted 6 lines
Review struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, · line 907
Quoted 4 lines
(quoted diff) +1
-3- handle = bdev_open_by_dev(dev, mode, holder, hops); - if (IS_ERR(handle)) - return ERR_CAST(handle); + ret = bdev_permission(dev, 0, holder);^^ Maybe I'm missing something but why
do you pass 0 mode here?
Lack of caffeine? Fixed. Thanks for catching that.
Quoted 9 lines
Quoted 9 lines
(quoted diff) +6
-0+ if (ret) + return ERR_PTR(ret); + + bdev = blkdev_get_no_open(dev); + if (!bdev) + return ERR_PTR(-ENXIO);
Quoted 15 lines
Review struct bdev_handle *bdev_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,
Quoted 11 lines
(quoted diff) +3
-3flags = blk_to_file_flags(mode); - bdev_file = alloc_file_pseudo_noaccount(handle->bdev->bd_inode, + bdev_file = alloc_file_pseudo_noaccount(bdev->bd_inode, blockdev_mnt, "", flags | O_LARGEFILE, &def_blk_fops); if (IS_ERR(bdev_file)) { - bdev_release(handle); + blkdev_put_no_open(bdev); return bdev_file; } - ihold(handle->bdev->bd_inode); + bdev_file->f_mode &= ~FMODE_OPENED;Hum, why do you need these games with
FMODE_OPENED? I suspect you want to influencefput()behavior but then AFAICT we will leak dentry, mnt, etc. on error? If this is indeed needed, it deserves a comment...
I rewrote this.
Total diff I applied is:
block/bdev.c +3 -11
@@ -893,12 +893,6 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder, handle->holder = holder; handle->mode = mode; -/* -* Preserve backwards compatibility and allow large file access -* even if userspace doesn't ask for it explicitly. Some mkfs -* binary needs it. We might want to drop this workaround -* during an unstable branch. -*/ bdev_file->f_flags |=O_LARGEFILE ; bdev_file->f_mode |=FMODE_BUF_RASYNC |FMODE_CAN_ODIRECT ;if (bdev_nowait (bdev))
@@ -960,7 +954,7 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,unsigned int flags;int ret; - ret =bdev_permission (dev,0 , holder); + ret =bdev_permission (dev, mode, holder);if (ret)return ERR_PTR (ret);
@@ -975,16 +969,14 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,blkdev_put_no_open (bdev);return bdev_file; } - bdev_file->f_mode &= ~FMODE_OPENED ; -ihold (bdev->bd_inode); + ret =bdev_open (bdev, mode, holder, hops, bdev_file);if (ret) { +blkdev_put_no_open (bdev);fput (bdev_file);return ERR_PTR (ret); } -/* Now that thing is opened. */ - bdev_file->f_mode |=FMODE_OPENED ;return bdev_file; }EXPORT_SYMBOL (bdev_file_open_by_dev);
block/fops.c +2 -1
@@ -622,7 +622,8 @@ static int blkdev_open(struct inode *inode, struct file *filp)static int blkdev_release (struct inode *inode,struct file *filp) { -bdev_release (filp->private_data); +if (filp->private_data) +bdev_release (filp->private_data);return 0 ; }
Jan Kara
reviewerRe: [PATCH v2 29/34] bdev: make struct bdev_handle private to the block layer
Quoted 23 lines · Christian Brauner
Quoted 7 lines
Quoted 7 lines
(quoted diff) +6
-0+ if (ret) + return ERR_PTR(ret); + + bdev = blkdev_get_no_open(dev); + if (!bdev) + return ERR_PTR(-ENXIO);Quoted 15 lines
Review
Quoted 11 lines
(quoted diff) +3
-3flags = blk_to_file_flags(mode); - bdev_file = alloc_file_pseudo_noaccount(handle->bdev->bd_inode, + bdev_file = alloc_file_pseudo_noaccount(bdev->bd_inode, blockdev_mnt, "", flags | O_LARGEFILE, &def_blk_fops); if (IS_ERR(bdev_file)) { - bdev_release(handle); + blkdev_put_no_open(bdev); return bdev_file; } - ihold(handle->bdev->bd_inode); + bdev_file->f_mode &= ~FMODE_OPENED;Hum, why do you need these games with
FMODE_OPENED? I suspect you want to influencefput()behavior but then AFAICT we will leak dentry, mnt, etc. on error? If this is indeed needed, it deserves a comment...
Quoted 3 lines
I rewrote this.
Total diff I applied is:
Looks good now.
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Jan Kara
reviewerRe: [PATCH v2 29/34] bdev: make struct bdev_handle private to the block layer
In reply to Christian BraunerQuoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>
One more thing I've noticed:
Quoted 4 lines
block/bdev.c +2
-2-struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, -const struct blk_holder_ops *hops) +int bdev_open (struct block_device *bdev,blk_mode_t mode,void *holder, +const struct blk_holder_ops *hops,struct file *bdev_file)
block/bdev.c static void bdev_yield_write_access(struct block_device *bdev, blk_mode_t mode) · line 845
Quoted 10 lines
block/bdev.c +2
-2{struct bdev_handle *handle =kmalloc (sizeof (struct bdev_handle ),GFP_KERNEL ); -struct block_device *bdev;bool unblock_events = true; -struct gendisk *disk; +struct gendisk *disk = bdev->bd_disk;int ret; + handle =kmalloc (sizeof (struct bdev_handle ),GFP_KERNEL );
You are leaking handle here. It gets fixed up later in the series but still...
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerRe: [PATCH v2 29/34] bdev: make struct bdev_handle private to the block layer
Quoted 18 lines · Jan Kara
Quoted 1 line · Christian Brauner
Signed-off-by Christian Brauner <[email protected]>One more thing I've noticed:
Quoted 13 lines
block/bdev.c +3
-4-struct bdev_handle *bdev_open_by_dev (dev_t dev,blk_mode_t mode,void *holder, -const struct blk_holder_ops *hops) +int bdev_open (struct block_device *bdev,blk_mode_t mode,void *holder, +const struct blk_holder_ops *hops,struct file *bdev_file) {struct bdev_handle *handle =kmalloc (sizeof (struct bdev_handle ),GFP_KERNEL ); -struct block_device *bdev;bool unblock_events = true; -struct gendisk *disk; +struct gendisk *disk = bdev->bd_disk;int ret;
Quoted 4 lines
block/bdev.c static void bdev_yield_write_access(struct block_device *bdev, blk_mode_t mode) · line 845
Quoted 1 line
block/bdev.c +1
-0+ handle =kmalloc (sizeof (struct bdev_handle ),GFP_KERNEL );You are leaking handle here. It gets fixed up later in the series but still...
Bah, called twice instead of removed it. Fixed.
Christian Brauner
maintainerPATCH v2 30/34 bdev: remove bdev pointer from struct bdev_handle
In reply to Christian BraunerWe can always go directly via:
* I_BDEV(bdev_file->f_inode)
* I_BDEV(bdev_file->f_mapping->host)
So keeping struct bdev in struct bdev_handle is redundant.
--- block/bdev.c | 26 ++++++++++++-------------- block/blk.h | 3 +-- block/fops.c | 2 +- 3 files changed, 14 insertions(+), 17 deletions(-)
block/bdev.c +12 -14
@@ -51,8 +51,7 @@ EXPORT_SYMBOL(I_BDEV);struct block_device *file_bdev (struct file *bdev_file) { -struct bdev_handle *handle = bdev_file->private_data; -return handle->bdev; +return I_BDEV (bdev_file->f_mapping->host); }EXPORT_SYMBOL (file_bdev);
@@ -894,7 +893,6 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder,if (unblock_events)disk_unblock_events (disk); - handle->bdev = bdev; handle->holder = holder; handle->mode = mode;
@@ -908,7 +906,7 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder, bdev_file->f_mode |=FMODE_BUF_RASYNC |FMODE_CAN_ODIRECT ;if (bdev_nowait (bdev)) bdev_file->f_mode |=FMODE_NOWAIT ; - bdev_file->f_mapping = handle->bdev->bd_inode->i_mapping; + bdev_file->f_mapping = bdev->bd_inode->i_mapping; bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); bdev_file->private_data = handle;
@@ -998,7 +996,7 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,void *holder, const struct blk_holder_ops *hops) { - struct file *bdev_file; + struct file *file;dev_t dev;int error;
@@ -1006,22 +1004,22 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,if (error)return ERR_PTR (error); - bdev_file =bdev_file_open_by_dev (dev, mode, holder, hops); -if (!IS_ERR (bdev_file) && (mode &BLK_OPEN_WRITE )) { -struct bdev_handle *handle = bdev_file->private_data; -if (bdev_read_only (handle->bdev)) { -fput (bdev_file); - bdev_file =ERR_PTR (-EACCES ); + file =bdev_file_open_by_dev (dev, mode, holder, hops); +if (!IS_ERR (file) && (mode &BLK_OPEN_WRITE )) { +if (bdev_read_only (file_bdev (file))) { +fput (file); + file =ERR_PTR (-EACCES ); } } -return bdev_file; +return file; }EXPORT_SYMBOL (bdev_file_open_by_path); -void bdev_release (struct bdev_handle *handle) +void bdev_release (struct file *bdev_file) { -struct block_device *bdev = handle->bdev; +struct block_device *bdev =file_bdev (bdev_file); +struct bdev_handle *handle = bdev_file->private_data;struct gendisk *disk = bdev->bd_disk;/*
block/blk.h +1 -2
@@ -26,7 +26,6 @@ struct blk_flush_queue { };struct bdev_handle { -struct block_device *bdev;void *holder;blk_mode_t mode; };
@@ -522,7 +521,7 @@ static inline int req_ref_read(struct request *req)return atomic_read (&req->ref); } -void bdev_release (struct bdev_handle *handle); +void bdev_release (struct file *bdev_file);int bdev_open (struct block_device *bdev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops,struct file *bdev_file);int bdev_permission (dev_t dev,blk_mode_t mode,void *holder);
block/fops.c +1 -1
@@ -622,7 +622,7 @@ static int blkdev_open(struct inode *inode, struct file *filp)static int blkdev_release (struct inode *inode,struct file *filp) { -bdev_release (filp->private_data); +bdev_release (filp);return 0 ; }
Signature · 1 line
2.43.0
Re: [PATCH v2 30/34] bdev: remove bdev pointer from struct bdev_handle
Looks good:
Re: [PATCH v2 30/34] bdev: remove bdev pointer from struct bdev_handle
In reply to Christian BraunerQuoted 8 lines · Christian Brauner
We can always go directly via:
*
I_BDEV(bdev_file->f_inode)
*I_BDEV(bdev_file->f_mapping->host)So keeping struct bdev in struct
bdev_handleis redundant.Signed-off-by Christian Brauner <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 116 lines
--- block/bdev.c | 26 ++++++++++++-------------- block/blk.h | 3 +-- block/fops.c | 2 +- 3 files changed, 14 insertions(+), 17 deletions(-)block/bdev.c +12
-14@@ -51,8 +51,7 @@ EXPORT_SYMBOL(I_BDEV);struct block_device *file_bdev (struct file *bdev_file) { -struct bdev_handle *handle = bdev_file->private_data; -return handle->bdev; +return I_BDEV (bdev_file->f_mapping->host); }EXPORT_SYMBOL (file_bdev);@@ -894,7 +893,6 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder,if (unblock_events)disk_unblock_events (disk); - handle->bdev = bdev; handle->holder = holder; handle->mode = mode;@@ -908,7 +906,7 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder, bdev_file->f_mode |=FMODE_BUF_RASYNC |FMODE_CAN_ODIRECT ;if (bdev_nowait (bdev)) bdev_file->f_mode |=FMODE_NOWAIT ; - bdev_file->f_mapping = handle->bdev->bd_inode->i_mapping; + bdev_file->f_mapping = bdev->bd_inode->i_mapping; bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); bdev_file->private_data = handle;@@ -998,7 +996,7 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,void *holder, const struct blk_holder_ops *hops) { - struct file *bdev_file; + struct file *file;dev_t dev;int error;@@ -1006,22 +1004,22 @@ struct file *bdev_file_open_by_path(const char *path, blk_mode_t mode,if (error)return ERR_PTR (error); - bdev_file =bdev_file_open_by_dev (dev, mode, holder, hops); -if (!IS_ERR (bdev_file) && (mode &BLK_OPEN_WRITE )) { -struct bdev_handle *handle = bdev_file->private_data; -if (bdev_read_only (handle->bdev)) { -fput (bdev_file); - bdev_file =ERR_PTR (-EACCES ); + file =bdev_file_open_by_dev (dev, mode, holder, hops); +if (!IS_ERR (file) && (mode &BLK_OPEN_WRITE )) { +if (bdev_read_only (file_bdev (file))) { +fput (file); + file =ERR_PTR (-EACCES ); } } -return bdev_file; +return file; }EXPORT_SYMBOL (bdev_file_open_by_path); -void bdev_release (struct bdev_handle *handle) +void bdev_release (struct file *bdev_file) { -struct block_device *bdev = handle->bdev; +struct block_device *bdev =file_bdev (bdev_file); +struct bdev_handle *handle = bdev_file->private_data;struct gendisk *disk = bdev->bd_disk;/* block/blk.h +1
-2@@ -26,7 +26,6 @@ struct blk_flush_queue { };struct bdev_handle { -struct block_device *bdev;void *holder;blk_mode_t mode; };@@ -522,7 +521,7 @@ static inline int req_ref_read(struct request *req)return atomic_read (&req->ref); } -void bdev_release (struct bdev_handle *handle); +void bdev_release (struct file *bdev_file);int bdev_open (struct block_device *bdev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops,struct file *bdev_file);int bdev_permission (dev_t dev,blk_mode_t mode,void *holder);block/fops.c +1
-1@@ -622,7 +622,7 @@ static int blkdev_open(struct inode *inode, struct file *filp)static int blkdev_release (struct inode *inode,struct file *filp) { -bdev_release (filp->private_data); +bdev_release (filp);return 0 ; }Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 31/34 block: use file->f_op to indicate restricted writes
In reply to Christian BraunerMake it possible to detected a block device that was opened with restricted write access solely based on its file operations that it was opened with. This avoids wasting an FMODE_* flag.
def_blk_fops isn't needed to check whether something is a block device checking the inode type is enough for that. And def_blk_fops_restricted can be kept private to the block layer.
--- block/bdev.c | 16 ++++++++++++---- block/blk.h | 2 ++ block/fops.c | 3 +++ 3 files changed, 17 insertions(+), 4 deletions(-)
block/bdev.c +12 -4
@@ -799,13 +799,16 @@ static void bdev_claim_write_access(struct block_device *bdev, blk_mode_t mode) bdev->bd_writers++; } -static void bdev_yield_write_access (struct block_device *bdev,blk_mode_t mode) +static void bdev_yield_write_access (struct file *bdev_file,blk_mode_t mode) { +struct block_device *bdev; +if (bdev_allow_write_mounted)return ; + bdev =file_bdev (bdev_file);/* Yield exclusive or shared write access. */ -if (mode &BLK_OPEN_RESTRICT_WRITES ) +if (bdev_file->f_op == &def_blk_fops_restricted)bdev_unblock_writes (bdev);else if (mode &BLK_OPEN_WRITE ) bdev->bd_writers--;
@@ -959,6 +962,7 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, const struct blk_holder_ops *hops) {struct file *bdev_file; +const struct file_operations *blk_fops;struct block_device *bdev;unsigned int flags;int ret;
@@ -972,8 +976,12 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,return ERR_PTR (-ENXIO ); flags =blk_to_file_flags (mode); +if (mode &BLK_OPEN_RESTRICT_WRITES ) + blk_fops = &def_blk_fops_restricted; +else + blk_fops = &def_blk_fops; bdev_file =alloc_file_pseudo_noaccount (bdev->bd_inode, - blockdev_mnt,"" , flags |O_LARGEFILE , &def_blk_fops); + blockdev_mnt,"" , flags |O_LARGEFILE , blk_fops);if (IS_ERR (bdev_file)) {blkdev_put_no_open (bdev);return bdev_file;
@@ -1033,7 +1041,7 @@ void bdev_release(struct file *bdev_file)sync_blockdev (bdev);mutex_lock (&disk->open_mutex); -bdev_yield_write_access (bdev, handle->mode); +bdev_yield_write_access (bdev_file, handle->mode);if (handle->holder)bd_end_claim (bdev, handle->holder);
block/blk.h +2 -0
@@ -9,6 +9,8 @@struct elevator_type ; +extern const struct file_operations def_blk_fops_restricted; +/* Max future timer expiry for timeouts */ #define BLK_MAX_TIMEOUT (5 * HZ)
block/fops.c +3 -0
@@ -862,6 +862,9 @@ const struct file_operations def_blk_fops = { .fallocate = blkdev_fallocate, }; +/* Indicator that this block device is opened with restricted write access. */ +const struct file_operations def_blk_fops_restricted = def_blk_fops; +static __init int blkdev_init (void ) { return bioset_init(&blkdev_dio_pool, 4,
Signature · 1 line
2.43.0
Christoph Hellwig
maintainerRe: [PATCH v2 31/34] block: use file->f_op to indicate restricted writes
Quoted 7 lines · Christian Brauner
Make it possible to detected a block device that was opened with restricted write access solely based on its file operations that it was opened with. This avoids wasting an FMODE_* flag.
def_blk_fopsisn't needed to check whether something is a block device checking the inode type is enough for that. Anddef_blk_fops_restrictedcan be kept private to the block layer.
I agree with not wasting a FMODE_* flag, but I also really hate duplicating the file operations.
I went to search for a good place to stash this information and ended up at the f_version field in struct file. That one is never touched by the VFS proper but just the file system and a few lseek helpers. The latter currently happen to be used by block devices unfortunately, but it seem like moving the f_version clearing into the few filesystem actualy using it would be good code hygiene anyway.
Christian Brauner
maintainerRe: [PATCH v2 31/34] block: use file->f_op to indicate restricted writes
Quoted 11 lines · Christoph Hellwig
Quoted 7 lines · Christian Brauner
Make it possible to detected a block device that was opened with restricted write access solely based on its file operations that it was opened with. This avoids wasting an FMODE_* flag.
def_blk_fopsisn't needed to check whether something is a block device checking the inode type is enough for that. Anddef_blk_fops_restrictedcan be kept private to the block layer.I agree with not wasting a FMODE_* flag, but I also really hate duplicating the file operations.
I don't think it's that bad and is temporary until we can unconditionally disable writing to mounted block devices. Until then we can place all of this under #if IS_ENABLED(CONFIG_BLK_DEV_WRITE_MOUNTED) in a single location in block/fops.c so its nicely encapsulated and confined.
Quoted 6 lines
I went to search for a good place to stash this information and ended up at the
f_versionfield in struct file. That one is never touched by the VFS proper but just the file system and a few lseek helpers. The latter currently happen to be used by block devices unfortunately, but it seem like moving thef_versionclearing into the few filesystem actualy using it would be good code hygiene anyway.
Kinda like choosing between pest and cholera. I think that the f_op solution is nicer. Overloading f_version is not something I feel I have the stomach for. The cleanup itself might still be worth it ofc.
Christoph Hellwig
maintainerRe: [PATCH v2 31/34] block: use file->f_op to indicate restricted writes
Quoted 5 lines · Christian Brauner
I don't think it's that bad and is temporary until we can unconditionally disable writing to mounted block devices. Until then we can place all of this under #if
IS_ENABLED(CONFIG_BLK_DEV_WRITE_MOUNTED)in a single location inblock/fops.cso its nicely encapsulated and confined.
Oh well. If Jens is fine with this I can live with it even if I don't like it too much. I'll probably just clean it up as a follow up.
OTOH I fear we won't be able to unconditionally disable writing to mounted block devices anytime soon if ever.
Christian Brauner
maintainerRe: [PATCH v2 31/34] block: use file->f_op to indicate restricted writes
Quoted 7 lines · Christoph Hellwig
Quoted 5 lines · Christian Brauner
I don't think it's that bad and is temporary until we can unconditionally disable writing to mounted block devices. Until then we can place all of this under #if
IS_ENABLED(CONFIG_BLK_DEV_WRITE_MOUNTED)in a single location inblock/fops.cso its nicely encapsulated and confined.
Quoted 5 lines
Oh well. If Jens is fine with this I can live with it even if I don't like it too much. I'll probably just clean it up as a follow up.
OTOH I fear we won't be able to unconditionally disable writing to mounted block devices anytime soon if ever.
One my dream. Put another way, if we don't even allow us to think that we can remove insecure functionality in the future then we have to accept that we'll be piling on #ifdefine's and mostly unused code forever which is just sad. :/
I'm hopeful that writing to mounted block devices is something that we can make all major distros move away from. We should start just because we need to figure out what tools do actually try to do stuff like that.
Jan Kara
reviewerRe: [PATCH v2 31/34] block: use file->f_op to indicate restricted writes
In reply to Christian BraunerQuoted 9 lines · Christian Brauner
Make it possible to detected a block device that was opened with restricted write access solely based on its file operations that it was opened with. This avoids wasting an FMODE_* flag.
def_blk_fopsisn't needed to check whether something is a block device checking the inode type is enough for that. Anddef_blk_fops_restrictedcan be kept private to the block layer.Signed-off-by Christian Brauner <[email protected]>
I don't think we need def_blk_fops_restricted. If we have BLK_OPEN_WRITE file against a bdev with bdev_writes_blocked() == true, we are sure this is the handle blocking other writes so we can unblock them in bdev_yield_write_access()...
Honza
Quoted 91 lines
--- block/bdev.c | 16 ++++++++++++---- block/blk.h | 2 ++ block/fops.c | 3 +++ 3 files changed, 17 insertions(+), 4 deletions(-)block/bdev.c +12
-4@@ -799,13 +799,16 @@ static void bdev_claim_write_access(struct block_device *bdev, blk_mode_t mode) bdev->bd_writers++; } -static void bdev_yield_write_access (struct block_device *bdev,blk_mode_t mode) +static void bdev_yield_write_access (struct file *bdev_file,blk_mode_t mode) { +struct block_device *bdev; +if (bdev_allow_write_mounted)return ; + bdev =file_bdev (bdev_file);/* Yield exclusive or shared write access. */ -if (mode &BLK_OPEN_RESTRICT_WRITES ) +if (bdev_file->f_op == &def_blk_fops_restricted)bdev_unblock_writes (bdev);else if (mode &BLK_OPEN_WRITE ) bdev->bd_writers--;@@ -959,6 +962,7 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, const struct blk_holder_ops *hops) {struct file *bdev_file; +const struct file_operations *blk_fops;struct block_device *bdev;unsigned int flags;int ret;@@ -972,8 +976,12 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,return ERR_PTR (-ENXIO ); flags =blk_to_file_flags (mode); +if (mode &BLK_OPEN_RESTRICT_WRITES ) + blk_fops = &def_blk_fops_restricted; +else + blk_fops = &def_blk_fops; bdev_file =alloc_file_pseudo_noaccount (bdev->bd_inode, - blockdev_mnt,"" , flags |O_LARGEFILE , &def_blk_fops); + blockdev_mnt,"" , flags |O_LARGEFILE , blk_fops);if (IS_ERR (bdev_file)) {blkdev_put_no_open (bdev);return bdev_file;@@ -1033,7 +1041,7 @@ void bdev_release(struct file *bdev_file)sync_blockdev (bdev);mutex_lock (&disk->open_mutex); -bdev_yield_write_access (bdev, handle->mode); +bdev_yield_write_access (bdev_file, handle->mode);if (handle->holder)bd_end_claim (bdev, handle->holder);block/blk.h +2
-0@@ -9,6 +9,8 @@struct elevator_type ; +extern const struct file_operations def_blk_fops_restricted; +/* Max future timer expiry for timeouts */ #define BLK_MAX_TIMEOUT (5 * HZ)block/fops.c +3
-0@@ -862,6 +862,9 @@ const struct file_operations def_blk_fops = { .fallocate = blkdev_fallocate, }; +/* Indicator that this block device is opened with restricted write access. */ +const struct file_operations def_blk_fops_restricted = def_blk_fops; +static __init int blkdev_init (void ) { return bioset_init(&blkdev_dio_pool, 4,Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerRe: [PATCH v2 31/34] block: use file->f_op to indicate restricted writes
Quoted 9 lines · Jan Kara
Quoted 8 lines · Christian Brauner
Make it possible to detected a block device that was opened with restricted write access solely based on its file operations that it was opened with. This avoids wasting an FMODE_* flag.
def_blk_fopsisn't needed to check whether something is a block device checking the inode type is enough for that. Anddef_blk_fops_restrictedcan be kept private to the block layer.
Quoted 6 lines
Quoted 1 line
Signed-off-by Christian Brauner <[email protected]>I don't think we need
def_blk_fops_restricted. If we haveBLK_OPEN_WRITEfile against a bdev withbdev_writes_blocked()== true, we are sure this is the handle blocking other writes so we can unblock them inbdev_yield_write_access()...
Excellent:
commit e2dd15e4c32ad66d938d35e1acd26375a7f355fb
Author: Christian Brauner <[email protected]> AuthorDate: Tue Jan 23 14:26:48 2024 +0100 Commit: Christian Brauner <[email protected]> CommitDate: Thu Feb 1 17:13:16 2024 +0100
block: don't rely on BLK_OPEN_RESTRICT_WRITES when yielding write access
Make it possible to detected a block device that was opened with restricted write access based only on BLK_OPEN_WRITE and bdev->bd_writers < 0 so we won't have to claim another FMODE_* flag.
base-commit: 0bd1bf95a554f5f877724c27dbe33d4db0af4d0c
block/bdev.c +12 -3
@@ -799,13 +799,22 @@ static void bdev_claim_write_access(struct block_device *bdev, blk_mode_t mode) bdev->bd_writers++; } -static void bdev_yield_write_access (struct block_device *bdev,blk_mode_t mode) +static void bdev_yield_write_access (struct file *bdev_file,blk_mode_t mode) { +struct block_device *bdev; +if (bdev_allow_write_mounted)return ; + bdev =file_bdev (bdev_file);/* Yield exclusive or shared write access. */ -if (mode &BLK_OPEN_RESTRICT_WRITES ) +if (mode &BLK_OPEN_WRITE ) { +if (bdev_writes_blocked (bdev)) +bdev_unblock_writes (bdev); +else + bdev->bd_writers--; + } +if (bdev_file->f_op == &def_blk_fops_restricted)bdev_unblock_writes (bdev);else if (mode &BLK_OPEN_WRITE ) bdev->bd_writers--;
@@ -1020,7 +1029,7 @@ void bdev_release(struct file *bdev_file)sync_blockdev (bdev);mutex_lock (&disk->open_mutex); -bdev_yield_write_access (bdev, handle->mode); +bdev_yield_write_access (bdev_file, handle->mode);if (handle->holder)bd_end_claim (bdev, handle->holder);
Jan Kara
reviewerRe: [PATCH v2 31/34] block: use file->f_op to indicate restricted writes
Quoted 16 lines · Christian Brauner
Quoted 15 lines · Jan Kara
Quoted 9 lines · Christian Brauner
Make it possible to detected a block device that was opened with restricted write access solely based on its file operations that it was opened with. This avoids wasting an FMODE_* flag.
def_blk_fopsisn't needed to check whether something is a block device checking the inode type is enough for that. Anddef_blk_fops_restrictedcan be kept private to the block layer.Signed-off-by Christian Brauner <[email protected]>I don't think we need
def_blk_fops_restricted. If we haveBLK_OPEN_WRITEfile against a bdev withbdev_writes_blocked()== true, we are sure this is the handle blocking other writes so we can unblock them inbdev_yield_write_access()...
...
block/bdev.c static void bdev_claim_write_access(struct block_device *bdev, blk_mode_t mode) · line 817
Quoted 8 lines
block/bdev.c +7
-1-if (mode &BLK_OPEN_RESTRICT_WRITES ) +if (mode &BLK_OPEN_WRITE ) { +if (bdev_writes_blocked (bdev)) +bdev_unblock_writes (bdev); +else + bdev->bd_writers--; + } +if (bdev_file->f_op == &def_blk_fops_restricted)
Uh, why are you leaving def_blk_fops_restricted check here? I'd expect you can delete def_blk_fops_restricted completely...
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerRe: [PATCH v2 31/34] block: use file->f_op to indicate restricted writes
Quoted 29 lines · Jan Kara
Quoted 16 lines · Christian Brauner
Quoted 15 lines · Jan Kara
Quoted 9 lines · Christian Brauner
Make it possible to detected a block device that was opened with restricted write access solely based on its file operations that it was opened with. This avoids wasting an FMODE_* flag.
def_blk_fopsisn't needed to check whether something is a block device checking the inode type is enough for that. Anddef_blk_fops_restrictedcan be kept private to the block layer.Signed-off-by Christian Brauner <[email protected]>I don't think we need
def_blk_fops_restricted. If we haveBLK_OPEN_WRITEfile against a bdev withbdev_writes_blocked()== true, we are sure this is the handle blocking other writes so we can unblock them inbdev_yield_write_access()......
Review
Quoted 8 lines
(quoted diff) +7
-1- if (mode & BLK_OPEN_RESTRICT_WRITES) + if (mode & BLK_OPEN_WRITE) { + if (bdev_writes_blocked(bdev)) + bdev_unblock_writes(bdev); + else + bdev->bd_writers--; + } + if (bdev_file->f_op == &def_blk_fops_restricted)
Quoted 2 lines
Uh, why are you leaving
def_blk_fops_restrictedcheck here? I'd expect you can deletedef_blk_fops_restrictedcompletely...
Copy-paste error when dumping this into here. Here's the full patch.
From 25609e947674d2c24fb18edd0dabb5a49f27f23d Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Tue, 23 Jan 2024 14:26:48 +0100
Subject: [PATCH] block: don't rely on BLK_OPEN_RESTRICT_WRITES when yielding
write access
Make it possible to detected a block device that was opened with restricted write access based only on BLK_OPEN_WRITE and bdev->bd_writers < 0 so we won't have to claim another FMODE_* flag.
base-commit: 0bd1bf95a554f5f877724c27dbe33d4db0af4d0c
--- block/bdev.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-)
block/bdev.c +11 -6
@@ -799,16 +799,21 @@ static void bdev_claim_write_access(struct block_device *bdev, blk_mode_t mode) bdev->bd_writers++; } -static void bdev_yield_write_access (struct block_device *bdev,blk_mode_t mode) +static void bdev_yield_write_access (struct file *bdev_file,blk_mode_t mode) { +struct block_device *bdev; +if (bdev_allow_write_mounted)return ; + bdev =file_bdev (bdev_file);/* Yield exclusive or shared write access. */ -if (mode &BLK_OPEN_RESTRICT_WRITES ) -bdev_unblock_writes (bdev); -else if (mode &BLK_OPEN_WRITE ) - bdev->bd_writers--; +if (mode &BLK_OPEN_WRITE ) { +if (bdev_writes_blocked (bdev)) +bdev_unblock_writes (bdev); +else + bdev->bd_writers--; + } }/**
@@ -1020,7 +1025,7 @@ void bdev_release(struct file *bdev_file)sync_blockdev (bdev);mutex_lock (&disk->open_mutex); -bdev_yield_write_access (bdev, handle->mode); +bdev_yield_write_access (bdev_file, handle->mode);if (handle->holder)bd_end_claim (bdev, handle->holder);
Signature · 1 line
2.43.0
Jan Kara
reviewerRe: [PATCH v2 31/34] block: use file->f_op to indicate restricted writes
Quoted 30 lines · Christian Brauner
Quoted 29 lines · Jan Kara
Quoted 16 lines · Christian Brauner
Quoted 15 lines · Jan Kara
Quoted 9 lines · Christian Brauner
Make it possible to detected a block device that was opened with restricted write access solely based on its file operations that it was opened with. This avoids wasting an FMODE_* flag.
def_blk_fopsisn't needed to check whether something is a block device checking the inode type is enough for that. Anddef_blk_fops_restrictedcan be kept private to the block layer.Signed-off-by Christian Brauner <[email protected]>I don't think we need
def_blk_fops_restricted. If we haveBLK_OPEN_WRITEfile against a bdev withbdev_writes_blocked()== true, we are sure this is the handle blocking other writes so we can unblock them inbdev_yield_write_access()......
Quoted 8 lines
block/bdev.c +7
-1-if (mode &BLK_OPEN_RESTRICT_WRITES ) +if (mode &BLK_OPEN_WRITE ) { +if (bdev_writes_blocked (bdev)) +bdev_unblock_writes (bdev); +else + bdev->bd_writers--; + } +if (bdev_file->f_op == &def_blk_fops_restricted)
Quoted 4 lines
Quoted 2 lines
Uh, why are you leaving
def_blk_fops_restrictedcheck here? I'd expect you can deletedef_blk_fops_restrictedcompletely...Copy-paste error when dumping this into here. Here's the full patch.
Yes, the full patch looks good to me! Thanks!
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 32/34 block: remove bdev_handle completely
In reply to Christian BraunerWe just need to use the holder to indicate whether a block device open was exclusive or not. We did use to do that before but had to give that up once we switched to struct bdev_handle. Before struct bdev_handle we only stashed stuff in file->private_data if this was an exclusive open but after struct bdev_handle we always set file->private_data to a struct bdev_handle and so we had to use bdev_handle->mode or bdev_handle->holder. Now that we don't use struct bdev_handle anymore we can revert back to the old behavior.
--- block/bdev.c | 24 +++++++----------------- block/blk.h | 5 ----- block/fops.c | 18 +++++++++++------- 3 files changed, 18 insertions(+), 29 deletions(-)
block/bdev.c +7 -17
@@ -799,7 +799,7 @@ static void bdev_claim_write_access(struct block_device *bdev, blk_mode_t mode) bdev->bd_writers++; } -static void bdev_yield_write_access (struct file *bdev_file,blk_mode_t mode) +static void bdev_yield_write_access (struct file *bdev_file) {struct block_device *bdev;
@@ -810,7 +810,7 @@ static void bdev_yield_write_access(struct file *bdev_file, blk_mode_t mode)/* Yield exclusive or shared write access. */ if (bdev_file->f_op == &def_blk_fops_restricted)bdev_unblock_writes (bdev); -else if (mode &BLK_OPEN_WRITE ) +else if (bdev_file->f_mode &FMODE_WRITE ) bdev->bd_writers--; }
@@ -838,16 +838,10 @@ static void bdev_yield_write_access(struct file *bdev_file, blk_mode_t mode)int bdev_open (struct block_device *bdev,blk_mode_t mode,void *holder,const struct blk_holder_ops *hops,struct file *bdev_file) { -struct bdev_handle *handle =kmalloc (sizeof (struct bdev_handle ), -GFP_KERNEL );bool unblock_events = true;struct gendisk *disk = bdev->bd_disk;int ret; - handle =kmalloc (sizeof (struct bdev_handle ),GFP_KERNEL ); -if (!handle) -return -ENOMEM ; -if (holder) { mode |=BLK_OPEN_EXCL ; ret =bd_prepare_to_claim (bdev, holder, hops);
@@ -896,8 +890,6 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder,if (unblock_events)disk_unblock_events (disk); - handle->holder = holder; - handle->mode = mode;/* * Preserve backwards compatibility and allow large file access
@@ -911,7 +903,7 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder, bdev_file->f_mode |=FMODE_NOWAIT ; bdev_file->f_mapping = bdev->bd_inode->i_mapping; bdev_file->f_wb_err =filemap_sample_wb_err (bdev_file->f_mapping); - bdev_file->private_data = handle; + bdev_file->private_data = holder;return 0 ; put_module:
@@ -921,7 +913,6 @@ int bdev_open(struct block_device *bdev, blk_mode_t mode, void *holder,bd_abort_claiming (bdev, holder);mutex_unlock (&disk->open_mutex);disk_unblock_events (disk); -kfree (handle);return ret; }
@@ -1027,7 +1018,7 @@ EXPORT_SYMBOL(bdev_file_open_by_path);void bdev_release (struct file *bdev_file) {struct block_device *bdev =file_bdev (bdev_file); -struct bdev_handle *handle = bdev_file->private_data; +void *holder = bdev_file->private_data;struct gendisk *disk = bdev->bd_disk;/*
@@ -1041,10 +1032,10 @@ void bdev_release(struct file *bdev_file)sync_blockdev (bdev);mutex_lock (&disk->open_mutex); -bdev_yield_write_access (bdev_file, handle->mode); +bdev_yield_write_access (bdev_file); -if (handle->holder) -bd_end_claim (bdev, handle->holder); +if (holder) +bd_end_claim (bdev, holder);/* * Trigger event checking and tell drivers to flush MEDIA_CHANGE
@@ -1061,7 +1052,6 @@ void bdev_release(struct file *bdev_file)module_put (disk->fops->owner);blkdev_put_no_open (bdev); -kfree (handle); }/**
block/blk.h +0 -5
@@ -27,11 +27,6 @@ struct blk_flush_queue {struct request *flush_rq; }; -struct bdev_handle { -void *holder; -blk_mode_t mode; -}; -bool is_flush_rq (struct request *req); struct blk_flush_queue *blk_alloc_flush_queue(int node, int cmd_size,
block/fops.c +11 -7
@@ -569,7 +569,6 @@ static int blkdev_fsync(struct file *filp, loff_t start, loff_t end,blk_mode_t file_to_blk_mode (struct file *file) {blk_mode_t mode =0 ; -struct bdev_handle *handle = file->private_data;if (file->f_mode &FMODE_READ ) mode |=BLK_OPEN_READ ;
@@ -579,8 +578,8 @@ blk_mode_t file_to_blk_mode(struct file *file)* do_dentry_open() clears O_EXCL from f_flags, use handle->mode to * determine whether the open was exclusive for already open files. */ -if (handle) - mode |= handle->mode &BLK_OPEN_EXCL ; +if (file->private_data) + mode |=BLK_OPEN_EXCL ;else if (file->f_flags &O_EXCL ) mode |=BLK_OPEN_EXCL ;if (file->f_flags &O_NDELAY )
@@ -601,12 +600,17 @@ static int blkdev_open(struct inode *inode, struct file *filp) {struct block_device *bdev;blk_mode_t mode; -void *holder;int ret; +/* +* Use the file private data to store the holder for exclusive opens. +* file_to_blk_mode relies on it being present to set BLK_OPEN_EXCL. +*/ +if (filp->f_flags &O_EXCL ) + filp->private_data = filp; + mode =file_to_blk_mode (filp); - holder = mode &BLK_OPEN_EXCL ? filp :NULL ; - ret =bdev_permission (inode->i_rdev, mode, holder); + ret =bdev_permission (inode->i_rdev, mode, filp->private_data);if (ret)return ret;
@@ -614,7 +618,7 @@ static int blkdev_open(struct inode *inode, struct file *filp)if (!bdev)return -ENXIO ; - ret =bdev_open (bdev, mode, holder,NULL , filp); + ret =bdev_open (bdev, mode, filp->private_data,NULL , filp);if (ret)blkdev_put_no_open (bdev);return ret;
Signature · 1 line
2.43.0
Re: [PATCH v2 32/34] block: remove bdev_handle completely
Looks good:
Jan Kara
reviewerRe: [PATCH v2 32/34] block: remove bdev_handle completely
In reply to Christian BraunerQuoted 10 lines · Christian Brauner
We just need to use the holder to indicate whether a block device open was exclusive or not. We did use to do that before but had to give that up once we switched to struct
bdev_handle. Before structbdev_handlewe only stashed stuff infile->private_dataif this was an exclusive open but after structbdev_handlewe always setfile->private_datato a structbdev_handleand so we had to usebdev_handle->modeorbdev_handle->holder. Now that we don't use structbdev_handleanymore we can revert back to the old behavior.Signed-off-by Christian Brauner <[email protected]>
Two small comments below.
Quoted 13 lines
block/fops.c +0
-1@@ -569,7 +569,6 @@ static int blkdev_fsync(struct file *filp, loff_t start, loff_t end,blk_mode_t file_to_blk_mode (struct file *file) {blk_mode_t mode =0 ; -struct bdev_handle *handle = file->private_data;if (file->f_mode &FMODE_READ ) mode |=BLK_OPEN_READ ;
block/fops.c blk_mode_t file_to_blk_mode(struct file *file) · line 580
Quoted 3 lines
block/fops.c +0
-0@@ -579,8 +578,8 @@ blk_mode_t file_to_blk_mode(struct file *file)* do_dentry_open() clears O_EXCL from f_flags, use handle->mode to * determine whether the open was exclusive for already open files. */
^^^ This comment needs update now...
Quoted 10 lines
block/fops.c +2
-2-if (handle) - mode |= handle->mode &BLK_OPEN_EXCL ; +if (file->private_data) + mode |=BLK_OPEN_EXCL ;else if (file->f_flags &O_EXCL ) mode |=BLK_OPEN_EXCL ;if (file->f_flags &O_NDELAY )@@ -601,12 +600,17 @@ static int blkdev_open(struct inode *inode, struct file *filp) {struct block_device *bdev;
block/fops.c static int blkdev_open(struct inode *inode, struct file *filp) · line 610
Quoted 10 lines
block/fops.c +6
-1blk_mode_t mode; -void *holder;int ret; +/* +* Use the file private data to store the holder for exclusive opens. +* file_to_blk_mode relies on it being present to set BLK_OPEN_EXCL. +*/ +if (filp->f_flags &O_EXCL ) + filp->private_data = filp;
Well, if we have O_EXCL in f_flags here, then file_to_blk_mode() on the next line is going to do the right thing and set BLK_OPEN_EXCL even without filp->private_data. So this shound't be needed AFAICT.
block/fops.c static int blkdev_open(struct inode *inode, struct file *filp) · line 615
Quoted 6 lines
block/fops.c +1
-2mode =file_to_blk_mode (filp); - holder = mode &BLK_OPEN_EXCL ? filp :NULL ; - ret =bdev_permission (inode->i_rdev, mode, holder); + ret =bdev_permission (inode->i_rdev, mode, filp->private_data);if (ret)return ret;
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerRe: [PATCH v2 32/34] block: remove bdev_handle completely
Quoted 46 lines · Jan Kara
Quoted 10 lines · Christian Brauner
We just need to use the holder to indicate whether a block device open was exclusive or not. We did use to do that before but had to give that up once we switched to struct
bdev_handle. Before structbdev_handlewe only stashed stuff infile->private_dataif this was an exclusive open but after structbdev_handlewe always setfile->private_datato a structbdev_handleand so we had to usebdev_handle->modeorbdev_handle->holder. Now that we don't use structbdev_handleanymore we can revert back to the old behavior.Signed-off-by Christian Brauner <[email protected]>Two small comments below.
Quoted 13 lines
block/fops.c +0
-1@@ -569,7 +569,6 @@ static int blkdev_fsync(struct file *filp, loff_t start, loff_t end,blk_mode_t file_to_blk_mode (struct file *file) {blk_mode_t mode =0 ; -struct bdev_handle *handle = file->private_data;if (file->f_mode &FMODE_READ ) mode |=BLK_OPEN_READ ;block/fops.c blk_mode_t file_to_blk_mode(struct file *file) · line 580
Quoted 3 lines
block/fops.c +0
-0@@ -579,8 +578,8 @@ blk_mode_t file_to_blk_mode(struct file *file)* do_dentry_open() clears O_EXCL from f_flags, use handle->mode to * determine whether the open was exclusive for already open files. */ ^^^ This comment needs update now...
Quoted 14 lines
block/fops.c +2
-3-if (handle) - mode |= handle->mode &BLK_OPEN_EXCL ; +if (file->private_data) + mode |=BLK_OPEN_EXCL ;else if (file->f_flags &O_EXCL ) mode |=BLK_OPEN_EXCL ;if (file->f_flags &O_NDELAY )@@ -601,12 +600,17 @@ static int blkdev_open(struct inode *inode, struct file *filp) {struct block_device *bdev;blk_mode_t mode; -void *holder;int ret;
Quoted 10 lines
block/fops.c static int blkdev_open(struct inode *inode, struct file *filp) · line 610
Quoted 6 lines
block/fops.c +6
-0+/* +* Use the file private data to store the holder for exclusive opens. +* file_to_blk_mode relies on it being present to set BLK_OPEN_EXCL. +*/ +if (filp->f_flags &O_EXCL ) + filp->private_data = filp;Well, if we have
O_EXCLinf_flagshere, thenfile_to_blk_mode()on the next line is going to do the right thing and setBLK_OPEN_EXCLeven withoutfilp->private_data. So this shound't be needed AFAICT.
Fixed.
Christian Brauner
maintainerPATCH v2 33/34 block: expose bdev_file_inode()
In reply to Christian BraunerNow that we open block devices as files we don't need to rely on bd_inode to get to the correct inode. Use the helper.
We could use bdev_file->f_inode directly here since we know that @f_inode refers to a bdev fs inode but it is generically correct to use bdev_file->f_mapping->host since that will also work for bdev_files opened from userspace.
--- block/bdev.c | 2 +- block/fops.c | 5 ----- include/linux/blkdev.h | 5 +++++ 3 files changed, 6 insertions(+), 6 deletions(-)
block/bdev.c +1 -1
@@ -51,7 +51,7 @@ EXPORT_SYMBOL(I_BDEV);struct block_device *file_bdev (struct file *bdev_file) { -return I_BDEV (bdev_file->f_mapping->host); +return I_BDEV (bdev_file_inode (bdev_file)); }EXPORT_SYMBOL (file_bdev);
block/fops.c +0 -5
@@ -19,11 +19,6 @@#include <linux/module.h> #include "blk.h" -static inline struct inode *bdev_file_inode (struct file *file) -{ -return file->f_mapping->host; -} -static blk_opf_t dio_bio_write_op (struct kiocb *iocb) {blk_opf_t opf =REQ_OP_WRITE |REQ_SYNC |REQ_IDLE ;
include/linux/blkdev.h +5 -0
@@ -1490,6 +1490,11 @@ void blkdev_put_no_open(struct block_device *bdev);struct block_device *I_BDEV (struct inode *inode);struct block_device *file_bdev (struct file *bdev_file); +static inline struct inode *bdev_file_inode (struct file *file) +{ +return file->f_mapping->host; +} +#ifdef CONFIG_BLOCK void invalidate_bdev (struct block_device *bdev);int sync_blockdev (struct block_device *bdev);
Signature · 1 line
2.43.0
Jan Kara
reviewerRe: [PATCH v2 33/34] block: expose bdev_file_inode()
Quoted 9 lines · Christian Brauner
Now that we open block devices as files we don't need to rely on
bd_inodeto get to the correct inode. Use the helper.We could use
bdev_file->f_inodedirectly here since we know that @f_inode refers to a bdev fs inode but it is generically correct to usebdev_file->f_mapping->hostsince that will also work forbdev_filesopened from userspace.Signed-off-by Christian Brauner <[email protected]>
I think you wouldn't need this patch, if you picked up patch:
https://lore.kernel.org/all/[email protected]
from previous Yu Kuai's series. Because the only user of bdev_file_inode() in ext4 is actually dead code...
Honza
Quoted 55 lines
--- block/bdev.c | 2 +- block/fops.c | 5 ----- include/linux/blkdev.h | 5 +++++ 3 files changed, 6 insertions(+), 6 deletions(-)block/bdev.c +1
-1@@ -51,7 +51,7 @@ EXPORT_SYMBOL(I_BDEV);struct block_device *file_bdev (struct file *bdev_file) { -return I_BDEV (bdev_file->f_mapping->host); +return I_BDEV (bdev_file_inode (bdev_file)); }EXPORT_SYMBOL (file_bdev);block/fops.c +0
-5@@ -19,11 +19,6 @@#include <linux/module.h> #include "blk.h" -static inline struct inode *bdev_file_inode (struct file *file) -{ -return file->f_mapping->host; -} -static blk_opf_t dio_bio_write_op (struct kiocb *iocb) {blk_opf_t opf =REQ_OP_WRITE |REQ_SYNC |REQ_IDLE ;include/linux/blkdev.h +5
-0@@ -1490,6 +1490,11 @@ void blkdev_put_no_open(struct block_device *bdev);struct block_device *I_BDEV (struct inode *inode);struct block_device *file_bdev (struct file *bdev_file); +static inline struct inode *bdev_file_inode (struct file *file) +{ +return file->f_mapping->host; +} +#ifdef CONFIG_BLOCK void invalidate_bdev (struct block_device *bdev);int sync_blockdev (struct block_device *bdev);Signature · 2 lines
-- 2.43.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerPATCH v2 34/34 ext4: rely on sb->f_bdev only
In reply to Christian Brauner(1) Instead of bdev->bd_inode->i_mapping we do f_bdev->f_mapping
(2) Instead of bdev->bd_inode we could do f_bdev->f_inode
I mention this explicitly because (1) is dependent on how the block device is opened while (2) isn't. Consider:
mount -t tmpfs tmpfs /mnt
mknod /mnt/foo b <minor> <major>open("/mnt/foo", O_RDWR);
then (1) doesn't work because f_bdev->f_inode is a tmpfs inode _not_ the actual bdev filesystem inode. But (2) is still the bd_inode->i_mapping as that's set up during bdev_open().
IOW, I'm explicitly _not_ going via f_bdev->f_inode but via f_bdev->f_mapping->host aka bdev_file_inode(f_bdev). Currently this isn't a problem because sb->s_bdev_file stashes the a block device file opened via bdev_open_by_*() which is always a file on the bdev filesystem.
_If_ we ever wanted to allow userspace to pass a block device file descriptor during superblock creation. Say:
fsconfig(fs_fd, FSCONFIG_CMD_CREATE_EXCL, "source", bdev_fd);
then using f_bdev->f_inode would be very wrong. Another thing to keep in mind there would be that this would implicitly pin another filesystem. Say:
mount -t ext4 /dev/sda /mnt
mknod /mnt/foo b <minor> <major>bdev_fd = open("/mnt/foo", O_RDWR);
fd_fs = fsopen("xfs")fsconfig(fd_fs, FSCONFIG_CMD_CREATE, "source", bdev_fd); fd_mnt = fsmount(fd_fs);move_mount(fd_mnt, "/mnt2");
umount /mnt # EBUSY
Because the xfs filesystem now pins the ext4 filesystem via the bdev_file we're keeping. In other words, this is probably a bad idea and if we allow userspace to do this then we should only use the provided fd to lookup the block device and open our own handle to it.
--- fs/ext4/dir.c | 2 +- fs/ext4/ext4_jbd2.c | 2 +- fs/ext4/fast_commit.c | 2 +- fs/ext4/super.c | 37 +++++++++++++++++++------------------ 4 files changed, 22 insertions(+), 21 deletions(-)
fs/ext4/dir.c +1 -1
@@ -192,7 +192,7 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx) (PAGE_SHIFT - inode->i_blkbits);if (!ra_has_index (&file->f_ra, index))page_cache_sync_readahead ( - sb->s_bdev->bd_inode->i_mapping, + sb->s_bdev_file->f_mapping, &file->f_ra, file, index,1 ); file->f_ra.prev_pos = (loff_t )index <<PAGE_SHIFT ;
fs/ext4/ext4_jbd2.c +1 -1
@@ -206,7 +206,7 @@ static void ext4_journal_abort_handle(const char *caller, unsigned int line,static void ext4_check_bdev_write_error (struct super_block *sb) { -struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping; +struct address_space *mapping = sb->s_bdev_file->f_mapping;struct ext4_sb_info *sbi =EXT4_SB (sb);int err;
fs/ext4/fast_commit.c +1 -1
@@ -1605,7 +1605,7 @@ static int ext4_fc_replay_inode(struct super_block *sb, out:iput (inode);if (!ret) -blkdev_issue_flush (sb->s_bdev); +blkdev_issue_flush (file_bdev (sb->s_bdev_file));return 0 ; }
fs/ext4/super.c +19 -18
@@ -244,7 +244,7 @@ static struct buffer_head *__ext4_sb_bread_gfp(struct super_block *sb,struct buffer_head *ext4_sb_bread (struct super_block *sb,sector_t block,blk_opf_t op_flags) { -gfp_t gfp =mapping_gfp_constraint (sb->s_bdev->bd_inode->i_mapping, +gfp_t gfp =mapping_gfp_constraint (sb->s_bdev_file->f_mapping, ~__GFP_FS) | __GFP_MOVABLE;return __ext4_sb_bread_gfp (sb, block, op_flags, gfp);
@@ -253,7 +253,7 @@ struct buffer_head *ext4_sb_bread(struct super_block *sb, sector_t block,struct buffer_head *ext4_sb_bread_unmovable (struct super_block *sb,sector_t block) { -gfp_t gfp =mapping_gfp_constraint (sb->s_bdev->bd_inode->i_mapping, +gfp_t gfp =mapping_gfp_constraint (sb->s_bdev_file->f_mapping, ~__GFP_FS);return __ext4_sb_bread_gfp (sb, block,0 , gfp);
@@ -261,7 +261,7 @@ struct buffer_head *ext4_sb_bread_unmovable(struct super_block *sb,void ext4_sb_breadahead_unmovable (struct super_block *sb,sector_t block) { -struct buffer_head *bh =bdev_getblk (sb->s_bdev, block, +struct buffer_head *bh =bdev_getblk (file_bdev (sb->s_bdev_file), block, sb->s_blocksize,GFP_NOWAIT | __GFP_NOWARN);if (likely (bh)) {
@@ -477,7 +477,7 @@ static void ext4_maybe_update_superblock(struct super_block *sb)return ; lifetime_write_kbytes = sbi->s_kbytes_written + - ((part_stat_read (sb->s_bdev, sectors[STAT_WRITE ]) - + ((part_stat_read (file_bdev (sb->s_bdev_file), sectors[STAT_WRITE ]) - sbi->s_sectors_written_start) >>1 );/* Get the number of kilobytes not written to disk to account
@@ -502,7 +502,7 @@ static void ext4_maybe_update_superblock(struct super_block *sb)*/ static int block_device_ejected (struct super_block *sb) { -struct inode *bd_inode = sb->s_bdev->bd_inode; +struct inode *bd_inode =bdev_file_inode (sb->s_bdev_file);struct backing_dev_info *bdi =inode_to_bdi (bd_inode);return bdi->dev ==NULL ;
@@ -722,7 +722,7 @@ static void ext4_handle_error(struct super_block *sb, bool force_ro, int error,jbd2_journal_abort (journal, -EIO ); } -if (!bdev_read_only (sb->s_bdev)) { +if (!bdev_read_only (file_bdev (sb->s_bdev_file))) {save_error_info (sb, error, ino, block, func, line);/* * In case the fs should keep running, we need to writeout
@@ -1084,7 +1084,7 @@ __acquires(bitlock)if (test_opt (sb,WARN_ON_ERROR ))WARN_ON_ONCE (1 );EXT4_SB (sb)->s_mount_state |=EXT4_ERROR_FS ; -if (!bdev_read_only (sb->s_bdev)) { +if (!bdev_read_only (file_bdev (sb->s_bdev_file))) {save_error_info (sb,EFSCORRUPTED , ino, block, function, line);schedule_work (&EXT4_SB (sb)->s_sb_upd_work);
@@ -1357,8 +1357,8 @@ static void ext4_put_super(struct super_block *sb)dump_orphan_list (sb, sbi);ASSERT (list_empty (&sbi->s_orphan)); -sync_blockdev (sb->s_bdev); -invalidate_bdev (sb->s_bdev); +sync_blockdev (file_bdev (sb->s_bdev_file)); +invalidate_bdev (file_bdev (sb->s_bdev_file));if (sbi->s_journal_bdev_file) {/* * Invalidate the journal device's buffers. We don't want them
@@ -4329,7 +4329,7 @@ static struct ext4_sb_info *ext4_alloc_sbi(struct super_block *sb)if (!sbi)return NULL ; - sbi->s_daxdev =fs_dax_get_by_bdev (sb->s_bdev, &sbi->s_dax_part_off, + sbi->s_daxdev =fs_dax_get_by_bdev (file_bdev (sb->s_bdev_file), &sbi->s_dax_part_off,NULL ,NULL ); sbi->s_blockgroup_lock =
@@ -5222,7 +5222,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) sbi->s_inode_readahead_blks =EXT4_DEF_INODE_READAHEAD_BLKS ; sbi->s_sectors_written_start = -part_stat_read (sb->s_bdev, sectors[STAT_WRITE ]); +part_stat_read (file_bdev (sb->s_bdev_file), sectors[STAT_WRITE ]); err =ext4_load_super (sb, &logical_sb_block, silent);if (err)
@@ -5576,7 +5576,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb)* used to detect the metadata async write error. */ spin_lock_init (&sbi->s_bdev_wb_lock); -errseq_check_and_advance (&sb->s_bdev->bd_inode->i_mapping->wb_err, +errseq_check_and_advance (&sb->s_bdev_file->f_mapping->wb_err, &sbi->s_bdev_wb_err);EXT4_SB (sb)->s_mount_state |=EXT4_ORPHAN_FS ;ext4_orphan_cleanup (sb, es);
@@ -5596,7 +5596,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) goto failed_mount10; } -if (test_opt (sb,DISCARD ) && !bdev_max_discard_sectors (sb->s_bdev)) +if (test_opt (sb,DISCARD ) && !bdev_max_discard_sectors (file_bdev (sb->s_bdev_file)))ext4_msg (sb,KERN_WARNING ,"mounting with \"discard\" option, but the device does not support discard" );
@@ -5675,7 +5675,7 @@ failed_mount9: __maybe_unusedfput (sbi->s_journal_bdev_file); } out_fail: -invalidate_bdev (sb->s_bdev); +invalidate_bdev (file_bdev (sb->s_bdev_file)); sb->s_fs_info =NULL ;return err; }
@@ -5934,7 +5934,8 @@ static journal_t *ext4_open_dev_journal(struct super_block *sb,if (IS_ERR (bdev_file))return ERR_CAST (bdev_file); - journal =jbd2_journal_init_dev (file_bdev (bdev_file), sb->s_bdev, j_start, + journal =jbd2_journal_init_dev (file_bdev (bdev_file), +file_bdev (sb->s_bdev_file), j_start, j_len, sb->s_blocksize);if (IS_ERR (journal)) {ext4_msg (sb,KERN_ERR ,"failed to create device journal" );
@@ -5999,7 +6000,7 @@ static int ext4_load_journal(struct super_block *sb, } journal_dev_ro =bdev_read_only (journal->j_dev); - really_read_only =bdev_read_only (sb->s_bdev) | journal_dev_ro; + really_read_only =bdev_read_only (file_bdev (sb->s_bdev_file)) | journal_dev_ro;if (journal_dev_ro && !sb_rdonly (sb)) { ext4_msg(sb, KERN_ERR,
@@ -6116,7 +6117,7 @@ static void ext4_update_super(struct super_block *sb)ext4_update_tstamp (es, s_wtime); es->s_kbytes_written =cpu_to_le64 (sbi->s_kbytes_written + - ((part_stat_read (sb->s_bdev, sectors[STAT_WRITE ]) - + ((part_stat_read (file_bdev (sb->s_bdev_file), sectors[STAT_WRITE ]) - sbi->s_sectors_written_start) >>1 ));if (percpu_counter_initialized (&sbi->s_freeclusters_counter)) ext4_free_blocks_count_set(es,
@@ -6350,7 +6351,7 @@ static int ext4_sync_fs(struct super_block *sb, int wait) needs_barrier = true;if (needs_barrier) {int err; - err =blkdev_issue_flush (sb->s_bdev); + err =blkdev_issue_flush (file_bdev (sb->s_bdev_file));if (!ret) ret = err; }
Signature · 1 line
2.43.0
Jan Kara
reviewerRe: [PATCH v2 34/34] ext4: rely on sb->f_bdev only
Quoted 38 lines · Christian Brauner
(1) Instead of
bdev->bd_inode->i_mappingwe dof_bdev->f_mapping
(2) Instead ofbdev->bd_inodewe could dof_bdev->f_inodeI mention this explicitly because (1) is dependent on how the block device is opened while (2) isn't. Consider:
mount -t tmpfs tmpfs /mnt
mknod/mnt/foob <minor> <major>open("/mnt/foo", O_RDWR);then (1) doesn't work because
f_bdev->f_inodeis a tmpfs inode _not_ the actual bdev filesystem inode. But (2) is still thebd_inode->i_mappingas that's set up duringbdev_open().IOW, I'm explicitly _not_ going via
f_bdev->f_inodebut viaf_bdev->f_mapping->hostakabdev_file_inode(f_bdev). Currently this isn't a problem becausesb->s_bdev_filestashes the a block device file opened via bdev_open_by_*() which is always a file on the bdev filesystem._If_ we ever wanted to allow userspace to pass a block device file descriptor during superblock creation. Say:
fsconfig(fs_fd, FSCONFIG_CMD_CREATE_EXCL, "source", bdev_fd);then using
f_bdev->f_inodewould be very wrong. Another thing to keep in mind there would be that this would implicitly pin another filesystem. Say:mount -t ext4
/dev/sda/mnt
mknod/mnt/foob <minor> <major>bdev_fd=open("/mnt/foo", O_RDWR);
fd_fs=fsopen("xfs")fsconfig(fd_fs, FSCONFIG_CMD_CREATE, "source", bdev_fd);fd_mnt=fsmount(fd_fs);move_mount(fd_mnt, "/mnt2");
Quoted 8 lines
umount /mnt # EBUSY
Because the xfs filesystem now pins the ext4 filesystem via the
bdev_filewe're keeping. In other words, this is probably a bad idea and if we allow userspace to do this then we should only use the provided fd to lookup the block device and open our own handle to it.Signed-off-by Christian Brauner <[email protected]>
I suppose this is more or less a sample how to get rid of sb->s_bdev / bd_inode dereferences AFAICT? Because otherwise I'm not sure why it was included in this series...
fs/ext4/super.c static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) · line 5580
Quoted 7 lines
fs/ext4/super.c +1
-1@@ -5576,7 +5576,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb)* used to detect the metadata async write error. */ spin_lock_init (&sbi->s_bdev_wb_lock); -errseq_check_and_advance (&sb->s_bdev->bd_inode->i_mapping->wb_err, +errseq_check_and_advance (&sb->s_bdev_file->f_mapping->wb_err, &sbi->s_bdev_wb_err);
So when we have struct file, it would be actually nicer to drop EXT4_SB(sb)->s_bdev_wb_err completely and instead use file_check_and_advance_wb_err(sb->s_bdev_file). But that's a separate cleanup I suppose.
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Christian Brauner
maintainerRe: [PATCH v2 34/34] ext4: rely on sb->f_bdev only
Quoted 46 lines · Jan Kara
Quoted 45 lines · Christian Brauner
(1) Instead of
bdev->bd_inode->i_mappingwe dof_bdev->f_mapping
(2) Instead ofbdev->bd_inodewe could dof_bdev->f_inodeI mention this explicitly because (1) is dependent on how the block device is opened while (2) isn't. Consider:
mount -t tmpfs tmpfs /mnt
mknod/mnt/foob <minor> <major>open("/mnt/foo", O_RDWR);then (1) doesn't work because
f_bdev->f_inodeis a tmpfs inode _not_ the actual bdev filesystem inode. But (2) is still thebd_inode->i_mappingas that's set up duringbdev_open().IOW, I'm explicitly _not_ going via
f_bdev->f_inodebut viaf_bdev->f_mapping->hostakabdev_file_inode(f_bdev). Currently this isn't a problem becausesb->s_bdev_filestashes the a block device file opened via bdev_open_by_*() which is always a file on the bdev filesystem._If_ we ever wanted to allow userspace to pass a block device file descriptor during superblock creation. Say:
fsconfig(fs_fd, FSCONFIG_CMD_CREATE_EXCL, "source", bdev_fd);then using
f_bdev->f_inodewould be very wrong. Another thing to keep in mind there would be that this would implicitly pin another filesystem. Say:mount -t ext4
/dev/sda/mnt
mknod/mnt/foob <minor> <major>bdev_fd=open("/mnt/foo", O_RDWR);
fd_fs=fsopen("xfs")fsconfig(fd_fs, FSCONFIG_CMD_CREATE, "source", bdev_fd);fd_mnt=fsmount(fd_fs);move_mount(fd_mnt, "/mnt2");umount /mnt # EBUSY
Because the xfs filesystem now pins the ext4 filesystem via the
bdev_filewe're keeping. In other words, this is probably a bad idea and if we allow userspace to do this then we should only use the provided fd to lookup the block device and open our own handle to it.
Quoted 4 lines
Quoted 1 line
Signed-off-by Christian Brauner <[email protected]>I suppose this is more or less a sample how to get rid of
sb->s_bdev/bd_inodedereferences AFAICT? Because otherwise I'm not sure why it was
Yes, correct. That was just a way to show that you don't need that anymore.
Quoted 1 line
included in this series...
Yes, that would likely go separately.
Quoted 13 lines
fs/ext4/super.c static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) · line 5580
Quoted 8 lines
fs/ext4/super.c +1
-1@@ -5576,7 +5576,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb)* used to detect the metadata async write error. */ spin_lock_init (&sbi->s_bdev_wb_lock); -errseq_check_and_advance (&sb->s_bdev->bd_inode->i_mapping->wb_err, +errseq_check_and_advance (&sb->s_bdev_file->f_mapping->wb_err, &sbi->s_bdev_wb_err);So when we have struct file, it would be actually nicer to drop EXT4_SB(sb)->s_bdev_wb_err completely and instead use
file_check_and_advance_wb_err(sb->s_bdev_file). But that's a separate cleanup I suppose.
Yep. I forgot about that helper.
Christoph Hellwig
maintainerDo you have a git tree for this series?