Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
nfs/blocklayout: Convert to use bdev_open_by_dev/path()
Convert block device handling to use bdev_open_by_dev/path() and pass
the handle around.
CC: linux-nfs@vger.kernel.org
CC: Trond Myklebust <trond.myklebust@hammerspace.com>
CC: Anna Schumaker <anna@kernel.org>
Acked-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Christian Brauner <brauner@kernel.org>
Signed-off-by: Jan Kara <jack@suse.cz>
Link: https://lore.kernel.org/r/20230927093442.25915-25-jack@suse.cz
Signed-off-by: Christian Brauner <brauner@kernel.org>
authored by
Jan Kara
and committed by
Christian Brauner
3fe5d9fb
898c57f4
+37
-39
+1
-1
fs/nfs/blocklayout/blocklayout.h
+1
-1
fs/nfs/blocklayout/blocklayout.h
+36
-38
fs/nfs/blocklayout/dev.c
+36
-38
fs/nfs/blocklayout/dev.c
···
25
25
} else {
26
26
if (dev->pr_registered) {
27
27
const struct pr_ops *ops =
28
-
dev->bdev->bd_disk->fops->pr_ops;
28
+
dev->bdev_handle->bdev->bd_disk->fops->pr_ops;
29
29
int error;
30
30
31
-
error = ops->pr_register(dev->bdev, dev->pr_key, 0,
32
-
false);
31
+
error = ops->pr_register(dev->bdev_handle->bdev,
32
+
dev->pr_key, 0, false);
33
33
if (error)
34
34
pr_err("failed to unregister PR key.\n");
35
35
}
36
36
37
-
if (dev->bdev)
38
-
blkdev_put(dev->bdev, NULL);
37
+
if (dev->bdev_handle)
38
+
bdev_release(dev->bdev_handle);
39
39
}
40
40
}
41
41
···
169
169
map->start = dev->start;
170
170
map->len = dev->len;
171
171
map->disk_offset = dev->disk_offset;
172
-
map->bdev = dev->bdev;
172
+
map->bdev = dev->bdev_handle->bdev;
173
173
return true;
174
174
}
175
175
···
236
236
struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
237
237
{
238
238
struct pnfs_block_volume *v = &volumes[idx];
239
-
struct block_device *bdev;
239
+
struct bdev_handle *bdev_handle;
240
240
dev_t dev;
241
241
242
242
dev = bl_resolve_deviceid(server, v, gfp_mask);
243
243
if (!dev)
244
244
return -EIO;
245
245
246
-
bdev = blkdev_get_by_dev(dev, BLK_OPEN_READ | BLK_OPEN_WRITE, NULL,
247
-
NULL);
248
-
if (IS_ERR(bdev)) {
246
+
bdev_handle = bdev_open_by_dev(dev, BLK_OPEN_READ | BLK_OPEN_WRITE,
247
+
NULL, NULL);
248
+
if (IS_ERR(bdev_handle)) {
249
249
printk(KERN_WARNING "pNFS: failed to open device %d:%d (%ld)\n",
250
-
MAJOR(dev), MINOR(dev), PTR_ERR(bdev));
251
-
return PTR_ERR(bdev);
250
+
MAJOR(dev), MINOR(dev), PTR_ERR(bdev_handle));
251
+
return PTR_ERR(bdev_handle);
252
252
}
253
-
d->bdev = bdev;
254
-
255
-
256
-
d->len = bdev_nr_bytes(d->bdev);
253
+
d->bdev_handle = bdev_handle;
254
+
d->len = bdev_nr_bytes(bdev_handle->bdev);
257
255
d->map = bl_map_simple;
258
256
259
257
printk(KERN_INFO "pNFS: using block device %s\n",
260
-
d->bdev->bd_disk->disk_name);
258
+
bdev_handle->bdev->bd_disk->disk_name);
261
259
return 0;
262
260
}
263
261
···
300
302
}
301
303
}
302
304
303
-
static struct block_device *
305
+
static struct bdev_handle *
304
306
bl_open_path(struct pnfs_block_volume *v, const char *prefix)
305
307
{
306
-
struct block_device *bdev;
308
+
struct bdev_handle *bdev_handle;
307
309
const char *devname;
308
310
309
311
devname = kasprintf(GFP_KERNEL, "/dev/disk/by-id/%s%*phN",
···
311
313
if (!devname)
312
314
return ERR_PTR(-ENOMEM);
313
315
314
-
bdev = blkdev_get_by_path(devname, BLK_OPEN_READ | BLK_OPEN_WRITE, NULL,
315
-
NULL);
316
-
if (IS_ERR(bdev)) {
316
+
bdev_handle = bdev_open_by_path(devname, BLK_OPEN_READ | BLK_OPEN_WRITE,
317
+
NULL, NULL);
318
+
if (IS_ERR(bdev_handle)) {
317
319
pr_warn("pNFS: failed to open device %s (%ld)\n",
318
-
devname, PTR_ERR(bdev));
320
+
devname, PTR_ERR(bdev_handle));
319
321
}
320
322
321
323
kfree(devname);
322
-
return bdev;
324
+
return bdev_handle;
323
325
}
324
326
325
327
static int
···
327
329
struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
328
330
{
329
331
struct pnfs_block_volume *v = &volumes[idx];
330
-
struct block_device *bdev;
332
+
struct bdev_handle *bdev_handle;
331
333
const struct pr_ops *ops;
332
334
int error;
333
335
···
340
342
* On other distributions like Debian, the default SCSI by-id path will
341
343
* point to the dm-multipath device if one exists.
342
344
*/
343
-
bdev = bl_open_path(v, "dm-uuid-mpath-0x");
344
-
if (IS_ERR(bdev))
345
-
bdev = bl_open_path(v, "wwn-0x");
346
-
if (IS_ERR(bdev))
347
-
return PTR_ERR(bdev);
348
-
d->bdev = bdev;
345
+
bdev_handle = bl_open_path(v, "dm-uuid-mpath-0x");
346
+
if (IS_ERR(bdev_handle))
347
+
bdev_handle = bl_open_path(v, "wwn-0x");
348
+
if (IS_ERR(bdev_handle))
349
+
return PTR_ERR(bdev_handle);
350
+
d->bdev_handle = bdev_handle;
349
351
350
-
d->len = bdev_nr_bytes(d->bdev);
352
+
d->len = bdev_nr_bytes(d->bdev_handle->bdev);
351
353
d->map = bl_map_simple;
352
354
d->pr_key = v->scsi.pr_key;
353
355
354
356
pr_info("pNFS: using block device %s (reservation key 0x%llx)\n",
355
-
d->bdev->bd_disk->disk_name, d->pr_key);
357
+
d->bdev_handle->bdev->bd_disk->disk_name, d->pr_key);
356
358
357
-
ops = d->bdev->bd_disk->fops->pr_ops;
359
+
ops = d->bdev_handle->bdev->bd_disk->fops->pr_ops;
358
360
if (!ops) {
359
361
pr_err("pNFS: block device %s does not support reservations.",
360
-
d->bdev->bd_disk->disk_name);
362
+
d->bdev_handle->bdev->bd_disk->disk_name);
361
363
error = -EINVAL;
362
364
goto out_blkdev_put;
363
365
}
364
366
365
-
error = ops->pr_register(d->bdev, 0, d->pr_key, true);
367
+
error = ops->pr_register(d->bdev_handle->bdev, 0, d->pr_key, true);
366
368
if (error) {
367
369
pr_err("pNFS: failed to register key for block device %s.",
368
-
d->bdev->bd_disk->disk_name);
370
+
d->bdev_handle->bdev->bd_disk->disk_name);
369
371
goto out_blkdev_put;
370
372
}
371
373
···
373
375
return 0;
374
376
375
377
out_blkdev_put:
376
-
blkdev_put(d->bdev, NULL);
378
+
bdev_release(d->bdev_handle);
377
379
return error;
378
380
}
379
381