quota: Change quota error message to print out disk and function name
Jiaying Zhang [Tue, 20 Jul 2010 14:54:43 +0000 (16:54 +0200)]
The current quota error message doesn't always print the disk name, so
it is hard to identify the "bad" disk when quota error happens.

This patch changes the standardized quota error message to print out disk name
and function name. It also uses a combination of cpp macro and inline function
to provide better type checking and to lower the text size of the message.

[Jan Kara: Export __quota_error]

Signed-off-by: Jiaying Zhang <jiayingz@google.com>
Signed-off-by: Jan Kara <jack@suse.cz>

fs/quota/dquot.c
fs/quota/quota_tree.c
fs/quota/quota_tree.h
fs/quota/quota_v1.c
fs/quota/quota_v2.c
include/linux/quotaops.h

index 2eebf72..b171221 100644 (file)
@@ -132,6 +132,22 @@ static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock);
 __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
 EXPORT_SYMBOL(dq_data_lock);
 
+void __quota_error(struct super_block *sb, const char *func,
+                 const char *fmt, ...)
+{
+       va_list args;
+
+       if (printk_ratelimit()) {
+               va_start(args, fmt);
+               printk(KERN_ERR "Quota error (device %s): %s: ",
+                      sb->s_id, func);
+               vprintk(fmt, args);
+               printk("\n");
+               va_end(args);
+       }
+}
+EXPORT_SYMBOL(__quota_error);
+
 #if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING)
 static char *quotatypes[] = INITQFNAMES;
 #endif
@@ -705,11 +721,8 @@ void dqput(struct dquot *dquot)
                return;
 #ifdef CONFIG_QUOTA_DEBUG
        if (!atomic_read(&dquot->dq_count)) {
-               printk("VFS: dqput: trying to free free dquot\n");
-               printk("VFS: device %s, dquot of %s %d\n",
-                       dquot->dq_sb->s_id,
-                       quotatypes[dquot->dq_type],
-                       dquot->dq_id);
+               quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
+                           quotatypes[dquot->dq_type], dquot->dq_id);
                BUG();
        }
 #endif
@@ -732,9 +745,9 @@ we_slept:
                /* Commit dquot before releasing */
                ret = dquot->dq_sb->dq_op->write_dquot(dquot);
                if (ret < 0) {
-                       printk(KERN_ERR "VFS: cannot write quota structure on "
-                               "device %s (error %d). Quota may get out of "
-                               "sync!\n", dquot->dq_sb->s_id, ret);
+                       quota_error(dquot->dq_sb, "Can't write quota structure"
+                                   " (error %d). Quota may get out of sync!",
+                                   ret);
                        /*
                         * We clear dirty bit anyway, so that we avoid
                         * infinite loop here
@@ -914,9 +927,9 @@ static void add_dquot_ref(struct super_block *sb, int type)
 
 #ifdef CONFIG_QUOTA_DEBUG
        if (reserved) {
-               printk(KERN_WARNING "VFS (%s): Writes happened before quota"
-                       " was turned on thus quota information is probably "
-                       "inconsistent. Please run quotacheck(8).\n", sb->s_id);
+               quota_error(sb, "Writes happened before quota was turned on "
+                       "thus quota information is probably inconsistent. "
+                       "Please run quotacheck(8)");
        }
 #endif
 }
@@ -947,7 +960,9 @@ static int remove_inode_dquot_ref(struct inode *inode, int type,
                if (dqput_blocks(dquot)) {
 #ifdef CONFIG_QUOTA_DEBUG
                        if (atomic_read(&dquot->dq_count) != 1)
-                               printk(KERN_WARNING "VFS: Adding dquot with dq_count %d to dispose list.\n", atomic_read(&dquot->dq_count));
+                               quota_error(inode->i_sb, "Adding dquot with "
+                                           "dq_count %d to dispose list",
+                                           atomic_read(&dquot->dq_count));
 #endif
                        spin_lock(&dq_list_lock);
                        /* As dquot must have currently users it can't be on
index 24f0340..9e48874 100644 (file)
@@ -65,8 +65,7 @@ static ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf)
        ret = sb->s_op->quota_write(sb, info->dqi_type, buf,
               info->dqi_usable_bs, blk << info->dqi_blocksize_bits);
        if (ret != info->dqi_usable_bs) {
-               q_warn(KERN_WARNING "VFS: dquota write failed on "
-                       "dev %s\n", sb->s_id);
+               quota_error(sb, "dquota write failed");
                if (ret >= 0)
                        ret = -EIO;
        }
@@ -160,9 +159,8 @@ static int remove_free_dqentry(struct qtree_mem_dqinfo *info, char *buf,
        dh->dqdh_next_free = dh->dqdh_prev_free = cpu_to_le32(0);
        /* No matter whether write succeeds block is out of list */
        if (write_blk(info, blk, buf) < 0)
-               q_warn(KERN_ERR
-                      "VFS: Can't write block (%u) with free entries.\n",
-                      blk);
+               quota_error(info->dqi_sb, "Can't write block (%u) "
+                           "with free entries", blk);
        return 0;
 out_buf:
        kfree(tmpbuf);
@@ -252,9 +250,8 @@ static uint find_free_dqentry(struct qtree_mem_dqinfo *info,
        if (le16_to_cpu(dh->dqdh_entries) + 1 >= qtree_dqstr_in_blk(info)) {
                *err = remove_free_dqentry(info, buf, blk);
                if (*err < 0) {
-                       q_warn(KERN_ERR "VFS: find_free_dqentry(): Can't "
-                              "remove block (%u) from entry free list.\n",
-                              blk);
+                       quota_error(dquot->dq_sb, "Can't remove block (%u) "
+                                   "from entry free list", blk);
                        goto out_buf;
                }
        }
@@ -268,16 +265,15 @@ static uint find_free_dqentry(struct qtree_mem_dqinfo *info,
        }
 #ifdef __QUOTA_QT_PARANOIA
        if (i == qtree_dqstr_in_blk(info)) {
-               printk(KERN_ERR "VFS: find_free_dqentry(): Data block full "
-                               "but it shouldn't.\n");
+               quota_error(dquot->dq_sb, "Data block full but it shouldn't");
                *err = -EIO;
                goto out_buf;
        }
 #endif
        *err = write_blk(info, blk, buf);
        if (*err < 0) {
-               q_warn(KERN_ERR "VFS: find_free_dqentry(): Can't write quota "
-                               "data block %u.\n", blk);
+               quota_error(dquot->dq_sb, "Can't write quota data block %u",
+                           blk);
                goto out_buf;
        }
        dquot->dq_off = (blk << info->dqi_blocksize_bits) +
@@ -311,8 +307,8 @@ static int do_insert_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
        } else {
                ret = read_blk(info, *treeblk, buf);
                if (ret < 0) {
-                       q_warn(KERN_ERR "VFS: Can't read tree quota block "
-                                       "%u.\n", *treeblk);
+                       quota_error(dquot->dq_sb, "Can't read tree quota "
+                                   "block %u", *treeblk);
                        goto out_buf;
                }
        }
@@ -323,9 +319,9 @@ static int do_insert_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
        if (depth == info->dqi_qtree_depth - 1) {
 #ifdef __QUOTA_QT_PARANOIA
                if (newblk) {
-                       printk(KERN_ERR "VFS: Inserting already present quota "
-                                       "entry (block %u).\n",
-                              le32_to_cpu(ref[get_index(info,
+                       quota_error(dquot->dq_sb, "Inserting already present "
+                                   "quota entry (block %u)",
+                                   le32_to_cpu(ref[get_index(info,
                                                dquot->dq_id, depth)]));
                        ret = -EIO;
                        goto out_buf;
@@ -373,8 +369,8 @@ int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
        if (!dquot->dq_off) {
                ret = dq_insert_tree(info, dquot);
                if (ret < 0) {
-                       q_warn(KERN_ERR "VFS: Error %zd occurred while "
-                                       "creating quota.\n", ret);
+                       quota_error(sb, "Error %zd occurred while creating "
+                                   "quota", ret);
                        kfree(ddquot);
                        return ret;
                }
@@ -385,8 +381,7 @@ int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
        ret = sb->s_op->quota_write(sb, type, ddquot, info->dqi_entry_size,
                                    dquot->dq_off);
        if (ret != info->dqi_entry_size) {
-               q_warn(KERN_WARNING "VFS: dquota write failed on dev %s\n",
-                      sb->s_id);
+               quota_error(sb, "dquota write failed");
                if (ret >= 0)
                        ret = -ENOSPC;
        } else {
@@ -410,14 +405,15 @@ static int free_dqentry(struct qtree_mem_dqinfo *info, struct dquot *dquot,
        if (!buf)
                return -ENOMEM;
        if (dquot->dq_off >> info->dqi_blocksize_bits != blk) {
-               q_warn(KERN_ERR "VFS: Quota structure has offset to other "
-                 "block (%u) than it should (%u).\n", blk,
-                 (uint)(dquot->dq_off >> info->dqi_blocksize_bits));
+               quota_error(dquot->dq_sb, "Quota structure has offset to "
+                       "other block (%u) than it should (%u)", blk,
+                       (uint)(dquot->dq_off >> info->dqi_blocksize_bits));
                goto out_buf;
        }
        ret = read_blk(info, blk, buf);
        if (ret < 0) {
-               q_warn(KERN_ERR "VFS: Can't read quota data block %u\n", blk);
+               quota_error(dquot->dq_sb, "Can't read quota data block %u",
+                           blk);
                goto out_buf;
        }
        dh = (struct qt_disk_dqdbheader *)buf;
@@ -427,8 +423,8 @@ static int free_dqentry(struct qtree_mem_dqinfo *info, struct dquot *dquot,
                if (ret >= 0)
                        ret = put_free_dqblk(info, buf, blk);
                if (ret < 0) {
-                       q_warn(KERN_ERR "VFS: Can't move quota data block (%u) "
-                         "to free list.\n", blk);
+                       quota_error(dquot->dq_sb, "Can't move quota data block "
+                                   "(%u) to free list", blk);
                        goto out_buf;
                }
        } else {
@@ -440,15 +436,15 @@ static int free_dqentry(struct qtree_mem_dqinfo *info, struct dquot *dquot,
                        /* Insert will write block itself */
                        ret = insert_free_dqentry(info, buf, blk);
                        if (ret < 0) {
-                               q_warn(KERN_ERR "VFS: Can't insert quota data "
-                                      "block (%u) to free entry list.\n", blk);
+                               quota_error(dquot->dq_sb, "Can't insert quota "
+                                   "data block (%u) to free entry list", blk);
                                goto out_buf;
                        }
                } else {
                        ret = write_blk(info, blk, buf);
                        if (ret < 0) {
-                               q_warn(KERN_ERR "VFS: Can't write quota data "
-                                 "block %u\n", blk);
+                               quota_error(dquot->dq_sb, "Can't write quota "
+                                           "data block %u", blk);
                                goto out_buf;
                        }
                }
@@ -472,7 +468,8 @@ static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
                return -ENOMEM;
        ret = read_blk(info, *blk, buf);
        if (ret < 0) {
-               q_warn(KERN_ERR "VFS: Can't read quota data block %u\n", *blk);
+               quota_error(dquot->dq_sb, "Can't read quota data "
+                           "block %u", blk);
                goto out_buf;
        }
        newblk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]);
@@ -496,8 +493,8 @@ static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
                } else {
                        ret = write_blk(info, *blk, buf);
                        if (ret < 0)
-                               q_warn(KERN_ERR "VFS: Can't write quota tree "
-                                 "block %u.\n", *blk);
+                               quota_error(dquot->dq_sb, "Can't write quota "
+                                           "tree block %u", blk);
                }
        }
 out_buf:
@@ -529,7 +526,8 @@ static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info,
                return -ENOMEM;
        ret = read_blk(info, blk, buf);
        if (ret < 0) {
-               q_warn(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk);
+               quota_error(dquot->dq_sb, "Can't read quota tree "
+                           "block %u", blk);
                goto out_buf;
        }
        ddquot = buf + sizeof(struct qt_disk_dqdbheader);
@@ -539,8 +537,8 @@ static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info,
                ddquot += info->dqi_entry_size;
        }
        if (i == qtree_dqstr_in_blk(info)) {
-               q_warn(KERN_ERR "VFS: Quota for id %u referenced "
-                 "but not present.\n", dquot->dq_id);
+               quota_error(dquot->dq_sb, "Quota for id %u referenced "
+                           "but not present", dquot->dq_id);
                ret = -EIO;
                goto out_buf;
        } else {
@@ -564,7 +562,8 @@ static loff_t find_tree_dqentry(struct qtree_mem_dqinfo *info,
                return -ENOMEM;
        ret = read_blk(info, blk, buf);
        if (ret < 0) {
-               q_warn(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk);
+               quota_error(dquot->dq_sb, "Can't read quota tree block %u",
+                           blk);
                goto out_buf;
        }
        ret = 0;
@@ -598,7 +597,7 @@ int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
 #ifdef __QUOTA_QT_PARANOIA
        /* Invalidated quota? */
        if (!sb_dqopt(dquot->dq_sb)->files[type]) {
-               printk(KERN_ERR "VFS: Quota invalidated while reading!\n");
+               quota_error(sb, "Quota invalidated while reading!");
                return -EIO;
        }
 #endif
@@ -607,8 +606,8 @@ int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
                offset = find_dqentry(info, dquot);
                if (offset <= 0) {      /* Entry not present? */
                        if (offset < 0)
-                               q_warn(KERN_ERR "VFS: Can't read quota "
-                                 "structure for id %u.\n", dquot->dq_id);
+                               quota_error(sb, "Can't read quota structure "
+                                           "for id %u", dquot->dq_id);
                        dquot->dq_off = 0;
                        set_bit(DQ_FAKE_B, &dquot->dq_flags);
                        memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk));
@@ -625,8 +624,8 @@ int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
        if (ret != info->dqi_entry_size) {
                if (ret >= 0)
                        ret = -EIO;
-               q_warn(KERN_ERR "VFS: Error while reading quota "
-                               "structure for id %u.\n", dquot->dq_id);
+               quota_error(sb, "Error while reading quota structure for id %u",
+                           dquot->dq_id);
                set_bit(DQ_FAKE_B, &dquot->dq_flags);
                memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk));
                kfree(ddquot);
index ccc3e71..a1ab8db 100644 (file)
@@ -22,10 +22,4 @@ struct qt_disk_dqdbheader {
 
 #define QT_TREEOFF     1               /* Offset of tree in file in blocks */
 
-#define q_warn(fmt, args...) \
-do { \
-       if (printk_ratelimit()) \
-               printk(fmt, ## args); \
-} while(0)
-
 #endif /* _LINUX_QUOTAIO_TREE_H */
index 4af344c..34b37a6 100644 (file)
@@ -95,8 +95,7 @@ static int v1_commit_dqblk(struct dquot *dquot)
                        (char *)&dqblk, sizeof(struct v1_disk_dqblk),
                        v1_dqoff(dquot->dq_id));
        if (ret != sizeof(struct v1_disk_dqblk)) {
-               printk(KERN_WARNING "VFS: dquota write failed on dev %s\n",
-                       dquot->dq_sb->s_id);
+               quota_error(dquot->dq_sb, "dquota write failed");
                if (ret >= 0)
                        ret = -EIO;
                goto out;
index 135206a..65444d2 100644 (file)
@@ -63,9 +63,8 @@ static int v2_read_header(struct super_block *sb, int type,
        size = sb->s_op->quota_read(sb, type, (char *)dqhead,
                                    sizeof(struct v2_disk_dqheader), 0);
        if (size != sizeof(struct v2_disk_dqheader)) {
-               q_warn(KERN_WARNING "quota_v2: Failed header read:"
-                      " expected=%zd got=%zd\n",
-                       sizeof(struct v2_disk_dqheader), size);
+               quota_error(sb, "Failed header read: expected=%zd got=%zd",
+                           sizeof(struct v2_disk_dqheader), size);
                return 0;
        }
        return 1;
@@ -106,8 +105,7 @@ static int v2_read_file_info(struct super_block *sb, int type)
        size = sb->s_op->quota_read(sb, type, (char *)&dinfo,
               sizeof(struct v2_disk_dqinfo), V2_DQINFOOFF);
        if (size != sizeof(struct v2_disk_dqinfo)) {
-               q_warn(KERN_WARNING "quota_v2: Can't read info structure on device %s.\n",
-                       sb->s_id);
+               quota_error(sb, "Can't read info structure");
                return -1;
        }
        info->dqi_priv = kmalloc(sizeof(struct qtree_mem_dqinfo), GFP_NOFS);
@@ -167,8 +165,7 @@ static int v2_write_file_info(struct super_block *sb, int type)
        size = sb->s_op->quota_write(sb, type, (char *)&dinfo,
               sizeof(struct v2_disk_dqinfo), V2_DQINFOOFF);
        if (size != sizeof(struct v2_disk_dqinfo)) {
-               q_warn(KERN_WARNING "Can't write info structure on device %s.\n",
-                       sb->s_id);
+               quota_error(sb, "Can't write info structure");
                return -1;
        }
        return 0;
index 126193c..4881b49 100644 (file)
@@ -28,6 +28,12 @@ static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
 
 #if defined(CONFIG_QUOTA)
 
+#define quota_error(sb, fmt, args...) \
+       __quota_error((sb), __func__, fmt , ## args)
+
+extern void __quota_error(struct super_block *sb, const char *func,
+                        const char *fmt, ...);
+
 /*
  * declaration of quota_function calls in kernel.
  */