Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
block: use the holder as indication for exclusive opens
The current interface for exclusive opens is rather confusing as it
requires both the FMODE_EXCL flag and a holder. Remove the need to pass
FMODE_EXCL and just key off the exclusive open off a non-NULL holder.
For blkdev_put this requires adding the holder argument, which provides
better debug checking that only the holder actually releases the hold,
but at the same time allows removing the now superfluous mode argument.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Acked-by: Christian Brauner <brauner@kernel.org>
Acked-by: David Sterba <dsterba@suse.com> [btrfs]
Acked-by: Jack Wang <jinpu.wang@ionos.com> [rnbd]
Link: https://lore.kernel.org/r/20230608110258.189493-16-hch@lst.de
Signed-off-by: Jens Axboe <axboe@kernel.dk>
authored by
Christoph Hellwig
and committed by
Jens Axboe
2736e8ee
2ef78928
+183
-192
+21
-16
block/bdev.c
+21
-16
block/bdev.c
···
604
604
}
605
605
EXPORT_SYMBOL(bd_abort_claiming);
606
606
607
-
static void bd_end_claim(struct block_device *bdev)
607
+
static void bd_end_claim(struct block_device *bdev, void *holder)
608
608
{
609
609
struct block_device *whole = bdev_whole(bdev);
610
610
bool unblock = false;
···
614
614
* bdev_lock. open_mutex is used to synchronize disk_holder unlinking.
615
615
*/
616
616
mutex_lock(&bdev_lock);
617
+
WARN_ON_ONCE(bdev->bd_holder != holder);
617
618
WARN_ON_ONCE(--bdev->bd_holders < 0);
618
619
WARN_ON_ONCE(--whole->bd_holders < 0);
619
620
if (!bdev->bd_holders) {
···
751
750
* @holder: exclusive holder identifier
752
751
* @hops: holder operations
753
752
*
754
-
* Open the block device described by device number @dev. If @mode includes
755
-
* %FMODE_EXCL, the block device is opened with exclusive access. Specifying
756
-
* %FMODE_EXCL with a %NULL @holder is invalid. Exclusive opens may nest for
757
-
* the same @holder.
753
+
* Open the block device described by device number @dev. If @holder is not
754
+
* %NULL, the block device is opened with exclusive access. Exclusive opens may
755
+
* nest for the same @holder.
758
756
*
759
757
* Use this interface ONLY if you really do not have anything better - i.e. when
760
758
* you are behind a truly sucky interface and all you are given is a device
···
785
785
return ERR_PTR(-ENXIO);
786
786
disk = bdev->bd_disk;
787
787
788
-
if (mode & FMODE_EXCL) {
788
+
if (holder) {
789
+
mode |= FMODE_EXCL;
789
790
ret = bd_prepare_to_claim(bdev, holder, hops);
790
791
if (ret)
791
792
goto put_blkdev;
793
+
} else {
794
+
if (WARN_ON_ONCE(mode & FMODE_EXCL)) {
795
+
ret = -EIO;
796
+
goto put_blkdev;
797
+
}
792
798
}
793
799
794
800
disk_block_events(disk);
···
811
805
ret = blkdev_get_whole(bdev, mode);
812
806
if (ret)
813
807
goto put_module;
814
-
if (mode & FMODE_EXCL) {
808
+
if (holder) {
815
809
bd_finish_claiming(bdev, holder, hops);
816
810
817
811
/*
···
835
829
put_module:
836
830
module_put(disk->fops->owner);
837
831
abort_claiming:
838
-
if (mode & FMODE_EXCL)
832
+
if (holder)
839
833
bd_abort_claiming(bdev, holder);
840
834
mutex_unlock(&disk->open_mutex);
841
835
disk_unblock_events(disk);
···
851
845
* @mode: FMODE_* mask
852
846
* @holder: exclusive holder identifier
853
847
*
854
-
* Open the block device described by the device file at @path. If @mode
855
-
* includes %FMODE_EXCL, the block device is opened with exclusive access.
856
-
* Specifying %FMODE_EXCL with a %NULL @holder is invalid. Exclusive opens may
857
-
* nest for the same @holder.
848
+
* Open the block device described by the device file at @path. If @holder is
849
+
* not %NULL, the block device is opened with exclusive access. Exclusive opens
850
+
* may nest for the same @holder.
858
851
*
859
852
* CONTEXT:
860
853
* Might sleep.
···
874
869
875
870
bdev = blkdev_get_by_dev(dev, mode, holder, hops);
876
871
if (!IS_ERR(bdev) && (mode & FMODE_WRITE) && bdev_read_only(bdev)) {
877
-
blkdev_put(bdev, mode);
872
+
blkdev_put(bdev, holder);
878
873
return ERR_PTR(-EACCES);
879
874
}
880
875
···
882
877
}
883
878
EXPORT_SYMBOL(blkdev_get_by_path);
884
879
885
-
void blkdev_put(struct block_device *bdev, fmode_t mode)
880
+
void blkdev_put(struct block_device *bdev, void *holder)
886
881
{
887
882
struct gendisk *disk = bdev->bd_disk;
888
883
···
897
892
sync_blockdev(bdev);
898
893
899
894
mutex_lock(&disk->open_mutex);
900
-
if (mode & FMODE_EXCL)
901
-
bd_end_claim(bdev);
895
+
if (holder)
896
+
bd_end_claim(bdev, holder);
902
897
903
898
/*
904
899
* Trigger event checking and tell drivers to flush MEDIA_CHANGE
+4
-2
block/fops.c
+4
-2
block/fops.c
···
490
490
if ((filp->f_flags & O_ACCMODE) == 3)
491
491
filp->f_mode |= FMODE_WRITE_IOCTL;
492
492
493
-
bdev = blkdev_get_by_dev(inode->i_rdev, filp->f_mode, filp, NULL);
493
+
bdev = blkdev_get_by_dev(inode->i_rdev, filp->f_mode,
494
+
(filp->f_mode & FMODE_EXCL) ? filp : NULL,
495
+
NULL);
494
496
if (IS_ERR(bdev))
495
497
return PTR_ERR(bdev);
496
498
···
506
504
{
507
505
struct block_device *bdev = filp->private_data;
508
506
509
-
blkdev_put(bdev, filp->f_mode);
507
+
blkdev_put(bdev, (filp->f_mode & FMODE_EXCL) ? filp : NULL);
510
508
return 0;
511
509
}
512
510
+2
-3
block/genhd.c
+2
-3
block/genhd.c
···
365
365
}
366
366
367
367
set_bit(GD_NEED_PART_SCAN, &disk->state);
368
-
bdev = blkdev_get_by_dev(disk_devt(disk), mode & ~FMODE_EXCL, NULL,
369
-
NULL);
368
+
bdev = blkdev_get_by_dev(disk_devt(disk), mode, NULL, NULL);
370
369
if (IS_ERR(bdev))
371
370
ret = PTR_ERR(bdev);
372
371
else
373
-
blkdev_put(bdev, mode & ~FMODE_EXCL);
372
+
blkdev_put(bdev, NULL);
374
373
375
374
/*
376
375
* If blkdev_get_by_dev() failed early, GD_NEED_PART_SCAN is still set,
+2
-3
block/ioctl.c
+2
-3
block/ioctl.c
···
454
454
if (mode & FMODE_EXCL)
455
455
return set_blocksize(bdev, n);
456
456
457
-
if (IS_ERR(blkdev_get_by_dev(bdev->bd_dev, mode | FMODE_EXCL, &bdev,
458
-
NULL)))
457
+
if (IS_ERR(blkdev_get_by_dev(bdev->bd_dev, mode, &bdev, NULL)))
459
458
return -EBUSY;
460
459
ret = set_blocksize(bdev, n);
461
-
blkdev_put(bdev, mode | FMODE_EXCL);
460
+
blkdev_put(bdev, &bdev);
462
461
463
462
return ret;
464
463
}
+14
-9
drivers/block/drbd/drbd_nl.c
+14
-9
drivers/block/drbd/drbd_nl.c
···
1640
1640
struct block_device *bdev;
1641
1641
int err = 0;
1642
1642
1643
-
bdev = blkdev_get_by_path(bdev_path,
1644
-
FMODE_READ | FMODE_WRITE | FMODE_EXCL,
1643
+
bdev = blkdev_get_by_path(bdev_path, FMODE_READ | FMODE_WRITE,
1645
1644
claim_ptr, NULL);
1646
1645
if (IS_ERR(bdev)) {
1647
1646
drbd_err(device, "open(\"%s\") failed with %ld\n",
···
1653
1654
1654
1655
err = bd_link_disk_holder(bdev, device->vdisk);
1655
1656
if (err) {
1656
-
blkdev_put(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
1657
+
blkdev_put(bdev, claim_ptr);
1657
1658
drbd_err(device, "bd_link_disk_holder(\"%s\", ...) failed with %d\n",
1658
1659
bdev_path, err);
1659
1660
bdev = ERR_PTR(err);
···
1695
1696
}
1696
1697
1697
1698
static void close_backing_dev(struct drbd_device *device, struct block_device *bdev,
1698
-
bool do_bd_unlink)
1699
+
void *claim_ptr, bool do_bd_unlink)
1699
1700
{
1700
1701
if (!bdev)
1701
1702
return;
1702
1703
if (do_bd_unlink)
1703
1704
bd_unlink_disk_holder(bdev, device->vdisk);
1704
-
blkdev_put(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
1705
+
blkdev_put(bdev, claim_ptr);
1705
1706
}
1706
1707
1707
1708
void drbd_backing_dev_free(struct drbd_device *device, struct drbd_backing_dev *ldev)
···
1709
1710
if (ldev == NULL)
1710
1711
return;
1711
1712
1712
-
close_backing_dev(device, ldev->md_bdev, ldev->md_bdev != ldev->backing_bdev);
1713
-
close_backing_dev(device, ldev->backing_bdev, true);
1713
+
close_backing_dev(device, ldev->md_bdev,
1714
+
ldev->md.meta_dev_idx < 0 ?
1715
+
(void *)device : (void *)drbd_m_holder,
1716
+
ldev->md_bdev != ldev->backing_bdev);
1717
+
close_backing_dev(device, ldev->backing_bdev, device, true);
1714
1718
1715
1719
kfree(ldev->disk_conf);
1716
1720
kfree(ldev);
···
2129
2127
fail:
2130
2128
conn_reconfig_done(connection);
2131
2129
if (nbc) {
2132
-
close_backing_dev(device, nbc->md_bdev, nbc->md_bdev != nbc->backing_bdev);
2133
-
close_backing_dev(device, nbc->backing_bdev, true);
2130
+
close_backing_dev(device, nbc->md_bdev,
2131
+
nbc->disk_conf->meta_dev_idx < 0 ?
2132
+
(void *)device : (void *)drbd_m_holder,
2133
+
nbc->md_bdev != nbc->backing_bdev);
2134
+
close_backing_dev(device, nbc->backing_bdev, device, true);
2134
2135
kfree(nbc);
2135
2136
}
2136
2137
kfree(new_disk_conf);
+6
-7
drivers/block/pktcdvd.c
+6
-7
drivers/block/pktcdvd.c
···
2167
2167
* to read/write from/to it. It is already opened in O_NONBLOCK mode
2168
2168
* so open should not fail.
2169
2169
*/
2170
-
bdev = blkdev_get_by_dev(pd->bdev->bd_dev, FMODE_READ | FMODE_EXCL, pd,
2171
-
NULL);
2170
+
bdev = blkdev_get_by_dev(pd->bdev->bd_dev, FMODE_READ, pd, NULL);
2172
2171
if (IS_ERR(bdev)) {
2173
2172
ret = PTR_ERR(bdev);
2174
2173
goto out;
···
2214
2215
return 0;
2215
2216
2216
2217
out_putdev:
2217
-
blkdev_put(bdev, FMODE_READ | FMODE_EXCL);
2218
+
blkdev_put(bdev, pd);
2218
2219
out:
2219
2220
return ret;
2220
2221
}
···
2233
2234
pkt_lock_door(pd, 0);
2234
2235
2235
2236
pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);
2236
-
blkdev_put(pd->bdev, FMODE_READ | FMODE_EXCL);
2237
+
blkdev_put(pd->bdev, pd);
2237
2238
2238
2239
pkt_shrink_pktlist(pd);
2239
2240
}
···
2519
2520
return PTR_ERR(bdev);
2520
2521
sdev = scsi_device_from_queue(bdev->bd_disk->queue);
2521
2522
if (!sdev) {
2522
-
blkdev_put(bdev, FMODE_READ | FMODE_NDELAY);
2523
+
blkdev_put(bdev, NULL);
2523
2524
return -EINVAL;
2524
2525
}
2525
2526
put_device(&sdev->sdev_gendev);
···
2544
2545
return 0;
2545
2546
2546
2547
out_mem:
2547
-
blkdev_put(bdev, FMODE_READ | FMODE_NDELAY);
2548
+
blkdev_put(bdev, NULL);
2548
2549
/* This is safe: open() is still holding a reference. */
2549
2550
module_put(THIS_MODULE);
2550
2551
return -ENOMEM;
···
2750
2751
pkt_debugfs_dev_remove(pd);
2751
2752
pkt_sysfs_dev_remove(pd);
2752
2753
2753
-
blkdev_put(pd->bdev, FMODE_READ | FMODE_NDELAY);
2754
+
blkdev_put(pd->bdev, NULL);
2754
2755
2755
2756
remove_proc_entry(pd->disk->disk_name, pkt_proc);
2756
2757
dev_notice(ddev, "writer unmapped\n");
+2
-2
drivers/block/rnbd/rnbd-srv.c
+2
-2
drivers/block/rnbd/rnbd-srv.c
···
219
219
rnbd_put_sess_dev(sess_dev);
220
220
wait_for_completion(&dc); /* wait for inflights to drop to zero */
221
221
222
-
blkdev_put(sess_dev->bdev, sess_dev->open_flags);
222
+
blkdev_put(sess_dev->bdev, NULL);
223
223
mutex_lock(&sess_dev->dev->lock);
224
224
list_del(&sess_dev->dev_list);
225
225
if (sess_dev->open_flags & FMODE_WRITE)
···
791
791
}
792
792
rnbd_put_srv_dev(srv_dev);
793
793
blkdev_put:
794
-
blkdev_put(bdev, open_flags);
794
+
blkdev_put(bdev, NULL);
795
795
free_path:
796
796
kfree(full_path);
797
797
reject:
+1
-1
drivers/block/xen-blkback/xenbus.c
+1
-1
drivers/block/xen-blkback/xenbus.c
+4
-4
drivers/block/zram/zram_drv.c
+4
-4
drivers/block/zram/zram_drv.c
···
420
420
return;
421
421
422
422
bdev = zram->bdev;
423
-
blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
423
+
blkdev_put(bdev, zram);
424
424
/* hope filp_close flush all of IO */
425
425
filp_close(zram->backing_dev, NULL);
426
426
zram->backing_dev = NULL;
···
507
507
goto out;
508
508
}
509
509
510
-
bdev = blkdev_get_by_dev(inode->i_rdev,
511
-
FMODE_READ | FMODE_WRITE | FMODE_EXCL, zram, NULL);
510
+
bdev = blkdev_get_by_dev(inode->i_rdev, FMODE_READ | FMODE_WRITE, zram,
511
+
NULL);
512
512
if (IS_ERR(bdev)) {
513
513
err = PTR_ERR(bdev);
514
514
bdev = NULL;
···
539
539
kvfree(bitmap);
540
540
541
541
if (bdev)
542
-
blkdev_put(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
542
+
blkdev_put(bdev, zram);
543
543
544
544
if (backing_dev)
545
545
filp_close(backing_dev, NULL);
+7
-8
drivers/md/bcache/super.c
+7
-8
drivers/md/bcache/super.c
···
1369
1369
put_page(virt_to_page(dc->sb_disk));
1370
1370
1371
1371
if (!IS_ERR_OR_NULL(dc->bdev))
1372
-
blkdev_put(dc->bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
1372
+
blkdev_put(dc->bdev, bcache_kobj);
1373
1373
1374
1374
wake_up(&unregister_wait);
1375
1375
···
2218
2218
put_page(virt_to_page(ca->sb_disk));
2219
2219
2220
2220
if (!IS_ERR_OR_NULL(ca->bdev))
2221
-
blkdev_put(ca->bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
2221
+
blkdev_put(ca->bdev, bcache_kobj);
2222
2222
2223
2223
kfree(ca);
2224
2224
module_put(THIS_MODULE);
···
2359
2359
* call blkdev_put() to bdev in bch_cache_release(). So we
2360
2360
* explicitly call blkdev_put() here.
2361
2361
*/
2362
-
blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
2362
+
blkdev_put(bdev, bcache_kobj);
2363
2363
if (ret == -ENOMEM)
2364
2364
err = "cache_alloc(): -ENOMEM";
2365
2365
else if (ret == -EPERM)
···
2461
2461
if (!dc) {
2462
2462
fail = true;
2463
2463
put_page(virt_to_page(args->sb_disk));
2464
-
blkdev_put(args->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2464
+
blkdev_put(args->bdev, bcache_kobj);
2465
2465
goto out;
2466
2466
}
2467
2467
···
2491
2491
if (!ca) {
2492
2492
fail = true;
2493
2493
put_page(virt_to_page(args->sb_disk));
2494
-
blkdev_put(args->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2494
+
blkdev_put(args->bdev, bcache_kobj);
2495
2495
goto out;
2496
2496
}
2497
2497
···
2558
2558
2559
2559
ret = -EINVAL;
2560
2560
err = "failed to open device";
2561
-
bdev = blkdev_get_by_path(strim(path),
2562
-
FMODE_READ|FMODE_WRITE|FMODE_EXCL,
2561
+
bdev = blkdev_get_by_path(strim(path), FMODE_READ | FMODE_WRITE,
2563
2562
bcache_kobj, NULL);
2564
2563
if (IS_ERR(bdev)) {
2565
2564
if (bdev == ERR_PTR(-EBUSY)) {
···
2647
2648
out_put_sb_page:
2648
2649
put_page(virt_to_page(sb_disk));
2649
2650
out_blkdev_put:
2650
-
blkdev_put(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2651
+
blkdev_put(bdev, register_bcache);
2651
2652
out_free_sb:
2652
2653
kfree(sb);
2653
2654
out_free_path:
+3
-3
drivers/md/dm.c
+3
-3
drivers/md/dm.c
···
746
746
return ERR_PTR(-ENOMEM);
747
747
refcount_set(&td->count, 1);
748
748
749
-
bdev = blkdev_get_by_dev(dev, mode | FMODE_EXCL, _dm_claim_ptr, NULL);
749
+
bdev = blkdev_get_by_dev(dev, mode, _dm_claim_ptr, NULL);
750
750
if (IS_ERR(bdev)) {
751
751
r = PTR_ERR(bdev);
752
752
goto out_free_td;
···
771
771
return td;
772
772
773
773
out_blkdev_put:
774
-
blkdev_put(bdev, mode | FMODE_EXCL);
774
+
blkdev_put(bdev, _dm_claim_ptr);
775
775
out_free_td:
776
776
kfree(td);
777
777
return ERR_PTR(r);
···
784
784
{
785
785
if (md->disk->slave_dir)
786
786
bd_unlink_disk_holder(td->dm_dev.bdev, md->disk);
787
-
blkdev_put(td->dm_dev.bdev, td->dm_dev.mode | FMODE_EXCL);
787
+
blkdev_put(td->dm_dev.bdev, _dm_claim_ptr);
788
788
put_dax(td->dm_dev.dax_dev);
789
789
list_del(&td->list);
790
790
kfree(td);
+20
-18
drivers/md/md.c
+20
-18
drivers/md/md.c
···
2449
2449
2450
2450
void md_autodetect_dev(dev_t dev);
2451
2451
2452
-
static void export_rdev(struct md_rdev *rdev)
2452
+
/* just for claiming the bdev */
2453
+
static struct md_rdev claim_rdev;
2454
+
2455
+
static void export_rdev(struct md_rdev *rdev, struct mddev *mddev)
2453
2456
{
2454
2457
pr_debug("md: export_rdev(%pg)\n", rdev->bdev);
2455
2458
md_rdev_clear(rdev);
···
2460
2457
if (test_bit(AutoDetected, &rdev->flags))
2461
2458
md_autodetect_dev(rdev->bdev->bd_dev);
2462
2459
#endif
2463
-
blkdev_put(rdev->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2460
+
blkdev_put(rdev->bdev, mddev->major_version == -2 ? &claim_rdev : rdev);
2464
2461
rdev->bdev = NULL;
2465
2462
kobject_put(&rdev->kobj);
2466
2463
}
···
2488
2485
INIT_WORK(&rdev->del_work, rdev_delayed_delete);
2489
2486
kobject_get(&rdev->kobj);
2490
2487
queue_work(md_rdev_misc_wq, &rdev->del_work);
2491
-
export_rdev(rdev);
2488
+
export_rdev(rdev, rdev->mddev);
2492
2489
}
2493
2490
2494
2491
static void export_array(struct mddev *mddev)
···
3615
3612
return badblocks_init(&rdev->badblocks, 0);
3616
3613
}
3617
3614
EXPORT_SYMBOL_GPL(md_rdev_init);
3615
+
3618
3616
/*
3619
3617
* Import a device. If 'super_format' >= 0, then sanity check the superblock
3620
3618
*
···
3628
3624
*/
3629
3625
static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
3630
3626
{
3631
-
static struct md_rdev claim_rdev; /* just for claiming the bdev */
3632
3627
struct md_rdev *rdev;
3633
3628
sector_t size;
3634
3629
int err;
···
3643
3640
if (err)
3644
3641
goto out_clear_rdev;
3645
3642
3646
-
rdev->bdev = blkdev_get_by_dev(newdev,
3647
-
FMODE_READ | FMODE_WRITE | FMODE_EXCL,
3643
+
rdev->bdev = blkdev_get_by_dev(newdev, FMODE_READ | FMODE_WRITE,
3648
3644
super_format == -2 ? &claim_rdev : rdev, NULL);
3649
3645
if (IS_ERR(rdev->bdev)) {
3650
3646
pr_warn("md: could not open device unknown-block(%u,%u).\n",
···
3681
3679
return rdev;
3682
3680
3683
3681
out_blkdev_put:
3684
-
blkdev_put(rdev->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
3682
+
blkdev_put(rdev->bdev, super_format == -2 ? &claim_rdev : rdev);
3685
3683
out_clear_rdev:
3686
3684
md_rdev_clear(rdev);
3687
3685
out_free_rdev:
···
4562
4560
err = bind_rdev_to_array(rdev, mddev);
4563
4561
out:
4564
4562
if (err)
4565
-
export_rdev(rdev);
4563
+
export_rdev(rdev, mddev);
4566
4564
mddev_unlock(mddev);
4567
4565
if (!err)
4568
4566
md_new_event();
···
6500
6498
rdev_for_each_list(rdev, tmp, &candidates) {
6501
6499
list_del_init(&rdev->same_set);
6502
6500
if (bind_rdev_to_array(rdev, mddev))
6503
-
export_rdev(rdev);
6501
+
export_rdev(rdev, mddev);
6504
6502
}
6505
6503
autorun_array(mddev);
6506
6504
mddev_unlock(mddev);
···
6510
6508
*/
6511
6509
rdev_for_each_list(rdev, tmp, &candidates) {
6512
6510
list_del_init(&rdev->same_set);
6513
-
export_rdev(rdev);
6511
+
export_rdev(rdev, mddev);
6514
6512
}
6515
6513
mddev_put(mddev);
6516
6514
}
···
6698
6696
pr_warn("md: %pg has different UUID to %pg\n",
6699
6697
rdev->bdev,
6700
6698
rdev0->bdev);
6701
-
export_rdev(rdev);
6699
+
export_rdev(rdev, mddev);
6702
6700
return -EINVAL;
6703
6701
}
6704
6702
}
6705
6703
err = bind_rdev_to_array(rdev, mddev);
6706
6704
if (err)
6707
-
export_rdev(rdev);
6705
+
export_rdev(rdev, mddev);
6708
6706
return err;
6709
6707
}
6710
6708
···
6748
6746
/* This was a hot-add request, but events doesn't
6749
6747
* match, so reject it.
6750
6748
*/
6751
-
export_rdev(rdev);
6749
+
export_rdev(rdev, mddev);
6752
6750
return -EINVAL;
6753
6751
}
6754
6752
···
6774
6772
}
6775
6773
}
6776
6774
if (has_journal || mddev->bitmap) {
6777
-
export_rdev(rdev);
6775
+
export_rdev(rdev, mddev);
6778
6776
return -EBUSY;
6779
6777
}
6780
6778
set_bit(Journal, &rdev->flags);
···
6789
6787
/* --add initiated by this node */
6790
6788
err = md_cluster_ops->add_new_disk(mddev, rdev);
6791
6789
if (err) {
6792
-
export_rdev(rdev);
6790
+
export_rdev(rdev, mddev);
6793
6791
return err;
6794
6792
}
6795
6793
}
···
6799
6797
err = bind_rdev_to_array(rdev, mddev);
6800
6798
6801
6799
if (err)
6802
-
export_rdev(rdev);
6800
+
export_rdev(rdev, mddev);
6803
6801
6804
6802
if (mddev_is_clustered(mddev)) {
6805
6803
if (info->state & (1 << MD_DISK_CANDIDATE)) {
···
6862
6860
6863
6861
err = bind_rdev_to_array(rdev, mddev);
6864
6862
if (err) {
6865
-
export_rdev(rdev);
6863
+
export_rdev(rdev, mddev);
6866
6864
return err;
6867
6865
}
6868
6866
}
···
6987
6985
return 0;
6988
6986
6989
6987
abort_export:
6990
-
export_rdev(rdev);
6988
+
export_rdev(rdev, mddev);
6991
6989
return err;
6992
6990
}
6993
6991
+2
-2
drivers/mtd/devices/block2mtd.c
+2
-2
drivers/mtd/devices/block2mtd.c
···
209
209
if (dev->blkdev) {
210
210
invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping,
211
211
0, -1);
212
-
blkdev_put(dev->blkdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
212
+
blkdev_put(dev->blkdev, NULL);
213
213
}
214
214
215
215
kfree(dev);
···
261
261
static struct block2mtd_dev *add_device(char *devname, int erase_size,
262
262
char *label, int timeout)
263
263
{
264
-
const fmode_t mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
264
+
const fmode_t mode = FMODE_READ | FMODE_WRITE;
265
265
struct block_device *bdev;
266
266
struct block2mtd_dev *dev;
267
267
char *name;
+1
-1
drivers/nvme/target/io-cmd-bdev.c
+1
-1
drivers/nvme/target/io-cmd-bdev.c
+1
-1
drivers/s390/block/dasd_genhd.c
+1
-1
drivers/s390/block/dasd_genhd.c
+3
-3
drivers/target/target_core_iblock.c
+3
-3
drivers/target/target_core_iblock.c
···
108
108
pr_debug( "IBLOCK: Claiming struct block_device: %s\n",
109
109
ib_dev->ibd_udev_path);
110
110
111
-
mode = FMODE_READ|FMODE_EXCL;
111
+
mode = FMODE_READ;
112
112
if (!ib_dev->ibd_readonly)
113
113
mode |= FMODE_WRITE;
114
114
else
···
175
175
return 0;
176
176
177
177
out_blkdev_put:
178
-
blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL);
178
+
blkdev_put(ib_dev->ibd_bd, ib_dev);
179
179
out_free_bioset:
180
180
bioset_exit(&ib_dev->ibd_bio_set);
181
181
out:
···
201
201
struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
202
202
203
203
if (ib_dev->ibd_bd != NULL)
204
-
blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL);
204
+
blkdev_put(ib_dev->ibd_bd, ib_dev);
205
205
bioset_exit(&ib_dev->ibd_bio_set);
206
206
}
207
207
+3
-5
drivers/target/target_core_pscsi.c
+3
-5
drivers/target/target_core_pscsi.c
···
366
366
* Claim exclusive struct block_device access to struct scsi_device
367
367
* for TYPE_DISK and TYPE_ZBC using supplied udev_path
368
368
*/
369
-
bd = blkdev_get_by_path(dev->udev_path,
370
-
FMODE_WRITE|FMODE_READ|FMODE_EXCL, pdv,
369
+
bd = blkdev_get_by_path(dev->udev_path, FMODE_WRITE | FMODE_READ, pdv,
371
370
NULL);
372
371
if (IS_ERR(bd)) {
373
372
pr_err("pSCSI: blkdev_get_by_path() failed\n");
···
377
378
378
379
ret = pscsi_add_device_to_list(dev, sd);
379
380
if (ret) {
380
-
blkdev_put(pdv->pdv_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL);
381
+
blkdev_put(pdv->pdv_bd, pdv);
381
382
scsi_device_put(sd);
382
383
return ret;
383
384
}
···
565
566
*/
566
567
if ((sd->type == TYPE_DISK || sd->type == TYPE_ZBC) &&
567
568
pdv->pdv_bd) {
568
-
blkdev_put(pdv->pdv_bd,
569
-
FMODE_WRITE|FMODE_READ|FMODE_EXCL);
569
+
blkdev_put(pdv->pdv_bd, pdv);
570
570
pdv->pdv_bd = NULL;
571
571
}
572
572
/*
+3
-3
fs/btrfs/dev-replace.c
+3
-3
fs/btrfs/dev-replace.c
···
257
257
return -EINVAL;
258
258
}
259
259
260
-
bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
260
+
bdev = blkdev_get_by_path(device_path, FMODE_WRITE,
261
261
fs_info->bdev_holder, NULL);
262
262
if (IS_ERR(bdev)) {
263
263
btrfs_err(fs_info, "target device %s is invalid!", device_path);
···
315
315
device->bdev = bdev;
316
316
set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
317
317
set_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state);
318
-
device->mode = FMODE_EXCL;
318
+
device->holder = fs_info->bdev_holder;
319
319
device->dev_stats_valid = 1;
320
320
set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
321
321
device->fs_devices = fs_devices;
···
334
334
return 0;
335
335
336
336
error:
337
-
blkdev_put(bdev, FMODE_EXCL);
337
+
blkdev_put(bdev, fs_info->bdev_holder);
338
338
return ret;
339
339
}
340
340
+6
-6
fs/btrfs/ioctl.c
+6
-6
fs/btrfs/ioctl.c
···
2672
2672
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2673
2673
struct btrfs_ioctl_vol_args_v2 *vol_args;
2674
2674
struct block_device *bdev = NULL;
2675
-
fmode_t mode;
2675
+
void *holder;
2676
2676
int ret;
2677
2677
bool cancel = false;
2678
2678
···
2709
2709
goto err_drop;
2710
2710
2711
2711
/* Exclusive operation is now claimed */
2712
-
ret = btrfs_rm_device(fs_info, &args, &bdev, &mode);
2712
+
ret = btrfs_rm_device(fs_info, &args, &bdev, &holder);
2713
2713
2714
2714
btrfs_exclop_finish(fs_info);
2715
2715
···
2724
2724
err_drop:
2725
2725
mnt_drop_write_file(file);
2726
2726
if (bdev)
2727
-
blkdev_put(bdev, mode);
2727
+
blkdev_put(bdev, holder);
2728
2728
out:
2729
2729
btrfs_put_dev_args_from_path(&args);
2730
2730
kfree(vol_args);
···
2738
2738
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2739
2739
struct btrfs_ioctl_vol_args *vol_args;
2740
2740
struct block_device *bdev = NULL;
2741
-
fmode_t mode;
2741
+
void *holder;
2742
2742
int ret;
2743
2743
bool cancel = false;
2744
2744
···
2765
2765
ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_DEV_REMOVE,
2766
2766
cancel);
2767
2767
if (ret == 0) {
2768
-
ret = btrfs_rm_device(fs_info, &args, &bdev, &mode);
2768
+
ret = btrfs_rm_device(fs_info, &args, &bdev, &holder);
2769
2769
if (!ret)
2770
2770
btrfs_info(fs_info, "disk deleted %s", vol_args->name);
2771
2771
btrfs_exclop_finish(fs_info);
···
2773
2773
2774
2774
mnt_drop_write_file(file);
2775
2775
if (bdev)
2776
-
blkdev_put(bdev, mode);
2776
+
blkdev_put(bdev, holder);
2777
2777
out:
2778
2778
btrfs_put_dev_args_from_path(&args);
2779
2779
kfree(vol_args);
+13
-15
fs/btrfs/volumes.c
+13
-15
fs/btrfs/volumes.c
···
507
507
sync_blockdev(*bdev);
508
508
ret = set_blocksize(*bdev, BTRFS_BDEV_BLOCKSIZE);
509
509
if (ret) {
510
-
blkdev_put(*bdev, flags);
510
+
blkdev_put(*bdev, holder);
511
511
goto error;
512
512
}
513
513
invalidate_bdev(*bdev);
514
514
*disk_super = btrfs_read_dev_super(*bdev);
515
515
if (IS_ERR(*disk_super)) {
516
516
ret = PTR_ERR(*disk_super);
517
-
blkdev_put(*bdev, flags);
517
+
blkdev_put(*bdev, holder);
518
518
goto error;
519
519
}
520
520
···
642
642
643
643
device->bdev = bdev;
644
644
clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
645
-
device->mode = flags;
645
+
device->holder = holder;
646
646
647
647
fs_devices->open_devices++;
648
648
if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) &&
···
656
656
657
657
error_free_page:
658
658
btrfs_release_disk_super(disk_super);
659
-
blkdev_put(bdev, flags);
659
+
blkdev_put(bdev, holder);
660
660
661
661
return -EINVAL;
662
662
}
···
1057
1057
continue;
1058
1058
1059
1059
if (device->bdev) {
1060
-
blkdev_put(device->bdev, device->mode);
1060
+
blkdev_put(device->bdev, device->holder);
1061
1061
device->bdev = NULL;
1062
1062
fs_devices->open_devices--;
1063
1063
}
···
1103
1103
invalidate_bdev(device->bdev);
1104
1104
}
1105
1105
1106
-
blkdev_put(device->bdev, device->mode);
1106
+
blkdev_put(device->bdev, device->holder);
1107
1107
}
1108
1108
1109
1109
static void btrfs_close_one_device(struct btrfs_device *device)
···
1212
1212
struct btrfs_device *device;
1213
1213
struct btrfs_device *latest_dev = NULL;
1214
1214
struct btrfs_device *tmp_device;
1215
-
1216
-
flags |= FMODE_EXCL;
1217
1215
1218
1216
list_for_each_entry_safe(device, tmp_device, &fs_devices->devices,
1219
1217
dev_list) {
···
1398
1400
btrfs_release_disk_super(disk_super);
1399
1401
1400
1402
error_bdev_put:
1401
-
blkdev_put(bdev, flags);
1403
+
blkdev_put(bdev, NULL);
1402
1404
1403
1405
return device;
1404
1406
}
···
2085
2087
2086
2088
int btrfs_rm_device(struct btrfs_fs_info *fs_info,
2087
2089
struct btrfs_dev_lookup_args *args,
2088
-
struct block_device **bdev, fmode_t *mode)
2090
+
struct block_device **bdev, void **holder)
2089
2091
{
2090
2092
struct btrfs_trans_handle *trans;
2091
2093
struct btrfs_device *device;
···
2224
2226
}
2225
2227
2226
2228
*bdev = device->bdev;
2227
-
*mode = device->mode;
2229
+
*holder = device->holder;
2228
2230
synchronize_rcu();
2229
2231
btrfs_free_device(device);
2230
2232
···
2392
2394
else
2393
2395
memcpy(args->fsid, disk_super->fsid, BTRFS_FSID_SIZE);
2394
2396
btrfs_release_disk_super(disk_super);
2395
-
blkdev_put(bdev, FMODE_READ);
2397
+
blkdev_put(bdev, NULL);
2396
2398
return 0;
2397
2399
}
2398
2400
···
2625
2627
if (sb_rdonly(sb) && !fs_devices->seeding)
2626
2628
return -EROFS;
2627
2629
2628
-
bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
2630
+
bdev = blkdev_get_by_path(device_path, FMODE_WRITE,
2629
2631
fs_info->bdev_holder, NULL);
2630
2632
if (IS_ERR(bdev))
2631
2633
return PTR_ERR(bdev);
···
2688
2690
device->commit_total_bytes = device->total_bytes;
2689
2691
set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
2690
2692
clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state);
2691
-
device->mode = FMODE_EXCL;
2693
+
device->holder = fs_info->bdev_holder;
2692
2694
device->dev_stats_valid = 1;
2693
2695
set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
2694
2696
···
2846
2848
error_free_device:
2847
2849
btrfs_free_device(device);
2848
2850
error:
2849
-
blkdev_put(bdev, FMODE_EXCL);
2851
+
blkdev_put(bdev, fs_info->bdev_holder);
2850
2852
if (locked) {
2851
2853
mutex_unlock(&uuid_mutex);
2852
2854
up_write(&sb->s_umount);
+3
-3
fs/btrfs/volumes.h
+3
-3
fs/btrfs/volumes.h
···
94
94
95
95
struct btrfs_zoned_device_info *zone_info;
96
96
97
-
/* the mode sent to blkdev_get */
98
-
fmode_t mode;
97
+
/* block device holder for blkdev_get/put */
98
+
void *holder;
99
99
100
100
/*
101
101
* Device's major-minor number. Must be set even if the device is not
···
619
619
void btrfs_free_device(struct btrfs_device *device);
620
620
int btrfs_rm_device(struct btrfs_fs_info *fs_info,
621
621
struct btrfs_dev_lookup_args *args,
622
-
struct block_device **bdev, fmode_t *mode);
622
+
struct block_device **bdev, void **holder);
623
623
void __exit btrfs_cleanup_fs_uuids(void);
624
624
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
625
625
int btrfs_grow_device(struct btrfs_trans_handle *trans,
+4
-3
fs/erofs/super.c
+4
-3
fs/erofs/super.c
···
19
19
#include <trace/events/erofs.h>
20
20
21
21
static struct kmem_cache *erofs_inode_cachep __read_mostly;
22
+
struct file_system_type erofs_fs_type;
22
23
23
24
void _erofs_err(struct super_block *sb, const char *function,
24
25
const char *fmt, ...)
···
254
253
return PTR_ERR(fscache);
255
254
dif->fscache = fscache;
256
255
} else if (!sbi->devs->flatdev) {
257
-
bdev = blkdev_get_by_path(dif->path, FMODE_READ | FMODE_EXCL,
258
-
sb->s_type, NULL);
256
+
bdev = blkdev_get_by_path(dif->path, FMODE_READ, sb->s_type,
257
+
NULL);
259
258
if (IS_ERR(bdev))
260
259
return PTR_ERR(bdev);
261
260
dif->bdev = bdev;
···
878
877
879
878
fs_put_dax(dif->dax_dev, NULL);
880
879
if (dif->bdev)
881
-
blkdev_put(dif->bdev, FMODE_READ | FMODE_EXCL);
880
+
blkdev_put(dif->bdev, &erofs_fs_type);
882
881
erofs_fscache_unregister_cookie(dif->fscache);
883
882
dif->fscache = NULL;
884
883
kfree(dif->path);
+3
-8
fs/ext4/super.c
+3
-8
fs/ext4/super.c
···
1112
1112
{
1113
1113
struct block_device *bdev;
1114
1114
1115
-
bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, sb,
1115
+
bdev = blkdev_get_by_dev(dev, FMODE_READ | FMODE_WRITE, sb,
1116
1116
&ext4_holder_ops);
1117
1117
if (IS_ERR(bdev))
1118
1118
goto fail;
···
1128
1128
/*
1129
1129
* Release the journal device
1130
1130
*/
1131
-
static void ext4_blkdev_put(struct block_device *bdev)
1132
-
{
1133
-
blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
1134
-
}
1135
-
1136
1131
static void ext4_blkdev_remove(struct ext4_sb_info *sbi)
1137
1132
{
1138
1133
struct block_device *bdev;
1139
1134
bdev = sbi->s_journal_bdev;
1140
1135
if (bdev) {
1141
-
ext4_blkdev_put(bdev);
1136
+
blkdev_put(bdev, sbi->s_es);
1142
1137
sbi->s_journal_bdev = NULL;
1143
1138
}
1144
1139
}
···
5910
5915
out_journal:
5911
5916
jbd2_journal_destroy(journal);
5912
5917
out_bdev:
5913
-
ext4_blkdev_put(bdev);
5918
+
blkdev_put(bdev, sb);
5914
5919
return NULL;
5915
5920
}
5916
5921
+1
-1
fs/f2fs/super.c
+1
-1
fs/f2fs/super.c
+3
-3
fs/jfs/jfs_logmgr.c
+3
-3
fs/jfs/jfs_logmgr.c
···
1100
1100
* file systems to log may have n-to-1 relationship;
1101
1101
*/
1102
1102
1103
-
bdev = blkdev_get_by_dev(sbi->logdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
1103
+
bdev = blkdev_get_by_dev(sbi->logdev, FMODE_READ | FMODE_WRITE,
1104
1104
log, NULL);
1105
1105
if (IS_ERR(bdev)) {
1106
1106
rc = PTR_ERR(bdev);
···
1141
1141
lbmLogShutdown(log);
1142
1142
1143
1143
close: /* close external log device */
1144
-
blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
1144
+
blkdev_put(bdev, log);
1145
1145
1146
1146
free: /* free log descriptor */
1147
1147
mutex_unlock(&jfs_log_mutex);
···
1485
1485
bdev = log->bdev;
1486
1486
rc = lmLogShutdown(log);
1487
1487
1488
-
blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
1488
+
blkdev_put(bdev, log);
1489
1489
1490
1490
kfree(log);
1491
1491
+2
-2
fs/nfs/blocklayout/dev.c
+2
-2
fs/nfs/blocklayout/dev.c
···
35
35
}
36
36
37
37
if (dev->bdev)
38
-
blkdev_put(dev->bdev, FMODE_READ | FMODE_WRITE);
38
+
blkdev_put(dev->bdev, NULL);
39
39
}
40
40
}
41
41
···
374
374
return 0;
375
375
376
376
out_blkdev_put:
377
-
blkdev_put(d->bdev, FMODE_READ | FMODE_WRITE);
377
+
blkdev_put(d->bdev, NULL);
378
378
return error;
379
379
}
380
380
+3
-3
fs/nilfs2/super.c
+3
-3
fs/nilfs2/super.c
···
1278
1278
{
1279
1279
struct nilfs_super_data sd;
1280
1280
struct super_block *s;
1281
-
fmode_t mode = FMODE_READ | FMODE_EXCL;
1281
+
fmode_t mode = FMODE_READ;
1282
1282
struct dentry *root_dentry;
1283
1283
int err, s_new = false;
1284
1284
···
1357
1357
}
1358
1358
1359
1359
if (!s_new)
1360
-
blkdev_put(sd.bdev, mode);
1360
+
blkdev_put(sd.bdev, fs_type);
1361
1361
1362
1362
return root_dentry;
1363
1363
···
1366
1366
1367
1367
failed:
1368
1368
if (!s_new)
1369
-
blkdev_put(sd.bdev, mode);
1369
+
blkdev_put(sd.bdev, fs_type);
1370
1370
return ERR_PTR(err);
1371
1371
}
1372
1372
+2
-2
fs/ocfs2/cluster/heartbeat.c
+2
-2
fs/ocfs2/cluster/heartbeat.c
···
1503
1503
}
1504
1504
1505
1505
if (reg->hr_bdev)
1506
-
blkdev_put(reg->hr_bdev, FMODE_READ|FMODE_WRITE);
1506
+
blkdev_put(reg->hr_bdev, NULL);
1507
1507
1508
1508
kfree(reg->hr_slots);
1509
1509
···
1893
1893
1894
1894
out3:
1895
1895
if (ret < 0) {
1896
-
blkdev_put(reg->hr_bdev, FMODE_READ | FMODE_WRITE);
1896
+
blkdev_put(reg->hr_bdev, NULL);
1897
1897
reg->hr_bdev = NULL;
1898
1898
}
1899
1899
out2:
+9
-10
fs/reiserfs/journal.c
+9
-10
fs/reiserfs/journal.c
···
2589
2589
struct reiserfs_journal *journal)
2590
2590
{
2591
2591
if (journal->j_dev_bd != NULL) {
2592
-
blkdev_put(journal->j_dev_bd, journal->j_dev_mode);
2592
+
blkdev_put(journal->j_dev_bd, journal);
2593
2593
journal->j_dev_bd = NULL;
2594
2594
}
2595
2595
}
···
2598
2598
struct reiserfs_journal *journal,
2599
2599
const char *jdev_name)
2600
2600
{
2601
+
fmode_t blkdev_mode = FMODE_READ;
2602
+
void *holder = journal;
2601
2603
int result;
2602
2604
dev_t jdev;
2603
-
fmode_t blkdev_mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
2604
2605
2605
2606
result = 0;
2606
2607
···
2609
2608
jdev = SB_ONDISK_JOURNAL_DEVICE(super) ?
2610
2609
new_decode_dev(SB_ONDISK_JOURNAL_DEVICE(super)) : super->s_dev;
2611
2610
2612
-
if (bdev_read_only(super->s_bdev))
2613
-
blkdev_mode = FMODE_READ;
2611
+
if (!bdev_read_only(super->s_bdev))
2612
+
blkdev_mode |= FMODE_WRITE;
2614
2613
2615
2614
/* there is no "jdev" option and journal is on separate device */
2616
2615
if ((!jdev_name || !jdev_name[0])) {
2617
2616
if (jdev == super->s_dev)
2618
-
blkdev_mode &= ~FMODE_EXCL;
2619
-
journal->j_dev_bd = blkdev_get_by_dev(jdev, blkdev_mode,
2620
-
journal, NULL);
2621
-
journal->j_dev_mode = blkdev_mode;
2617
+
holder = NULL;
2618
+
journal->j_dev_bd = blkdev_get_by_dev(jdev, blkdev_mode, holder,
2619
+
NULL);
2622
2620
if (IS_ERR(journal->j_dev_bd)) {
2623
2621
result = PTR_ERR(journal->j_dev_bd);
2624
2622
journal->j_dev_bd = NULL;
···
2631
2631
return 0;
2632
2632
}
2633
2633
2634
-
journal->j_dev_mode = blkdev_mode;
2635
-
journal->j_dev_bd = blkdev_get_by_path(jdev_name, blkdev_mode, journal,
2634
+
journal->j_dev_bd = blkdev_get_by_path(jdev_name, blkdev_mode, holder,
2636
2635
NULL);
2637
2636
if (IS_ERR(journal->j_dev_bd)) {
2638
2637
result = PTR_ERR(journal->j_dev_bd);
-1
fs/reiserfs/reiserfs.h
-1
fs/reiserfs/reiserfs.h
+9
-11
fs/super.c
+9
-11
fs/super.c
···
1255
1255
{
1256
1256
struct block_device *bdev;
1257
1257
struct super_block *s;
1258
-
fmode_t mode = FMODE_READ | FMODE_EXCL;
1258
+
fmode_t mode = FMODE_READ;
1259
1259
int error = 0;
1260
1260
1261
1261
if (!(fc->sb_flags & SB_RDONLY))
···
1279
1279
if (bdev->bd_fsfreeze_count > 0) {
1280
1280
mutex_unlock(&bdev->bd_fsfreeze_mutex);
1281
1281
warnf(fc, "%pg: Can't mount, blockdev is frozen", bdev);
1282
-
blkdev_put(bdev, mode);
1282
+
blkdev_put(bdev, fc->fs_type);
1283
1283
return -EBUSY;
1284
1284
}
1285
1285
···
1288
1288
s = sget_fc(fc, test_bdev_super_fc, set_bdev_super_fc);
1289
1289
mutex_unlock(&bdev->bd_fsfreeze_mutex);
1290
1290
if (IS_ERR(s)) {
1291
-
blkdev_put(bdev, mode);
1291
+
blkdev_put(bdev, fc->fs_type);
1292
1292
return PTR_ERR(s);
1293
1293
}
1294
1294
···
1297
1297
if ((fc->sb_flags ^ s->s_flags) & SB_RDONLY) {
1298
1298
warnf(fc, "%pg: Can't mount, would change RO state", bdev);
1299
1299
deactivate_locked_super(s);
1300
-
blkdev_put(bdev, mode);
1300
+
blkdev_put(bdev, fc->fs_type);
1301
1301
return -EBUSY;
1302
1302
}
1303
1303
···
1309
1309
* holding an active reference.
1310
1310
*/
1311
1311
up_write(&s->s_umount);
1312
-
blkdev_put(bdev, mode);
1312
+
blkdev_put(bdev, fc->fs_type);
1313
1313
down_write(&s->s_umount);
1314
1314
} else {
1315
1315
s->s_mode = mode;
···
1344
1344
{
1345
1345
struct block_device *bdev;
1346
1346
struct super_block *s;
1347
-
fmode_t mode = FMODE_READ | FMODE_EXCL;
1347
+
fmode_t mode = FMODE_READ;
1348
1348
int error = 0;
1349
1349
1350
1350
if (!(flags & SB_RDONLY))
···
1386
1386
* holding an active reference.
1387
1387
*/
1388
1388
up_write(&s->s_umount);
1389
-
blkdev_put(bdev, mode);
1389
+
blkdev_put(bdev, fs_type);
1390
1390
down_write(&s->s_umount);
1391
1391
} else {
1392
1392
s->s_mode = mode;
···
1409
1409
error_s:
1410
1410
error = PTR_ERR(s);
1411
1411
error_bdev:
1412
-
blkdev_put(bdev, mode);
1412
+
blkdev_put(bdev, fs_type);
1413
1413
error:
1414
1414
return ERR_PTR(error);
1415
1415
}
···
1418
1418
void kill_block_super(struct super_block *sb)
1419
1419
{
1420
1420
struct block_device *bdev = sb->s_bdev;
1421
-
fmode_t mode = sb->s_mode;
1422
1421
1423
1422
bdev->bd_super = NULL;
1424
1423
generic_shutdown_super(sb);
1425
1424
sync_blockdev(bdev);
1426
-
WARN_ON_ONCE(!(mode & FMODE_EXCL));
1427
-
blkdev_put(bdev, mode | FMODE_EXCL);
1425
+
blkdev_put(bdev, sb->s_type);
1428
1426
}
1429
1427
1430
1428
EXPORT_SYMBOL(kill_block_super);
+8
-7
fs/xfs/xfs_super.c
+8
-7
fs/xfs/xfs_super.c
···
396
396
{
397
397
int error = 0;
398
398
399
-
*bdevp = blkdev_get_by_path(name, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
400
-
mp, &xfs_holder_ops);
399
+
*bdevp = blkdev_get_by_path(name, FMODE_READ | FMODE_WRITE, mp,
400
+
&xfs_holder_ops);
401
401
if (IS_ERR(*bdevp)) {
402
402
error = PTR_ERR(*bdevp);
403
403
xfs_warn(mp, "Invalid device [%s], error=%d", name, error);
···
408
408
409
409
STATIC void
410
410
xfs_blkdev_put(
411
+
struct xfs_mount *mp,
411
412
struct block_device *bdev)
412
413
{
413
414
if (bdev)
414
-
blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
415
+
blkdev_put(bdev, mp);
415
416
}
416
417
417
418
STATIC void
···
423
422
struct block_device *logdev = mp->m_logdev_targp->bt_bdev;
424
423
425
424
xfs_free_buftarg(mp->m_logdev_targp);
426
-
xfs_blkdev_put(logdev);
425
+
xfs_blkdev_put(mp, logdev);
427
426
}
428
427
if (mp->m_rtdev_targp) {
429
428
struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev;
430
429
431
430
xfs_free_buftarg(mp->m_rtdev_targp);
432
-
xfs_blkdev_put(rtdev);
431
+
xfs_blkdev_put(mp, rtdev);
433
432
}
434
433
xfs_free_buftarg(mp->m_ddev_targp);
435
434
}
···
504
503
out_free_ddev_targ:
505
504
xfs_free_buftarg(mp->m_ddev_targp);
506
505
out_close_rtdev:
507
-
xfs_blkdev_put(rtdev);
506
+
xfs_blkdev_put(mp, rtdev);
508
507
out_close_logdev:
509
508
if (logdev && logdev != ddev)
510
-
xfs_blkdev_put(logdev);
509
+
xfs_blkdev_put(mp, logdev);
511
510
return error;
512
511
}
513
512
+1
-1
include/linux/blkdev.h
+1
-1
include/linux/blkdev.h
···
1480
1480
int bd_prepare_to_claim(struct block_device *bdev, void *holder,
1481
1481
const struct blk_holder_ops *hops);
1482
1482
void bd_abort_claiming(struct block_device *bdev, void *holder);
1483
-
void blkdev_put(struct block_device *bdev, fmode_t mode);
1483
+
void blkdev_put(struct block_device *bdev, void *holder);
1484
1484
1485
1485
/* just for blk-cgroup, don't use elsewhere */
1486
1486
struct block_device *blkdev_get_no_open(dev_t dev);
+4
-8
kernel/power/hibernate.c
+4
-8
kernel/power/hibernate.c
···
688
688
{
689
689
int error;
690
690
unsigned int flags;
691
-
fmode_t mode = FMODE_READ;
692
-
693
-
if (snapshot_test)
694
-
mode |= FMODE_EXCL;
695
691
696
692
pm_pr_dbg("Loading hibernation image.\n");
697
693
698
694
lock_device_hotplug();
699
695
error = create_basic_memory_bitmaps();
700
696
if (error) {
701
-
swsusp_close(mode);
697
+
swsusp_close(snapshot_test);
702
698
goto Unlock;
703
699
}
704
700
705
701
error = swsusp_read(&flags);
706
-
swsusp_close(mode);
702
+
swsusp_close(snapshot_test);
707
703
if (!error)
708
704
error = hibernation_restore(flags & SF_PLATFORM_MODE);
709
705
···
952
956
/* The snapshot device should not be opened while we're running */
953
957
if (!hibernate_acquire()) {
954
958
error = -EBUSY;
955
-
swsusp_close(FMODE_READ | FMODE_EXCL);
959
+
swsusp_close(false);
956
960
goto Unlock;
957
961
}
958
962
···
987
991
pm_pr_dbg("Hibernation image not present or could not be loaded.\n");
988
992
return error;
989
993
Close_Finish:
990
-
swsusp_close(FMODE_READ | FMODE_EXCL);
994
+
swsusp_close(false);
991
995
goto Finish;
992
996
}
993
997
+1
-1
kernel/power/power.h
+1
-1
kernel/power/power.h
···
177
177
extern void swsusp_free(void);
178
178
extern int swsusp_read(unsigned int *flags_p);
179
179
extern int swsusp_write(unsigned int flags);
180
-
extern void swsusp_close(fmode_t);
180
+
void swsusp_close(bool snapshot_test);
181
181
#ifdef CONFIG_SUSPEND
182
182
extern int swsusp_unmark(void);
183
183
#endif
+9
-12
kernel/power/swap.c
+9
-12
kernel/power/swap.c
···
363
363
364
364
res = set_blocksize(hib_resume_bdev, PAGE_SIZE);
365
365
if (res < 0)
366
-
blkdev_put(hib_resume_bdev, FMODE_WRITE);
366
+
blkdev_put(hib_resume_bdev, NULL);
367
367
368
368
return res;
369
369
}
···
443
443
err_rel:
444
444
release_swap_writer(handle);
445
445
err_close:
446
-
swsusp_close(FMODE_WRITE);
446
+
swsusp_close(false);
447
447
return ret;
448
448
}
449
449
···
508
508
if (error)
509
509
free_all_swap_pages(root_swap);
510
510
release_swap_writer(handle);
511
-
swsusp_close(FMODE_WRITE);
511
+
swsusp_close(false);
512
512
513
513
return error;
514
514
}
···
1518
1518
1519
1519
int swsusp_check(bool snapshot_test)
1520
1520
{
1521
+
void *holder = snapshot_test ? &swsusp_holder : NULL;
1521
1522
int error;
1522
-
fmode_t mode = FMODE_READ;
1523
1523
1524
-
if (snapshot_test)
1525
-
mode |= FMODE_EXCL;
1526
-
1527
-
hib_resume_bdev = blkdev_get_by_dev(swsusp_resume_device,
1528
-
mode, &swsusp_holder, NULL);
1524
+
hib_resume_bdev = blkdev_get_by_dev(swsusp_resume_device, FMODE_READ,
1525
+
holder, NULL);
1529
1526
if (!IS_ERR(hib_resume_bdev)) {
1530
1527
set_blocksize(hib_resume_bdev, PAGE_SIZE);
1531
1528
clear_page(swsusp_header);
···
1549
1552
1550
1553
put:
1551
1554
if (error)
1552
-
blkdev_put(hib_resume_bdev, mode);
1555
+
blkdev_put(hib_resume_bdev, holder);
1553
1556
else
1554
1557
pr_debug("Image signature found, resuming\n");
1555
1558
} else {
···
1566
1569
* swsusp_close - close swap device.
1567
1570
*/
1568
1571
1569
-
void swsusp_close(fmode_t mode)
1572
+
void swsusp_close(bool snapshot_test)
1570
1573
{
1571
1574
if (IS_ERR(hib_resume_bdev)) {
1572
1575
pr_debug("Image device not initialised\n");
1573
1576
return;
1574
1577
}
1575
1578
1576
-
blkdev_put(hib_resume_bdev, mode);
1579
+
blkdev_put(hib_resume_bdev, snapshot_test ? &swsusp_holder : NULL);
1577
1580
}
1578
1581
1579
1582
/**
+3
-4
mm/swapfile.c
+3
-4
mm/swapfile.c
···
2539
2539
struct block_device *bdev = I_BDEV(inode);
2540
2540
2541
2541
set_blocksize(bdev, old_block_size);
2542
-
blkdev_put(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2542
+
blkdev_put(bdev, p);
2543
2543
}
2544
2544
2545
2545
inode_lock(inode);
···
2770
2770
2771
2771
if (S_ISBLK(inode->i_mode)) {
2772
2772
p->bdev = blkdev_get_by_dev(inode->i_rdev,
2773
-
FMODE_READ | FMODE_WRITE | FMODE_EXCL, p,
2774
-
NULL);
2773
+
FMODE_READ | FMODE_WRITE, p, NULL);
2775
2774
if (IS_ERR(p->bdev)) {
2776
2775
error = PTR_ERR(p->bdev);
2777
2776
p->bdev = NULL;
···
3221
3222
p->cluster_next_cpu = NULL;
3222
3223
if (inode && S_ISBLK(inode->i_mode) && p->bdev) {
3223
3224
set_blocksize(p->bdev, p->old_block_size);
3224
-
blkdev_put(p->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
3225
+
blkdev_put(p->bdev, p);
3225
3226
}
3226
3227
inode = NULL;
3227
3228
destroy_swap_extents(p);