korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-12-02 00:24:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

dm: stop using bdevname

Browse Source 
Just use the %pg format specifier instead.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
This commit is contained in:
Christoph Hellwig 2022-03-01 10:38:15 +02:00 committed by Mike Snitzer
parent 977ff73e64
commit 385411ffba
5 changed files with 27 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
drivers/md/dm-cache-target.c
View File

@ -2015,7 +2015,6 @@ static int parse_metadata_dev(struct cache_args *ca, struct dm_arg_set *as,
{ {
int r; int r;
sector_t metadata_dev_size; sector_t metadata_dev_size;
char b[BDEVNAME_SIZE];
if (!at_least_one_arg(as, error)) if (!at_least_one_arg(as, error))
return -EINVAL; return -EINVAL;
@ -2029,8 +2028,8 @@ static int parse_metadata_dev(struct cache_args *ca, struct dm_arg_set *as,
metadata_dev_size = get_dev_size(ca->metadata_dev); metadata_dev_size = get_dev_size(ca->metadata_dev);
if (metadata_dev_size > DM_CACHE_METADATA_MAX_SECTORS_WARNING) if (metadata_dev_size > DM_CACHE_METADATA_MAX_SECTORS_WARNING)
DMWARN("Metadata device %s is larger than %u sectors: excess space will not be used.", DMWARN("Metadata device %pg is larger than %u sectors: excess space will not be used.",
bdevname(ca->metadata_dev->bdev, b), THIN_METADATA_MAX_SECTORS); ca->metadata_dev->bdev, THIN_METADATA_MAX_SECTORS);
return 0; return 0;
} }
@ -3345,7 +3344,6 @@ static void disable_passdown_if_not_supported(struct cache *cache)
struct block_device *origin_bdev = cache->origin_dev->bdev; struct block_device *origin_bdev = cache->origin_dev->bdev;
struct queue_limits *origin_limits = &bdev_get_queue(origin_bdev)->limits; struct queue_limits *origin_limits = &bdev_get_queue(origin_bdev)->limits;
const char *reason = NULL; const char *reason = NULL;
char buf[BDEVNAME_SIZE];
if (!cache->features.discard_passdown) if (!cache->features.discard_passdown)
return; return;
@ -3357,8 +3355,8 @@ static void disable_passdown_if_not_supported(struct cache *cache)
reason = "max discard sectors smaller than a block"; reason = "max discard sectors smaller than a block";
if (reason) { if (reason) {
DMWARN("Origin device (%s) %s: Disabling discard passdown.", DMWARN("Origin device (%pg) %s: Disabling discard passdown.",
bdevname(origin_bdev, buf), reason); origin_bdev, reason);
cache->features.discard_passdown = false; cache->features.discard_passdown = false;
} }
} }

10
drivers/md/dm-clone-target.c
View File

@ -1682,7 +1682,6 @@ static int parse_metadata_dev(struct clone *clone, struct dm_arg_set *as, char *
{ {
int r; int r;
sector_t metadata_dev_size; sector_t metadata_dev_size;
char b[BDEVNAME_SIZE];
r = dm_get_device(clone->ti, dm_shift_arg(as), FMODE_READ | FMODE_WRITE, r = dm_get_device(clone->ti, dm_shift_arg(as), FMODE_READ | FMODE_WRITE,
&clone->metadata_dev); &clone->metadata_dev);
@ -1693,8 +1692,8 @@ static int parse_metadata_dev(struct clone *clone, struct dm_arg_set *as, char *
metadata_dev_size = get_dev_size(clone->metadata_dev); metadata_dev_size = get_dev_size(clone->metadata_dev);
if (metadata_dev_size > DM_CLONE_METADATA_MAX_SECTORS_WARNING) if (metadata_dev_size > DM_CLONE_METADATA_MAX_SECTORS_WARNING)
DMWARN("Metadata device %s is larger than %u sectors: excess space will not be used.", DMWARN("Metadata device %pg is larger than %u sectors: excess space will not be used.",
bdevname(clone->metadata_dev->bdev, b), DM_CLONE_METADATA_MAX_SECTORS); clone->metadata_dev->bdev, DM_CLONE_METADATA_MAX_SECTORS);
return 0; return 0;
} }
@ -2033,7 +2032,6 @@ static void disable_passdown_if_not_supported(struct clone *clone)
struct block_device *dest_dev = clone->dest_dev->bdev; struct block_device *dest_dev = clone->dest_dev->bdev;
struct queue_limits *dest_limits = &bdev_get_queue(dest_dev)->limits; struct queue_limits *dest_limits = &bdev_get_queue(dest_dev)->limits;
const char *reason = NULL; const char *reason = NULL;
char buf[BDEVNAME_SIZE];
if (!test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags)) if (!test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags))
return; return;
@ -2044,8 +2042,8 @@ static void disable_passdown_if_not_supported(struct clone *clone)
reason = "max discard sectors smaller than a region"; reason = "max discard sectors smaller than a region";
if (reason) { if (reason) {
DMWARN("Destination device (%s) %s: Disabling discard passdown.", DMWARN("Destination device (%pd) %s: Disabling discard passdown.",
bdevname(dest_dev, buf), reason); dest_dev, reason);
clear_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags); clear_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags);
} }
} }

6
drivers/md/dm-mpath.c
View File

@ -899,10 +899,8 @@ retain:
if (m->hw_handler_name) { if (m->hw_handler_name) {
r = scsi_dh_attach(q, m->hw_handler_name); r = scsi_dh_attach(q, m->hw_handler_name);
if (r == -EBUSY) { if (r == -EBUSY) {
char b[BDEVNAME_SIZE]; printk(KERN_INFO "dm-mpath: retaining handler on device %pg\n",
bdev);
printk(KERN_INFO "dm-mpath: retaining handler on device %s\n",
bdevname(bdev, b));
goto retain; goto retain;
} }
if (r < 0) { if (r < 0) {

30
drivers/md/dm-table.c
View File

@ -230,15 +230,14 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
sector_t dev_size = bdev_nr_sectors(bdev); sector_t dev_size = bdev_nr_sectors(bdev);
unsigned short logical_block_size_sectors = unsigned short logical_block_size_sectors =
limits->logical_block_size >> SECTOR_SHIFT; limits->logical_block_size >> SECTOR_SHIFT;
char b[BDEVNAME_SIZE];
if (!dev_size) if (!dev_size)
return 0; return 0;
if ((start >= dev_size) || (start + len > dev_size)) { if ((start >= dev_size) || (start + len > dev_size)) {
DMWARN("%s: %s too small for target: " DMWARN("%s: %pg too small for target: "
"start=%llu, len=%llu, dev_size=%llu", "start=%llu, len=%llu, dev_size=%llu",
dm_device_name(ti->table->md), bdevname(bdev, b), dm_device_name(ti->table->md), bdev,
(unsigned long long)start, (unsigned long long)start,
(unsigned long long)len, (unsigned long long)len,
(unsigned long long)dev_size); (unsigned long long)dev_size);
@ -253,10 +252,10 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
unsigned int zone_sectors = bdev_zone_sectors(bdev); unsigned int zone_sectors = bdev_zone_sectors(bdev);
if (start & (zone_sectors - 1)) { if (start & (zone_sectors - 1)) {
DMWARN("%s: start=%llu not aligned to h/w zone size %u of %s", DMWARN("%s: start=%llu not aligned to h/w zone size %u of %pg",
dm_device_name(ti->table->md), dm_device_name(ti->table->md),
(unsigned long long)start, (unsigned long long)start,
zone_sectors, bdevname(bdev, b)); zone_sectors, bdev);
return 1; return 1;
} }
@ -270,10 +269,10 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
* the sector range. * the sector range.
*/ */
if (len & (zone_sectors - 1)) { if (len & (zone_sectors - 1)) {
DMWARN("%s: len=%llu not aligned to h/w zone size %u of %s", DMWARN("%s: len=%llu not aligned to h/w zone size %u of %pg",
dm_device_name(ti->table->md), dm_device_name(ti->table->md),
(unsigned long long)len, (unsigned long long)len,
zone_sectors, bdevname(bdev, b)); zone_sectors, bdev);
return 1; return 1;
} }
} }
@ -283,19 +282,19 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
if (start & (logical_block_size_sectors - 1)) { if (start & (logical_block_size_sectors - 1)) {
DMWARN("%s: start=%llu not aligned to h/w " DMWARN("%s: start=%llu not aligned to h/w "
"logical block size %u of %s", "logical block size %u of %pg",
dm_device_name(ti->table->md), dm_device_name(ti->table->md),
(unsigned long long)start, (unsigned long long)start,
limits->logical_block_size, bdevname(bdev, b)); limits->logical_block_size, bdev);
return 1; return 1;
} }
if (len & (logical_block_size_sectors - 1)) { if (len & (logical_block_size_sectors - 1)) {
DMWARN("%s: len=%llu not aligned to h/w " DMWARN("%s: len=%llu not aligned to h/w "
"logical block size %u of %s", "logical block size %u of %pg",
dm_device_name(ti->table->md), dm_device_name(ti->table->md),
(unsigned long long)len, (unsigned long long)len,
limits->logical_block_size, bdevname(bdev, b)); limits->logical_block_size, bdev);
return 1; return 1;
} }
@ -400,20 +399,19 @@ static int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
struct queue_limits *limits = data; struct queue_limits *limits = data;
struct block_device *bdev = dev->bdev; struct block_device *bdev = dev->bdev;
struct request_queue *q = bdev_get_queue(bdev); struct request_queue *q = bdev_get_queue(bdev);
char b[BDEVNAME_SIZE];
if (unlikely(!q)) { if (unlikely(!q)) {
DMWARN("%s: Cannot set limits for nonexistent device %s", DMWARN("%s: Cannot set limits for nonexistent device %pg",
dm_device_name(ti->table->md), bdevname(bdev, b)); dm_device_name(ti->table->md), bdev);
return 0; return 0;
} }
if (blk_stack_limits(limits, &q->limits, if (blk_stack_limits(limits, &q->limits,
get_start_sect(bdev) + start) < 0) get_start_sect(bdev) + start) < 0)
DMWARN("%s: adding target device %s caused an alignment inconsistency: " DMWARN("%s: adding target device %pg caused an alignment inconsistency: "
"physical_block_size=%u, logical_block_size=%u, " "physical_block_size=%u, logical_block_size=%u, "
"alignment_offset=%u, start=%llu", "alignment_offset=%u, start=%llu",
dm_device_name(ti->table->md), bdevname(bdev, b), dm_device_name(ti->table->md), bdev,
q->limits.physical_block_size, q->limits.physical_block_size,
q->limits.logical_block_size, q->limits.logical_block_size,
q->limits.alignment_offset, q->limits.alignment_offset,

8
drivers/md/dm-thin.c
View File

@ -2824,7 +2824,6 @@ static void disable_passdown_if_not_supported(struct pool_c *pt)
struct block_device *data_bdev = pt->data_dev->bdev; struct block_device *data_bdev = pt->data_dev->bdev;
struct queue_limits *data_limits = &bdev_get_queue(data_bdev)->limits; struct queue_limits *data_limits = &bdev_get_queue(data_bdev)->limits;
const char *reason = NULL; const char *reason = NULL;
char buf[BDEVNAME_SIZE];
if (!pt->adjusted_pf.discard_passdown) if (!pt->adjusted_pf.discard_passdown)
return; return;
@ -2836,7 +2835,7 @@ static void disable_passdown_if_not_supported(struct pool_c *pt)
reason = "max discard sectors smaller than a block"; reason = "max discard sectors smaller than a block";
if (reason) { if (reason) {
DMWARN("Data device (%s) %s: Disabling discard passdown.", bdevname(data_bdev, buf), reason); DMWARN("Data device (%pg) %s: Disabling discard passdown.", data_bdev, reason);
pt->adjusted_pf.discard_passdown = false; pt->adjusted_pf.discard_passdown = false;
} }
} }
@ -3201,11 +3200,10 @@ static sector_t get_dev_size(struct block_device *bdev)
static void warn_if_metadata_device_too_big(struct block_device *bdev) static void warn_if_metadata_device_too_big(struct block_device *bdev)
{ {
sector_t metadata_dev_size = get_dev_size(bdev); sector_t metadata_dev_size = get_dev_size(bdev);
char buffer[BDEVNAME_SIZE];
if (metadata_dev_size > THIN_METADATA_MAX_SECTORS_WARNING) if (metadata_dev_size > THIN_METADATA_MAX_SECTORS_WARNING)
DMWARN("Metadata device %s is larger than %u sectors: excess space will not be used.", DMWARN("Metadata device %pg is larger than %u sectors: excess space will not be used.",
bdevname(bdev, buffer), THIN_METADATA_MAX_SECTORS); bdev, THIN_METADATA_MAX_SECTORS);
} }
static sector_t get_metadata_dev_size(struct block_device *bdev) static sector_t get_metadata_dev_size(struct block_device *bdev)