gfs2: Use fs_* functions instead of pr_* function where we can

Before this patch, various errors and messages were reported using
the pr_* functions: pr_err, pr_warn, pr_info, etc., but that does
not tell you which gfs2 mount had the problem, which is often vital
to debugging. This patch changes the calls from pr_* to fs_* in
most of the messages so that the file system id is printed along
with the message.

Signed-off-by: Bob Peterson <rpeterso@redhat.com>

diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index e37002560c11f6982f1624f5b25ddb13cf76b8b5..2e28fc947f7fa9f3759a07107ee03d7b6d662e8c 100644 (file)
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -506,7 +506,8 @@ static int gfs2_dirent_gather(const struct gfs2_dirent *dent,
  * For now the most important thing is to check that the various sizes
  * are correct.
  */
-static int gfs2_check_dirent(struct gfs2_dirent *dent, unsigned int offset,
+static int gfs2_check_dirent(struct gfs2_sbd *sdp,
+                            struct gfs2_dirent *dent, unsigned int offset,
                             unsigned int size, unsigned int len, int first)
 {
        const char *msg = "gfs2_dirent too small";
@@ -528,12 +529,12 @@ static int gfs2_check_dirent(struct gfs2_dirent *dent, unsigned int offset,
                goto error;
        return 0;
 error:
-       pr_warn("%s: %s (%s)\n",
+       fs_warn(sdp, "%s: %s (%s)\n",
                __func__, msg, first ? "first in block" : "not first in block");
        return -EIO;
 }
 
-static int gfs2_dirent_offset(const void *buf)
+static int gfs2_dirent_offset(struct gfs2_sbd *sdp, const void *buf)
 {
        const struct gfs2_meta_header *h = buf;
        int offset;
@@ -552,7 +553,8 @@ static int gfs2_dirent_offset(const void *buf)
        }
        return offset;
 wrong_type:
-       pr_warn("%s: wrong block type %u\n", __func__, be32_to_cpu(h->mh_type));
+       fs_warn(sdp, "%s: wrong block type %u\n", __func__,
+               be32_to_cpu(h->mh_type));
        return -1;
 }
 
@@ -566,7 +568,7 @@ static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode, void *buf,
        unsigned size;
        int ret = 0;
 
-       ret = gfs2_dirent_offset(buf);
+       ret = gfs2_dirent_offset(GFS2_SB(inode), buf);
        if (ret < 0)
                goto consist_inode;
 
@@ -574,7 +576,7 @@ static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode, void *buf,
        prev = NULL;
        dent = buf + offset;
        size = be16_to_cpu(dent->de_rec_len);
-       if (gfs2_check_dirent(dent, offset, size, len, 1))
+       if (gfs2_check_dirent(GFS2_SB(inode), dent, offset, size, len, 1))
                goto consist_inode;
        do {
                ret = scan(dent, name, opaque);
@@ -586,7 +588,8 @@ static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode, void *buf,
                prev = dent;
                dent = buf + offset;
                size = be16_to_cpu(dent->de_rec_len);
-               if (gfs2_check_dirent(dent, offset, size, len, 0))
+               if (gfs2_check_dirent(GFS2_SB(inode), dent, offset, size,
+                                     len, 0))
                        goto consist_inode;
        } while(1);
 
@@ -1043,7 +1046,7 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name)
        len = BIT(dip->i_depth - be16_to_cpu(oleaf->lf_depth));
        half_len = len >> 1;
        if (!half_len) {
-               pr_warn("i_depth %u lf_depth %u index %u\n",
+               fs_warn(GFS2_SB(inode), "i_depth %u lf_depth %u index %u\n",
                        dip->i_depth, be16_to_cpu(oleaf->lf_depth), index);
                gfs2_consist_inode(dip);
                error = -EIO;
@@ -1351,7 +1354,7 @@ static int gfs2_set_cookies(struct gfs2_sbd *sdp, struct buffer_head *bh,
                if (!sdp->sd_args.ar_loccookie)
                        continue;
                offset = (char *)(darr[i]) -
-                        (bh->b_data + gfs2_dirent_offset(bh->b_data));
+                       (bh->b_data + gfs2_dirent_offset(sdp, bh->b_data));
                offset /= GFS2_MIN_DIRENT_SIZE;
                offset += leaf_nr * sdp->sd_max_dents_per_leaf;
                if (offset >= GFS2_USE_HASH_FLAG ||

diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index 4614ee25f6211efe24550edfdd68021ceaa20bf7..05431324b262b265683bf7efdb439f8bbf6cf8e7 100644 (file)
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -494,7 +494,8 @@ static void finish_xmote(struct gfs2_glock *gl, unsigned int ret)
                        do_xmote(gl, gh, LM_ST_UNLOCKED);
                        break;
                default: /* Everything else */
-                       pr_err("wanted %u got %u\n", gl->gl_target, state);
+                       fs_err(gl->gl_name.ln_sbd, "wanted %u got %u\n",
+                              gl->gl_target, state);
                        GLOCK_BUG_ON(gl, 1);
                }
                spin_unlock(&gl->gl_lockref.lock);
@@ -577,7 +578,7 @@ __acquires(&gl->gl_lockref.lock)
                        gfs2_glock_queue_work(gl, 0);
                }
                else if (ret) {
-                       pr_err("lm_lock ret %d\n", ret);
+                       fs_err(sdp, "lm_lock ret %d\n", ret);
                        GLOCK_BUG_ON(gl, !test_bit(SDF_SHUTDOWN,
                                                   &sdp->sd_flags));
                }
@@ -1064,13 +1065,13 @@ __acquires(&gl->gl_lockref.lock)
        return;
 
 trap_recursive:
-       pr_err("original: %pSR\n", (void *)gh2->gh_ip);
-       pr_err("pid: %d\n", pid_nr(gh2->gh_owner_pid));
-       pr_err("lock type: %d req lock state : %d\n",
+       fs_err(sdp, "original: %pSR\n", (void *)gh2->gh_ip);
+       fs_err(sdp, "pid: %d\n", pid_nr(gh2->gh_owner_pid));
+       fs_err(sdp, "lock type: %d req lock state : %d\n",
               gh2->gh_gl->gl_name.ln_type, gh2->gh_state);
-       pr_err("new: %pSR\n", (void *)gh->gh_ip);
-       pr_err("pid: %d\n", pid_nr(gh->gh_owner_pid));
-       pr_err("lock type: %d req lock state : %d\n",
+       fs_err(sdp, "new: %pSR\n", (void *)gh->gh_ip);
+       fs_err(sdp, "pid: %d\n", pid_nr(gh->gh_owner_pid));
+       fs_err(sdp, "lock type: %d req lock state : %d\n",
               gh->gh_gl->gl_name.ln_type, gh->gh_state);
        gfs2_dump_glock(NULL, gl);
        BUG();

diff --git a/fs/gfs2/lock_dlm.c b/fs/gfs2/lock_dlm.c
index ac7caa267ed6090c1f4f3f18293399783162a021..31df26ed78540ed5b8f364a6fd2af4da25dc53a7 100644 (file)
--- a/fs/gfs2/lock_dlm.c
+++ b/fs/gfs2/lock_dlm.c
@@ -177,14 +177,14 @@ static void gdlm_bast(void *arg, int mode)
                gfs2_glock_cb(gl, LM_ST_SHARED);
                break;
        default:
-               pr_err("unknown bast mode %d\n", mode);
+               fs_err(gl->gl_name.ln_sbd, "unknown bast mode %d\n", mode);
                BUG();
        }
 }
 
 /* convert gfs lock-state to dlm lock-mode */
 
-static int make_mode(const unsigned int lmstate)
+static int make_mode(struct gfs2_sbd *sdp, const unsigned int lmstate)
 {
        switch (lmstate) {
        case LM_ST_UNLOCKED:
@@ -196,7 +196,7 @@ static int make_mode(const unsigned int lmstate)
        case LM_ST_SHARED:
                return DLM_LOCK_PR;
        }
-       pr_err("unknown LM state %d\n", lmstate);
+       fs_err(sdp, "unknown LM state %d\n", lmstate);
        BUG();
        return -1;
 }
@@ -257,7 +257,7 @@ static int gdlm_lock(struct gfs2_glock *gl, unsigned int req_state,
        u32 lkf;
        char strname[GDLM_STRNAME_BYTES] = "";
 
-       req = make_mode(req_state);
+       req = make_mode(gl->gl_name.ln_sbd, req_state);
        lkf = make_flags(gl, flags, req);
        gfs2_glstats_inc(gl, GFS2_LKS_DCOUNT);
        gfs2_sbstats_inc(gl, GFS2_LKS_DCOUNT);
@@ -309,7 +309,7 @@ static void gdlm_put_lock(struct gfs2_glock *gl)
        error = dlm_unlock(ls->ls_dlm, gl->gl_lksb.sb_lkid, DLM_LKF_VALBLK,
                           NULL, gl);
        if (error) {
-               pr_err("gdlm_unlock %x,%llx err=%d\n",
+               fs_err(sdp, "gdlm_unlock %x,%llx err=%d\n",
                       gl->gl_name.ln_type,
                       (unsigned long long)gl->gl_name.ln_number, error);
                return;

diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index fc181c81cca22c778ed91622135b7f6f9f1ba5b2..b445ae15f87e37a6a46c71a345425fbe8bf21309 100644 (file)
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -101,12 +101,16 @@ static inline void gfs2_setbit(const struct gfs2_rbm *rbm, bool do_clone,
        cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
 
        if (unlikely(!valid_change[new_state * 4 + cur_state])) {
-               pr_warn("buf_blk = 0x%x old_state=%d, new_state=%d\n",
+               struct gfs2_sbd *sdp = rbm->rgd->rd_sbd;
+
+               fs_warn(sdp, "buf_blk = 0x%x old_state=%d, new_state=%d\n",
                        rbm->offset, cur_state, new_state);
-               pr_warn("rgrp=0x%llx bi_start=0x%x\n",
-                       (unsigned long long)rbm->rgd->rd_addr, bi->bi_start);
-               pr_warn("bi_offset=0x%x bi_len=0x%x\n",
-                       bi->bi_offset, bi->bi_len);
+               fs_warn(sdp, "rgrp=0x%llx bi_start=0x%x biblk: 0x%llx\n",
+                       (unsigned long long)rbm->rgd->rd_addr, bi->bi_start,
+                       (unsigned long long)bi->bi_bh->b_blocknr);
+               fs_warn(sdp, "bi_offset=0x%x bi_len=0x%x block=0x%llx\n",
+                       bi->bi_offset, bi->bi_len,
+                       (unsigned long long)gfs2_rbm_to_block(rbm));
                dump_stack();
                gfs2_consist_rgrpd(rbm->rgd);
                return;
@@ -738,11 +742,13 @@ void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
 
 static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
 {
-       pr_info("ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
-       pr_info("ri_length = %u\n", rgd->rd_length);
-       pr_info("ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
-       pr_info("ri_data = %u\n", rgd->rd_data);
-       pr_info("ri_bitbytes = %u\n", rgd->rd_bitbytes);
+       struct gfs2_sbd *sdp = rgd->rd_sbd;
+
+       fs_info(sdp, "ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
+       fs_info(sdp, "ri_length = %u\n", rgd->rd_length);
+       fs_info(sdp, "ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
+       fs_info(sdp, "ri_data = %u\n", rgd->rd_data);
+       fs_info(sdp, "ri_bitbytes = %u\n", rgd->rd_bitbytes);
 }
 
 /**
@@ -2423,7 +2429,7 @@ int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
                }
        }
        if (rbm.rgd->rd_free < *nblocks) {
-               pr_warn("nblocks=%u\n", *nblocks);
+               fs_warn(sdp, "nblocks=%u\n", *nblocks);
                goto rgrp_error;
        }
 

diff --git a/fs/gfs2/trans.c b/fs/gfs2/trans.c
index 064c9a0ef046068cd2547af5b5578d5bc65a4fe6..423bc2d03dd82cba438acc9f74c731e049f7e41c 100644 (file)
--- a/fs/gfs2/trans.c
+++ b/fs/gfs2/trans.c
@@ -74,13 +74,13 @@ int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,
        return error;
 }
 
-static void gfs2_print_trans(const struct gfs2_trans *tr)
+static void gfs2_print_trans(struct gfs2_sbd *sdp, const struct gfs2_trans *tr)
 {
-       pr_warn("Transaction created at: %pSR\n", (void *)tr->tr_ip);
-       pr_warn("blocks=%u revokes=%u reserved=%u touched=%u\n",
+       fs_warn(sdp, "Transaction created at: %pSR\n", (void *)tr->tr_ip);
+       fs_warn(sdp, "blocks=%u revokes=%u reserved=%u touched=%u\n",
                tr->tr_blocks, tr->tr_revokes, tr->tr_reserved,
                test_bit(TR_TOUCHED, &tr->tr_flags));
-       pr_warn("Buf %u/%u Databuf %u/%u Revoke %u/%u\n",
+       fs_warn(sdp, "Buf %u/%u Databuf %u/%u Revoke %u/%u\n",
                tr->tr_num_buf_new, tr->tr_num_buf_rm,
                tr->tr_num_databuf_new, tr->tr_num_databuf_rm,
                tr->tr_num_revoke, tr->tr_num_revoke_rm);
@@ -109,7 +109,7 @@ void gfs2_trans_end(struct gfs2_sbd *sdp)
 
        if (gfs2_assert_withdraw(sdp, (nbuf <= tr->tr_blocks) &&
                                       (tr->tr_num_revoke <= tr->tr_revokes)))
-               gfs2_print_trans(tr);
+               gfs2_print_trans(sdp, tr);
 
        gfs2_log_commit(sdp, tr);
        if (alloced && !test_bit(TR_ATTACHED, &tr->tr_flags))
@@ -225,12 +225,13 @@ void gfs2_trans_add_meta(struct gfs2_glock *gl, struct buffer_head *bh)
        set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags);
        mh = (struct gfs2_meta_header *)bd->bd_bh->b_data;
        if (unlikely(mh->mh_magic != cpu_to_be32(GFS2_MAGIC))) {
-               pr_err("Attempting to add uninitialised block to journal (inplace block=%lld)\n",
+               fs_err(sdp, "Attempting to add uninitialised block to "
+                      "journal (inplace block=%lld)\n",
                       (unsigned long long)bd->bd_bh->b_blocknr);
                BUG();
        }
        if (unlikely(state == SFS_FROZEN)) {
-               printk(KERN_INFO "GFS2:adding buf while frozen\n");
+               fs_info(sdp, "GFS2:adding buf while frozen\n");
                gfs2_assert_withdraw(sdp, 0);
        }
        gfs2_pin(sdp, bd->bd_bh);

diff --git a/fs/gfs2/util.h b/fs/gfs2/util.h
index 96ac4aba47387eb146a8af242168d8180442bcf1..9278fecba6321680141f5e7c2a8b779421576fe6 100644 (file)
--- a/fs/gfs2/util.h
+++ b/fs/gfs2/util.h
@@ -86,7 +86,7 @@ static inline int gfs2_meta_check(struct gfs2_sbd *sdp,
        struct gfs2_meta_header *mh = (struct gfs2_meta_header *)bh->b_data;
        u32 magic = be32_to_cpu(mh->mh_magic);
        if (unlikely(magic != GFS2_MAGIC)) {
-               pr_err("Magic number missing at %llu\n",
+               fs_err(sdp, "Magic number missing at %llu\n",
                       (unsigned long long)bh->b_blocknr);
                return -EIO;
        }