nilfs2: replace nilfs_warning() with nilfs_msg()

Use nilfs_msg() to output warning messages and get rid of
nilfs_warning() function.  This also removes function names from the
messages unless we embed them explicitly in format strings.  Instead,
some messages are revised to clarify the context.

[arnd@arndb.de: avoid warning about unused variables]
Link: http://lkml.kernel.org/r/20160615201945.3348205-1-arnd@arndb.de
Link: http://lkml.kernel.org/r/1464875891-5443-6-git-send-email-konishi.ryusuke@lab.ntt.co.jp
Signed-off-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/fs/nilfs2/alloc.c b/fs/nilfs2/alloc.c
index 1a85d94f5b25f161fdcdef907d506d1c157a78bd..2c90e285d7c6725089641bc2a3fcb336b35d054b 100644 (file)
--- a/fs/nilfs2/alloc.c
+++ b/fs/nilfs2/alloc.c
@@ -622,10 +622,10 @@ void nilfs_palloc_commit_free_entry(struct inode *inode,
        lock = nilfs_mdt_bgl_lock(inode, group);
 
        if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
-               nilfs_warning(inode->i_sb, __func__,
-                             "entry number %llu already freed: ino=%lu",
-                             (unsigned long long)req->pr_entry_nr,
-                             (unsigned long)inode->i_ino);
+               nilfs_msg(inode->i_sb, KERN_WARNING,
+                         "%s (ino=%lu): entry number %llu already freed",
+                         __func__, inode->i_ino,
+                         (unsigned long long)req->pr_entry_nr);
        else
                nilfs_palloc_group_desc_add_entries(desc, lock, 1);
 
@@ -663,10 +663,10 @@ void nilfs_palloc_abort_alloc_entry(struct inode *inode,
        lock = nilfs_mdt_bgl_lock(inode, group);
 
        if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
-               nilfs_warning(inode->i_sb, __func__,
-                             "entry number %llu already freed: ino=%lu",
-                             (unsigned long long)req->pr_entry_nr,
-                             (unsigned long)inode->i_ino);
+               nilfs_msg(inode->i_sb, KERN_WARNING,
+                         "%s (ino=%lu): entry number %llu already freed",
+                         __func__, inode->i_ino,
+                         (unsigned long long)req->pr_entry_nr);
        else
                nilfs_palloc_group_desc_add_entries(desc, lock, 1);
 
@@ -772,10 +772,10 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
                do {
                        if (!nilfs_clear_bit_atomic(lock, group_offset,
                                                    bitmap)) {
-                               nilfs_warning(inode->i_sb, __func__,
-                                             "entry number %llu already freed: ino=%lu",
-                                             (unsigned long long)entry_nrs[j],
-                                             (unsigned long)inode->i_ino);
+                               nilfs_msg(inode->i_sb, KERN_WARNING,
+                                         "%s (ino=%lu): entry number %llu already freed",
+                                         __func__, inode->i_ino,
+                                         (unsigned long long)entry_nrs[j]);
                        } else {
                                n++;
                        }
@@ -816,12 +816,11 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
                for (k = 0; k < nempties; k++) {
                        ret = nilfs_palloc_delete_entry_block(inode,
                                                              last_nrs[k]);
-                       if (ret && ret != -ENOENT) {
-                               nilfs_warning(inode->i_sb, __func__,
-                                             "failed to delete block of entry %llu: ino=%lu, err=%d",
-                                             (unsigned long long)last_nrs[k],
-                                             (unsigned long)inode->i_ino, ret);
-                       }
+                       if (ret && ret != -ENOENT)
+                               nilfs_msg(inode->i_sb, KERN_WARNING,
+                                         "error %d deleting block that object (entry=%llu, ino=%lu) belongs to",
+                                         ret, (unsigned long long)last_nrs[k],
+                                         inode->i_ino);
                }
 
                desc_kaddr = kmap_atomic(desc_bh->b_page);
@@ -835,12 +834,10 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
 
                if (nfree == nilfs_palloc_entries_per_group(inode)) {
                        ret = nilfs_palloc_delete_bitmap_block(inode, group);
-                       if (ret && ret != -ENOENT) {
-                               nilfs_warning(inode->i_sb, __func__,
-                                             "failed to delete bitmap block of group %lu: ino=%lu, err=%d",
-                                             group,
-                                             (unsigned long)inode->i_ino, ret);
-                       }
+                       if (ret && ret != -ENOENT)
+                               nilfs_msg(inode->i_sb, KERN_WARNING,
+                                         "error %d deleting bitmap block of group=%lu, ino=%lu",
+                                         ret, group, inode->i_ino);
                }
        }
        return 0;

diff --git a/fs/nilfs2/ifile.c b/fs/nilfs2/ifile.c
index b1c96285aa4ac7d06bac711028c307779036bb59..b8fa45c20c63fdbded97c3474ac68438529cfca6 100644 (file)
--- a/fs/nilfs2/ifile.c
+++ b/fs/nilfs2/ifile.c
@@ -151,8 +151,8 @@ int nilfs_ifile_get_inode_block(struct inode *ifile, ino_t ino,
 
        err = nilfs_palloc_get_entry_block(ifile, ino, 0, out_bh);
        if (unlikely(err))
-               nilfs_warning(sb, __func__, "unable to read inode: %lu",
-                             (unsigned long) ino);
+               nilfs_msg(sb, KERN_WARNING, "error %d reading inode: ino=%lu",
+                         err, (unsigned long)ino);
        return err;
 }
 

diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index a965fcf7795529080f812071607f0ff51d025ad7..b286b35174a5e5505b1244b8e3b182a2750d0c77 100644 (file)
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -723,9 +723,9 @@ repeat:
                goto repeat;
 
 failed:
-       nilfs_warning(ii->vfs_inode.i_sb, __func__,
-                     "failed to truncate bmap (ino=%lu, err=%d)",
-                     ii->vfs_inode.i_ino, ret);
+       nilfs_msg(ii->vfs_inode.i_sb, KERN_WARNING,
+                 "error %d truncating bmap (ino=%lu)", ret,
+                 ii->vfs_inode.i_ino);
 }
 
 void nilfs_truncate(struct inode *inode)
@@ -936,9 +936,9 @@ int nilfs_set_file_dirty(struct inode *inode, unsigned int nr_dirty)
                         * This will happen when somebody is freeing
                         * this inode.
                         */
-                       nilfs_warning(inode->i_sb, __func__,
-                                     "cannot get inode (ino=%lu)",
-                                     inode->i_ino);
+                       nilfs_msg(inode->i_sb, KERN_WARNING,
+                                 "cannot set file dirty (ino=%lu): the file is being freed",
+                                 inode->i_ino);
                        spin_unlock(&nilfs->ns_inode_lock);
                        return -EINVAL; /*
                                         * NILFS_I_DIRTY may remain for
@@ -959,8 +959,9 @@ int __nilfs_mark_inode_dirty(struct inode *inode, int flags)
 
        err = nilfs_load_inode_block(inode, &ibh);
        if (unlikely(err)) {
-               nilfs_warning(inode->i_sb, __func__,
-                             "failed to reget inode block.");
+               nilfs_msg(inode->i_sb, KERN_WARNING,
+                         "cannot mark inode dirty (ino=%lu): error %d loading inode block",
+                         inode->i_ino, err);
                return err;
        }
        nilfs_update_inode(inode, ibh, flags);
@@ -986,8 +987,8 @@ void nilfs_dirty_inode(struct inode *inode, int flags)
        struct nilfs_mdt_info *mdi = NILFS_MDT(inode);
 
        if (is_bad_inode(inode)) {
-               nilfs_warning(inode->i_sb, __func__,
-                             "tried to mark bad_inode dirty. ignored.");
+               nilfs_msg(inode->i_sb, KERN_WARNING,
+                         "tried to mark bad_inode dirty. ignored.");
                dump_stack();
                return;
        }

diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index 1ec8ae5995a59c94d4dd5b6f1f41054b461b7c59..dbcf1dc93a511de88502b342d2b3e7beaa675791 100644 (file)
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -283,9 +283,9 @@ static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
                goto out;
 
        if (!inode->i_nlink) {
-               nilfs_warning(inode->i_sb, __func__,
-                             "deleting nonexistent file (%lu), %d",
-                             inode->i_ino, inode->i_nlink);
+               nilfs_msg(inode->i_sb, KERN_WARNING,
+                         "deleting nonexistent file (ino=%lu), %d",
+                         inode->i_ino, inode->i_nlink);
                set_nlink(inode, 1);
        }
        err = nilfs_delete_entry(de, page);

diff --git a/fs/nilfs2/nilfs.h b/fs/nilfs2/nilfs.h
index b57ce41e8a1a0fae262732b3c678d783b3ed9533..46fbd4e00315d4712ea07dcbc4ceeef98478e195 100644 (file)
--- a/fs/nilfs2/nilfs.h
+++ b/fs/nilfs2/nilfs.h
@@ -306,8 +306,6 @@ void __nilfs_msg(struct super_block *sb, const char *level,
 extern __printf(3, 4)
 void __nilfs_error(struct super_block *sb, const char *function,
                   const char *fmt, ...);
-extern __printf(3, 4)
-void nilfs_warning(struct super_block *, const char *, const char *, ...);
 
 #ifdef CONFIG_PRINTK
 
@@ -319,7 +317,10 @@ void nilfs_warning(struct super_block *, const char *, const char *, ...);
 #else
 
 #define nilfs_msg(sb, level, fmt, ...)                                 \
-       no_printk(fmt, ##__VA_ARGS__)
+       do {                                                            \
+               no_printk(fmt, ##__VA_ARGS__);                          \
+               (void)(sb);                                             \
+       } while (0)
 #define nilfs_error(sb, fmt, ...)                                      \
        do {                                                            \
                no_printk(fmt, ##__VA_ARGS__);                          \

diff --git a/fs/nilfs2/page.c b/fs/nilfs2/page.c
index d97ba5f11b77260d7e11390c849227fd6ea184e7..eaccf12c296eac382163f9ca73b586cbdbb14284 100644 (file)
--- a/fs/nilfs2/page.c
+++ b/fs/nilfs2/page.c
@@ -403,11 +403,10 @@ void nilfs_clear_dirty_page(struct page *page, bool silent)
 
        BUG_ON(!PageLocked(page));
 
-       if (!silent) {
-               nilfs_warning(sb, __func__,
-                               "discard page: offset %lld, ino %lu",
-                               page_offset(page), inode->i_ino);
-       }
+       if (!silent)
+               nilfs_msg(sb, KERN_WARNING,
+                         "discard dirty page: offset=%lld, ino=%lu",
+                         page_offset(page), inode->i_ino);
 
        ClearPageUptodate(page);
        ClearPageMappedToDisk(page);
@@ -422,11 +421,11 @@ void nilfs_clear_dirty_page(struct page *page, bool silent)
                bh = head = page_buffers(page);
                do {
                        lock_buffer(bh);
-                       if (!silent) {
-                               nilfs_warning(sb, __func__,
-                                       "discard block %llu, size %zu",
-                                       (u64)bh->b_blocknr, bh->b_size);
-                       }
+                       if (!silent)
+                               nilfs_msg(sb, KERN_WARNING,
+                                         "discard dirty block: blocknr=%llu, size=%zu",
+                                         (u64)bh->b_blocknr, bh->b_size);
+
                        set_mask_bits(&bh->b_state, clear_bits, 0);
                        unlock_buffer(bh);
                } while (bh = bh->b_this_page, bh != head);

diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index 1cc968502e53ac7e4b8c2ca90dc7d8ec5beb5a61..7e1864c6035bb4b55f3248bab76f132a050325db 100644 (file)
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -1951,8 +1951,9 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci,
                        err = nilfs_ifile_get_inode_block(
                                ifile, ii->vfs_inode.i_ino, &ibh);
                        if (unlikely(err)) {
-                               nilfs_warning(sci->sc_super, __func__,
-                                             "failed to get inode block.");
+                               nilfs_msg(sci->sc_super, KERN_WARNING,
+                                         "log writer: error %d getting inode block (ino=%lu)",
+                                         err, ii->vfs_inode.i_ino);
                                return err;
                        }
                        mark_buffer_dirty(ibh);
@@ -2458,8 +2459,7 @@ int nilfs_clean_segments(struct super_block *sb, struct nilfs_argv *argv,
                if (likely(!err))
                        break;
 
-               nilfs_warning(sb, __func__,
-                             "segment construction failed. (err=%d)", err);
+               nilfs_msg(sb, KERN_WARNING, "error %d cleaning segments", err);
                set_current_state(TASK_INTERRUPTIBLE);
                schedule_timeout(sci->sc_interval);
        }
@@ -2738,14 +2738,14 @@ static void nilfs_segctor_destroy(struct nilfs_sc_info *sci)
                nilfs_segctor_write_out(sci);
 
        if (!list_empty(&sci->sc_dirty_files)) {
-               nilfs_warning(sci->sc_super, __func__,
-                             "dirty file(s) after the final construction");
+               nilfs_msg(sci->sc_super, KERN_WARNING,
+                         "disposed unprocessed dirty file(s) when stopping log writer");
                nilfs_dispose_list(nilfs, &sci->sc_dirty_files, 1);
        }
 
        if (!list_empty(&sci->sc_iput_queue)) {
-               nilfs_warning(sci->sc_super, __func__,
-                             "iput queue is not empty");
+               nilfs_msg(sci->sc_super, KERN_WARNING,
+                         "disposed unprocessed inode(s) in iput queue when stopping log writer");
                nilfs_dispose_list(nilfs, &sci->sc_iput_queue, 1);
        }
 
@@ -2821,8 +2821,8 @@ void nilfs_detach_log_writer(struct super_block *sb)
        spin_lock(&nilfs->ns_inode_lock);
        if (!list_empty(&nilfs->ns_dirty_files)) {
                list_splice_init(&nilfs->ns_dirty_files, &garbage_list);
-               nilfs_warning(sb, __func__,
-                             "Hit dirty file after stopped log writer");
+               nilfs_msg(sb, KERN_WARNING,
+                         "disposed unprocessed dirty file(s) when detaching log writer");
        }
        spin_unlock(&nilfs->ns_inode_lock);
        up_write(&nilfs->ns_segctor_sem);

diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c
index 90c62b4898570e1881ad88a1957247a5b9b9b93f..33ba6f78de69cffbcf8b481575854b3d72e76de2 100644 (file)
--- a/fs/nilfs2/super.c
+++ b/fs/nilfs2/super.c
@@ -115,8 +115,7 @@ static void nilfs_set_error(struct super_block *sb)
  *
  * This implements the body of nilfs_error() macro.  Normally,
  * nilfs_error() should be used.  As for sustainable errors such as a
- * single-shot I/O error, nilfs_warning() or printk() should be used
- * instead.
+ * single-shot I/O error, nilfs_msg() should be used instead.
  *
  * Callers should not add a trailing newline since this will do it.
  */
@@ -151,24 +150,6 @@ void __nilfs_error(struct super_block *sb, const char *function,
                      sb->s_id);
 }
 
-void nilfs_warning(struct super_block *sb, const char *function,
-                  const char *fmt, ...)
-{
-       struct va_format vaf;
-       va_list args;
-
-       va_start(args, fmt);
-
-       vaf.fmt = fmt;
-       vaf.va = &args;
-
-       printk(KERN_WARNING "NILFS warning (device %s): %s: %pV\n",
-              sb->s_id, function, &vaf);
-
-       va_end(args);
-}
-
-
 struct inode *nilfs_alloc_inode(struct super_block *sb)
 {
        struct nilfs_inode_info *ii;