nilfs2: use a more common logging style

Add macros for nilfs_<level>(sb, fmt, ...) and convert the uses of
'nilfs_msg(sb, KERN_<LEVEL>, ...)' to 'nilfs_<level>(sb, ...)' so nilfs2
uses a logging style more like the typical kernel logging style.

Miscellanea:

o Realign arguments for these uses

Signed-off-by: Joe Perches <[email protected]>
Signed-off-by: Ryusuke Konishi <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
Link: https://lkml.kernel.org/r/[email protected]
Signed-off-by: Linus Torvalds <[email protected]>

fs/nilfs2/alloc.c

@@ -613,10 +613,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_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);
+ nilfs_warn(inode->i_sb,
+  "%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);
 
@@ -654,10 +654,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_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);
+ nilfs_warn(inode->i_sb,
+  "%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);
 
@@ -763,10 +763,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_msg(inode->i_sb, KERN_WARNING,
- "%s (ino=%lu): entry number %llu already freed",
- __func__, inode->i_ino,
- (unsigned long long)entry_nrs[j]);
+ nilfs_warn(inode->i_sb,
+  "%s (ino=%lu): entry number %llu already freed",
+  __func__, inode->i_ino,
+  (unsigned long long)entry_nrs[j]);
  } else {
  n++;
  }
@@ -808,10 +808,10 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
  ret = nilfs_palloc_delete_entry_block(inode,
  last_nrs[k]);
  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);
+ nilfs_warn(inode->i_sb,
+  "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);
@@ -826,9 +826,9 @@ 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_msg(inode->i_sb, KERN_WARNING,
- "error %d deleting bitmap block of group=%lu, ino=%lu",
- ret, group, inode->i_ino);
+ nilfs_warn(inode->i_sb,
+  "error %d deleting bitmap block of group=%lu, ino=%lu",
+  ret, group, inode->i_ino);
  }
  }
  return 0;

fs/nilfs2/btree.c

@@ -351,10 +351,10 @@ static int nilfs_btree_node_broken(const struct nilfs_btree_node *node,
  (flags & NILFS_BTREE_NODE_ROOT) ||
  nchildren < 0 ||
  nchildren > NILFS_BTREE_NODE_NCHILDREN_MAX(size))) {
- nilfs_msg(inode->i_sb, KERN_CRIT,
- "bad btree node (ino=%lu, blocknr=%llu): level = %d, flags = 0x%x, nchildren = %d",
- inode->i_ino, (unsigned long long)blocknr, level,
- flags, nchildren);
+ nilfs_crit(inode->i_sb,
+  "bad btree node (ino=%lu, blocknr=%llu): level = %d, flags = 0x%x, nchildren = %d",
+  inode->i_ino, (unsigned long long)blocknr, level,
+  flags, nchildren);
  ret = 1;
  }
  return ret;
@@ -381,9 +381,9 @@ static int nilfs_btree_root_broken(const struct nilfs_btree_node *node,
  level >= NILFS_BTREE_LEVEL_MAX ||
  nchildren < 0 ||
  nchildren > NILFS_BTREE_ROOT_NCHILDREN_MAX)) {
- nilfs_msg(inode->i_sb, KERN_CRIT,
- "bad btree root (ino=%lu): level = %d, flags = 0x%x, nchildren = %d",
- inode->i_ino, level, flags, nchildren);
+ nilfs_crit(inode->i_sb,
+  "bad btree root (ino=%lu): level = %d, flags = 0x%x, nchildren = %d",
+  inode->i_ino, level, flags, nchildren);
  ret = 1;
  }
  return ret;
@@ -450,10 +450,10 @@ static int nilfs_btree_bad_node(const struct nilfs_bmap *btree,
 {
  if (unlikely(nilfs_btree_node_get_level(node) != level)) {
  dump_stack();
- nilfs_msg(btree->b_inode->i_sb, KERN_CRIT,
- "btree level mismatch (ino=%lu): %d != %d",
- btree->b_inode->i_ino,
- nilfs_btree_node_get_level(node), level);
+ nilfs_crit(btree->b_inode->i_sb,
+  "btree level mismatch (ino=%lu): %d != %d",
+  btree->b_inode->i_ino,
+  nilfs_btree_node_get_level(node), level);
  return 1;
  }
  return 0;
@@ -508,7 +508,7 @@ static int __nilfs_btree_get_block(const struct nilfs_bmap *btree, __u64 ptr,
 
  out_no_wait:
  if (!buffer_uptodate(bh)) {
- nilfs_msg(btree->b_inode->i_sb, KERN_ERR,
+ nilfs_err(btree->b_inode->i_sb,
  "I/O error reading b-tree node block (ino=%lu, blocknr=%llu)",
  btree->b_inode->i_ino, (unsigned long long)ptr);
  brelse(bh);
@@ -2074,10 +2074,10 @@ static int nilfs_btree_propagate(struct nilfs_bmap *btree,
  ret = nilfs_btree_do_lookup(btree, path, key, NULL, level + 1, 0);
  if (ret < 0) {
  if (unlikely(ret == -ENOENT))
- nilfs_msg(btree->b_inode->i_sb, KERN_CRIT,
- "writing node/leaf block does not appear in b-tree (ino=%lu) at key=%llu, level=%d",
- btree->b_inode->i_ino,
- (unsigned long long)key, level);
+ nilfs_crit(btree->b_inode->i_sb,
+  "writing node/leaf block does not appear in b-tree (ino=%lu) at key=%llu, level=%d",
+  btree->b_inode->i_ino,
+  (unsigned long long)key, level);
  goto out;
  }
 
@@ -2114,11 +2114,11 @@ static void nilfs_btree_add_dirty_buffer(struct nilfs_bmap *btree,
  if (level < NILFS_BTREE_LEVEL_NODE_MIN ||
  level >= NILFS_BTREE_LEVEL_MAX) {
  dump_stack();
- nilfs_msg(btree->b_inode->i_sb, KERN_WARNING,
- "invalid btree level: %d (key=%llu, ino=%lu, blocknr=%llu)",
- level, (unsigned long long)key,
- btree->b_inode->i_ino,
- (unsigned long long)bh->b_blocknr);
+ nilfs_warn(btree->b_inode->i_sb,
+  "invalid btree level: %d (key=%llu, ino=%lu, blocknr=%llu)",
+  level, (unsigned long long)key,
+  btree->b_inode->i_ino,
+  (unsigned long long)bh->b_blocknr);
  return;
  }
 

fs/nilfs2/cpfile.c

@@ -322,7 +322,7 @@ int nilfs_cpfile_delete_checkpoints(struct inode *cpfile,
  int ret, ncps, nicps, nss, count, i;
 
  if (unlikely(start == 0 || start > end)) {
- nilfs_msg(cpfile->i_sb, KERN_ERR,
+ nilfs_err(cpfile->i_sb,
  "cannot delete checkpoints: invalid range [%llu, %llu)",
  (unsigned long long)start, (unsigned long long)end);
  return -EINVAL;
@@ -376,7 +376,7 @@ int nilfs_cpfile_delete_checkpoints(struct inode *cpfile,
  cpfile, cno);
  if (ret == 0)
  continue;
- nilfs_msg(cpfile->i_sb, KERN_ERR,
+ nilfs_err(cpfile->i_sb,
  "error %d deleting checkpoint block",
  ret);
  break;
@@ -981,12 +981,10 @@ int nilfs_cpfile_read(struct super_block *sb, size_t cpsize,
  int err;
 
  if (cpsize > sb->s_blocksize) {
- nilfs_msg(sb, KERN_ERR,
- "too large checkpoint size: %zu bytes", cpsize);
+ nilfs_err(sb, "too large checkpoint size: %zu bytes", cpsize);
  return -EINVAL;
  } else if (cpsize < NILFS_MIN_CHECKPOINT_SIZE) {
- nilfs_msg(sb, KERN_ERR,
- "too small checkpoint size: %zu bytes", cpsize);
+ nilfs_err(sb, "too small checkpoint size: %zu bytes", cpsize);
  return -EINVAL;
  }
 

fs/nilfs2/dat.c

@@ -340,11 +340,11 @@ int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr)
  kaddr = kmap_atomic(entry_bh->b_page);
  entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
  if (unlikely(entry->de_blocknr == cpu_to_le64(0))) {
- nilfs_msg(dat->i_sb, KERN_CRIT,
- "%s: invalid vblocknr = %llu, [%llu, %llu)",
- __func__, (unsigned long long)vblocknr,
- (unsigned long long)le64_to_cpu(entry->de_start),
- (unsigned long long)le64_to_cpu(entry->de_end));
+ nilfs_crit(dat->i_sb,
+  "%s: invalid vblocknr = %llu, [%llu, %llu)",
+  __func__, (unsigned long long)vblocknr,
+  (unsigned long long)le64_to_cpu(entry->de_start),
+  (unsigned long long)le64_to_cpu(entry->de_end));
  kunmap_atomic(kaddr);
  brelse(entry_bh);
  return -EINVAL;
@@ -471,11 +471,11 @@ int nilfs_dat_read(struct super_block *sb, size_t entry_size,
  int err;
 
  if (entry_size > sb->s_blocksize) {
- nilfs_msg(sb, KERN_ERR, "too large DAT entry size: %zu bytes",
+ nilfs_err(sb, "too large DAT entry size: %zu bytes",
  entry_size);
  return -EINVAL;
  } else if (entry_size < NILFS_MIN_DAT_ENTRY_SIZE) {
- nilfs_msg(sb, KERN_ERR, "too small DAT entry size: %zu bytes",
+ nilfs_err(sb, "too small DAT entry size: %zu bytes",
  entry_size);
  return -EINVAL;
  }

fs/nilfs2/direct.c

@@ -328,16 +328,18 @@ static int nilfs_direct_assign(struct nilfs_bmap *bmap,
 
  key = nilfs_bmap_data_get_key(bmap, *bh);
  if (unlikely(key > NILFS_DIRECT_KEY_MAX)) {
- nilfs_msg(bmap->b_inode->i_sb, KERN_CRIT,
- "%s (ino=%lu): invalid key: %llu", __func__,
- bmap->b_inode->i_ino, (unsigned long long)key);
+ nilfs_crit(bmap->b_inode->i_sb,
+ "%s (ino=%lu): invalid key: %llu",
+ __func__,
+ bmap->b_inode->i_ino, (unsigned long long)key);
  return -EINVAL;
  }
  ptr = nilfs_direct_get_ptr(bmap, key);
  if (unlikely(ptr == NILFS_BMAP_INVALID_PTR)) {
- nilfs_msg(bmap->b_inode->i_sb, KERN_CRIT,
- "%s (ino=%lu): invalid pointer: %llu", __func__,
- bmap->b_inode->i_ino, (unsigned long long)ptr);
+ nilfs_crit(bmap->b_inode->i_sb,
+ "%s (ino=%lu): invalid pointer: %llu",
+ __func__,
+ bmap->b_inode->i_ino, (unsigned long long)ptr);
  return -EINVAL;
  }
 

fs/nilfs2/gcinode.c

@@ -142,7 +142,7 @@ int nilfs_gccache_wait_and_mark_dirty(struct buffer_head *bh)
  if (!buffer_uptodate(bh)) {
  struct inode *inode = bh->b_page->mapping->host;
 
- nilfs_msg(inode->i_sb, KERN_ERR,
+ nilfs_err(inode->i_sb,
  "I/O error reading %s block for GC (ino=%lu, vblocknr=%llu)",
  buffer_nilfs_node(bh) ? "node" : "data",
  inode->i_ino, (unsigned long long)bh->b_blocknr);

fs/nilfs2/ifile.c

@@ -142,8 +142,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_msg(sb, KERN_WARNING, "error %d reading inode: ino=%lu",
- err, (unsigned long)ino);
+ nilfs_warn(sb, "error %d reading inode: ino=%lu",
+  err, (unsigned long)ino);
  return err;
 }
 

fs/nilfs2/inode.c

@@ -104,10 +104,10 @@ int nilfs_get_block(struct inode *inode, sector_t blkoff,
  * However, the page having this block must
  * be locked in this case.
  */
- nilfs_msg(inode->i_sb, KERN_WARNING,
- "%s (ino=%lu): a race condition while inserting a data block at offset=%llu",
- __func__, inode->i_ino,
- (unsigned long long)blkoff);
+ nilfs_warn(inode->i_sb,
+  "%s (ino=%lu): a race condition while inserting a data block at offset=%llu",
+  __func__, inode->i_ino,
+  (unsigned long long)blkoff);
  err = 0;
  }
  nilfs_transaction_abort(inode->i_sb);
@@ -707,9 +707,8 @@ static void nilfs_truncate_bmap(struct nilfs_inode_info *ii,
  goto repeat;
 
 failed:
- nilfs_msg(ii->vfs_inode.i_sb, KERN_WARNING,
- "error %d truncating bmap (ino=%lu)", ret,
- ii->vfs_inode.i_ino);
+ nilfs_warn(ii->vfs_inode.i_sb, "error %d truncating bmap (ino=%lu)",
+ ret, ii->vfs_inode.i_ino);
 }
 
 void nilfs_truncate(struct inode *inode)
@@ -920,9 +919,9 @@ int nilfs_set_file_dirty(struct inode *inode, unsigned int nr_dirty)
  * This will happen when somebody is freeing
  * this inode.
  */
- nilfs_msg(inode->i_sb, KERN_WARNING,
- "cannot set file dirty (ino=%lu): the file is being freed",
- inode->i_ino);
+ nilfs_warn(inode->i_sb,
+  "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
@@ -943,9 +942,9 @@ int __nilfs_mark_inode_dirty(struct inode *inode, int flags)
 
  err = nilfs_load_inode_block(inode, &ibh);
  if (unlikely(err)) {
- nilfs_msg(inode->i_sb, KERN_WARNING,
- "cannot mark inode dirty (ino=%lu): error %d loading inode block",
- inode->i_ino, err);
+ nilfs_warn(inode->i_sb,
+  "cannot mark inode dirty (ino=%lu): error %d loading inode block",
+  inode->i_ino, err);
  return err;
  }
  nilfs_update_inode(inode, ibh, flags);
@@ -971,8 +970,8 @@ void nilfs_dirty_inode(struct inode *inode, int flags)
  struct nilfs_mdt_info *mdi = NILFS_MDT(inode);
 
  if (is_bad_inode(inode)) {
- nilfs_msg(inode->i_sb, KERN_WARNING,
- "tried to mark bad_inode dirty. ignored.");
+ nilfs_warn(inode->i_sb,
+  "tried to mark bad_inode dirty. ignored.");
  dump_stack();
  return;
  }

fs/nilfs2/ioctl.c

@@ -569,25 +569,25 @@ static int nilfs_ioctl_move_inode_block(struct inode *inode,
 
  if (unlikely(ret < 0)) {
  if (ret == -ENOENT)
- nilfs_msg(inode->i_sb, KERN_CRIT,
- "%s: invalid virtual block address (%s): ino=%llu, cno=%llu, offset=%llu, blocknr=%llu, vblocknr=%llu",
- __func__, vdesc->vd_flags ? "node" : "data",
- (unsigned long long)vdesc->vd_ino,
- (unsigned long long)vdesc->vd_cno,
- (unsigned long long)vdesc->vd_offset,
- (unsigned long long)vdesc->vd_blocknr,
- (unsigned long long)vdesc->vd_vblocknr);
+ nilfs_crit(inode->i_sb,
+  "%s: invalid virtual block address (%s): ino=%llu, cno=%llu, offset=%llu, blocknr=%llu, vblocknr=%llu",
+  __func__, vdesc->vd_flags ? "node" : "data",
+  (unsigned long long)vdesc->vd_ino,
+  (unsigned long long)vdesc->vd_cno,
+  (unsigned long long)vdesc->vd_offset,
+  (unsigned long long)vdesc->vd_blocknr,
+  (unsigned long long)vdesc->vd_vblocknr);
  return ret;
  }
  if (unlikely(!list_empty(&bh->b_assoc_buffers))) {
- nilfs_msg(inode->i_sb, KERN_CRIT,
- "%s: conflicting %s buffer: ino=%llu, cno=%llu, offset=%llu, blocknr=%llu, vblocknr=%llu",
- __func__, vdesc->vd_flags ? "node" : "data",
- (unsigned long long)vdesc->vd_ino,
- (unsigned long long)vdesc->vd_cno,
- (unsigned long long)vdesc->vd_offset,
- (unsigned long long)vdesc->vd_blocknr,
- (unsigned long long)vdesc->vd_vblocknr);
+ nilfs_crit(inode->i_sb,
+  "%s: conflicting %s buffer: ino=%llu, cno=%llu, offset=%llu, blocknr=%llu, vblocknr=%llu",
+  __func__, vdesc->vd_flags ? "node" : "data",
+  (unsigned long long)vdesc->vd_ino,
+  (unsigned long long)vdesc->vd_cno,
+  (unsigned long long)vdesc->vd_offset,
+  (unsigned long long)vdesc->vd_blocknr,
+  (unsigned long long)vdesc->vd_vblocknr);
  brelse(bh);
  return -EEXIST;
  }
@@ -837,8 +837,7 @@ int nilfs_ioctl_prepare_clean_segments(struct the_nilfs *nilfs,
  return 0;
 
  failed:
- nilfs_msg(nilfs->ns_sb, KERN_ERR, "error %d preparing GC: %s", ret,
- msg);
+ nilfs_err(nilfs->ns_sb, "error %d preparing GC: %s", ret, msg);
  return ret;
 }
 
@@ -947,7 +946,7 @@ static int nilfs_ioctl_clean_segments(struct inode *inode, struct file *filp,
 
  ret = nilfs_ioctl_move_blocks(inode->i_sb, &argv[0], kbufs[0]);
  if (ret < 0) {
- nilfs_msg(inode->i_sb, KERN_ERR,
+ nilfs_err(inode->i_sb,
  "error %d preparing GC: cannot read source blocks",
  ret);
  } else {

fs/nilfs2/mdt.c

@@ -199,7 +199,7 @@ static int nilfs_mdt_read_block(struct inode *inode, unsigned long block,
  out_no_wait:
  err = -EIO;
  if (!buffer_uptodate(first_bh)) {
- nilfs_msg(inode->i_sb, KERN_ERR,
+ nilfs_err(inode->i_sb,
  "I/O error reading meta-data file (ino=%lu, block-offset=%lu)",
  inode->i_ino, block);
  goto failed_bh;