The commit is pushed to "branch-rh7-3.10.0-1160.80.1.vz7.192.x-ovz" and will
appear at https://src.openvz.org/scm/ovz/vzkernel.git
after rh7-3.10.0-1160.80.1.vz7.192.3
------>
commit a1a2aec9e057c618418a3e39783aa0e51278e894
Author: Alexander Atanasov <alexander.atana...@virtuozzo.com>
Date: Fri Jan 20 11:03:40 2023 +0200
ploop: Add device name to log messages
Add logging macros that take ploop object and print device name in the
generated log message. Switch pr_* macros to corresponding PL_* macros.
No functional changes.
https://jira.sw.ru/browse/PSBM-144575
Signed-off-by: Alexander Atanasov <alexander.atana...@virtuozzo.com>
---
drivers/block/ploop/dev.c | 78 +++++++++++++++++----------------------
drivers/block/ploop/fmt_ploop1.c | 17 ++++-----
drivers/block/ploop/fmt_raw.c | 9 ++---
drivers/block/ploop/freeblks.c | 14 +++----
drivers/block/ploop/io_direct.c | 12 +++---
drivers/block/ploop/io_kaio.c | 35 ++++++++----------
drivers/block/ploop/map.c | 6 +--
drivers/block/ploop/push_backup.c | 17 ++++-----
drivers/block/ploop/sysfs.c | 10 ++---
include/linux/ploop/ploop.h | 6 +++
10 files changed, 97 insertions(+), 107 deletions(-)
diff --git a/drivers/block/ploop/dev.c b/drivers/block/ploop/dev.c
index dfad24818216..6eb22168b5fe 100644
--- a/drivers/block/ploop/dev.c
+++ b/drivers/block/ploop/dev.c
@@ -1968,7 +1968,7 @@ ploop_entry_zero_req(struct ploop_request *preq)
level = map_get_index(preq, preq->req_cluster, &iblk);
if (level != top_delta->level) {
- pr_warn("Can't zero index on wrong level=%d "
+ PL_WARN(plo, "Can't zero index on wrong level=%d "
"(top_level=%d req_cluster=%u iblk=%u/%u)\n",
level, top_delta->level, preq->req_cluster,
iblk, preq->iblock);
@@ -2104,14 +2104,14 @@ ploop_entry_reloc_s_req(struct ploop_request *preq,
iblock_t *iblk)
level = map_get_index(preq, preq->req_cluster, iblk);
if (level != top_delta->level) {
- pr_warn("Can't relocate block on wrong level=%d "
+ PL_WARN(plo, "Can't relocate block on wrong level=%d "
"(top_level=%d req_cluster=%u iblk=%u/%u)\n",
level, top_delta->level, preq->req_cluster,
*iblk, preq->iblock);
return -EIO;
}
if (preq->src_iblock != *iblk) {
- pr_warn("Can't relocate block due to wrong mapping: "
+ PL_WARN(plo, "Can't relocate block due to wrong mapping: "
"req_cluster=%u should point to iblk=%u while "
"map_get_index() calculated iblk=%u\n",
preq->req_cluster, preq->src_iblock, *iblk);
@@ -2251,7 +2251,7 @@ static int ploop_entry_discard_req(struct ploop_request
*preq)
preq->dst_iblock = 0;
if (err) {
if (err == -EINVAL) {
- pr_warn("ploop_entry_discard_req1: "
+ PL_WARN(plo, "ploop_entry_discard_req1:
"
"(%lu %u; %u %u; %u %u)\n",
preq->req_sector, preq->req_size,
preq->req_cluster, preq->iblock,
@@ -2273,7 +2273,7 @@ static int ploop_entry_discard_req(struct ploop_request
*preq)
err = ploop_fb_add_free_extent(plo->fbd, preq->dst_cluster,
preq->dst_iblock, len);
if (err == -EINVAL) {
- pr_warn("ploop_entry_discard_req2: "
+ PL_WARN(plo, "ploop_entry_discard_req2: "
"(%lu %u; %u %u; %u %u)\n",
preq->req_sector, preq->req_size,
preq->req_cluster, preq->iblock,
@@ -2826,7 +2826,7 @@ static void ploop_req_state_process(struct ploop_request
* preq)
case PLOOP_E_COMPLETE:
if (unlikely(test_bit(PLOOP_REQ_RELOC_S, &preq->state) &&
preq->error)) {
- pr_warn("RELOC_S completed with err %d"
+ PL_WARN(plo, "RELOC_S completed with err %d"
" (%u %u %u %u %u)\n",
preq->error, preq->req_cluster, preq->iblock,
preq->src_iblock, preq->dst_cluster,
@@ -3984,7 +3984,7 @@ static void rename_deltas(struct ploop_device * plo, int
level)
"%d", delta->level);
#endif
if (err)
- pr_warn("rename_deltas: %d %d %d\n", err, level,
delta->level);
+ PL_WARN(plo, "rename_deltas: %d %d %d\n", err, level,
delta->level);
}
}
@@ -4014,8 +4014,7 @@ static int ploop_del_delta(struct ploop_device * plo,
unsigned long arg)
return -EBUSY;
if (level == 0 && test_bit(PLOOP_S_RUNNING, &plo->state)) {
- pr_info("Can't del base delta on running ploop%d\n",
- plo->index);
+ PL_INFO(plo, "Can't del base delta on running\n");
return -EBUSY;
}
@@ -4196,8 +4195,7 @@ static int ploop_merge(struct ploop_device * plo)
err = ploop_prepare_merge(next, &sd);
if (err) {
- pr_warn("prepare_merge for ploop%d failed (%d)\n",
- plo->index, err);
+ PL_WARN(plo, "prepare_merge failed (%d)\n", err);
goto out;
}
@@ -4222,8 +4220,7 @@ static int ploop_merge(struct ploop_device * plo)
* in prepare_merge. Failed start_merge means
* abort of the device.
*/
- pr_warn("start_merge for ploop%d failed (%d)\n",
- plo->index, err);
+ PL_WARN(plo, "start_merge failed (%d)\n", err);
set_bit(PLOOP_S_ABORT, &plo->state);
}
@@ -4250,8 +4247,7 @@ static int ploop_merge(struct ploop_device * plo)
delta = map_top_delta(plo->trans_map);
if (test_bit(PLOOP_S_ABORT, &plo->state)) {
- pr_warn("merge for ploop%d failed (state ABORT)\n",
- plo->index);
+ PL_WARN(plo, "merge failed (state ABORT)\n");
err = -EIO;
}
@@ -4314,9 +4310,9 @@ static int ploop_bd_full(struct backing_dev_info *bdi,
long long nr, int root)
static unsigned long full_warn_time;
if (printk_timed_ratelimit(&full_warn_time, 60*60*HZ))
- pr_warn("ploop%d: host disk is almost full "
+ PL_WARN(plo, "host disk is almost full "
"(%llu < %llu); CT sees -ENOSPC !\n",
- plo->index, buf.f_bfree * buf.f_bsize,
+ buf.f_bfree * buf.f_bsize,
reserved + nr);
rc = 1;
@@ -4400,6 +4396,7 @@ static int ploop_start(struct ploop_device * plo, struct
block_device *bdev)
wake_up_process(plo->thread);
set_bit(PLOOP_S_RUNNING, &plo->state);
BUG_ON(list_empty(&plo->map.delta_list));
+ PL_INFO(plo, "Started\n");
return 0;
out_err:
@@ -4417,8 +4414,7 @@ static int ploop_stop(struct ploop_device * plo, struct
block_device *bdev)
if (bdev != bdev->bd_contains) {
if (printk_ratelimit())
- pr_info("stop ploop%d failed (wrong bdev)\n",
- plo->index);
+ PL_INFO(plo, "stop failed (wrong bdev)\n");
return -ENODEV;
}
@@ -4428,8 +4424,8 @@ static int ploop_stop(struct ploop_device * plo, struct
block_device *bdev)
holders = bdev->bd_contains->bd_holders;
mutex_unlock(&plo->ctl_mutex);
active = ploop_has_active_sb(plo, bdev);
- pr_info("stop ploop%d failed (holders=%d, sb=%d)\n",
- plo->index, holders, active);
+ PL_INFO(plo, "stop failed (holders=%d, sb=%d)\n",
+ holders, active);
mutex_lock(&plo->ctl_mutex);
}
return -EBUSY;
@@ -4439,38 +4435,35 @@ static int ploop_stop(struct ploop_device * plo, struct
block_device *bdev)
return -EINVAL;
if (list_empty(&plo->map.delta_list)) {
- pr_info("stop ploop%d failed (no deltas)\n",
- plo->index);
+ PL_INFO(plo, "stop failed (no deltas)\n");
return -ENOENT;
}
cnt = atomic_read(&plo->open_count);
if (cnt > 1) {
if (printk_ratelimit())
- pr_info("stop ploop%d failed (cnt=%d)\n",
- plo->index, cnt);
+ PL_INFO(plo, "stop failed (cnt=%d)\n", cnt);
return -EBUSY;
}
cnt = atomic_read(&plo->maintenance_cnt);
if (plo->maintenance_type != PLOOP_MNTN_OFF && cnt) {
if (printk_ratelimit())
- pr_info("stop ploop%d failed "
- "(type=%d cnt=%d)\n",
- plo->index, plo->maintenance_type, cnt);
+ PL_INFO(plo, "stop failed (type=%d cnt=%d)\n",
+ plo->maintenance_type, cnt);
return -EBUSY;
}
if (plo->freeze_state != PLOOP_F_NORMAL) {
if (printk_ratelimit())
- pr_info("stop ploop%d failed (freeze_state=%d)\n",
- plo->index, plo->freeze_state);
+ PL_INFO(plo, "stop failed (freeze_state=%d)\n",
+ plo->freeze_state);
return -EBUSY;
}
active_reqs = plo->active_reqs;
if (active_reqs) {
- WARN_ONCE(1, "stop ploop%d failed (active_reqs=%d)\n",
+ WARN_ONCE(1, "ploop%d: stop failed (active_reqs=%d)\n",
plo->index, active_reqs);
return -EBUSY;
}
@@ -4535,6 +4528,7 @@ static int ploop_stop(struct ploop_device * plo, struct
block_device *bdev)
if (plo->trans_map)
ploop_map_destroy(plo->trans_map);
+ PL_INFO(plo, "Stopped\n");
return 0;
}
@@ -4580,22 +4574,19 @@ static int ploop_clear(struct ploop_device * plo,
struct block_device * bdev)
if (test_bit(PLOOP_S_RUNNING, &plo->state)) {
if (printk_ratelimit())
- pr_info("clear ploop%d failed (RUNNING)\n",
- plo->index);
+ PL_INFO(plo, "clear failed (RUNNING)\n");
return -EBUSY;
}
if (plo->maintenance_type == PLOOP_MNTN_TRACK) {
if (printk_ratelimit())
- pr_info("clear ploop%d failed (TRACK)\n",
- plo->index);
+ PL_INFO(plo, "clear failed (TRACK)\n");
return -EBUSY;
}
cnt = atomic_read(&plo->maintenance_cnt);
if (plo->maintenance_type != PLOOP_MNTN_OFF && cnt) {
if (printk_ratelimit())
- pr_info("clear ploop%d failed "
- "(type=%d cnt=%d)\n",
- plo->index, plo->maintenance_type, cnt);
+ PL_INFO(plo, "clear failed (type=%d cnt=%d)\n",
+ plo->maintenance_type, cnt);
return -EBUSY;
}
@@ -4962,14 +4953,14 @@ static int ploop_freeblks_ioc(struct ploop_device *plo,
unsigned long arg)
extent.iblk, extent.len);
if (rc) {
if (rc == -EINVAL) {
- pr_warn("ploop_freeblks_ioc: n=%d\n",
ctl.n_extents);
+ PL_WARN(plo, "ploop_freeblks_ioc: n=%d\n",
ctl.n_extents);
for (i = 0; i < ctl.n_extents; i++) {
if (copy_from_user(&extent, &extents[i],
sizeof(extent))) {
pr_warn("copy failed: i=%d\n",
i);
break;
}
- pr_warn("ploop_freeblks_ioc: i=%d: %u
%u %u\n",
+ PL_WARN(plo, "ploop_freeblks_ioc: i=%d:
%u %u %u\n",
i, extent.clu, extent.iblk,
extent.len);
}
WARN_ONCE(1, "add_free_extent failed\n");
@@ -5443,8 +5434,7 @@ static int ploop_push_backup_io(struct ploop_device *plo,
unsigned long arg)
return -EINVAL;
if (ploop_pb_check_uuid(pbd, ctl.cbt_uuid)) {
- pr_warn("ploop(%d): PUSH_BACKUP_IO uuid mismatch\n",
- plo->index);
+ PL_WARN(plo, "PUSH_BACKUP_IO uuid mismatch\n");
return -EINVAL;
}
@@ -5473,8 +5463,7 @@ static int ploop_push_backup_stop(struct ploop_device
*plo, unsigned long arg)
return -EFAULT;
if (pbd && ploop_pb_check_uuid(pbd, ctl.cbt_uuid)) {
- pr_warn("ploop(%d): PUSH_BACKUP_STOP uuid mismatch\n",
- plo->index);
+ PL_WARN(plo, "PUSH_BACKUP_STOP uuid mismatch\n");
return -EINVAL;
}
@@ -6095,6 +6084,7 @@ static void __exit ploop_mod_exit(void)
unregister_blkdev(PLOOP_DEVICE_MAJOR, "ploop");
ploop_map_exit();
WARN_ON(atomic_read(&plo_count));
+ pr_info("ploop_dev: module unloaded\n");
}
module_init(ploop_mod_init);
module_exit(ploop_mod_exit);
diff --git a/drivers/block/ploop/fmt_ploop1.c b/drivers/block/ploop/fmt_ploop1.c
index 40a7919e1ec8..e59a9eb50ac2 100644
--- a/drivers/block/ploop/fmt_ploop1.c
+++ b/drivers/block/ploop/fmt_ploop1.c
@@ -34,7 +34,7 @@ static void ploop_set_holes_bitmap_bit(unsigned int nr,
struct ploop_delta *delt
struct ploop1_private *ph = delta->priv;
if (WARN_ON_ONCE(nr >= ph->nr_clusters_in_bitmap)) {
- pr_err("nr=%u, nr_clusters=%u\n", nr,
ph->nr_clusters_in_bitmap);
+ PL_ERR(delta->plo, "nr=%u, nr_clusters=%u\n", nr,
ph->nr_clusters_in_bitmap);
return;
}
@@ -46,7 +46,7 @@ static void ploop_clear_holes_bitmap_bit(unsigned int nr,
struct ploop_delta *de
struct ploop1_private *ph = delta->priv;
if (WARN_ON_ONCE(nr >= ph->nr_clusters_in_bitmap)) {
- pr_err("nr=%u, nr_clusters=%u\n", nr,
ph->nr_clusters_in_bitmap);
+ PL_ERR(delta->plo, "nr=%u, nr_clusters=%u\n", nr,
ph->nr_clusters_in_bitmap);
return;
}
@@ -221,8 +221,7 @@ static int populate_holes_bitmap(struct ploop_delta *delta,
* This may be a result of shrinking large disk
* to a small size.
*/
- pr_err("ploop%u: bat is bigger than disk size\n",
- delta->plo->index);
+ PL_ERR(delta->plo, "bat is bigger than disk size\n");
goto out;
}
/* Images with big BAT and small data may be shorter than
nr_all_pages */
@@ -230,7 +229,7 @@ static int populate_holes_bitmap(struct ploop_delta *delta,
(ph->l1_off << 9) / PAGE_SIZE - consumed);
ret = delta->io.ops->sync_read_many(&delta->io, pages, count,
sec);
if (ret) {
- pr_err("ploop: too short BAT\n");
+ PL_ERR(delta->plo, "too short BAT\n");
goto out;
}
@@ -594,8 +593,8 @@ ploop1_start_merge(struct ploop_delta * delta, struct
ploop_snapdata * sd)
return err;
if (test_bit(PLOOP_S_ABORT, &delta->plo->state)) {
- pr_warn("ploop1_start_merge for ploop%d failed "
- "(state ABORT)\n", delta->plo->index);
+ PL_WARN(delta->plo, "ploop1_start_merge failed "
+ "(state ABORT)\n");
return -EIO;
}
@@ -698,7 +697,7 @@ static int expand_holes_bitmap(struct ploop_delta *delta,
holes_bitmap = kvmalloc(size, GFP_KERNEL);
if (!holes_bitmap) {
- pr_err("Can't allocate holes_bitmap\n");
+ PL_ERR(delta->plo, "Can't allocate holes_bitmap\n");
return -ENOMEM;
}
@@ -814,7 +813,7 @@ static int ploop1_complete_grow(struct ploop_delta * delta,
u64 new_size)
vh_bsize = le32_to_cpu(vh->m_Sectors);
if (vh_bsize != (1 << delta->io.plo->cluster_log)) {
- pr_warn("grow: vh->m_Sectors=%u != 1<<plo->cluster_log=%u\n",
+ PL_WARN(delta->plo, "grow: vh->m_Sectors=%u !=
1<<plo->cluster_log=%u\n",
vh_bsize, 1 << delta->io.plo->cluster_log);
return -EINVAL;
}
diff --git a/drivers/block/ploop/fmt_raw.c b/drivers/block/ploop/fmt_raw.c
index 6d4364581764..11eabfabda72 100644
--- a/drivers/block/ploop/fmt_raw.c
+++ b/drivers/block/ploop/fmt_raw.c
@@ -57,7 +57,7 @@ raw_open(struct ploop_delta * delta)
delta->io.alloc_head = pos >> (cluster_log + 9);
if (!delta->io.alloc_head) {
- pr_err("ploop: zero length file\n");
+ PL_ERR(delta->plo, "zero length file\n");
return -EINVAL;
}
@@ -85,11 +85,11 @@ raw_refresh(struct ploop_delta * delta)
pos = delta->io.ops->i_size_read(&delta->io);
if (pos & (cluster_size_in_bytes(delta->plo) - 1)) {
- pr_warn("raw delta is not aligned (%llu bytes)\n", pos);
+ PL_WARN(delta->plo, "raw delta is not aligned (%llu bytes)\n",
pos);
return -EINVAL;
}
if ((pos >> (cluster_log + 9)) < delta->io.alloc_head) {
- pr_warn("raw delta was corrupted "
+ PL_WARN(delta->plo, "raw delta was corrupted "
"(old_size=%u new_size=%llu iblocks)\n",
delta->io.alloc_head,
pos >> (cluster_log + 9));
@@ -198,8 +198,7 @@ raw_start_merge(struct ploop_delta * delta, struct
ploop_snapdata * sd)
return err;
if (test_bit(PLOOP_S_ABORT, &delta->plo->state)) {
- pr_warn(KERN_WARNING "raw_start_merge for ploop%d failed "
- "(state ABORT)\n", delta->plo->index);
+ PL_WARN(delta->plo, "raw_start_merge failed (state ABORT)\n");
return -EIO;
}
diff --git a/drivers/block/ploop/freeblks.c b/drivers/block/ploop/freeblks.c
index 46699c6a7c63..6b53660c973b 100644
--- a/drivers/block/ploop/freeblks.c
+++ b/drivers/block/ploop/freeblks.c
@@ -391,7 +391,7 @@ static int split_fb_extent(struct ploop_freeblks_extent
*extent, u32 *off_p,
new_extent = kzalloc(sizeof(*new_extent), GFP_KERNEL);
if (new_extent == NULL) {
- pr_warn("Can't allocate new freeblks extent for splittig!\n");
+ PL_WARN(fbd->plo, "Can't allocate new freeblks extent for
splittig!\n");
return -ENOMEM;
}
@@ -855,7 +855,7 @@ int ploop_fb_add_free_extent(struct ploop_freeblks_desc
*fbd,
struct ploop_freeblks_extent *ex;
if (len == 0) {
- pr_warn("ploop_fb_add_free_extent(): empty extent! (%u/%u)\n",
+ PL_WARN(fbd->plo, "ploop_fb_add_free_extent(): empty extent!
(%u/%u)\n",
clu, iblk);
return 0;
}
@@ -870,7 +870,7 @@ int ploop_fb_add_free_extent(struct ploop_freeblks_desc
*fbd,
if (iblk + len > tmp->iblk) {
int c = &ex->list != &fbd->fbd_free_list;
- pr_warn("ploop_fb_add_free_extent(): next (%u %u %u) "
+ PL_WARN(fbd->plo, "ploop_fb_add_free_extent(): next (%u
%u %u) "
"intersects with (%u %u %u); ex (%u %u %d)\n",
tmp->clu, tmp->iblk, tmp->len, clu, iblk, len,
c ? ex->clu : 0, c ? ex->iblk : 0, c ? ex->len :
-1);
@@ -883,7 +883,7 @@ int ploop_fb_add_free_extent(struct ploop_freeblks_desc
*fbd,
struct ploop_freeblks_extent *t = NULL;
if (ex->list.next != &fbd->fbd_free_list)
t = list_entry(ex->list.next, struct
ploop_freeblks_extent, list);
- pr_warn("ploop_fb_add_free_extent(): ex (%u %u %u) "
+ PL_WARN(fbd->plo, "ploop_fb_add_free_extent(): ex (%u
%u %u) "
"intersects with (%u %u %u); next (%u %u %d)\n",
ex->clu, ex->iblk, ex->len, clu, iblk, len,
t ? t->clu : 0, t ? t->iblk : 0, t ? t->len :
-1);
@@ -915,7 +915,7 @@ int ploop_fb_add_reloc_extent(struct ploop_freeblks_desc
*fbd,
struct ploop_relocblks_extent *rblk_extent;
if (len == 0) {
- pr_warn("ploop_fb_add_reloc_extent(): empty extent! (%u/%u)\n",
+ PL_WARN(fbd->plo, "ploop_fb_add_reloc_extent(): empty extent!
(%u/%u)\n",
clu, iblk);
return 0;
}
@@ -924,7 +924,7 @@ int ploop_fb_add_reloc_extent(struct ploop_freeblks_desc
*fbd,
rblk_extent = list_entry(fbd->fbd_reloc_list.prev,
struct ploop_relocblks_extent, list);
if (rblk_extent->iblk + rblk_extent->len > iblk) {
- pr_warn("ploop_fb_add_reloc_extent(): extents should be
sorted\n");
+ PL_WARN(fbd->plo, "ploop_fb_add_reloc_extent(): extents
should be sorted\n");
return -EINVAL;
}
@@ -932,7 +932,7 @@ int ploop_fb_add_reloc_extent(struct ploop_freeblks_desc
*fbd,
rblk_extent = list_entry(rblk_extent->list.next,
struct ploop_relocblks_extent, list);
if (iblk + len > rblk_extent->iblk) {
- pr_warn("ploop_fb_add_reloc_extent():
intersected extents\n");
+ PL_WARN(fbd->plo, "ploop_fb_add_reloc_extent():
intersected extents\n");
return -EINVAL;
}
}
diff --git a/drivers/block/ploop/io_direct.c b/drivers/block/ploop/io_direct.c
index d2759447e23a..a3632b12be91 100644
--- a/drivers/block/ploop/io_direct.c
+++ b/drivers/block/ploop/io_direct.c
@@ -880,7 +880,7 @@ static int dio_invalidate_cache(struct ploop_io * io)
struct ploop_device *plo = io->plo;
struct block_device *dm_crypt_bdev;
- pr_warn("PLOOP: failed to invalidate page cache %d/%d\n", err,
attempt2);
+ PL_WARN(plo, "failed to invalidate page cache %d/%d\n", err,
attempt2);
if (attempt2)
return err;
attempt2 = 1;
@@ -915,7 +915,7 @@ static int dio_release_prealloced(struct ploop_io * io)
ret = dio_truncate(io, io->files.file, io->alloc_head);
if (ret)
- pr_warn("Can't release %llu prealloced bytes: "
+ PL_WARN(io->plo, "Can't release %llu prealloced bytes: "
"truncate to %llu failed (%d)\n",
io->prealloced_size - end_pos, end_pos, ret);
else
@@ -1764,7 +1764,7 @@ static int dio_autodetect(struct ploop_io *io, unsigned
int id)
return -1;
if (inode->i_sb->s_bdev == NULL) {
- pr_warn("File on FS EXT(%s) without backing device\n", s_id);
+ PL_WARN(io->plo, "File on FS EXT(%s) without backing device\n",
s_id);
return -1;
}
@@ -1773,12 +1773,12 @@ static int dio_autodetect(struct ploop_io *io, unsigned
int id)
"File on FS w/o fallocate");
if (!file->f_op->unlocked_ioctl) {
- pr_warn("Cannot run on EXT4(%s): no unlocked_ioctl\n", s_id);
+ PL_WARN(io->plo, "Cannot run on EXT4(%s): no unlocked_ioctl\n",
s_id);
return -1;
}
if (!file->f_op->fsync) {
- pr_warn("Cannot run on EXT4(%s): no fsync\n", s_id);
+ PL_WARN(io->plo, "Cannot run on EXT4(%s): no fsync\n", s_id);
return -1;
}
@@ -1789,7 +1789,7 @@ static int dio_autodetect(struct ploop_io *io, unsigned
int id)
set_fs(fs);
if (err != 0) {
- pr_warn("Cannot run on EXT4(%s): failed FS_IOC_GETFLAGS (%d)\n",
+ PL_WARN(io->plo, "Cannot run on EXT4(%s): failed
FS_IOC_GETFLAGS (%d)\n",
s_id, err);
return -1;
}
diff --git a/drivers/block/ploop/io_kaio.c b/drivers/block/ploop/io_kaio.c
index f9413e701736..35c0fad43baf 100644
--- a/drivers/block/ploop/io_kaio.c
+++ b/drivers/block/ploop/io_kaio.c
@@ -130,8 +130,7 @@ static void check_standby_mode(long res, struct
ploop_device *plo) {
spin_unlock_irq(q->queue_lock);
if (!prev)
- pr_warn("ploop%d was switched into "
- "the standby mode\n", plo->index);
+ PL_WARN(plo,"was switched into the standby mode\n");
}
static void kaio_rw_aio_complete(u64 data, long res)
@@ -141,14 +140,14 @@ static void kaio_rw_aio_complete(u64 data, long res)
if (unlikely(res < 0)) {
struct bio *b = preq->aux_bio;
- pr_warn("kaio_rw_aio_complete: kaio failed with err=%ld "
+ PL_WARN(preq->plo, "kaio_rw_aio_complete: kaio failed with
err=%ld "
"(rw=%s; state=%ld/0x%lx; clu=%d; iblk=%d; aux=%ld)\n",
res, (preq->req_rw & REQ_WRITE) ? "WRITE" : "READ",
preq->eng_state, preq->state, preq->req_cluster,
preq->iblock, b ? b->bi_sector : -1);
bio_list_for_each(b, &preq->bl)
- pr_warn(" bio=%p: bi_sector=%ld bi_size=%d\n",
+ PL_WARN(preq->plo," bio=%p: bi_sector=%ld bi_size=%d\n",
b, b->bi_sector, b->bi_size);
if (static_key_false(&ploop_standby_check))
check_standby_mode(res, preq->plo);
@@ -216,7 +215,7 @@ static int kaio_kernel_submit(struct file *file, struct
kaio_req *kreq,
err = aio_kernel_submit(iocb);
if (err)
- pr_warn("kaio_kernel_submit: aio_kernel_submit failed with "
+ PL_WARN(kreq->preq->plo, "kaio_kernel_submit: aio_kernel_submit
failed with "
"err=%d (rw=%s; state=%ld/0x%lx; pos=%lld; len=%ld)\n",
err, (rw & REQ_WRITE) ? "WRITE" : "READ",
kreq->preq->eng_state, kreq->preq->state, pos, count);
@@ -480,7 +479,7 @@ static int kaio_resubmit(struct ploop_request * preq)
preq->eng_state = PLOOP_E_DELTA_COPIED; /* skip bcopy() */
return 0;
default:
- pr_warn("Resubmit bad state %lu\n", preq->eng_state);
+ PL_WARN(preq->plo, "Resubmit bad state %lu\n", preq->eng_state);
BUG();
}
@@ -559,11 +558,10 @@ static int kaio_fsync_thread(void * data)
struct file *file = io->files.file;
err = vfs_fsync(file, 1);
if (err) {
- pr_warn("kaio_fsync_thread: vfs_fsync failed "
- "with err=%d (i_ino=%ld of level=%d "
- "on ploop%d)\n",
+ PL_WARN(plo, "kaio_fsync_thread: vfs_fsync
failed "
+ "with err=%d (i_ino=%ld of level=%d\n",
err, io->files.inode->i_ino,
- io2level(io), plo->index);
+ io2level(io));
if (static_key_false(&ploop_standby_check))
check_standby_mode(err, plo);
PLOOP_REQ_SET_ERROR(preq, -EIO);
@@ -648,7 +646,7 @@ static int kaio_release_prealloced(struct ploop_io * io)
ret = kaio_truncate(io, io->files.file, io->alloc_head);
if (ret)
- pr_warn("Can't release %llu prealloced bytes: "
+ PL_WARN(io->plo, "Can't release %llu prealloced bytes: "
"truncate to %llu failed (%d)\n",
io->prealloced_size - end_pos, end_pos, ret);
else
@@ -747,7 +745,7 @@ kaio_io_page(struct ploop_io * io, int op, struct
ploop_request * preq,
err = aio_kernel_submit(iocb);
if (err) {
- pr_warn("kaio_io_page: aio_kernel_submit failed with "
+ PL_WARN(preq->plo, "kaio_io_page: aio_kernel_submit failed with
"
"err=%d (rw=%s; state=%ld/0x%lx; pos=%lld)\n",
err, (op == IOCB_CMD_WRITE_ITER) ? "WRITE" : "READ",
preq->eng_state, preq->state, pos);
@@ -862,7 +860,7 @@ kaio_sync_io(struct ploop_io * io, int op, struct page
**pages,
err = aio_kernel_submit(iocb);
if (err) {
- pr_warn("kaio_sync_io: aio_kernel_submit failed with "
+ PL_WARN(io->plo, "kaio_sync_io: aio_kernel_submit failed with "
"err=%d (rw=%s; pos=%lld; len=%d off=%d)\n",
err, (op == IOCB_CMD_WRITE_ITER) ? "WRITE" : "READ",
pos, len, off);
@@ -877,7 +875,7 @@ kaio_sync_io(struct ploop_io * io, int op, struct page
**pages,
wait_for_completion(&comp.comp);
if (!err && comp.error)
- pr_warn("kaio_sync_io: kaio failed with err=%d "
+ PL_WARN(io->plo, "kaio_sync_io: kaio failed with err=%d "
"(rw=%s; pos=%lld; len=%d off=%d)\n",
comp.error,
(op == IOCB_CMD_WRITE_ITER) ? "WRITE" : "READ",
@@ -1157,10 +1155,10 @@ static int __kaio_truncate(struct ploop_io * io, struct
file * file, u64 pos)
mutex_unlock(&io->files.inode->i_mutex);
if (err) {
- pr_warn("__kaio_truncate(i_ino=%ld of level=%d on ploop%d, "
+ PL_WARN(io->plo, "__kaio_truncate(i_ino=%ld of level=%d, "
"pos=%lld): notify_change failed with err=%d "
"(i_size=%lld)\n",
- io->files.inode->i_ino, io2level(io), io->plo->index,
+ io->files.inode->i_ino, io2level(io),
pos, err, i_size_read(io->files.inode));
return err;
}
@@ -1168,10 +1166,9 @@ static int __kaio_truncate(struct ploop_io * io, struct
file * file, u64 pos)
err = vfs_fsync(file, 0);
if (err)
- pr_warn("__kaio_truncate(i_ino=%ld of level=%d on ploop%d, "
+ PL_WARN(io->plo, "__kaio_truncate(i_ino=%ld of level=%d, "
"pos=%lld): vfs_fsync failed with err=%d\n",
- io->files.inode->i_ino, io2level(io), io->plo->index,
- pos, err);
+ io->files.inode->i_ino, io2level(io), pos, err);
return err;
}
diff --git a/drivers/block/ploop/map.c b/drivers/block/ploop/map.c
index 73ac24ac3304..d084a1bd271c 100644
--- a/drivers/block/ploop/map.c
+++ b/drivers/block/ploop/map.c
@@ -320,7 +320,7 @@ map_create(struct ploop_map * map, cluster_t block)
else if (block > entry->mn_end)
p = &(*p)->rb_right;
else
- pr_warn("map_create: Oops! block=%u;
mn_range=[%u..%u]\n",
+ PL_WARN(plo, "map_create: Oops! block=%u;
mn_range=[%u..%u]\n",
block, entry->mn_start, entry->mn_end);
}
@@ -700,7 +700,7 @@ void ploop_update_map(struct ploop_map * map, int level,
if (lvl == level)
p[idx] = iblk << ploop_map_log(map->plo);
else if (lvl < level)
- pr_warn("Unexpected condition: uptodate map_node %p "
+ PL_WARN(map->plo, "Unexpected condition: uptodate
map_node %p "
"covering range %u..%u maps %u to %u on level "
"%d, while user-space merge detected mapping "
"on level %d\n", m, m->mn_start, m->mn_end,
@@ -943,7 +943,7 @@ void ploop_index_update(struct ploop_request * preq)
BUG_ON (test_bit(PLOOP_REQ_ZERO, &preq->state) && preq->iblock);
if (test_bit(PLOOP_REQ_ZERO, &preq->state) && !blk) {
- pr_warn("Either map_node is corrupted or bug in "
+ PL_WARN(plo, "Either map_node is corrupted or bug in "
"ploop-balloon (%u)\n", preq->req_cluster);
PLOOP_REQ_SET_ERROR(preq, -EIO);
goto corrupted;
diff --git a/drivers/block/ploop/push_backup.c
b/drivers/block/ploop/push_backup.c
index 576eb36145e4..e2de05d705e9 100644
--- a/drivers/block/ploop/push_backup.c
+++ b/drivers/block/ploop/push_backup.c
@@ -129,8 +129,8 @@ int ploop_pb_cbt_map_release(struct ploop_pushbackup_desc
*pbd, bool do_merge)
pbd->cbt_block_max,
pbd->cbt_block_bits);
if (ret)
- pr_warn("ploop(%d): blk_cbt_map_merge() failed with "
- "%d\n", pbd->plo->index, ret);
+ PL_WARN(pbd->plo, "blk_cbt_map_merge() failed with "
+ "%d\n", ret);
}
ploop_pb_map_free(pbd->cbt_map, pbd->cbt_block_max);
@@ -326,7 +326,7 @@ static int convert_map_to_map(struct ploop_pushbackup_desc
*pbd)
u64 from_blk, to_blk;
if ((u64)from_max << from_bits != (u64)to_max << to_bits) {
- pr_warn("mismatch in map convert: %lu %lu ---> %u %d\n",
+ PL_WARN(pbd->plo, "mismatch in map convert: %lu %lu ---> %u
%d\n",
from_max, from_bits, to_max, to_bits);
return -EINVAL;
}
@@ -426,9 +426,9 @@ void ploop_pb_fini(struct ploop_pushbackup_desc *pbd)
return;
if (!RB_EMPTY_ROOT(&pbd->pending_set.tree))
- pr_warn("ploop_pb_fini: pending_tree is not empty!\n");
+ PL_WARN(pbd->plo, "ploop_pb_fini: pending_tree is not
empty!\n");
if (!RB_EMPTY_ROOT(&pbd->reported_set.tree))
- pr_warn("ploop_pb_fini: reported_tree is not empty!\n");
+ PL_WARN(pbd->plo, "ploop_pb_fini: reported_tree is not
empty!\n");
if (pbd->health_monitor_thread) {
kthread_stop(pbd->health_monitor_thread);
@@ -491,7 +491,7 @@ static void ploop_pb_add_req_to_tree(struct ploop_request
*preq,
mod_timer(&pbs->timer, preq->tstamp + timeout + 1);
if (pbs->list.prev->next != &pbs->list) {
- pr_warn("list_add corruption. pbs->list.prev->next should be "
+ PL_WARN(preq->plo, "list_add corruption. pbs->list.prev->next
should be "
"&pbs->list (%p), but was %p. (pbs->list.prev=%p)."
" preq=%p\n",
&pbs->list, pbs->list.prev->next, pbs->list.prev, preq);
@@ -1046,10 +1046,9 @@ static bool ploop_pb_set_expired(struct pb_set *pbs)
spin_unlock_irqrestore(&pbd->ppb_lock, flags);
if (ret)
- pr_warn("Abort push_backup for ploop%d: found "
+ PL_WARN(plo, "Abort push_backup found "
"preq (clu=%d) in %s tree delayed for %u msecs\n",
- plo->index, clu, pbs->name,
- jiffies_to_msecs(jiffies - tstamp));
+ clu, pbs->name, jiffies_to_msecs(jiffies - tstamp));
return ret;
}
diff --git a/drivers/block/ploop/sysfs.c b/drivers/block/ploop/sysfs.c
index 0eaabcb72654..e27860810e27 100644
--- a/drivers/block/ploop/sysfs.c
+++ b/drivers/block/ploop/sysfs.c
@@ -358,7 +358,7 @@ static u32 show_aborted(struct ploop_device * plo)
static int store_aborted(struct ploop_device * plo, u32 val)
{
- pr_warn("ploop: Force %s aborted state for ploop%d\n",
+ PL_WARN(plo, "Force %s aborted state for ploop%d\n",
val ? "set" : "clear", plo->index);
if (val)
@@ -799,21 +799,21 @@ void ploop_sysfs_init(struct ploop_device * plo)
plo->pstat_dir = kobject_add_attr(plo->disk, "pstat", &pstat_ktype);
if (plo->pstat_dir) {
if (sysfs_create_group(plo->pstat_dir, &stats_group))
- pr_warn("ploop: were not able to create pstat dir\n");
+ PL_WARN(plo, "were not able to create pstat dir\n");
}
plo->pstate_dir = kobject_add_attr(plo->disk, "pstate", &pattr_ktype);
if (plo->pstate_dir) {
if (sysfs_create_group(plo->pstate_dir, &state_group))
- pr_warn("ploop: were not able to create pstate dir\n");
+ PL_WARN(plo, "were not able to create pstate dir\n");
}
plo->ptune_dir = kobject_add_attr(plo->disk, "ptune", &pattr_ktype);
if (plo->ptune_dir) {
if (sysfs_create_group(plo->ptune_dir, &tune_group))
- pr_warn("ploop: were not able to create ptune dir\n");
+ PL_WARN(plo, "were not able to create ptune dir\n");
}
if (kobject_add(&plo->kobj, kobject_get(&disk_to_dev(plo->disk)->kobj),
"%s", "pdelta"))
- pr_warn("ploop: were not able to create pdelta dir\n");
+ PL_WARN(plo, "were not able to create pdelta dir\n");
}
void ploop_sysfs_uninit(struct ploop_device * plo)
diff --git a/include/linux/ploop/ploop.h b/include/linux/ploop/ploop.h
index d0f665796a42..8abd7d5217f0 100644
--- a/include/linux/ploop/ploop.h
+++ b/include/linux/ploop/ploop.h
@@ -983,4 +983,10 @@ extern void ploop_msg_once(struct ploop_device *plo, const
char *, ...)
#define __TRACE(a...) do { } while (0)
#endif
+#define PL_FMT(fmt) "ploop%d: " fmt
+#define PL_DEV_IDX(plo) (plo ? plo->index : 0)
+#define PL_ERR(plo, fmt, ...) pr_err(PL_FMT(fmt), PL_DEV_IDX(plo),
##__VA_ARGS__)
+#define PL_INFO(plo, fmt, ...) pr_info(PL_FMT(fmt), PL_DEV_IDX(plo),
##__VA_ARGS__)
+#define PL_WARN(plo, fmt, ...) pr_warn(PL_FMT(fmt), PL_DEV_IDX(plo),
##__VA_ARGS__)
+
#endif /* _LINUX_PLOOP_H_ */
_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel
