reiserfs: rework reiserfs_warning
Jeff Mahoney [Mon, 30 Mar 2009 18:02:21 +0000 (14:02 -0400)]
ReiserFS warnings can be somewhat inconsistent.
In some cases:
 * a unique identifier may be associated with it
 * the function name may be included
 * the device may be printed separately

This patch aims to make warnings more consistent. reiserfs_warning() prints
the device name, so printing it a second time is not required. The function
name for a warning is always helpful in debugging, so it is now automatically
inserted into the output. Hans has stated that every warning should have
a unique identifier. Some cases lack them, others really shouldn't have them.
reiserfs_warning() now expects an id associated with each message. In the
rare case where one isn't needed, "" will suffice.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

17 files changed:
fs/reiserfs/bitmap.c
fs/reiserfs/do_balan.c
fs/reiserfs/file.c
fs/reiserfs/fix_node.c
fs/reiserfs/inode.c
fs/reiserfs/item_ops.c
fs/reiserfs/journal.c
fs/reiserfs/lbalance.c
fs/reiserfs/namei.c
fs/reiserfs/objectid.c
fs/reiserfs/prints.c
fs/reiserfs/procfs.c
fs/reiserfs/stree.c
fs/reiserfs/super.c
fs/reiserfs/tail_conversion.c
fs/reiserfs/xattr.c
include/linux/reiserfs_fs.h

index 98b92a3..51b1161 100644 (file)
@@ -64,8 +64,8 @@ int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
        unsigned int bmap_count = reiserfs_bmap_count(s);
 
        if (block == 0 || block >= SB_BLOCK_COUNT(s)) {
-               reiserfs_warning(s,
-                                "vs-4010: is_reusable: block number is out of range %lu (%u)",
+               reiserfs_warning(s, "vs-4010",
+                                "block number is out of range %lu (%u)",
                                 block, SB_BLOCK_COUNT(s));
                return 0;
        }
@@ -79,30 +79,29 @@ int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
                b_blocknr_t bmap1 = REISERFS_SB(s)->s_sbh->b_blocknr + 1;
                if (block >= bmap1 &&
                    block <= bmap1 + bmap_count) {
-                       reiserfs_warning(s, "vs: 4019: is_reusable: "
-                                        "bitmap block %lu(%u) can't be freed or reused",
+                       reiserfs_warning(s, "vs-4019", "bitmap block %lu(%u) "
+                                        "can't be freed or reused",
                                         block, bmap_count);
                        return 0;
                }
        } else {
                if (offset == 0) {
-                       reiserfs_warning(s, "vs: 4020: is_reusable: "
-                                        "bitmap block %lu(%u) can't be freed or reused",
+                       reiserfs_warning(s, "vs-4020", "bitmap block %lu(%u) "
+                                        "can't be freed or reused",
                                         block, bmap_count);
                        return 0;
                }
        }
 
        if (bmap >= bmap_count) {
-               reiserfs_warning(s,
-                                "vs-4030: is_reusable: there is no so many bitmap blocks: "
-                                "block=%lu, bitmap_nr=%u", block, bmap);
+               reiserfs_warning(s, "vs-4030", "bitmap for requested block "
+                                "is out of range: block=%lu, bitmap_nr=%u",
+                                block, bmap);
                return 0;
        }
 
        if (bit_value == 0 && block == SB_ROOT_BLOCK(s)) {
-               reiserfs_warning(s,
-                                "vs-4050: is_reusable: this is root block (%u), "
+               reiserfs_warning(s, "vs-4050", "this is root block (%u), "
                                 "it must be busy", SB_ROOT_BLOCK(s));
                return 0;
        }
@@ -154,8 +153,8 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
 /* - I mean `a window of zero bits' as in description of this function - Zam. */
 
        if (!bi) {
-               reiserfs_warning(s, "NULL bitmap info pointer for bitmap %d",
-                                bmap_n);
+               reiserfs_warning(s, "jdm-4055", "NULL bitmap info pointer "
+                                "for bitmap %d", bmap_n);
                return 0;
        }
 
@@ -400,11 +399,8 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
        get_bit_address(s, block, &nr, &offset);
 
        if (nr >= reiserfs_bmap_count(s)) {
-               reiserfs_warning(s, "vs-4075: reiserfs_free_block: "
-                                "block %lu is out of range on %s "
-                                "(nr=%u,max=%u)", block,
-                                reiserfs_bdevname(s), nr,
-                                reiserfs_bmap_count(s));
+               reiserfs_warning(s, "vs-4075", "block %lu is out of range",
+                                block);
                return;
        }
 
@@ -416,9 +412,8 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
 
        /* clear bit for the given block in bit map */
        if (!reiserfs_test_and_clear_le_bit(offset, bmbh->b_data)) {
-               reiserfs_warning(s, "vs-4080: reiserfs_free_block: "
-                                "free_block (%s:%lu)[dev:blocknr]: bit already cleared",
-                                reiserfs_bdevname(s), block);
+               reiserfs_warning(s, "vs-4080",
+                                "block %lu: bit already cleared", block);
        }
        apbi[nr].free_count++;
        journal_mark_dirty(th, s, bmbh);
@@ -477,9 +472,8 @@ static void __discard_prealloc(struct reiserfs_transaction_handle *th,
        BUG_ON(!th->t_trans_id);
 #ifdef CONFIG_REISERFS_CHECK
        if (ei->i_prealloc_count < 0)
-               reiserfs_warning(th->t_super,
-                                "zam-4001:%s: inode has negative prealloc blocks count.",
-                                __func__);
+               reiserfs_warning(th->t_super, "zam-4001",
+                                "inode has negative prealloc blocks count.");
 #endif
        while (ei->i_prealloc_count > 0) {
                reiserfs_free_prealloc_block(th, inode, ei->i_prealloc_block);
@@ -515,9 +509,9 @@ void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th)
                                i_prealloc_list);
 #ifdef CONFIG_REISERFS_CHECK
                if (!ei->i_prealloc_count) {
-                       reiserfs_warning(th->t_super,
-                                        "zam-4001:%s: inode is in prealloc list but has no preallocated blocks.",
-                                        __func__);
+                       reiserfs_warning(th->t_super, "zam-4001",
+                                        "inode is in prealloc list but has "
+                                        "no preallocated blocks.");
                }
 #endif
                __discard_prealloc(th, ei);
@@ -631,8 +625,8 @@ int reiserfs_parse_alloc_options(struct super_block *s, char *options)
                        continue;
                }
 
-               reiserfs_warning(s, "zam-4001: %s : unknown option - %s",
-                                __func__, this_char);
+               reiserfs_warning(s, "zam-4001", "unknown option - %s",
+                                this_char);
                return 1;
        }
 
index 99f8053..f701f37 100644 (file)
@@ -1752,15 +1752,16 @@ static void store_thrown(struct tree_balance *tb, struct buffer_head *bh)
        int i;
 
        if (buffer_dirty(bh))
-               reiserfs_warning(tb->tb_sb,
-                                "store_thrown deals with dirty buffer");
+               reiserfs_warning(tb->tb_sb, "reiserfs-12320",
+                                "called with dirty buffer");
        for (i = 0; i < ARRAY_SIZE(tb->thrown); i++)
                if (!tb->thrown[i]) {
                        tb->thrown[i] = bh;
                        get_bh(bh);     /* free_thrown puts this */
                        return;
                }
-       reiserfs_warning(tb->tb_sb, "store_thrown: too many thrown buffers");
+       reiserfs_warning(tb->tb_sb, "reiserfs-12321",
+                        "too many thrown buffers");
 }
 
 static void free_thrown(struct tree_balance *tb)
@@ -1771,8 +1772,8 @@ static void free_thrown(struct tree_balance *tb)
                if (tb->thrown[i]) {
                        blocknr = tb->thrown[i]->b_blocknr;
                        if (buffer_dirty(tb->thrown[i]))
-                               reiserfs_warning(tb->tb_sb,
-                                                "free_thrown deals with dirty buffer %d",
+                               reiserfs_warning(tb->tb_sb, "reiserfs-12322",
+                                                "called with dirty buffer %d",
                                                 blocknr);
                        brelse(tb->thrown[i]);  /* incremented in store_thrown */
                        reiserfs_free_block(tb->transaction_handle, NULL,
@@ -1877,13 +1878,12 @@ static void check_internal_node(struct super_block *s, struct buffer_head *bh,
        }
 }
 
-static int locked_or_not_in_tree(struct buffer_head *bh, char *which)
+static int locked_or_not_in_tree(struct tree_balance *tb,
+                                 struct buffer_head *bh, char *which)
 {
        if ((!buffer_journal_prepared(bh) && buffer_locked(bh)) ||
            !B_IS_IN_TREE(bh)) {
-               reiserfs_warning(NULL,
-                                "vs-12339: locked_or_not_in_tree: %s (%b)",
-                                which, bh);
+               reiserfs_warning(tb->tb_sb, "vs-12339", "%s (%b)", which, bh);
                return 1;
        }
        return 0;
@@ -1902,18 +1902,19 @@ static int check_before_balancing(struct tree_balance *tb)
        /* double check that buffers that we will modify are unlocked. (fix_nodes should already have
           prepped all of these for us). */
        if (tb->lnum[0]) {
-               retval |= locked_or_not_in_tree(tb->L[0], "L[0]");
-               retval |= locked_or_not_in_tree(tb->FL[0], "FL[0]");
-               retval |= locked_or_not_in_tree(tb->CFL[0], "CFL[0]");
+               retval |= locked_or_not_in_tree(tb, tb->L[0], "L[0]");
+               retval |= locked_or_not_in_tree(tb, tb->FL[0], "FL[0]");
+               retval |= locked_or_not_in_tree(tb, tb->CFL[0], "CFL[0]");
                check_leaf(tb->L[0]);
        }
        if (tb->rnum[0]) {
-               retval |= locked_or_not_in_tree(tb->R[0], "R[0]");
-               retval |= locked_or_not_in_tree(tb->FR[0], "FR[0]");
-               retval |= locked_or_not_in_tree(tb->CFR[0], "CFR[0]");
+               retval |= locked_or_not_in_tree(tb, tb->R[0], "R[0]");
+               retval |= locked_or_not_in_tree(tb, tb->FR[0], "FR[0]");
+               retval |= locked_or_not_in_tree(tb, tb->CFR[0], "CFR[0]");
                check_leaf(tb->R[0]);
        }
-       retval |= locked_or_not_in_tree(PATH_PLAST_BUFFER(tb->tb_path), "S[0]");
+       retval |= locked_or_not_in_tree(tb, PATH_PLAST_BUFFER(tb->tb_path),
+                                       "S[0]");
        check_leaf(PATH_PLAST_BUFFER(tb->tb_path));
 
        return retval;
@@ -1952,7 +1953,7 @@ static void check_after_balance_leaf(struct tree_balance *tb)
                                               PATH_H_POSITION(tb->tb_path,
                                                               1))));
                print_cur_tb("12223");
-               reiserfs_warning(tb->tb_sb,
+               reiserfs_warning(tb->tb_sb, "reiserfs-12363",
                                 "B_FREE_SPACE (PATH_H_PBUFFER(tb->tb_path,0)) = %d; "
                                 "MAX_CHILD_SIZE (%d) - dc_size( %y, %d ) [%d] = %d",
                                 left,
@@ -2104,9 +2105,8 @@ void do_balance(struct tree_balance *tb,  /* tree_balance structure */
        }
        /* if we have no real work to do  */
        if (!tb->insert_size[0]) {
-               reiserfs_warning(tb->tb_sb,
-                                "PAP-12350: do_balance: insert_size == 0, mode == %c",
-                                flag);
+               reiserfs_warning(tb->tb_sb, "PAP-12350",
+                                "insert_size == 0, mode == %c", flag);
                unfix_nodes(tb);
                return;
        }
index 3340841..47bab89 100644 (file)
@@ -76,7 +76,7 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
                         * and let the admin know what is going on.
                         */
                        igrab(inode);
-                       reiserfs_warning(inode->i_sb,
+                       reiserfs_warning(inode->i_sb, "clm-9001",
                                         "pinning inode %lu because the "
                                         "preallocation can't be freed",
                                         inode->i_ino);
index 07d05e0..59735a9 100644 (file)
@@ -496,8 +496,8 @@ static int get_num_ver(int mode, struct tree_balance *tb, int h,
                snum012[needed_nodes - 1 + 3] = units;
 
                if (needed_nodes > 2)
-                       reiserfs_warning(tb->tb_sb, "vs-8111: get_num_ver: "
-                                        "split_item_position is out of boundary");
+                       reiserfs_warning(tb->tb_sb, "vs-8111",
+                                        "split_item_position is out of range");
                snum012[needed_nodes - 1]++;
                split_item_positions[needed_nodes - 1] = i;
                needed_nodes++;
@@ -533,8 +533,8 @@ static int get_num_ver(int mode, struct tree_balance *tb, int h,
 
                if (vn->vn_vi[split_item_num].vi_index != TYPE_DIRENTRY &&
                    vn->vn_vi[split_item_num].vi_index != TYPE_INDIRECT)
-                       reiserfs_warning(tb->tb_sb, "vs-8115: get_num_ver: not "
-                                        "directory or indirect item");
+                       reiserfs_warning(tb->tb_sb, "vs-8115",
+                                        "not directory or indirect item");
        }
 
        /* now we know S2bytes, calculate S1bytes */
@@ -2268,9 +2268,9 @@ static int wait_tb_buffers_until_unlocked(struct tree_balance *p_s_tb)
 #ifdef CONFIG_REISERFS_CHECK
                        repeat_counter++;
                        if ((repeat_counter % 10000) == 0) {
-                               reiserfs_warning(p_s_tb->tb_sb,
-                                                "wait_tb_buffers_until_released(): too many "
-                                                "iterations waiting for buffer to unlock "
+                               reiserfs_warning(p_s_tb->tb_sb, "reiserfs-8200",
+                                                "too many iterations waiting "
+                                                "for buffer to unlock "
                                                 "(%b)", locked);
 
                                /* Don't loop forever.  Try to recover from possible error. */
index 55fce92..9515776 100644 (file)
@@ -842,7 +842,9 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
                                if (retval) {
                                        if (retval != -ENOSPC)
                                                reiserfs_warning(inode->i_sb,
-                                                                "clm-6004: convert tail failed inode %lu, error %d",
+                                                        "clm-6004",
+                                                        "convert tail failed "
+                                                        "inode %lu, error %d",
                                                                 inode->i_ino,
                                                                 retval);
                                        if (allocated_block_nr) {
@@ -1006,8 +1008,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
                        goto failure;
                }
                if (retval == POSITION_FOUND) {
-                       reiserfs_warning(inode->i_sb,
-                                        "vs-825: reiserfs_get_block: "
+                       reiserfs_warning(inode->i_sb, "vs-825",
                                         "%K should not be found", &key);
                        retval = -EEXIST;
                        if (allocated_block_nr)
@@ -1332,9 +1333,9 @@ void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
                /* look for the object's stat data */
                retval = search_item(inode->i_sb, &key, &path);
                if (retval == IO_ERROR) {
-                       reiserfs_warning(inode->i_sb,
-                                        "vs-13050: reiserfs_update_sd: "
-                                        "i/o failure occurred trying to update %K stat data",
+                       reiserfs_warning(inode->i_sb, "vs-13050",
+                                        "i/o failure occurred trying to "
+                                        "update %K stat data",
                                         &key);
                        return;
                }
@@ -1345,9 +1346,9 @@ void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
                                /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
                                return;
                        }
-                       reiserfs_warning(inode->i_sb,
-                                        "vs-13060: reiserfs_update_sd: "
-                                        "stat data of object %k (nlink == %d) not found (pos %d)",
+                       reiserfs_warning(inode->i_sb, "vs-13060",
+                                        "stat data of object %k (nlink == %d) "
+                                        "not found (pos %d)",
                                         INODE_PKEY(inode), inode->i_nlink,
                                         pos);
                        reiserfs_check_path(&path);
@@ -1424,10 +1425,9 @@ void reiserfs_read_locked_inode(struct inode *inode,
        /* look for the object's stat data */
        retval = search_item(inode->i_sb, &key, &path_to_sd);
        if (retval == IO_ERROR) {
-               reiserfs_warning(inode->i_sb,
-                                "vs-13070: reiserfs_read_locked_inode: "
-                                "i/o failure occurred trying to find stat data of %K",
-                                &key);
+               reiserfs_warning(inode->i_sb, "vs-13070",
+                                "i/o failure occurred trying to find "
+                                "stat data of %K", &key);
                reiserfs_make_bad_inode(inode);
                return;
        }
@@ -1457,8 +1457,7 @@ void reiserfs_read_locked_inode(struct inode *inode,
           during mount (fs/reiserfs/super.c:finish_unfinished()). */
        if ((inode->i_nlink == 0) &&
            !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {
-               reiserfs_warning(inode->i_sb,
-                                "vs-13075: reiserfs_read_locked_inode: "
+               reiserfs_warning(inode->i_sb, "vs-13075",
                                 "dead inode read from disk %K. "
                                 "This is likely to be race with knfsd. Ignore",
                                 &key);
@@ -1555,7 +1554,7 @@ struct dentry *reiserfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
         */
        if (fh_type > fh_len) {
                if (fh_type != 6 || fh_len != 5)
-                       reiserfs_warning(sb,
+                       reiserfs_warning(sb, "reiserfs-13077",
                                "nfsd/reiserfs, fhtype=%d, len=%d - odd",
                                fh_type, fh_len);
                fh_type = 5;
@@ -1680,13 +1679,13 @@ static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
        /* look for place in the tree for new item */
        retval = search_item(sb, &key, path);
        if (retval == IO_ERROR) {
-               reiserfs_warning(sb, "vs-13080: reiserfs_new_directory: "
+               reiserfs_warning(sb, "vs-13080",
                                 "i/o failure occurred creating new directory");
                return -EIO;
        }
        if (retval == ITEM_FOUND) {
                pathrelse(path);
-               reiserfs_warning(sb, "vs-13070: reiserfs_new_directory: "
+               reiserfs_warning(sb, "vs-13070",
                                 "object with this key exists (%k)",
                                 &(ih->ih_key));
                return -EEXIST;
@@ -1720,13 +1719,13 @@ static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct i
        /* look for place in the tree for new item */
        retval = search_item(sb, &key, path);
        if (retval == IO_ERROR) {
-               reiserfs_warning(sb, "vs-13080: reiserfs_new_symlinik: "
+               reiserfs_warning(sb, "vs-13080",
                                 "i/o failure occurred creating new symlink");
                return -EIO;
        }
        if (retval == ITEM_FOUND) {
                pathrelse(path);
-               reiserfs_warning(sb, "vs-13080: reiserfs_new_symlink: "
+               reiserfs_warning(sb, "vs-13080",
                                 "object with this key exists (%k)",
                                 &(ih->ih_key));
                return -EEXIST;
@@ -1927,7 +1926,8 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
                        goto out_inserted_sd;
                }
        } else if (inode->i_sb->s_flags & MS_POSIXACL) {
-               reiserfs_warning(inode->i_sb, "ACLs aren't enabled in the fs, "
+               reiserfs_warning(inode->i_sb, "jdm-13090",
+                                "ACLs aren't enabled in the fs, "
                                 "but vfs thinks they are!");
        } else if (is_reiserfs_priv_object(dir)) {
                reiserfs_mark_inode_private(inode);
@@ -2044,8 +2044,8 @@ static int grab_tail_page(struct inode *p_s_inode,
                 ** I've screwed up the code to find the buffer, or the code to
                 ** call prepare_write
                 */
-               reiserfs_warning(p_s_inode->i_sb,
-                                "clm-6000: error reading block %lu on dev %s",
+               reiserfs_warning(p_s_inode->i_sb, "clm-6000",
+                                "error reading block %lu on dev %s",
                                 bh->b_blocknr,
                                 reiserfs_bdevname(p_s_inode->i_sb));
                error = -EIO;
@@ -2089,8 +2089,8 @@ int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)
                        // and get_block_create_0 could not find a block to read in,
                        // which is ok.
                        if (error != -ENOENT)
-                               reiserfs_warning(p_s_inode->i_sb,
-                                                "clm-6001: grab_tail_page failed %d",
+                               reiserfs_warning(p_s_inode->i_sb, "clm-6001",
+                                                "grab_tail_page failed %d",
                                                 error);
                        page = NULL;
                        bh = NULL;
@@ -2208,9 +2208,8 @@ static int map_block_for_writepage(struct inode *inode,
        /* we've found an unformatted node */
        if (indirect_item_found(retval, ih)) {
                if (bytes_copied > 0) {
-                       reiserfs_warning(inode->i_sb,
-                                        "clm-6002: bytes_copied %d",
-                                        bytes_copied);
+                       reiserfs_warning(inode->i_sb, "clm-6002",
+                                        "bytes_copied %d", bytes_copied);
                }
                if (!get_block_num(item, pos_in_item)) {
                        /* crap, we are writing to a hole */
@@ -2267,9 +2266,8 @@ static int map_block_for_writepage(struct inode *inode,
                        goto research;
                }
        } else {
-               reiserfs_warning(inode->i_sb,
-                                "clm-6003: bad item inode %lu, device %s",
-                                inode->i_ino, reiserfs_bdevname(inode->i_sb));
+               reiserfs_warning(inode->i_sb, "clm-6003",
+                                "bad item inode %lu", inode->i_ino);
                retval = -EIO;
                goto out;
        }
index 9475557..8a11cf3 100644 (file)
@@ -97,7 +97,8 @@ static int sd_unit_num(struct virtual_item *vi)
 
 static void sd_print_vi(struct virtual_item *vi)
 {
-       reiserfs_warning(NULL, "STATDATA, index %d, type 0x%x, %h",
+       reiserfs_warning(NULL, "reiserfs-16100",
+                        "STATDATA, index %d, type 0x%x, %h",
                         vi->vi_index, vi->vi_type, vi->vi_ih);
 }
 
@@ -190,7 +191,8 @@ static int direct_unit_num(struct virtual_item *vi)
 
 static void direct_print_vi(struct virtual_item *vi)
 {
-       reiserfs_warning(NULL, "DIRECT, index %d, type 0x%x, %h",
+       reiserfs_warning(NULL, "reiserfs-16101",
+                        "DIRECT, index %d, type 0x%x, %h",
                         vi->vi_index, vi->vi_type, vi->vi_ih);
 }
 
@@ -278,7 +280,7 @@ static void indirect_print_item(struct item_head *ih, char *item)
        unp = (__le32 *) item;
 
        if (ih_item_len(ih) % UNFM_P_SIZE)
-               reiserfs_warning(NULL, "indirect_print_item: invalid item len");
+               reiserfs_warning(NULL, "reiserfs-16102", "invalid item len");
 
        printk("%d pointers\n[ ", (int)I_UNFM_NUM(ih));
        for (j = 0; j < I_UNFM_NUM(ih); j++) {
@@ -334,7 +336,8 @@ static int indirect_unit_num(struct virtual_item *vi)
 
 static void indirect_print_vi(struct virtual_item *vi)
 {
-       reiserfs_warning(NULL, "INDIRECT, index %d, type 0x%x, %h",
+       reiserfs_warning(NULL, "reiserfs-16103",
+                        "INDIRECT, index %d, type 0x%x, %h",
                         vi->vi_index, vi->vi_type, vi->vi_ih);
 }
 
@@ -359,7 +362,7 @@ static struct item_operations indirect_ops = {
 
 static int direntry_bytes_number(struct item_head *ih, int block_size)
 {
-       reiserfs_warning(NULL, "vs-16090: direntry_bytes_number: "
+       reiserfs_warning(NULL, "vs-16090",
                         "bytes number is asked for direntry");
        return 0;
 }
@@ -614,7 +617,8 @@ static void direntry_print_vi(struct virtual_item *vi)
        int i;
        struct direntry_uarea *dir_u = vi->vi_uarea;
 
-       reiserfs_warning(NULL, "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
+       reiserfs_warning(NULL, "reiserfs-16104",
+                        "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
                         vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);
        printk("%d entries: ", dir_u->entry_count);
        for (i = 0; i < dir_u->entry_count; i++)
@@ -642,43 +646,43 @@ static struct item_operations direntry_ops = {
 //
 static int errcatch_bytes_number(struct item_head *ih, int block_size)
 {
-       reiserfs_warning(NULL,
-                        "green-16001: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16001",
+                        "Invalid item type observed, run fsck ASAP");
        return 0;
 }
 
 static void errcatch_decrement_key(struct cpu_key *key)
 {
-       reiserfs_warning(NULL,
-                        "green-16002: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16002",
+                        "Invalid item type observed, run fsck ASAP");
 }
 
 static int errcatch_is_left_mergeable(struct reiserfs_key *key,
                                      unsigned long bsize)
 {
-       reiserfs_warning(NULL,
-                        "green-16003: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16003",
+                        "Invalid item type observed, run fsck ASAP");
        return 0;
 }
 
 static void errcatch_print_item(struct item_head *ih, char *item)
 {
-       reiserfs_warning(NULL,
-                        "green-16004: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16004",
+                        "Invalid item type observed, run fsck ASAP");
 }
 
 static void errcatch_check_item(struct item_head *ih, char *item)
 {
-       reiserfs_warning(NULL,
-                        "green-16005: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16005",
+                        "Invalid item type observed, run fsck ASAP");
 }
 
 static int errcatch_create_vi(struct virtual_node *vn,
                              struct virtual_item *vi,
                              int is_affected, int insert_size)
 {
-       reiserfs_warning(NULL,
-                        "green-16006: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16006",
+                        "Invalid item type observed, run fsck ASAP");
        return 0;               // We might return -1 here as well, but it won't help as create_virtual_node() from where
        // this operation is called from is of return type void.
 }
@@ -686,36 +690,36 @@ static int errcatch_create_vi(struct virtual_node *vn,
 static int errcatch_check_left(struct virtual_item *vi, int free,
                               int start_skip, int end_skip)
 {
-       reiserfs_warning(NULL,
-                        "green-16007: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16007",
+                        "Invalid item type observed, run fsck ASAP");
        return -1;
 }
 
 static int errcatch_check_right(struct virtual_item *vi, int free)
 {
-       reiserfs_warning(NULL,
-                        "green-16008: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16008",
+                        "Invalid item type observed, run fsck ASAP");
        return -1;
 }
 
 static int errcatch_part_size(struct virtual_item *vi, int first, int count)
 {
-       reiserfs_warning(NULL,
-                        "green-16009: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16009",
+                        "Invalid item type observed, run fsck ASAP");
        return 0;
 }
 
 static int errcatch_unit_num(struct virtual_item *vi)
 {
-       reiserfs_warning(NULL,
-                        "green-16010: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16010",
+                        "Invalid item type observed, run fsck ASAP");
        return 0;
 }
 
 static void errcatch_print_vi(struct virtual_item *vi)
 {
-       reiserfs_warning(NULL,
-                        "green-16011: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16011",
+                        "Invalid item type observed, run fsck ASAP");
 }
 
 static struct item_operations errcatch_ops = {
index 677bb92..88a031f 100644 (file)
@@ -300,8 +300,8 @@ int reiserfs_allocate_list_bitmaps(struct super_block *p_s_sb,
                jb->journal_list = NULL;
                jb->bitmaps = vmalloc(mem);
                if (!jb->bitmaps) {
-                       reiserfs_warning(p_s_sb,
-                                        "clm-2000, unable to allocate bitmaps for journal lists");
+                       reiserfs_warning(p_s_sb, "clm-2000", "unable to "
+                                        "allocate bitmaps for journal lists");
                        failed = 1;
                        break;
                }
@@ -644,8 +644,8 @@ static void reiserfs_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
        char b[BDEVNAME_SIZE];
 
        if (buffer_journaled(bh)) {
-               reiserfs_warning(NULL,
-                                "clm-2084: pinned buffer %lu:%s sent to disk",
+               reiserfs_warning(NULL, "clm-2084",
+                                "pinned buffer %lu:%s sent to disk",
                                 bh->b_blocknr, bdevname(bh->b_bdev, b));
        }
        if (uptodate)
@@ -1122,7 +1122,8 @@ static int flush_commit_list(struct super_block *s,
                        sync_dirty_buffer(tbh);
                if (unlikely(!buffer_uptodate(tbh))) {
 #ifdef CONFIG_REISERFS_CHECK
-                       reiserfs_warning(s, "journal-601, buffer write failed");
+                       reiserfs_warning(s, "journal-601",
+                                        "buffer write failed");
 #endif
                        retval = -EIO;
                }
@@ -1154,14 +1155,14 @@ static int flush_commit_list(struct super_block *s,
         * up propagating the write error out to the filesystem. */
        if (unlikely(!buffer_uptodate(jl->j_commit_bh))) {
 #ifdef CONFIG_REISERFS_CHECK
-               reiserfs_warning(s, "journal-615: buffer write failed");
+               reiserfs_warning(s, "journal-615", "buffer write failed");
 #endif
                retval = -EIO;
        }
        bforget(jl->j_commit_bh);
        if (journal->j_last_commit_id != 0 &&
            (jl->j_trans_id - journal->j_last_commit_id) != 1) {
-               reiserfs_warning(s, "clm-2200: last commit %lu, current %lu",
+               reiserfs_warning(s, "clm-2200", "last commit %lu, current %lu",
                                 journal->j_last_commit_id, jl->j_trans_id);
        }
        journal->j_last_commit_id = jl->j_trans_id;
@@ -1250,7 +1251,7 @@ static void remove_all_from_journal_list(struct super_block *p_s_sb,
        while (cn) {
                if (cn->blocknr != 0) {
                        if (debug) {
-                               reiserfs_warning(p_s_sb,
+                               reiserfs_warning(p_s_sb, "reiserfs-2201",
                                                 "block %u, bh is %d, state %ld",
                                                 cn->blocknr, cn->bh ? 1 : 0,
                                                 cn->state);
@@ -1288,8 +1289,8 @@ static int _update_journal_header_block(struct super_block *p_s_sb,
                        wait_on_buffer((journal->j_header_bh));
                        if (unlikely(!buffer_uptodate(journal->j_header_bh))) {
 #ifdef CONFIG_REISERFS_CHECK
-                               reiserfs_warning(p_s_sb,
-                                                "journal-699: buffer write failed");
+                               reiserfs_warning(p_s_sb, "journal-699",
+                                                "buffer write failed");
 #endif
                                return -EIO;
                        }
@@ -1319,8 +1320,8 @@ static int _update_journal_header_block(struct super_block *p_s_sb,
                        sync_dirty_buffer(journal->j_header_bh);
                }
                if (!buffer_uptodate(journal->j_header_bh)) {
-                       reiserfs_warning(p_s_sb,
-                                        "journal-837: IO error during journal replay");
+                       reiserfs_warning(p_s_sb, "journal-837",
+                                        "IO error during journal replay");
                        return -EIO;
                }
        }
@@ -1401,8 +1402,7 @@ static int flush_journal_list(struct super_block *s,
        BUG_ON(j_len_saved <= 0);
 
        if (atomic_read(&journal->j_wcount) != 0) {
-               reiserfs_warning(s,
-                                "clm-2048: flush_journal_list called with wcount %d",
+               reiserfs_warning(s, "clm-2048", "called with wcount %d",
                                 atomic_read(&journal->j_wcount));
        }
        BUG_ON(jl->j_trans_id == 0);
@@ -1510,8 +1510,8 @@ static int flush_journal_list(struct super_block *s,
                 ** is not marked JDirty_wait
                 */
                if ((!was_jwait) && !buffer_locked(saved_bh)) {
-                       reiserfs_warning(s,
-                                        "journal-813: BAD! buffer %llu %cdirty %cjwait, "
+                       reiserfs_warning(s, "journal-813",
+                                        "BAD! buffer %llu %cdirty %cjwait, "
                                         "not in a newer tranasction",
                                         (unsigned long long)saved_bh->
                                         b_blocknr, was_dirty ? ' ' : '!',
@@ -1529,8 +1529,8 @@ static int flush_journal_list(struct super_block *s,
                                unlock_buffer(saved_bh);
                        count++;
                } else {
-                       reiserfs_warning(s,
-                                        "clm-2082: Unable to flush buffer %llu in %s",
+                       reiserfs_warning(s, "clm-2082",
+                                        "Unable to flush buffer %llu in %s",
                                         (unsigned long long)saved_bh->
                                         b_blocknr, __func__);
                }
@@ -1541,8 +1541,8 @@ static int flush_journal_list(struct super_block *s,
                        /* we incremented this to keep others from taking the buffer head away */
                        put_bh(saved_bh);
                        if (atomic_read(&(saved_bh->b_count)) < 0) {
-                               reiserfs_warning(s,
-                                                "journal-945: saved_bh->b_count < 0");
+                               reiserfs_warning(s, "journal-945",
+                                                "saved_bh->b_count < 0");
                        }
                }
        }
@@ -1561,8 +1561,8 @@ static int flush_journal_list(struct super_block *s,
                                }
                                if (unlikely(!buffer_uptodate(cn->bh))) {
 #ifdef CONFIG_REISERFS_CHECK
-                                       reiserfs_warning(s,
-                                                        "journal-949: buffer write failed\n");
+                                       reiserfs_warning(s, "journal-949",
+                                                        "buffer write failed");
 #endif
                                        err = -EIO;
                                }
@@ -1623,7 +1623,7 @@ static int flush_journal_list(struct super_block *s,
 
        if (journal->j_last_flush_id != 0 &&
            (jl->j_trans_id - journal->j_last_flush_id) != 1) {
-               reiserfs_warning(s, "clm-2201: last flush %lu, current %lu",
+               reiserfs_warning(s, "clm-2201", "last flush %lu, current %lu",
                                 journal->j_last_flush_id, jl->j_trans_id);
        }
        journal->j_last_flush_id = jl->j_trans_id;
@@ -2058,8 +2058,9 @@ static int journal_transaction_is_valid(struct super_block *p_s_sb,
                        return -1;
                }
                if (get_desc_trans_len(desc) > SB_JOURNAL(p_s_sb)->j_trans_max) {
-                       reiserfs_warning(p_s_sb,
-                                        "journal-2018: Bad transaction length %d encountered, ignoring transaction",
+                       reiserfs_warning(p_s_sb, "journal-2018",
+                                        "Bad transaction length %d "
+                                        "encountered, ignoring transaction",
                                         get_desc_trans_len(desc));
                        return -1;
                }
@@ -2195,8 +2196,8 @@ static int journal_read_transaction(struct super_block *p_s_sb,
                brelse(d_bh);
                kfree(log_blocks);
                kfree(real_blocks);
-               reiserfs_warning(p_s_sb,
-                                "journal-1169: kmalloc failed, unable to mount FS");
+               reiserfs_warning(p_s_sb, "journal-1169",
+                                "kmalloc failed, unable to mount FS");
                return -1;
        }
        /* get all the buffer heads */
@@ -2218,15 +2219,18 @@ static int journal_read_transaction(struct super_block *p_s_sb,
                                                  j_realblock[i - trans_half]));
                }
                if (real_blocks[i]->b_blocknr > SB_BLOCK_COUNT(p_s_sb)) {
-                       reiserfs_warning(p_s_sb,
-                                        "journal-1207: REPLAY FAILURE fsck required! Block to replay is outside of filesystem");
+                       reiserfs_warning(p_s_sb, "journal-1207",
+                                        "REPLAY FAILURE fsck required! "
+                                        "Block to replay is outside of "
+                                        "filesystem");
                        goto abort_replay;
                }
                /* make sure we don't try to replay onto log or reserved area */
                if (is_block_in_log_or_reserved_area
                    (p_s_sb, real_blocks[i]->b_blocknr)) {
-                       reiserfs_warning(p_s_sb,
-                                        "journal-1204: REPLAY FAILURE fsck required! Trying to replay onto a log block");
+                       reiserfs_warning(p_s_sb, "journal-1204",
+                                        "REPLAY FAILURE fsck required! "
+                                        "Trying to replay onto a log block");
                      abort_replay:
                        brelse_array(log_blocks, i);
                        brelse_array(real_blocks, i);
@@ -2242,8 +2246,9 @@ static int journal_read_transaction(struct super_block *p_s_sb,
        for (i = 0; i < get_desc_trans_len(desc); i++) {
                wait_on_buffer(log_blocks[i]);
                if (!buffer_uptodate(log_blocks[i])) {
-                       reiserfs_warning(p_s_sb,
-                                        "journal-1212: REPLAY FAILURE fsck required! buffer write failed");
+                       reiserfs_warning(p_s_sb, "journal-1212",
+                                        "REPLAY FAILURE fsck required! "
+                                        "buffer write failed");
                        brelse_array(log_blocks + i,
                                     get_desc_trans_len(desc) - i);
                        brelse_array(real_blocks, get_desc_trans_len(desc));
@@ -2266,8 +2271,9 @@ static int journal_read_transaction(struct super_block *p_s_sb,
        for (i = 0; i < get_desc_trans_len(desc); i++) {
                wait_on_buffer(real_blocks[i]);
                if (!buffer_uptodate(real_blocks[i])) {
-                       reiserfs_warning(p_s_sb,
-                                        "journal-1226: REPLAY FAILURE, fsck required! buffer write failed");
+                       reiserfs_warning(p_s_sb, "journal-1226",
+                                        "REPLAY FAILURE, fsck required! "
+                                        "buffer write failed");
                        brelse_array(real_blocks + i,
                                     get_desc_trans_len(desc) - i);
                        brelse(c_bh);
@@ -2418,8 +2424,8 @@ static int journal_read(struct super_block *p_s_sb)
        }
 
        if (continue_replay && bdev_read_only(p_s_sb->s_bdev)) {
-               reiserfs_warning(p_s_sb,
-                                "clm-2076: device is readonly, unable to replay log");
+               reiserfs_warning(p_s_sb, "clm-2076",
+                                "device is readonly, unable to replay log");
                return -1;
        }
 
@@ -2580,9 +2586,8 @@ static int release_journal_dev(struct super_block *super,
        }
 
        if (result != 0) {
-               reiserfs_warning(super,
-                                "sh-457: release_journal_dev: Cannot release journal device: %i",
-                                result);
+               reiserfs_warning(super, "sh-457",
+                                "Cannot release journal device: %i", result);
        }
        return result;
 }
@@ -2612,7 +2617,7 @@ static int journal_init_dev(struct super_block *super,
                if (IS_ERR(journal->j_dev_bd)) {
                        result = PTR_ERR(journal->j_dev_bd);
                        journal->j_dev_bd = NULL;
-                       reiserfs_warning(super, "sh-458: journal_init_dev: "
+                       reiserfs_warning(super, "sh-458",
                                         "cannot init journal device '%s': %i",
                                         __bdevname(jdev, b), result);
                        return result;
@@ -2676,16 +2681,16 @@ static int check_advise_trans_params(struct super_block *p_s_sb,
                    journal->j_trans_max < JOURNAL_TRANS_MIN_DEFAULT / ratio ||
                    SB_ONDISK_JOURNAL_SIZE(p_s_sb) / journal->j_trans_max <
                    JOURNAL_MIN_RATIO) {
-                       reiserfs_warning(p_s_sb,
-                                "sh-462: bad transaction max size (%u). FSCK?",
-                                journal->j_trans_max);
+                       reiserfs_warning(p_s_sb, "sh-462",
+                                        "bad transaction max size (%u). "
+                                        "FSCK?", journal->j_trans_max);
                        return 1;
                }
                if (journal->j_max_batch != (journal->j_trans_max) *
                        JOURNAL_MAX_BATCH_DEFAULT/JOURNAL_TRANS_MAX_DEFAULT) {
-                       reiserfs_warning(p_s_sb,
-                               "sh-463: bad transaction max batch (%u). FSCK?",
-                               journal->j_max_batch);
+                       reiserfs_warning(p_s_sb, "sh-463",
+                                        "bad transaction max batch (%u). "
+                                        "FSCK?", journal->j_max_batch);
                        return 1;
                }
        } else {
@@ -2693,9 +2698,11 @@ static int check_advise_trans_params(struct super_block *p_s_sb,
                    The file system was created by old version
                   of mkreiserfs, so some fields contain zeros,
                   and we need to advise proper values for them */
-               if (p_s_sb->s_blocksize != REISERFS_STANDARD_BLKSIZE)
-                       reiserfs_panic(p_s_sb, "sh-464: bad blocksize (%u)",
-                                      p_s_sb->s_blocksize);
+               if (p_s_sb->s_blocksize != REISERFS_STANDARD_BLKSIZE) {
+                       reiserfs_warning(p_s_sb, "sh-464", "bad blocksize (%u)",
+                                        p_s_sb->s_blocksize);
+                       return 1;
+               }
                journal->j_trans_max = JOURNAL_TRANS_MAX_DEFAULT;
                journal->j_max_batch = JOURNAL_MAX_BATCH_DEFAULT;
                journal->j_max_commit_age = JOURNAL_MAX_COMMIT_AGE;
@@ -2719,8 +2726,8 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
 
        journal = SB_JOURNAL(p_s_sb) = vmalloc(sizeof(struct reiserfs_journal));
        if (!journal) {
-               reiserfs_warning(p_s_sb,
-                                "journal-1256: unable to get memory for journal structure");
+               reiserfs_warning(p_s_sb, "journal-1256",
+                                "unable to get memory for journal structure");
                return 1;
        }
        memset(journal, 0, sizeof(struct reiserfs_journal));
@@ -2749,9 +2756,9 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
        if (!SB_ONDISK_JOURNAL_DEVICE(p_s_sb) &&
            (SB_JOURNAL_1st_RESERVED_BLOCK(p_s_sb) +
             SB_ONDISK_JOURNAL_SIZE(p_s_sb) > p_s_sb->s_blocksize * 8)) {
-               reiserfs_warning(p_s_sb,
-                                "journal-1393: journal does not fit for area "
-                                "addressed by first of bitmap blocks. It starts at "
+               reiserfs_warning(p_s_sb, "journal-1393",
+                                "journal does not fit for area addressed "
+                                "by first of bitmap blocks. It starts at "
                                 "%u and its size is %u. Block size %ld",
                                 SB_JOURNAL_1st_RESERVED_BLOCK(p_s_sb),
                                 SB_ONDISK_JOURNAL_SIZE(p_s_sb),
@@ -2760,8 +2767,8 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
        }
 
        if (journal_init_dev(p_s_sb, journal, j_dev_name) != 0) {
-               reiserfs_warning(p_s_sb,
-                                "sh-462: unable to initialize jornal device");
+               reiserfs_warning(p_s_sb, "sh-462",
+                                "unable to initialize jornal device");
                goto free_and_return;
        }
 
@@ -2772,8 +2779,8 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
                             SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) +
                             SB_ONDISK_JOURNAL_SIZE(p_s_sb));
        if (!bhjh) {
-               reiserfs_warning(p_s_sb,
-                                "sh-459: unable to read journal header");
+               reiserfs_warning(p_s_sb, "sh-459",
+                                "unable to read journal header");
                goto free_and_return;
        }
        jh = (struct reiserfs_journal_header *)(bhjh->b_data);
@@ -2782,10 +2789,10 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
        if (is_reiserfs_jr(rs)
            && (le32_to_cpu(jh->jh_journal.jp_journal_magic) !=
                sb_jp_journal_magic(rs))) {
-               reiserfs_warning(p_s_sb,
-                                "sh-460: journal header magic %x "
-                                "(device %s) does not match to magic found in super "
-                                "block %x", jh->jh_journal.jp_journal_magic,
+               reiserfs_warning(p_s_sb, "sh-460",
+                                "journal header magic %x (device %s) does "
+                                "not match to magic found in super block %x",
+                                jh->jh_journal.jp_journal_magic,
                                 bdevname(journal->j_dev_bd, b),
                                 sb_jp_journal_magic(rs));
                brelse(bhjh);
@@ -2852,7 +2859,7 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
        journal->j_must_wait = 0;
 
        if (journal->j_cnode_free == 0) {
-               reiserfs_warning(p_s_sb, "journal-2004: Journal cnode memory "
+               reiserfs_warning(p_s_sb, "journal-2004", "Journal cnode memory "
                                 "allocation failed (%ld bytes). Journal is "
                                 "too large for available memory. Usually "
                                 "this is due to a journal that is too large.",
@@ -2864,12 +2871,13 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
        jl = journal->j_current_jl;
        jl->j_list_bitmap = get_list_bitmap(p_s_sb, jl);
        if (!jl->j_list_bitmap) {
-               reiserfs_warning(p_s_sb,
-                                "journal-2005, get_list_bitmap failed for journal list 0");
+               reiserfs_warning(p_s_sb, "journal-2005",
+                                "get_list_bitmap failed for journal list 0");
                goto free_and_return;
        }
        if (journal_read(p_s_sb) < 0) {
-               reiserfs_warning(p_s_sb, "Replay Failure, unable to mount");
+               reiserfs_warning(p_s_sb, "reiserfs-2006",
+                                "Replay Failure, unable to mount");
                goto free_and_return;
        }
 
@@ -3196,16 +3204,17 @@ int journal_begin(struct reiserfs_transaction_handle *th,
                        cur_th->t_refcount++;
                        memcpy(th, cur_th, sizeof(*th));
                        if (th->t_refcount <= 1)
-                               reiserfs_warning(p_s_sb,
-                                                "BAD: refcount <= 1, but journal_info != 0");
+                               reiserfs_warning(p_s_sb, "reiserfs-2005",
+                                                "BAD: refcount <= 1, but "
+                                                "journal_info != 0");
                        return 0;
                } else {
                        /* we've ended up with a handle from a different filesystem.
                         ** save it and restore on journal_end.  This should never
                         ** really happen...
                         */
-                       reiserfs_warning(p_s_sb,
-                                        "clm-2100: nesting info a different FS");
+                       reiserfs_warning(p_s_sb, "clm-2100",
+                                        "nesting info a different FS");
                        th->t_handle_save = current->journal_info;
                        current->journal_info = th;
                }
@@ -3266,7 +3275,8 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th,
         ** could get to disk too early.  NOT GOOD.
         */
        if (!prepared || buffer_dirty(bh)) {
-               reiserfs_warning(p_s_sb, "journal-1777: buffer %llu bad state "
+               reiserfs_warning(p_s_sb, "journal-1777",
+                                "buffer %llu bad state "
                                 "%cPREPARED %cLOCKED %cDIRTY %cJDIRTY_WAIT",
                                 (unsigned long long)bh->b_blocknr,
                                 prepared ? ' ' : '!',
@@ -3276,8 +3286,8 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th,
        }
 
        if (atomic_read(&(journal->j_wcount)) <= 0) {
-               reiserfs_warning(p_s_sb,
-                                "journal-1409: journal_mark_dirty returning because j_wcount was %d",
+               reiserfs_warning(p_s_sb, "journal-1409",
+                                "returning because j_wcount was %d",
                                 atomic_read(&(journal->j_wcount)));
                return 1;
        }
@@ -3342,8 +3352,8 @@ int journal_end(struct reiserfs_transaction_handle *th,
                struct super_block *p_s_sb, unsigned long nblocks)
 {
        if (!current->journal_info && th->t_refcount > 1)
-               reiserfs_warning(p_s_sb, "REISER-NESTING: th NULL, refcount %d",
-                                th->t_refcount);
+               reiserfs_warning(p_s_sb, "REISER-NESTING",
+                                "th NULL, refcount %d", th->t_refcount);
 
        if (!th->t_trans_id) {
                WARN_ON(1);
@@ -3413,8 +3423,8 @@ static int remove_from_transaction(struct super_block *p_s_sb,
                clear_buffer_journal_test(bh);
                put_bh(bh);
                if (atomic_read(&(bh->b_count)) < 0) {
-                       reiserfs_warning(p_s_sb,
-                                        "journal-1752: remove from trans, b_count < 0");
+                       reiserfs_warning(p_s_sb, "journal-1752",
+                                        "b_count < 0");
                }
                ret = 1;
        }
@@ -3734,7 +3744,8 @@ int journal_mark_freed(struct reiserfs_transaction_handle *th,
                                                if (atomic_read
                                                    (&(cn->bh->b_count)) < 0) {
                                                        reiserfs_warning(p_s_sb,
-                                                                        "journal-2138: cn->bh->b_count < 0");
+                                                                "journal-2138",
+                                                                "cn->bh->b_count < 0");
                                                }
                                        }
                                        if (cn->jlist) {        /* since we are clearing the bh, we MUST dec nonzerolen */
@@ -4137,8 +4148,9 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
                        clear_buffer_journaled(cn->bh);
                } else {
                        /* JDirty cleared sometime during transaction.  don't log this one */
-                       reiserfs_warning(p_s_sb,
-                                        "journal-2048: do_journal_end: BAD, buffer in journal hash, but not JDirty!");
+                       reiserfs_warning(p_s_sb, "journal-2048",
+                                        "BAD, buffer in journal hash, "
+                                        "but not JDirty!");
                        brelse(cn->bh);
                }
                next = cn->next;
index 41bdd8c..381339b 100644 (file)
@@ -1288,12 +1288,16 @@ void leaf_paste_entries(struct buffer_info *bi,
                        prev = (i != 0) ? deh_location(&(deh[i - 1])) : 0;
 
                        if (prev && prev <= deh_location(&(deh[i])))
-                               reiserfs_warning(NULL,
-                                                "vs-10240: leaf_paste_entries: directory item (%h) corrupted (prev %a, cur(%d) %a)",
+                               reiserfs_warning(NULL, "vs-10240",
+                                                "directory item (%h) "
+                                                "corrupted (prev %a, "
+                                                "cur(%d) %a)",
                                                 ih, deh + i - 1, i, deh + i);
                        if (next && next >= deh_location(&(deh[i])))
-                               reiserfs_warning(NULL,
-                                                "vs-10250: leaf_paste_entries: directory item (%h) corrupted (cur(%d) %a, next %a)",
+                               reiserfs_warning(NULL, "vs-10250",
+                                                "directory item (%h) "
+                                                "corrupted (cur(%d) %a, "
+                                                "next %a)",
                                                 ih, i, deh + i, deh + i + 1);
                }
        }
index 738967f..bb41c6e 100644 (file)
@@ -120,8 +120,8 @@ int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
        switch (retval) {
        case ITEM_NOT_FOUND:
                if (!PATH_LAST_POSITION(path)) {
-                       reiserfs_warning(sb,
-                                        "vs-7000: search_by_entry_key: search_by_key returned item position == 0");
+                       reiserfs_warning(sb, "vs-7000", "search_by_key "
+                                        "returned item position == 0");
                        pathrelse(path);
                        return IO_ERROR;
                }
@@ -135,8 +135,7 @@ int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
 
        default:
                pathrelse(path);
-               reiserfs_warning(sb,
-                                "vs-7002: search_by_entry_key: no path to here");
+               reiserfs_warning(sb, "vs-7002", "no path to here");
                return IO_ERROR;
        }
 
@@ -300,8 +299,7 @@ static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
                    search_by_entry_key(dir->i_sb, &key_to_search,
                                        path_to_entry, de);
                if (retval == IO_ERROR) {
-                       reiserfs_warning(dir->i_sb, "zam-7001: io error in %s",
-                                        __func__);
+                       reiserfs_warning(dir->i_sb, "zam-7001", "io error");
                        return IO_ERROR;
                }
 
@@ -484,10 +482,9 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
                }
 
                if (retval != NAME_FOUND) {
-                       reiserfs_warning(dir->i_sb,
-                                        "zam-7002:%s: \"reiserfs_find_entry\" "
-                                        "has returned unexpected value (%d)",
-                                        __func__, retval);
+                       reiserfs_warning(dir->i_sb, "zam-7002",
+                                        "reiserfs_find_entry() returned "
+                                        "unexpected value (%d)", retval);
                }
 
                return -EEXIST;
@@ -498,8 +495,9 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
                                MAX_GENERATION_NUMBER + 1);
        if (gen_number > MAX_GENERATION_NUMBER) {
                /* there is no free generation number */
-               reiserfs_warning(dir->i_sb,
-                                "reiserfs_add_entry: Congratulations! we have got hash function screwed up");
+               reiserfs_warning(dir->i_sb, "reiserfs-7010",
+                                "Congratulations! we have got hash function "
+                                "screwed up");
                if (buffer != small_buf)
                        kfree(buffer);
                pathrelse(&path);
@@ -515,10 +513,9 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
        if (gen_number != 0) {  /* we need to re-search for the insertion point */
                if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
                    NAME_NOT_FOUND) {
-                       reiserfs_warning(dir->i_sb,
-                                        "vs-7032: reiserfs_add_entry: "
-                                        "entry with this key (%K) already exists",
-                                        &entry_key);
+                       reiserfs_warning(dir->i_sb, "vs-7032",
+                                        "entry with this key (%K) already "
+                                        "exists", &entry_key);
 
                        if (buffer != small_buf)
                                kfree(buffer);
@@ -903,8 +900,9 @@ static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
                goto end_rmdir;
 
        if (inode->i_nlink != 2 && inode->i_nlink != 1)
-               reiserfs_warning(inode->i_sb, "%s: empty directory has nlink "
-                                "!= 2 (%d)", __func__, inode->i_nlink);
+               reiserfs_warning(inode->i_sb, "reiserfs-7040",
+                                "empty directory has nlink != 2 (%d)",
+                                inode->i_nlink);
 
        clear_nlink(inode);
        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
@@ -980,10 +978,9 @@ static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
        }
 
        if (!inode->i_nlink) {
-               reiserfs_warning(inode->i_sb, "%s: deleting nonexistent file "
-                                "(%s:%lu), %d", __func__,
-                                reiserfs_bdevname(inode->i_sb), inode->i_ino,
-                                inode->i_nlink);
+               reiserfs_warning(inode->i_sb, "reiserfs-7042",
+                                "deleting nonexistent file (%lu), %d",
+                                inode->i_ino, inode->i_nlink);
                inode->i_nlink = 1;
        }
 
@@ -1499,8 +1496,8 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        if (reiserfs_cut_from_item
            (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
             0) < 0)
-               reiserfs_warning(old_dir->i_sb,
-                                "vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?");
+               reiserfs_warning(old_dir->i_sb, "vs-7060",
+                                "couldn't not cut old name. Fsck later?");
 
        old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
 
index ea0cf8c..a3a5f43 100644 (file)
@@ -61,7 +61,7 @@ __u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th)
        /* comment needed -Hans */
        unused_objectid = le32_to_cpu(map[1]);
        if (unused_objectid == U32_MAX) {
-               reiserfs_warning(s, "%s: no more object ids", __func__);
+               reiserfs_warning(s, "reiserfs-15100", "no more object ids");
                reiserfs_restore_prepared_buffer(s, SB_BUFFER_WITH_SB(s));
                return 0;
        }
@@ -160,8 +160,7 @@ void reiserfs_release_objectid(struct reiserfs_transaction_handle *th,
                i += 2;
        }
 
-       reiserfs_warning(s,
-                        "vs-15011: reiserfs_release_objectid: tried to free free object id (%lu)",
+       reiserfs_warning(s, "vs-15011", "tried to free free object id (%lu)",
                         (long unsigned)objectid_to_release);
 }
 
index 535a3c7..50ed4bd 100644 (file)
@@ -264,14 +264,17 @@ static void prepare_error_buf(const char *fmt, va_list args)
     va_end( args );\
 }
 
-void reiserfs_warning(struct super_block *sb, const char *fmt, ...)
+void __reiserfs_warning(struct super_block *sb, const char *id,
+                        const char *function, const char *fmt, ...)
 {
        do_reiserfs_warning(fmt);
        if (sb)
-               printk(KERN_WARNING "REISERFS warning (device %s): %s\n",
-                      sb->s_id, error_buf);
+               printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
+                      "%s\n", sb->s_id, id ? id : "", id ? " " : "",
+                      function, error_buf);
        else
-               printk(KERN_WARNING "REISERFS warning: %s\n", error_buf);
+               printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
+                      id ? id : "", id ? " " : "", function, error_buf);
 }
 
 /* No newline.. reiserfs_info calls can be followed by printk's */
index 370988e..d4d7f14 100644 (file)
@@ -503,7 +503,7 @@ int reiserfs_proc_info_init(struct super_block *sb)
                add_file(sb, "journal", show_journal);
                return 0;
        }
-       reiserfs_warning(sb, "reiserfs: cannot create /proc/%s/%s",
+       reiserfs_warning(sb, "cannot create /proc/%s/%s",
                         proc_info_root_name, b);
        return 1;
 }
@@ -559,8 +559,7 @@ int reiserfs_proc_info_global_init(void)
                if (proc_info_root) {
                        proc_info_root->owner = THIS_MODULE;
                } else {
-                       reiserfs_warning(NULL,
-                                        "reiserfs: cannot create /proc/%s",
+                       reiserfs_warning(NULL, "cannot create /proc/%s",
                                         proc_info_root_name);
                        return 1;
                }
index abbc64d..f328d27 100644 (file)
@@ -444,23 +444,24 @@ static int is_leaf(char *buf, int blocksize, struct buffer_head *bh)
 
        blkh = (struct block_head *)buf;
        if (blkh_level(blkh) != DISK_LEAF_NODE_LEVEL) {
-               reiserfs_warning(NULL,
-                                "is_leaf: this should be caught earlier");
+               reiserfs_warning(NULL, "reiserfs-5080",
+                                "this should be caught earlier");
                return 0;
        }
 
        nr = blkh_nr_item(blkh);
        if (nr < 1 || nr > ((blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN))) {
                /* item number is too big or too small */
-               reiserfs_warning(NULL, "is_leaf: nr_item seems wrong: %z", bh);
+               reiserfs_warning(NULL, "reiserfs-5081",
+                                "nr_item seems wrong: %z", bh);
                return 0;
        }
        ih = (struct item_head *)(buf + BLKH_SIZE) + nr - 1;
        used_space = BLKH_SIZE + IH_SIZE * nr + (blocksize - ih_location(ih));
        if (used_space != blocksize - blkh_free_space(blkh)) {
                /* free space does not match to calculated amount of use space */
-               reiserfs_warning(NULL, "is_leaf: free space seems wrong: %z",
-                                bh);
+               reiserfs_warning(NULL, "reiserfs-5082",
+                                "free space seems wrong: %z", bh);
                return 0;
        }
        // FIXME: it is_leaf will hit performance too much - we may have
@@ -471,29 +472,29 @@ static int is_leaf(char *buf, int blocksize, struct buffer_head *bh)
        prev_location = blocksize;
        for (i = 0; i < nr; i++, ih++) {
                if (le_ih_k_type(ih) == TYPE_ANY) {
-                       reiserfs_warning(NULL,
-                                        "is_leaf: wrong item type for item %h",
+                       reiserfs_warning(NULL, "reiserfs-5083",
+                                        "wrong item type for item %h",
                                         ih);
                        return 0;
                }
                if (ih_location(ih) >= blocksize
                    || ih_location(ih) < IH_SIZE * nr) {
-                       reiserfs_warning(NULL,
-                                        "is_leaf: item location seems wrong: %h",
+                       reiserfs_warning(NULL, "reiserfs-5084",
+                                        "item location seems wrong: %h",
                                         ih);
                        return 0;
                }
                if (ih_item_len(ih) < 1
                    || ih_item_len(ih) > MAX_ITEM_LEN(blocksize)) {
-                       reiserfs_warning(NULL,
-                                        "is_leaf: item length seems wrong: %h",
+                       reiserfs_warning(NULL, "reiserfs-5085",
+                                        "item length seems wrong: %h",
                                         ih);
                        return 0;
                }
                if (prev_location - ih_location(ih) != ih_item_len(ih)) {
-                       reiserfs_warning(NULL,
-                                        "is_leaf: item location seems wrong (second one): %h",
-                                        ih);
+                       reiserfs_warning(NULL, "reiserfs-5086",
+                                        "item location seems wrong "
+                                        "(second one): %h", ih);
                        return 0;
                }
                prev_location = ih_location(ih);
@@ -514,24 +515,23 @@ static int is_internal(char *buf, int blocksize, struct buffer_head *bh)
        nr = blkh_level(blkh);
        if (nr <= DISK_LEAF_NODE_LEVEL || nr > MAX_HEIGHT) {
                /* this level is not possible for internal nodes */
-               reiserfs_warning(NULL,
-                                "is_internal: this should be caught earlier");
+               reiserfs_warning(NULL, "reiserfs-5087",
+                                "this should be caught earlier");
                return 0;
        }
 
        nr = blkh_nr_item(blkh);
        if (nr > (blocksize - BLKH_SIZE - DC_SIZE) / (KEY_SIZE + DC_SIZE)) {
                /* for internal which is not root we might check min number of keys */
-               reiserfs_warning(NULL,
-                                "is_internal: number of key seems wrong: %z",
-                                bh);
+               reiserfs_warning(NULL, "reiserfs-5088",
+                                "number of key seems wrong: %z", bh);
                return 0;
        }
 
        used_space = BLKH_SIZE + KEY_SIZE * nr + DC_SIZE * (nr + 1);
        if (used_space != blocksize - blkh_free_space(blkh)) {
-               reiserfs_warning(NULL,
-                                "is_internal: free space seems wrong: %z", bh);
+               reiserfs_warning(NULL, "reiserfs-5089",
+                                "free space seems wrong: %z", bh);
                return 0;
        }
        // one may imagine much more checks
@@ -543,8 +543,8 @@ static int is_internal(char *buf, int blocksize, struct buffer_head *bh)
 static int is_tree_node(struct buffer_head *bh, int level)
 {
        if (B_LEVEL(bh) != level) {
-               reiserfs_warning(NULL,
-                                "is_tree_node: node level %d does not match to the expected one %d",
+               reiserfs_warning(NULL, "reiserfs-5090", "node level %d does "
+                                "not match to the expected one %d",
                                 B_LEVEL(bh), level);
                return 0;
        }
@@ -645,9 +645,9 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key,        /*
 
 #ifdef CONFIG_REISERFS_CHECK
                if (!(++n_repeat_counter % 50000))
-                       reiserfs_warning(p_s_sb, "PAP-5100: search_by_key: %s:"
-                                        "there were %d iterations of while loop "
-                                        "looking for key %K",
+                       reiserfs_warning(p_s_sb, "PAP-5100",
+                                        "%s: there were %d iterations of "
+                                        "while loop looking for key %K",
                                         current->comm, n_repeat_counter,
                                         p_s_key);
 #endif
@@ -721,9 +721,9 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key,        /*
                // make sure, that the node contents look like a node of
                // certain level
                if (!is_tree_node(p_s_bh, expected_level)) {
-                       reiserfs_warning(p_s_sb, "vs-5150: search_by_key: "
-                                        "invalid format found in block %ld. Fsck?",
-                                        p_s_bh->b_blocknr);
+                       reiserfs_warning(p_s_sb, "vs-5150",
+                                        "invalid format found in block %ld. "
+                                        "Fsck?", p_s_bh->b_blocknr);
                        pathrelse(p_s_search_path);
                        return IO_ERROR;
                }
@@ -1227,8 +1227,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
                if (n_ret_value == IO_ERROR)
                        break;
                if (n_ret_value == FILE_NOT_FOUND) {
-                       reiserfs_warning(p_s_sb,
-                                        "vs-5340: reiserfs_delete_item: "
+                       reiserfs_warning(p_s_sb, "vs-5340",
                                         "no items of the file %K found",
                                         p_s_item_key);
                        break;
@@ -1338,10 +1337,9 @@ void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
        while (1) {
                retval = search_item(th->t_super, &cpu_key, &path);
                if (retval == IO_ERROR) {
-                       reiserfs_warning(th->t_super,
-                                        "vs-5350: reiserfs_delete_solid_item: "
-                                        "i/o failure occurred trying to delete %K",
-                                        &cpu_key);
+                       reiserfs_warning(th->t_super, "vs-5350",
+                                        "i/o failure occurred trying "
+                                        "to delete %K", &cpu_key);
                        break;
                }
                if (retval != ITEM_FOUND) {
@@ -1355,9 +1353,8 @@ void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
                             GET_GENERATION_NUMBER(le_key_k_offset
                                                   (le_key_version(key),
                                                    key)) == 1))
-                               reiserfs_warning(th->t_super,
-                                                "vs-5355: reiserfs_delete_solid_item: %k not found",
-                                                key);
+                               reiserfs_warning(th->t_super, "vs-5355",
+                                                "%k not found", key);
                        break;
                }
                if (!tb_init) {
@@ -1389,8 +1386,7 @@ void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
                        break;
                }
                // IO_ERROR, NO_DISK_SPACE, etc
-               reiserfs_warning(th->t_super,
-                                "vs-5360: reiserfs_delete_solid_item: "
+               reiserfs_warning(th->t_super, "vs-5360",
                                 "could not delete %K due to fix_nodes failure",
                                 &cpu_key);
                unfix_nodes(&tb);
@@ -1533,8 +1529,9 @@ static void indirect_to_direct_roll_back(struct reiserfs_transaction_handle *th,
                set_cpu_key_k_offset(&tail_key,
                                     cpu_key_k_offset(&tail_key) - removed);
        }
-       reiserfs_warning(inode->i_sb,
-                        "indirect_to_direct_roll_back: indirect_to_direct conversion has been rolled back due to lack of disk space");
+       reiserfs_warning(inode->i_sb, "reiserfs-5091", "indirect_to_direct "
+                        "conversion has been rolled back due to "
+                        "lack of disk space");
        //mark_file_without_tail (inode);
        mark_inode_dirty(inode);
 }
@@ -1639,8 +1636,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
                if (n_ret_value == POSITION_FOUND)
                        continue;
 
-               reiserfs_warning(p_s_sb,
-                                "PAP-5610: reiserfs_cut_from_item: item %K not found",
+               reiserfs_warning(p_s_sb, "PAP-5610", "item %K not found",
                                 p_s_item_key);
                unfix_nodes(&s_cut_balance);
                return (n_ret_value == IO_ERROR) ? -EIO : -ENOENT;
@@ -1654,7 +1650,8 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
                        indirect_to_direct_roll_back(th, p_s_inode, p_s_path);
                }
                if (n_ret_value == NO_DISK_SPACE)
-                       reiserfs_warning(p_s_sb, "NO_DISK_SPACE");
+                       reiserfs_warning(p_s_sb, "reiserfs-5092",
+                                        "NO_DISK_SPACE");
                unfix_nodes(&s_cut_balance);
                return -EIO;
        }
@@ -1743,8 +1740,7 @@ static void truncate_directory(struct reiserfs_transaction_handle *th,
 {
        BUG_ON(!th->t_trans_id);
        if (inode->i_nlink)
-               reiserfs_warning(inode->i_sb,
-                                "vs-5655: truncate_directory: link count != 0");
+               reiserfs_warning(inode->i_sb, "vs-5655", "link count != 0");
 
        set_le_key_k_offset(KEY_FORMAT_3_5, INODE_PKEY(inode), DOT_OFFSET);
        set_le_key_k_type(KEY_FORMAT_3_5, INODE_PKEY(inode), TYPE_DIRENTRY);
@@ -1797,16 +1793,14 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p
            search_for_position_by_key(p_s_inode->i_sb, &s_item_key,
                                       &s_search_path);
        if (retval == IO_ERROR) {
-               reiserfs_warning(p_s_inode->i_sb,
-                                "vs-5657: reiserfs_do_truncate: "
+               reiserfs_warning(p_s_inode->i_sb, "vs-5657",
                                 "i/o failure occurred trying to truncate %K",
                                 &s_item_key);
                err = -EIO;
                goto out;
        }
        if (retval == POSITION_FOUND || retval == FILE_NOT_FOUND) {
-               reiserfs_warning(p_s_inode->i_sb,
-                                "PAP-5660: reiserfs_do_truncate: "
+               reiserfs_warning(p_s_inode->i_sb, "PAP-5660",
                                 "wrong result %d of search for %K", retval,
                                 &s_item_key);
 
@@ -1850,8 +1844,8 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p
                    reiserfs_cut_from_item(th, &s_search_path, &s_item_key,
                                           p_s_inode, page, n_new_file_size);
                if (n_deleted < 0) {
-                       reiserfs_warning(p_s_inode->i_sb,
-                                        "vs-5665: reiserfs_do_truncate: reiserfs_cut_from_item failed");
+                       reiserfs_warning(p_s_inode->i_sb, "vs-5665",
+                                        "reiserfs_cut_from_item failed");
                        reiserfs_check_path(&s_search_path);
                        return 0;
                }
@@ -2000,8 +1994,8 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct tree
                        goto error_out;
                }
                if (retval == POSITION_FOUND) {
-                       reiserfs_warning(inode->i_sb,
-                                        "PAP-5710: reiserfs_paste_into_item: entry or pasted byte (%K) exists",
+                       reiserfs_warning(inode->i_sb, "PAP-5710",
+                                        "entry or pasted byte (%K) exists",
                                         p_s_key);
                        retval = -EEXIST;
                        goto error_out;
@@ -2087,8 +2081,7 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th, struct treepath
                        goto error_out;
                }
                if (retval == ITEM_FOUND) {
-                       reiserfs_warning(th->t_super,
-                                        "PAP-5760: reiserfs_insert_item: "
+                       reiserfs_warning(th->t_super, "PAP-5760",
                                         "key %K already exists in the tree",
                                         key);
                        retval = -EEXIST;
index 0428004..bfc276c 100644 (file)
@@ -183,9 +183,9 @@ static int finish_unfinished(struct super_block *s)
                if (REISERFS_SB(s)->s_qf_names[i]) {
                        int ret = reiserfs_quota_on_mount(s, i);
                        if (ret < 0)
-                               reiserfs_warning(s,
-                                                "reiserfs: cannot turn on journaled quota: error %d",
-                                                ret);
+                               reiserfs_warning(s, "reiserfs-2500",
+                                                "cannot turn on journaled "
+                                                "quota: error %d", ret);
                }
        }
 #endif
@@ -195,8 +195,8 @@ static int finish_unfinished(struct super_block *s)
        while (!retval) {
                retval = search_item(s, &max_cpu_key, &path);
                if (retval != ITEM_NOT_FOUND) {
-                       reiserfs_warning(s,
-                                        "vs-2140: finish_unfinished: search_by_key returned %d",
+                       reiserfs_warning(s, "vs-2140",
+                                        "search_by_key returned %d",
                                         retval);
                        break;
                }
@@ -204,8 +204,8 @@ static int finish_unfinished(struct super_block *s)
                bh = get_last_bh(&path);
                item_pos = get_item_pos(&path);
                if (item_pos != B_NR_ITEMS(bh)) {
-                       reiserfs_warning(s,
-                                        "vs-2060: finish_unfinished: wrong position found");
+                       reiserfs_warning(s, "vs-2060",
+                                        "wrong position found");
                        break;
                }
                item_pos--;
@@ -235,8 +235,7 @@ static int finish_unfinished(struct super_block *s)
                if (!inode) {
                        /* the unlink almost completed, it just did not manage to remove
                           "save" link and release objectid */
-                       reiserfs_warning(s,
-                                        "vs-2180: finish_unfinished: iget failed for %K",
+                       reiserfs_warning(s, "vs-2180", "iget failed for %K",
                                         &obj_key);
                        retval = remove_save_link_only(s, &save_link_key, 1);
                        continue;
@@ -244,8 +243,8 @@ static int finish_unfinished(struct super_block *s)
 
                if (!truncate && inode->i_nlink) {
                        /* file is not unlinked */
-                       reiserfs_warning(s,
-                                        "vs-2185: finish_unfinished: file %K is not unlinked",
+                       reiserfs_warning(s, "vs-2185",
+                                        "file %K is not unlinked",
                                         &obj_key);
                        retval = remove_save_link_only(s, &save_link_key, 0);
                        continue;
@@ -257,8 +256,9 @@ static int finish_unfinished(struct super_block *s)
                           The only imaginable way is to execute unfinished truncate request
                           then boot into old kernel, remove the file and create dir with
                           the same key. */
-                       reiserfs_warning(s,
-                                        "green-2101: impossible truncate on a directory %k. Please report",
+                       reiserfs_warning(s, "green-2101",
+                                        "impossible truncate on a "
+                                        "directory %k. Please report",
                                         INODE_PKEY(inode));
                        retval = remove_save_link_only(s, &save_link_key, 0);
                        truncate = 0;
@@ -288,9 +288,10 @@ static int finish_unfinished(struct super_block *s)
                                /* removal gets completed in iput */
                                retval = 0;
                        } else {
-                               reiserfs_warning(s, "Dead loop in "
-                                               "finish_unfinished detected, "
-                                               "just remove save link\n");
+                               reiserfs_warning(s, "super-2189", "Dead loop "
+                                                "in finish_unfinished "
+                                                "detected, just remove "
+                                                "save link\n");
                                retval = remove_save_link_only(s,
                                                        &save_link_key, 0);
                        }
@@ -360,8 +361,9 @@ void add_save_link(struct reiserfs_transaction_handle *th,
        } else {
                /* truncate */
                if (S_ISDIR(inode->i_mode))
-                       reiserfs_warning(inode->i_sb,
-                                        "green-2102: Adding a truncate savelink for a directory %k! Please report",
+                       reiserfs_warning(inode->i_sb, "green-2102",
+                                        "Adding a truncate savelink for "
+                                        "a directory %k! Please report",
                                         INODE_PKEY(inode));
                set_cpu_key_k_offset(&key, 1);
                set_cpu_key_k_type(&key, TYPE_INDIRECT);
@@ -376,7 +378,7 @@ void add_save_link(struct reiserfs_transaction_handle *th,
        retval = search_item(inode->i_sb, &key, &path);
        if (retval != ITEM_NOT_FOUND) {
                if (retval != -ENOSPC)
-                       reiserfs_warning(inode->i_sb, "vs-2100: add_save_link:"
+                       reiserfs_warning(inode->i_sb, "vs-2100",
                                         "search_by_key (%K) returned %d", &key,
                                         retval);
                pathrelse(&path);
@@ -391,9 +393,8 @@ void add_save_link(struct reiserfs_transaction_handle *th,
            reiserfs_insert_item(th, &path, &key, &ih, NULL, (char *)&link);
        if (retval) {
                if (retval != -ENOSPC)
-                       reiserfs_warning(inode->i_sb,
-                                        "vs-2120: add_save_link: insert_item returned %d",
-                                        retval);
+                       reiserfs_warning(inode->i_sb, "vs-2120",
+                                        "insert_item returned %d", retval);
        } else {
                if (truncate)
                        REISERFS_I(inode)->i_flags |=
@@ -492,8 +493,7 @@ static void reiserfs_put_super(struct super_block *s)
        print_statistics(s);
 
        if (REISERFS_SB(s)->reserved_blocks != 0) {
-               reiserfs_warning(s,
-                                "green-2005: reiserfs_put_super: reserved blocks left %d",
+               reiserfs_warning(s, "green-2005", "reserved blocks left %d",
                                 REISERFS_SB(s)->reserved_blocks);
        }
 
@@ -559,8 +559,8 @@ static void reiserfs_dirty_inode(struct inode *inode)
 
        int err = 0;
        if (inode->i_sb->s_flags & MS_RDONLY) {
-               reiserfs_warning(inode->i_sb,
-                                "clm-6006: writing inode %lu on readonly FS",
+               reiserfs_warning(inode->i_sb, "clm-6006",
+                                "writing inode %lu on readonly FS",
                                 inode->i_ino);
                return;
        }
@@ -794,13 +794,15 @@ static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
                        if (bit_flags) {
                                if (opt->clrmask ==
                                    (1 << REISERFS_UNSUPPORTED_OPT))
-                                       reiserfs_warning(s, "%s not supported.",
+                                       reiserfs_warning(s, "super-6500",
+                                                        "%s not supported.\n",
                                                         p);
                                else
                                        *bit_flags &= ~opt->clrmask;
                                if (opt->setmask ==
                                    (1 << REISERFS_UNSUPPORTED_OPT))
-                                       reiserfs_warning(s, "%s not supported.",
+                                       reiserfs_warning(s, "super-6501",
+                                                        "%s not supported.\n",
                                                         p);
                                else
                                        *bit_flags |= opt->setmask;
@@ -809,7 +811,8 @@ static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
                }
        }
        if (!opt->option_name) {
-               reiserfs_warning(s, "unknown mount option \"%s\"", p);
+               reiserfs_warning(s, "super-6502",
+                                "unknown mount option \"%s\"", p);
                return -1;
        }
 
@@ -817,8 +820,9 @@ static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
        switch (*p) {
        case '=':
                if (!opt->arg_required) {
-                       reiserfs_warning(s,
-                                        "the option \"%s\" does not require an argument",
+                       reiserfs_warning(s, "super-6503",
+                                        "the option \"%s\" does not "
+                                        "require an argument\n",
                                         opt->option_name);
                        return -1;
                }
@@ -826,14 +830,15 @@ static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
 
        case 0:
                if (opt->arg_required) {
-                       reiserfs_warning(s,
-                                        "the option \"%s\" requires an argument",
-                                        opt->option_name);
+                       reiserfs_warning(s, "super-6504",
+                                        "the option \"%s\" requires an "
+                                        "argument\n", opt->option_name);
                        return -1;
                }
                break;
        default:
-               reiserfs_warning(s, "head of option \"%s\" is only correct",
+               reiserfs_warning(s, "super-6505",
+                                "head of option \"%s\" is only correct\n",
                                 opt->option_name);
                return -1;
        }
@@ -845,7 +850,8 @@ static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
            && !(opt->arg_required & (1 << REISERFS_OPT_ALLOWEMPTY))
            && !strlen(p)) {
                /* this catches "option=," if not allowed */
-               reiserfs_warning(s, "empty argument for \"%s\"",
+               reiserfs_warning(s, "super-6506",
+                                "empty argument for \"%s\"\n",
                                 opt->option_name);
                return -1;
        }
@@ -867,7 +873,8 @@ static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
                }
        }
 
-       reiserfs_warning(s, "bad value \"%s\" for option \"%s\"", p,
+       reiserfs_warning(s, "super-6506",
+                        "bad value \"%s\" for option \"%s\"\n", p,
                         opt->option_name);
        return -1;
 }
@@ -957,9 +964,9 @@ static int reiserfs_parse_options(struct super_block *s, char *options,     /* strin
                                *blocks = simple_strtoul(arg, &p, 0);
                                if (*p != '\0') {
                                        /* NNN does not look like a number */
-                                       reiserfs_warning(s,
-                                                        "reiserfs_parse_options: bad value %s",
-                                                        arg);
+                                       reiserfs_warning(s, "super-6507",
+                                                        "bad value %s for "
+                                                        "-oresize\n", arg);
                                        return 0;
                                }
                        }
@@ -970,8 +977,8 @@ static int reiserfs_parse_options(struct super_block *s, char *options,     /* strin
                        unsigned long val = simple_strtoul(arg, &p, 0);
                        /* commit=NNN (time in seconds) */
                        if (*p != '\0' || val >= (unsigned int)-1) {
-                               reiserfs_warning(s,
-                                                "reiserfs_parse_options: bad value %s",
+                               reiserfs_warning(s, "super-6508",
+                                                "bad value %s for -ocommit\n",
                                                 arg);
                                return 0;
                        }
@@ -979,16 +986,18 @@ static int reiserfs_parse_options(struct super_block *s, char *options,   /* strin
                }
 
                if (c == 'w') {
-                       reiserfs_warning(s, "reiserfs: nolargeio option is no longer supported");
+                       reiserfs_warning(s, "super-6509", "nolargeio option "
+                                        "is no longer supported");
                        return 0;
                }
 
                if (c == 'j') {
                        if (arg && *arg && jdev_name) {
                                if (*jdev_name) {       //Hm, already assigned?
-                                       reiserfs_warning(s,
-                                                        "reiserfs_parse_options: journal device was already  specified to be %s",
-                                                        *jdev_name);
+                                       reiserfs_warning(s, "super-6510",
+                                                        "journal device was "
+                                                        "already specified to "
+                                                        "be %s", *jdev_name);
                                        return 0;
                                }
                                *jdev_name = arg;
@@ -1000,29 +1009,35 @@ static int reiserfs_parse_options(struct super_block *s, char *options, /* strin
 
                        if (sb_any_quota_loaded(s) &&
                            (!*arg != !REISERFS_SB(s)->s_qf_names[qtype])) {
-                               reiserfs_warning(s,
-                                                "reiserfs_parse_options: cannot change journaled quota options when quota turned on.");
+                               reiserfs_warning(s, "super-6511",
+                                                "cannot change journaled "
+                                                "quota options when quota "
+                                                "turned on.");
                                return 0;
                        }
                        if (*arg) {     /* Some filename specified? */
                                if (REISERFS_SB(s)->s_qf_names[qtype]
                                    && strcmp(REISERFS_SB(s)->s_qf_names[qtype],
                                              arg)) {
-                                       reiserfs_warning(s,
-                                                        "reiserfs_parse_options: %s quota file already specified.",
+                                       reiserfs_warning(s, "super-6512",
+                                                        "%s quota file "
+                                                        "already specified.",
                                                         QTYPE2NAME(qtype));
                                        return 0;
                                }
                                if (strchr(arg, '/')) {
-                                       reiserfs_warning(s,
-                                                        "reiserfs_parse_options: quotafile must be on filesystem root.");
+                                       reiserfs_warning(s, "super-6513",
+                                                        "quotafile must be "
+                                                        "on filesystem root.");
                                        return 0;
                                }
                                qf_names[qtype] =
                                    kmalloc(strlen(arg) + 1, GFP_KERNEL);
                                if (!qf_names[qtype]) {
-                                       reiserfs_warning(s,
-                                                        "reiserfs_parse_options: not enough memory for storing quotafile name.");
+                                       reiserfs_warning(s, "reiserfs-2502",
+                                                        "not enough memory "
+                                                        "for storing "
+                                                        "quotafile name.");
                                        return 0;
                                }
                                strcpy(qf_names[qtype], arg);
@@ -1040,21 +1055,24 @@ static int reiserfs_parse_options(struct super_block *s, char *options, /* strin
                        else if (!strcmp(arg, "vfsv0"))
                                *qfmt = QFMT_VFS_V0;
                        else {
-                               reiserfs_warning(s,
-                                                "reiserfs_parse_options: unknown quota format specified.");
+                               reiserfs_warning(s, "super-6514",
+                                                "unknown quota format "
+                                                "specified.");
                                return 0;
                        }
                        if (sb_any_quota_loaded(s) &&
                            *qfmt != REISERFS_SB(s)->s_jquota_fmt) {
-                               reiserfs_warning(s,
-                                                "reiserfs_parse_options: cannot change journaled quota options when quota turned on.");
+                               reiserfs_warning(s, "super-6515",
+                                                "cannot change journaled "
+                                                "quota options when quota "
+                                                "turned on.");
                                return 0;
                        }
                }
 #else
                if (c == 'u' || c == 'g' || c == 'f') {
-                       reiserfs_warning(s,
-                                        "reiserfs_parse_options: journaled quota options not supported.");
+                       reiserfs_warning(s, "reiserfs-2503", "journaled "
+                                        "quota options not supported.");
                        return 0;
                }
 #endif
@@ -1063,15 +1081,15 @@ static int reiserfs_parse_options(struct super_block *s, char *options, /* strin
 #ifdef CONFIG_QUOTA
        if (!REISERFS_SB(s)->s_jquota_fmt && !*qfmt
            && (qf_names[USRQUOTA] || qf_names[GRPQUOTA])) {
-               reiserfs_warning(s,
-                                "reiserfs_parse_options: journaled quota format not specified.");
+               reiserfs_warning(s, "super-6515",
+                                "journaled quota format not specified.");
                return 0;
        }
        /* This checking is not precise wrt the quota type but for our purposes it is sufficient */
        if (!(*mount_options & (1 << REISERFS_QUOTA))
            && sb_any_quota_loaded(s)) {
-               reiserfs_warning(s,
-                                "reiserfs_parse_options: quota options must be present when quota is turned on.");
+               reiserfs_warning(s, "super-6516", "quota options must "
+                                "be present when quota is turned on.");
                return 0;
        }
 #endif
@@ -1131,14 +1149,15 @@ static void handle_attrs(struct super_block *s)
 
        if (reiserfs_attrs(s)) {
                if (old_format_only(s)) {
-                       reiserfs_warning(s,
-                                        "reiserfs: cannot support attributes on 3.5.x disk format");
+                       reiserfs_warning(s, "super-6517", "cannot support "
+                                        "attributes on 3.5.x disk format");
                        REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
                        return;
                }
                if (!(le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared)) {
-                       reiserfs_warning(s,
-                                        "reiserfs: cannot support attributes until flag is set in super-block");
+                       reiserfs_warning(s, "super-6518", "cannot support "
+                                        "attributes until flag is set in "
+                                        "super-block");
                        REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
                }
        }
@@ -1316,7 +1335,7 @@ static int read_super_block(struct super_block *s, int offset)
 
        bh = sb_bread(s, offset / s->s_blocksize);
        if (!bh) {
-               reiserfs_warning(s, "sh-2006: read_super_block: "
+               reiserfs_warning(s, "sh-2006",
                                 "bread failed (dev %s, block %lu, size %lu)",
                                 reiserfs_bdevname(s), offset / s->s_blocksize,
                                 s->s_blocksize);
@@ -1337,8 +1356,8 @@ static int read_super_block(struct super_block *s, int offset)
 
        bh = sb_bread(s, offset / s->s_blocksize);
        if (!bh) {
-               reiserfs_warning(s, "sh-2007: read_super_block: "
-                                "bread failed (dev %s, block %lu, size %lu)\n",
+               reiserfs_warning(s, "sh-2007",
+                                "bread failed (dev %s, block %lu, size %lu)",
                                 reiserfs_bdevname(s), offset / s->s_blocksize,
                                 s->s_blocksize);
                return 1;
@@ -1346,8 +1365,8 @@ static int read_super_block(struct super_block *s, int offset)
 
        rs = (struct reiserfs_super_block *)bh->b_data;
        if (sb_blocksize(rs) != s->s_blocksize) {
-               reiserfs_warning(s, "sh-2011: read_super_block: "
-                                "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",
+               reiserfs_warning(s, "sh-2011", "can't find a reiserfs "
+                                "filesystem on (dev %s, block %Lu, size %lu)",
                                 reiserfs_bdevname(s),
                                 (unsigned long long)bh->b_blocknr,
                                 s->s_blocksize);
@@ -1357,9 +1376,10 @@ static int read_super_block(struct super_block *s, int offset)
 
        if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {
                brelse(bh);
-               reiserfs_warning(s,
-                                "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"
-                                "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"
+               reiserfs_warning(s, "super-6519", "Unfinished reiserfsck "
+                                "--rebuild-tree run detected. Please run\n"
+                                "reiserfsck --rebuild-tree and wait for a "
+                                "completion. If that fails\n"
                                 "get newer reiserfsprogs package");
                return 1;
        }
@@ -1377,10 +1397,9 @@ static int read_super_block(struct super_block *s, int offset)
                        reiserfs_info(s, "found reiserfs format \"3.5\""
                                      " with non-standard journal\n");
                else {
-                       reiserfs_warning(s,
-                                        "sh-2012: read_super_block: found unknown "
-                                        "format \"%u\" of reiserfs with non-standard magic",
-                                        sb_version(rs));
+                       reiserfs_warning(s, "sh-2012", "found unknown "
+                                        "format \"%u\" of reiserfs with "
+                                        "non-standard magic", sb_version(rs));
                        return 1;
                }
        } else
@@ -1410,8 +1429,7 @@ static int reread_meta_blocks(struct super_block *s)
        ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s)));
        wait_on_buffer(SB_BUFFER_WITH_SB(s));
        if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
-               reiserfs_warning(s,
-                                "reread_meta_blocks, error reading the super");
+               reiserfs_warning(s, "reiserfs-2504", "error reading the super");
                return 1;
        }
 
@@ -1475,10 +1493,10 @@ static __u32 find_hash_out(struct super_block *s)
                        && (yurahash ==
                            GET_HASH_VALUE(deh_offset
                                           (&(de.de_deh[de.de_entry_num])))))) {
-                       reiserfs_warning(s,
-                                        "Unable to automatically detect hash function. "
-                                        "Please mount with -o hash={tea,rupasov,r5}",
-                                        reiserfs_bdevname(s));
+                       reiserfs_warning(s, "reiserfs-2506", "Unable to "
+                                        "automatically detect hash function. "
+                                        "Please mount with -o "
+                                        "hash={tea,rupasov,r5}");
                        hash = UNSET_HASH;
                        break;
                }
@@ -1492,7 +1510,8 @@ static __u32 find_hash_out(struct super_block *s)
                         (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)
                        hash = R5_HASH;
                else {
-                       reiserfs_warning(s, "Unrecognised hash function");
+                       reiserfs_warning(s, "reiserfs-2506",
+                                        "Unrecognised hash function");
                        hash = UNSET_HASH;
                }
        } while (0);
@@ -1520,17 +1539,20 @@ static int what_hash(struct super_block *s)
                 ** mount options 
                 */
                if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
-                       reiserfs_warning(s, "Error, %s hash detected, "
+                       reiserfs_warning(s, "reiserfs-2507",
+                                        "Error, %s hash detected, "
                                         "unable to force rupasov hash",
                                         reiserfs_hashname(code));
                        code = UNSET_HASH;
                } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
-                       reiserfs_warning(s, "Error, %s hash detected, "
+                       reiserfs_warning(s, "reiserfs-2508",
+                                        "Error, %s hash detected, "
                                         "unable to force tea hash",
                                         reiserfs_hashname(code));
                        code = UNSET_HASH;
                } else if (reiserfs_r5_hash(s) && code != R5_HASH) {
-                       reiserfs_warning(s, "Error, %s hash detected, "
+                       reiserfs_warning(s, "reiserfs-2509",
+                                        "Error, %s hash detected, "
                                         "unable to force r5 hash",
                                         reiserfs_hashname(code));
                        code = UNSET_HASH;
@@ -1589,9 +1611,9 @@ static int function2code(hashf_t func)
        return 0;
 }
 
-#define SWARN(silent, s, ...)                  \
+#define SWARN(silent, s, id, ...)                      \
        if (!(silent))                          \
-               reiserfs_warning (s, __VA_ARGS__)
+               reiserfs_warning(s, id, __VA_ARGS__)
 
 static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
 {
@@ -1643,8 +1665,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
 #endif
 
        if (blocks) {
-               SWARN(silent, s, "jmacd-7: reiserfs_fill_super: resize option "
-                     "for remount only");
+               SWARN(silent, s, "jmacd-7", "resize option for remount only");
                goto error;
        }
 
@@ -1653,8 +1674,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
                old_format = 1;
        /* try new format (64-th 1k block), which can contain reiserfs super block */
        else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) {
-               SWARN(silent, s,
-                     "sh-2021: reiserfs_fill_super: can not find reiserfs on %s",
+               SWARN(silent, s, "sh-2021", "can not find reiserfs on %s",
                      reiserfs_bdevname(s));
                goto error;
        }
@@ -1666,13 +1686,12 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
        if (s->s_bdev && s->s_bdev->bd_inode
            && i_size_read(s->s_bdev->bd_inode) <
            sb_block_count(rs) * sb_blocksize(rs)) {
-               SWARN(silent, s,
-                     "Filesystem on %s cannot be mounted because it is bigger than the device",
-                     reiserfs_bdevname(s));
-               SWARN(silent, s,
-                     "You may need to run fsck or increase size of your LVM partition");
-               SWARN(silent, s,
-                     "Or may be you forgot to reboot after fdisk when it told you to");
+               SWARN(silent, s, "", "Filesystem cannot be "
+                     "mounted because it is bigger than the device");
+               SWARN(silent, s, "", "You may need to run fsck "
+                     "or increase size of your LVM partition");
+               SWARN(silent, s, "", "Or may be you forgot to "
+                     "reboot after fdisk when it told you to");
                goto error;
        }
 
@@ -1680,14 +1699,13 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
        sbi->s_mount_state = REISERFS_VALID_FS;
 
        if ((errval = reiserfs_init_bitmap_cache(s))) {
-               SWARN(silent, s,
-                     "jmacd-8: reiserfs_fill_super: unable to read bitmap");
+               SWARN(silent, s, "jmacd-8", "unable to read bitmap");
                goto error;
        }
        errval = -EINVAL;
 #ifdef CONFIG_REISERFS_CHECK
-       SWARN(silent, s, "CONFIG_REISERFS_CHECK is set ON");
-       SWARN(silent, s, "- it is slow mode for debugging.");
+       SWARN(silent, s, "", "CONFIG_REISERFS_CHECK is set ON");
+       SWARN(silent, s, "", "- it is slow mode for debugging.");
 #endif
 
        /* make data=ordered the default */
@@ -1708,8 +1726,8 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
        }
        // set_device_ro(s->s_dev, 1) ;
        if (journal_init(s, jdev_name, old_format, commit_max_age)) {
-               SWARN(silent, s,
-                     "sh-2022: reiserfs_fill_super: unable to initialize journal space");
+               SWARN(silent, s, "sh-2022",
+                     "unable to initialize journal space");
                goto error;
        } else {
                jinit_done = 1; /* once this is set, journal_release must be called
@@ -1717,8 +1735,8 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
                                 */
        }
        if (reread_meta_blocks(s)) {
-               SWARN(silent, s,
-                     "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init");
+               SWARN(silent, s, "jmacd-9",
+                     "unable to reread meta blocks after journal init");
                goto error;
        }
 
@@ -1726,8 +1744,8 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
                goto error;
 
        if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
-               SWARN(silent, s,
-                     "clm-7000: Detected readonly device, marking FS readonly");
+               SWARN(silent, s, "clm-7000",
+                     "Detected readonly device, marking FS readonly");
                s->s_flags |= MS_RDONLY;
        }
        args.objectid = REISERFS_ROOT_OBJECTID;
@@ -1736,8 +1754,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
            iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor,
                         reiserfs_init_locked_inode, (void *)(&args));
        if (!root_inode) {
-               SWARN(silent, s,
-                     "jmacd-10: reiserfs_fill_super: get root inode failed");
+               SWARN(silent, s, "jmacd-10", "get root inode failed");
                goto error;
        }
 
@@ -1786,7 +1803,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
                 * avoiding corruption. -jeffm */
                if (bmap_would_wrap(reiserfs_bmap_count(s)) &&
                    sb_bmap_nr(rs) != 0) {
-                       reiserfs_warning(s, "super-2030: This file system "
+                       reiserfs_warning(s, "super-2030", "This file system "
                                        "claims to use %u bitmap blocks in "
                                        "its super block, but requires %u. "
                                        "Clearing to zero.", sb_bmap_nr(rs),
@@ -2087,8 +2104,8 @@ static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
        if (!(REISERFS_I(inode)->i_flags & i_nopack_mask)) {
                err = reiserfs_unpack(inode, NULL);
                if (err) {
-                       reiserfs_warning(sb,
-                               "reiserfs: Unpacking tail of quota file failed"
+                       reiserfs_warning(sb, "super-6520",
+                               "Unpacking tail of quota file failed"
                                " (%d). Cannot turn on quotas.", err);
                        err = -EINVAL;
                        goto out;
@@ -2099,8 +2116,8 @@ static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
        if (REISERFS_SB(sb)->s_qf_names[type]) {
                /* Quotafile not of fs root? */
                if (path.dentry->d_parent != sb->s_root)
-                       reiserfs_warning(sb,
-                                "reiserfs: Quota file not on filesystem root. "
+                       reiserfs_warning(sb, "super-6521",
+                                "Quota file not on filesystem root. "
                                 "Journalled quota will not work.");
        }
 
index f8121a1..256285d 100644 (file)
@@ -48,9 +48,9 @@ int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
 
        // FIXME: we could avoid this 
        if (search_for_position_by_key(sb, &end_key, path) == POSITION_FOUND) {
-               reiserfs_warning(sb, "PAP-14030: direct2indirect: "
-                                "pasted or inserted byte exists in the tree %K. "
-                                "Use fsck to repair.", &end_key);
+               reiserfs_warning(sb, "PAP-14030",
+                                "pasted or inserted byte exists in "
+                                "the tree %K. Use fsck to repair.", &end_key);
                pathrelse(path);
                return -EIO;
        }
index e11b004..d14f5c2 100644 (file)
@@ -259,7 +259,8 @@ static int __xattr_readdir(struct inode *inode, void *dirent, filldir_t filldir)
                ih = de.de_ih;
 
                if (!is_direntry_le_ih(ih)) {
-                       reiserfs_warning(inode->i_sb, "not direntry %h", ih);
+                       reiserfs_warning(inode->i_sb, "jdm-20000",
+                                        "not direntry %h", ih);
                        break;
                }
                copy_item_head(&tmp_ih, ih);
@@ -598,7 +599,7 @@ reiserfs_xattr_get(const struct inode *inode, const char *name, void *buffer,
                        if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) {
                                unlock_page(page);
                                reiserfs_put_page(page);
-                               reiserfs_warning(inode->i_sb,
+                               reiserfs_warning(inode->i_sb, "jdm-20001",
                                                 "Invalid magic for xattr (%s) "
                                                 "associated with %k", name,
                                                 INODE_PKEY(inode));
@@ -618,7 +619,7 @@ reiserfs_xattr_get(const struct inode *inode, const char *name, void *buffer,
 
        if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) !=
            hash) {
-               reiserfs_warning(inode->i_sb,
+               reiserfs_warning(inode->i_sb, "jdm-20002",
                                 "Invalid hash for xattr (%s) associated "
                                 "with %k", name, INODE_PKEY(inode));
                err = -EIO;
@@ -652,7 +653,8 @@ __reiserfs_xattr_del(struct dentry *xadir, const char *name, int namelen)
                goto out_file;
 
        if (!is_reiserfs_priv_object(dentry->d_inode)) {
-               reiserfs_warning(dir->i_sb, "OID %08x [%.*s/%.*s] doesn't have "
+               reiserfs_warning(dir->i_sb, "jdm-20003",
+                                "OID %08x [%.*s/%.*s] doesn't have "
                                 "priv flag set [parent is %sset].",
                                 le32_to_cpu(INODE_PKEY(dentry->d_inode)->
                                             k_objectid), xadir->d_name.len,
@@ -750,7 +752,7 @@ int reiserfs_delete_xattrs(struct inode *inode)
                reiserfs_write_unlock_xattrs(inode->i_sb);
                dput(root);
        } else {
-               reiserfs_warning(inode->i_sb,
+               reiserfs_warning(inode->i_sb, "jdm-20006",
                                 "Couldn't remove all entries in directory");
        }
        unlock_kernel();
@@ -1154,7 +1156,8 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
        } else if (reiserfs_xattrs_optional(s)) {
                /* Old format filesystem, but optional xattrs have been enabled
                 * at mount time. Error out. */
-               reiserfs_warning(s, "xattrs/ACLs not supported on pre v3.6 "
+               reiserfs_warning(s, "jdm-20005",
+                                "xattrs/ACLs not supported on pre v3.6 "
                                 "format filesystem. Failing mount.");
                err = -EOPNOTSUPP;
                goto error;
@@ -1201,8 +1204,10 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
                        /* If we're read-only it just means that the dir hasn't been
                         * created. Not an error -- just no xattrs on the fs. We'll
                         * check again if we go read-write */
-                       reiserfs_warning(s, "xattrs/ACLs enabled and couldn't "
-                                        "find/create .reiserfs_priv. Failing mount.");
+                       reiserfs_warning(s, "jdm-20006",
+                                        "xattrs/ACLs enabled and couldn't "
+                                        "find/create .reiserfs_priv. "
+                                        "Failing mount.");
                        err = -EOPNOTSUPP;
                }
        }
index 65bb5e3..056e2a3 100644 (file)
@@ -79,7 +79,10 @@ struct fid;
 */
 #define REISERFS_DEBUG_CODE 5  /* extra messages to help find/debug errors */
 
-void reiserfs_warning(struct super_block *s, const char *fmt, ...);
+void __reiserfs_warning(struct super_block *s, const char *id,
+                        const char *func, const char *fmt, ...);
+#define reiserfs_warning(s, id, fmt, args...) \
+        __reiserfs_warning(s, id, __func__, fmt, ##args)
 /* assertions handling */
 
 /** always check a condition and panic if it's false. */
@@ -558,7 +561,7 @@ static inline int uniqueness2type(__u32 uniqueness)
        case V1_DIRENTRY_UNIQUENESS:
                return TYPE_DIRENTRY;
        default:
-               reiserfs_warning(NULL, "vs-500: unknown uniqueness %d",
+               reiserfs_warning(NULL, "vs-500", "unknown uniqueness %d",
                                 uniqueness);
        case V1_ANY_UNIQUENESS:
                return TYPE_ANY;
@@ -578,7 +581,7 @@ static inline __u32 type2uniqueness(int type)
        case TYPE_DIRENTRY:
                return V1_DIRENTRY_UNIQUENESS;
        default:
-               reiserfs_warning(NULL, "vs-501: unknown type %d", type);
+               reiserfs_warning(NULL, "vs-501", "unknown type %d", type);
        case TYPE_ANY:
                return V1_ANY_UNIQUENESS;
        }