Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
block: introduce holder ops
Add a new blk_holder_ops structure, which is passed to blkdev_get_by_* and
installed in the block_device for exclusive claims. It will be used to
allow the block layer to call back into the user of the block device for
thing like notification of a removed device or a device resize.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Jan Kara <jack@suse.cz>
Acked-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Link: https://lore.kernel.org/r/20230601094459.1350643-10-hch@lst.de
Signed-off-by: Jens Axboe <axboe@kernel.dk>
authored by
Christoph Hellwig
and committed by
Jens Axboe
0718afd4
00080f7f
+90
-56
+29
-12
block/bdev.c
+29
-12
block/bdev.c
···
102
102
* under live filesystem.
103
103
*/
104
104
if (!(mode & FMODE_EXCL)) {
105
-
int err = bd_prepare_to_claim(bdev, truncate_bdev_range);
105
+
int err = bd_prepare_to_claim(bdev, truncate_bdev_range, NULL);
106
106
if (err)
107
107
goto invalidate;
108
108
}
···
415
415
bdev = I_BDEV(inode);
416
416
mutex_init(&bdev->bd_fsfreeze_mutex);
417
417
spin_lock_init(&bdev->bd_size_lock);
418
+
mutex_init(&bdev->bd_holder_lock);
418
419
bdev->bd_partno = partno;
419
420
bdev->bd_inode = inode;
420
421
bdev->bd_queue = disk->queue;
···
465
464
* bd_may_claim - test whether a block device can be claimed
466
465
* @bdev: block device of interest
467
466
* @holder: holder trying to claim @bdev
467
+
* @hops: holder ops
468
468
*
469
469
* Test whether @bdev can be claimed by @holder.
470
470
*
471
471
* RETURNS:
472
472
* %true if @bdev can be claimed, %false otherwise.
473
473
*/
474
-
static bool bd_may_claim(struct block_device *bdev, void *holder)
474
+
static bool bd_may_claim(struct block_device *bdev, void *holder,
475
+
const struct blk_holder_ops *hops)
475
476
{
476
477
struct block_device *whole = bdev_whole(bdev);
477
478
···
483
480
/*
484
481
* The same holder can always re-claim.
485
482
*/
486
-
if (bdev->bd_holder == holder)
483
+
if (bdev->bd_holder == holder) {
484
+
if (WARN_ON_ONCE(bdev->bd_holder_ops != hops))
485
+
return false;
487
486
return true;
487
+
}
488
488
return false;
489
489
}
490
490
···
505
499
* bd_prepare_to_claim - claim a block device
506
500
* @bdev: block device of interest
507
501
* @holder: holder trying to claim @bdev
502
+
* @hops: holder ops.
508
503
*
509
504
* Claim @bdev. This function fails if @bdev is already claimed by another
510
505
* holder and waits if another claiming is in progress. return, the caller
···
514
507
* RETURNS:
515
508
* 0 if @bdev can be claimed, -EBUSY otherwise.
516
509
*/
517
-
int bd_prepare_to_claim(struct block_device *bdev, void *holder)
510
+
int bd_prepare_to_claim(struct block_device *bdev, void *holder,
511
+
const struct blk_holder_ops *hops)
518
512
{
519
513
struct block_device *whole = bdev_whole(bdev);
520
514
···
524
516
retry:
525
517
mutex_lock(&bdev_lock);
526
518
/* if someone else claimed, fail */
527
-
if (!bd_may_claim(bdev, holder)) {
519
+
if (!bd_may_claim(bdev, holder, hops)) {
528
520
mutex_unlock(&bdev_lock);
529
521
return -EBUSY;
530
522
}
···
565
557
* Finish exclusive open of a block device. Mark the device as exlusively
566
558
* open by the holder and wake up all waiters for exclusive open to finish.
567
559
*/
568
-
static void bd_finish_claiming(struct block_device *bdev, void *holder)
560
+
static void bd_finish_claiming(struct block_device *bdev, void *holder,
561
+
const struct blk_holder_ops *hops)
569
562
{
570
563
struct block_device *whole = bdev_whole(bdev);
571
564
572
565
mutex_lock(&bdev_lock);
573
-
BUG_ON(!bd_may_claim(bdev, holder));
566
+
BUG_ON(!bd_may_claim(bdev, holder, hops));
574
567
/*
575
568
* Note that for a whole device bd_holders will be incremented twice,
576
569
* and bd_holder will be set to bd_may_claim before being set to holder
···
579
570
whole->bd_holders++;
580
571
whole->bd_holder = bd_may_claim;
581
572
bdev->bd_holders++;
573
+
mutex_lock(&bdev->bd_holder_lock);
582
574
bdev->bd_holder = holder;
575
+
bdev->bd_holder_ops = hops;
576
+
mutex_unlock(&bdev->bd_holder_lock);
583
577
bd_clear_claiming(whole, holder);
584
578
mutex_unlock(&bdev_lock);
585
579
}
···
617
605
WARN_ON_ONCE(--bdev->bd_holders < 0);
618
606
WARN_ON_ONCE(--whole->bd_holders < 0);
619
607
if (!bdev->bd_holders) {
608
+
mutex_lock(&bdev->bd_holder_lock);
620
609
bdev->bd_holder = NULL;
610
+
bdev->bd_holder_ops = NULL;
611
+
mutex_unlock(&bdev->bd_holder_lock);
621
612
if (bdev->bd_write_holder)
622
613
unblock = true;
623
614
}
···
750
735
* @dev: device number of block device to open
751
736
* @mode: FMODE_* mask
752
737
* @holder: exclusive holder identifier
738
+
* @hops: holder operations
753
739
*
754
740
* Open the block device described by device number @dev. If @mode includes
755
741
* %FMODE_EXCL, the block device is opened with exclusive access. Specifying
···
767
751
* RETURNS:
768
752
* Reference to the block_device on success, ERR_PTR(-errno) on failure.
769
753
*/
770
-
struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder)
754
+
struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder,
755
+
const struct blk_holder_ops *hops)
771
756
{
772
757
bool unblock_events = true;
773
758
struct block_device *bdev;
···
788
771
disk = bdev->bd_disk;
789
772
790
773
if (mode & FMODE_EXCL) {
791
-
ret = bd_prepare_to_claim(bdev, holder);
774
+
ret = bd_prepare_to_claim(bdev, holder, hops);
792
775
if (ret)
793
776
goto put_blkdev;
794
777
}
···
808
791
if (ret)
809
792
goto put_module;
810
793
if (mode & FMODE_EXCL) {
811
-
bd_finish_claiming(bdev, holder);
794
+
bd_finish_claiming(bdev, holder, hops);
812
795
813
796
/*
814
797
* Block event polling for write claims if requested. Any write
···
859
842
* Reference to the block_device on success, ERR_PTR(-errno) on failure.
860
843
*/
861
844
struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
862
-
void *holder)
845
+
void *holder, const struct blk_holder_ops *hops)
863
846
{
864
847
struct block_device *bdev;
865
848
dev_t dev;
···
869
852
if (error)
870
853
return ERR_PTR(error);
871
854
872
-
bdev = blkdev_get_by_dev(dev, mode, holder);
855
+
bdev = blkdev_get_by_dev(dev, mode, holder, hops);
873
856
if (!IS_ERR(bdev) && (mode & FMODE_WRITE) && bdev_read_only(bdev)) {
874
857
blkdev_put(bdev, mode);
875
858
return ERR_PTR(-EACCES);
+1
-1
block/fops.c
+1
-1
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);
493
+
bdev = blkdev_get_by_dev(inode->i_rdev, filp->f_mode, filp, NULL);
494
494
if (IS_ERR(bdev))
495
495
return PTR_ERR(bdev);
496
496
+4
-2
block/genhd.c
+4
-2
block/genhd.c
···
370
370
* scanners.
371
371
*/
372
372
if (!(mode & FMODE_EXCL)) {
373
-
ret = bd_prepare_to_claim(disk->part0, disk_scan_partitions);
373
+
ret = bd_prepare_to_claim(disk->part0, disk_scan_partitions,
374
+
NULL);
374
375
if (ret)
375
376
return ret;
376
377
}
377
378
378
379
set_bit(GD_NEED_PART_SCAN, &disk->state);
379
-
bdev = blkdev_get_by_dev(disk_devt(disk), mode & ~FMODE_EXCL, NULL);
380
+
bdev = blkdev_get_by_dev(disk_devt(disk), mode & ~FMODE_EXCL, NULL,
381
+
NULL);
380
382
if (IS_ERR(bdev))
381
383
ret = PTR_ERR(bdev);
382
384
else
+2
-1
block/ioctl.c
+2
-1
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)))
457
+
if (IS_ERR(blkdev_get_by_dev(bdev->bd_dev, mode | FMODE_EXCL, &bdev,
458
+
NULL)))
458
459
return -EBUSY;
459
460
ret = set_blocksize(bdev, n);
460
461
blkdev_put(bdev, mode | FMODE_EXCL);
+2
-1
drivers/block/drbd/drbd_nl.c
+2
-1
drivers/block/drbd/drbd_nl.c
···
1641
1641
int err = 0;
1642
1642
1643
1643
bdev = blkdev_get_by_path(bdev_path,
1644
-
FMODE_READ | FMODE_WRITE | FMODE_EXCL, claim_ptr);
1644
+
FMODE_READ | FMODE_WRITE | FMODE_EXCL,
1645
+
claim_ptr, NULL);
1645
1646
if (IS_ERR(bdev)) {
1646
1647
drbd_err(device, "open(\"%s\") failed with %ld\n",
1647
1648
bdev_path, PTR_ERR(bdev));
+1
-1
drivers/block/loop.c
+1
-1
drivers/block/loop.c
+3
-2
drivers/block/pktcdvd.c
+3
-2
drivers/block/pktcdvd.c
···
2125
2125
* to read/write from/to it. It is already opened in O_NONBLOCK mode
2126
2126
* so open should not fail.
2127
2127
*/
2128
-
bdev = blkdev_get_by_dev(pd->bdev->bd_dev, FMODE_READ | FMODE_EXCL, pd);
2128
+
bdev = blkdev_get_by_dev(pd->bdev->bd_dev, FMODE_READ | FMODE_EXCL, pd,
2129
+
NULL);
2129
2130
if (IS_ERR(bdev)) {
2130
2131
ret = PTR_ERR(bdev);
2131
2132
goto out;
···
2531
2530
}
2532
2531
}
2533
2532
2534
-
bdev = blkdev_get_by_dev(dev, FMODE_READ | FMODE_NDELAY, NULL);
2533
+
bdev = blkdev_get_by_dev(dev, FMODE_READ | FMODE_NDELAY, NULL, NULL);
2535
2534
if (IS_ERR(bdev))
2536
2535
return PTR_ERR(bdev);
2537
2536
sdev = scsi_device_from_queue(bdev->bd_disk->queue);
+1
-1
drivers/block/rnbd/rnbd-srv.c
+1
-1
drivers/block/rnbd/rnbd-srv.c
···
719
719
goto reject;
720
720
}
721
721
722
-
bdev = blkdev_get_by_path(full_path, open_flags, THIS_MODULE);
722
+
bdev = blkdev_get_by_path(full_path, open_flags, THIS_MODULE, NULL);
723
723
if (IS_ERR(bdev)) {
724
724
ret = PTR_ERR(bdev);
725
725
pr_err("Opening device '%s' on session %s failed, failed to open the block device, err: %d\n",
+1
-1
drivers/block/xen-blkback/xenbus.c
+1
-1
drivers/block/xen-blkback/xenbus.c
···
492
492
vbd->pdevice = MKDEV(major, minor);
493
493
494
494
bdev = blkdev_get_by_dev(vbd->pdevice, vbd->readonly ?
495
-
FMODE_READ : FMODE_WRITE, NULL);
495
+
FMODE_READ : FMODE_WRITE, NULL, NULL);
496
496
497
497
if (IS_ERR(bdev)) {
498
498
pr_warn("xen_vbd_create: device %08x could not be opened\n",
+1
-1
drivers/block/zram/zram_drv.c
+1
-1
drivers/block/zram/zram_drv.c
+1
-1
drivers/md/bcache/super.c
+1
-1
drivers/md/bcache/super.c
+1
-1
drivers/md/dm.c
+1
-1
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);
749
+
bdev = blkdev_get_by_dev(dev, mode | FMODE_EXCL, _dm_claim_ptr, NULL);
750
750
if (IS_ERR(bdev)) {
751
751
r = PTR_ERR(bdev);
752
752
goto out_free_td;
+1
-1
drivers/md/md.c
+1
-1
drivers/md/md.c
···
3642
3642
3643
3643
rdev->bdev = blkdev_get_by_dev(newdev,
3644
3644
FMODE_READ | FMODE_WRITE | FMODE_EXCL,
3645
-
super_format == -2 ? &claim_rdev : rdev);
3645
+
super_format == -2 ? &claim_rdev : rdev, NULL);
3646
3646
if (IS_ERR(rdev->bdev)) {
3647
3647
pr_warn("md: could not open device unknown-block(%u,%u).\n",
3648
3648
MAJOR(newdev), MINOR(newdev));
+2
-2
drivers/mtd/devices/block2mtd.c
+2
-2
drivers/mtd/devices/block2mtd.c
···
235
235
return NULL;
236
236
237
237
/* Get a handle on the device */
238
-
bdev = blkdev_get_by_path(devname, mode, dev);
238
+
bdev = blkdev_get_by_path(devname, mode, dev, NULL);
239
239
240
240
#ifndef MODULE
241
241
/*
···
257
257
devt = name_to_dev_t(devname);
258
258
if (!devt)
259
259
continue;
260
-
bdev = blkdev_get_by_dev(devt, mode, dev);
260
+
bdev = blkdev_get_by_dev(devt, mode, dev, NULL);
261
261
}
262
262
#endif
263
263
+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
···
130
130
struct block_device *bdev;
131
131
int rc;
132
132
133
-
bdev = blkdev_get_by_dev(disk_devt(block->gdp), FMODE_READ, NULL);
133
+
bdev = blkdev_get_by_dev(disk_devt(block->gdp), FMODE_READ, NULL, NULL);
134
134
if (IS_ERR(bdev)) {
135
135
DBF_DEV_EVENT(DBF_ERR, block->base,
136
136
"scan partitions error, blkdev_get returned %ld",
+1
-1
drivers/target/target_core_iblock.c
+1
-1
drivers/target/target_core_iblock.c
+2
-1
drivers/target/target_core_pscsi.c
+2
-1
drivers/target/target_core_pscsi.c
···
367
367
* for TYPE_DISK and TYPE_ZBC using supplied udev_path
368
368
*/
369
369
bd = blkdev_get_by_path(dev->udev_path,
370
-
FMODE_WRITE|FMODE_READ|FMODE_EXCL, pdv);
370
+
FMODE_WRITE|FMODE_READ|FMODE_EXCL, pdv,
371
+
NULL);
371
372
if (IS_ERR(bd)) {
372
373
pr_err("pSCSI: blkdev_get_by_path() failed\n");
373
374
scsi_device_put(sd);
+1
-1
fs/btrfs/dev-replace.c
+1
-1
fs/btrfs/dev-replace.c
+3
-3
fs/btrfs/volumes.c
+3
-3
fs/btrfs/volumes.c
···
496
496
{
497
497
int ret;
498
498
499
-
*bdev = blkdev_get_by_path(device_path, flags, holder);
499
+
*bdev = blkdev_get_by_path(device_path, flags, holder, NULL);
500
500
501
501
if (IS_ERR(*bdev)) {
502
502
ret = PTR_ERR(*bdev);
···
1377
1377
* values temporarily, as the device paths of the fsid are the only
1378
1378
* required information for assembling the volume.
1379
1379
*/
1380
-
bdev = blkdev_get_by_path(path, flags, holder);
1380
+
bdev = blkdev_get_by_path(path, flags, holder, NULL);
1381
1381
if (IS_ERR(bdev))
1382
1382
return ERR_CAST(bdev);
1383
1383
···
2629
2629
return -EROFS;
2630
2630
2631
2631
bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
2632
-
fs_info->bdev_holder);
2632
+
fs_info->bdev_holder, NULL);
2633
2633
if (IS_ERR(bdev))
2634
2634
return PTR_ERR(bdev);
2635
2635
+1
-1
fs/erofs/super.c
+1
-1
fs/erofs/super.c
+2
-1
fs/ext4/super.c
+2
-1
fs/ext4/super.c
···
1103
1103
{
1104
1104
struct block_device *bdev;
1105
1105
1106
-
bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, sb);
1106
+
bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, sb,
1107
+
NULL);
1107
1108
if (IS_ERR(bdev))
1108
1109
goto fail;
1109
1110
return bdev;
+2
-2
fs/f2fs/super.c
+2
-2
fs/f2fs/super.c
···
4025
4025
/* Single zoned block device mount */
4026
4026
FDEV(0).bdev =
4027
4027
blkdev_get_by_dev(sbi->sb->s_bdev->bd_dev,
4028
-
sbi->sb->s_mode, sbi->sb->s_type);
4028
+
sbi->sb->s_mode, sbi->sb->s_type, NULL);
4029
4029
} else {
4030
4030
/* Multi-device mount */
4031
4031
memcpy(FDEV(i).path, RDEV(i).path, MAX_PATH_LEN);
···
4044
4044
sbi->log_blocks_per_seg) - 1;
4045
4045
}
4046
4046
FDEV(i).bdev = blkdev_get_by_path(FDEV(i).path,
4047
-
sbi->sb->s_mode, sbi->sb->s_type);
4047
+
sbi->sb->s_mode, sbi->sb->s_type, NULL);
4048
4048
}
4049
4049
if (IS_ERR(FDEV(i).bdev))
4050
4050
return PTR_ERR(FDEV(i).bdev);
+1
-1
fs/jfs/jfs_logmgr.c
+1
-1
fs/jfs/jfs_logmgr.c
+3
-2
fs/nfs/blocklayout/dev.c
+3
-2
fs/nfs/blocklayout/dev.c
···
243
243
if (!dev)
244
244
return -EIO;
245
245
246
-
bdev = blkdev_get_by_dev(dev, FMODE_READ | FMODE_WRITE, NULL);
246
+
bdev = blkdev_get_by_dev(dev, FMODE_READ | FMODE_WRITE, NULL, NULL);
247
247
if (IS_ERR(bdev)) {
248
248
printk(KERN_WARNING "pNFS: failed to open device %d:%d (%ld)\n",
249
249
MAJOR(dev), MINOR(dev), PTR_ERR(bdev));
···
312
312
if (!devname)
313
313
return ERR_PTR(-ENOMEM);
314
314
315
-
bdev = blkdev_get_by_path(devname, FMODE_READ | FMODE_WRITE, NULL);
315
+
bdev = blkdev_get_by_path(devname, FMODE_READ | FMODE_WRITE, NULL,
316
+
NULL);
316
317
if (IS_ERR(bdev)) {
317
318
pr_warn("pNFS: failed to open device %s (%ld)\n",
318
319
devname, PTR_ERR(bdev));
+1
-1
fs/nilfs2/super.c
+1
-1
fs/nilfs2/super.c
+1
-1
fs/ocfs2/cluster/heartbeat.c
+1
-1
fs/ocfs2/cluster/heartbeat.c
···
1786
1786
goto out2;
1787
1787
1788
1788
reg->hr_bdev = blkdev_get_by_dev(f.file->f_mapping->host->i_rdev,
1789
-
FMODE_WRITE | FMODE_READ, NULL);
1789
+
FMODE_WRITE | FMODE_READ, NULL, NULL);
1790
1790
if (IS_ERR(reg->hr_bdev)) {
1791
1791
ret = PTR_ERR(reg->hr_bdev);
1792
1792
reg->hr_bdev = NULL;
+3
-2
fs/reiserfs/journal.c
+3
-2
fs/reiserfs/journal.c
···
2616
2616
if (jdev == super->s_dev)
2617
2617
blkdev_mode &= ~FMODE_EXCL;
2618
2618
journal->j_dev_bd = blkdev_get_by_dev(jdev, blkdev_mode,
2619
-
journal);
2619
+
journal, NULL);
2620
2620
journal->j_dev_mode = blkdev_mode;
2621
2621
if (IS_ERR(journal->j_dev_bd)) {
2622
2622
result = PTR_ERR(journal->j_dev_bd);
···
2632
2632
}
2633
2633
2634
2634
journal->j_dev_mode = blkdev_mode;
2635
-
journal->j_dev_bd = blkdev_get_by_path(jdev_name, blkdev_mode, journal);
2635
+
journal->j_dev_bd = blkdev_get_by_path(jdev_name, blkdev_mode, journal,
2636
+
NULL);
2636
2637
if (IS_ERR(journal->j_dev_bd)) {
2637
2638
result = PTR_ERR(journal->j_dev_bd);
2638
2639
journal->j_dev_bd = NULL;
+2
-2
fs/super.c
+2
-2
fs/super.c
···
1248
1248
if (!fc->source)
1249
1249
return invalf(fc, "No source specified");
1250
1250
1251
-
bdev = blkdev_get_by_path(fc->source, mode, fc->fs_type);
1251
+
bdev = blkdev_get_by_path(fc->source, mode, fc->fs_type, NULL);
1252
1252
if (IS_ERR(bdev)) {
1253
1253
errorf(fc, "%s: Can't open blockdev", fc->source);
1254
1254
return PTR_ERR(bdev);
···
1333
1333
if (!(flags & SB_RDONLY))
1334
1334
mode |= FMODE_WRITE;
1335
1335
1336
-
bdev = blkdev_get_by_path(dev_name, mode, fs_type);
1336
+
bdev = blkdev_get_by_path(dev_name, mode, fs_type, NULL);
1337
1337
if (IS_ERR(bdev))
1338
1338
return ERR_CAST(bdev);
1339
1339
+1
-1
fs/xfs/xfs_super.c
+1
-1
fs/xfs/xfs_super.c
+2
include/linux/blk_types.h
+2
include/linux/blk_types.h
+8
-3
include/linux/blkdev.h
+8
-3
include/linux/blkdev.h
···
1470
1470
#define BLKDEV_MAJOR_MAX 0
1471
1471
#endif
1472
1472
1473
+
struct blk_holder_ops {
1474
+
};
1475
+
1476
+
struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder,
1477
+
const struct blk_holder_ops *hops);
1473
1478
struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
1474
-
void *holder);
1475
-
struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder);
1476
-
int bd_prepare_to_claim(struct block_device *bdev, void *holder);
1479
+
void *holder, const struct blk_holder_ops *hops);
1480
+
int bd_prepare_to_claim(struct block_device *bdev, void *holder,
1481
+
const struct blk_holder_ops *hops);
1477
1482
void bd_abort_claiming(struct block_device *bdev, void *holder);
1478
1483
void blkdev_put(struct block_device *bdev, fmode_t mode);
1479
1484
+2
-2
kernel/power/swap.c
+2
-2
kernel/power/swap.c
···
357
357
root_swap = res;
358
358
359
359
hib_resume_bdev = blkdev_get_by_dev(swsusp_resume_device, FMODE_WRITE,
360
-
NULL);
360
+
NULL, NULL);
361
361
if (IS_ERR(hib_resume_bdev))
362
362
return PTR_ERR(hib_resume_bdev);
363
363
···
1524
1524
mode |= FMODE_EXCL;
1525
1525
1526
1526
hib_resume_bdev = blkdev_get_by_dev(swsusp_resume_device,
1527
-
mode, &holder);
1527
+
mode, &holder, NULL);
1528
1528
if (!IS_ERR(hib_resume_bdev)) {
1529
1529
set_blocksize(hib_resume_bdev, PAGE_SIZE);
1530
1530
clear_page(swsusp_header);
+2
-1
mm/swapfile.c
+2
-1
mm/swapfile.c
···
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);
2773
+
FMODE_READ | FMODE_WRITE | FMODE_EXCL, p,
2774
+
NULL);
2774
2775
if (IS_ERR(p->bdev)) {
2775
2776
error = PTR_ERR(p->bdev);
2776
2777
p->bdev = NULL;