redonkable
/
remarkable-linux
1
0
Fork 0
Code Releases Activity

nilfs2: hide function name argument from nilfs_error() 

Simplify nilfs_error(), an output function used to report critical
issues in file system.  This renames the original nilfs_error() function
to __nilfs_error() and redefines it as a macro to hide its function name
argument within the macro.

Every call site of nilfs_error() is changed to strip __func__ argument
except nilfs_bmap_convert_error(); nilfs_bmap_convert_error() directly
calls __nilfs_error() because it inherits caller's function name.

Link: http://lkml.kernel.org/r/1464875891-5443-2-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>
steinar/wifi_calib_4_9_kernel
Ryusuke Konishi 2016-08-02 14:05:00 -07:00 committed by Linus Torvalds
parent a310dcb7a4
commit cae3d4ca6f
5 changed files with 51 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fs/nilfs2/bmap.c
View File

@ -41,8 +41,8 @@ static int nilfs_bmap_convert_error(struct nilfs_bmap *bmap,
struct inode *inode = bmap->b_inode; struct inode *inode = bmap->b_inode;
if (err == -EINVAL) { if (err == -EINVAL) {
nilfs_error(inode->i_sb, fname, __nilfs_error(inode->i_sb, fname,
"broken bmap (inode number=%lu)", inode->i_ino); "broken bmap (inode number=%lu)", inode->i_ino);
err = -EIO; err = -EIO;
} }
return err; return err;

38
fs/nilfs2/dir.c
View File

@ -140,10 +140,9 @@ out:
/* Too bad, we had an error */ /* Too bad, we had an error */
Ebadsize: Ebadsize:
nilfs_error(sb, "nilfs_check_page", nilfs_error(sb,
"size of directory #%lu is not a multiple of chunk size", "size of directory #%lu is not a multiple of chunk size",
dir->i_ino dir->i_ino);
);
goto fail; goto fail;
Eshort: Eshort:
error = "rec_len is smaller than minimal"; error = "rec_len is smaller than minimal";
@ -157,19 +156,18 @@ Enamelen:
Espan: Espan:
error = "directory entry across blocks"; error = "directory entry across blocks";
bad_entry: bad_entry:
nilfs_error(sb, "nilfs_check_page", "bad entry in directory #%lu: %s - " nilfs_error(sb,
"offset=%lu, inode=%lu, rec_len=%d, name_len=%d", "bad entry in directory #%lu: %s - offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
dir->i_ino, error, (page->index<<PAGE_SHIFT)+offs, dir->i_ino, error, (page->index << PAGE_SHIFT) + offs,
(unsigned long) le64_to_cpu(p->inode), (unsigned long)le64_to_cpu(p->inode),
rec_len, p->name_len); rec_len, p->name_len);
goto fail; goto fail;
Eend: Eend:
p = (struct nilfs_dir_entry *)(kaddr + offs); p = (struct nilfs_dir_entry *)(kaddr + offs);
nilfs_error(sb, "nilfs_check_page", nilfs_error(sb,
"entry in directory #%lu spans the page boundary" "entry in directory #%lu spans the page boundary offset=%lu, inode=%lu",
"offset=%lu, inode=%lu", dir->i_ino, (page->index << PAGE_SHIFT) + offs,
dir->i_ino, (page->index<<PAGE_SHIFT)+offs, (unsigned long)le64_to_cpu(p->inode));
(unsigned long) le64_to_cpu(p->inode));
fail: fail:
SetPageError(page); SetPageError(page);
return false; return false;
@ -267,8 +265,7 @@ static int nilfs_readdir(struct file *file, struct dir_context *ctx)
struct page *page = nilfs_get_page(inode, n); struct page *page = nilfs_get_page(inode, n);
if (IS_ERR(page)) { if (IS_ERR(page)) {
nilfs_error(sb, __func__, "bad page in #%lu", nilfs_error(sb, "bad page in #%lu", inode->i_ino);
inode->i_ino);
ctx->pos += PAGE_SIZE - offset; ctx->pos += PAGE_SIZE - offset;
return -EIO; return -EIO;
} }
@ -278,8 +275,7 @@ static int nilfs_readdir(struct file *file, struct dir_context *ctx)
NILFS_DIR_REC_LEN(1); NILFS_DIR_REC_LEN(1);
for ( ; (char *)de <= limit; de = nilfs_next_entry(de)) { for ( ; (char *)de <= limit; de = nilfs_next_entry(de)) {
if (de->rec_len == 0) { if (de->rec_len == 0) {
nilfs_error(sb, __func__, nilfs_error(sb, "zero-length directory entry");
"zero-length directory entry");
nilfs_put_page(page); nilfs_put_page(page);
return -EIO; return -EIO;
} }
@ -345,7 +341,7 @@ nilfs_find_entry(struct inode *dir, const struct qstr *qstr,
kaddr += nilfs_last_byte(dir, n) - reclen; kaddr += nilfs_last_byte(dir, n) - reclen;
while ((char *) de <= kaddr) { while ((char *) de <= kaddr) {
if (de->rec_len == 0) { if (de->rec_len == 0) {
nilfs_error(dir->i_sb, __func__, nilfs_error(dir->i_sb,
"zero-length directory entry"); "zero-length directory entry");
nilfs_put_page(page); nilfs_put_page(page);
goto out; goto out;
@ -360,7 +356,7 @@ nilfs_find_entry(struct inode *dir, const struct qstr *qstr,
n = 0; n = 0;
/* next page is past the blocks we've got */ /* next page is past the blocks we've got */
if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) { if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) {
nilfs_error(dir->i_sb, __func__, nilfs_error(dir->i_sb,
"dir %lu size %lld exceeds block count %llu", "dir %lu size %lld exceeds block count %llu",
dir->i_ino, dir->i_size, dir->i_ino, dir->i_size,
(unsigned long long)dir->i_blocks); (unsigned long long)dir->i_blocks);
@ -469,7 +465,7 @@ int nilfs_add_link(struct dentry *dentry, struct inode *inode)
goto got_it; goto got_it;
} }
if (de->rec_len == 0) { if (de->rec_len == 0) {
nilfs_error(dir->i_sb, __func__, nilfs_error(dir->i_sb,
"zero-length directory entry"); "zero-length directory entry");
err = -EIO; err = -EIO;
goto out_unlock; goto out_unlock;
@ -541,7 +537,7 @@ int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)
while ((char *)de < (char *)dir) { while ((char *)de < (char *)dir) {
if (de->rec_len == 0) { if (de->rec_len == 0) {
nilfs_error(inode->i_sb, __func__, nilfs_error(inode->i_sb,
"zero-length directory entry"); "zero-length directory entry");
err = -EIO; err = -EIO;
goto out; goto out;
@ -628,7 +624,7 @@ int nilfs_empty_dir(struct inode *inode)
while ((char *)de <= kaddr) { while ((char *)de <= kaddr) {
if (de->rec_len == 0) { if (de->rec_len == 0) {
nilfs_error(inode->i_sb, __func__, nilfs_error(inode->i_sb,
"zero-length directory entry (kaddr=%p, de=%p)", "zero-length directory entry (kaddr=%p, de=%p)",
kaddr, de); kaddr, de);
goto not_empty; goto not_empty;

3
fs/nilfs2/ifile.c
View File

@ -145,8 +145,7 @@ int nilfs_ifile_get_inode_block(struct inode *ifile, ino_t ino,
int err; int err;
if (unlikely(!NILFS_VALID_INODE(sb, ino))) { if (unlikely(!NILFS_VALID_INODE(sb, ino))) {
nilfs_error(sb, __func__, "bad inode number: %lu", nilfs_error(sb, "bad inode number: %lu", (unsigned long)ino);
(unsigned long) ino);
return -EINVAL; return -EINVAL;
} }

20
fs/nilfs2/nilfs.h
View File

@ -299,10 +299,28 @@ static inline int nilfs_mark_inode_dirty_sync(struct inode *inode)
/* super.c */ /* super.c */
extern struct inode *nilfs_alloc_inode(struct super_block *); extern struct inode *nilfs_alloc_inode(struct super_block *);
extern void nilfs_destroy_inode(struct inode *); extern void nilfs_destroy_inode(struct inode *);
extern __printf(3, 4) extern __printf(3, 4)
void nilfs_error(struct super_block *, const char *, const char *, ...); void __nilfs_error(struct super_block *sb, const char *function,
const char *fmt, ...);
extern __printf(3, 4) extern __printf(3, 4)
void nilfs_warning(struct super_block *, const char *, const char *, ...); void nilfs_warning(struct super_block *, const char *, const char *, ...);
#ifdef CONFIG_PRINTK
#define nilfs_error(sb, fmt, ...) \
__nilfs_error(sb, __func__, fmt, ##__VA_ARGS__)
#else
#define nilfs_error(sb, fmt, ...) \
do { \
no_printk(fmt, ##__VA_ARGS__); \
__nilfs_error(sb, "", " "); \
} while (0)
#endif /* CONFIG_PRINTK */
extern struct nilfs_super_block * extern struct nilfs_super_block *
nilfs_read_super_block(struct super_block *, u64, int, struct buffer_head **); nilfs_read_super_block(struct super_block *, u64, int, struct buffer_head **);
extern int nilfs_store_magic_and_option(struct super_block *, extern int nilfs_store_magic_and_option(struct super_block *,

22
fs/nilfs2/super.c
View File

@ -91,19 +91,21 @@ static void nilfs_set_error(struct super_block *sb)
} }
/** /**
* nilfs_error() - report failure condition on a filesystem * __nilfs_error() - report failure condition on a filesystem
* *
* nilfs_error() sets an ERROR_FS flag on the superblock as well as * __nilfs_error() sets an ERROR_FS flag on the superblock as well as
* reporting an error message. It should be called when NILFS detects * reporting an error message. This function should be called when
* incoherences or defects of meta data on disk. As for sustainable * NILFS detects incoherences or defects of meta data on disk.
* errors such as a single-shot I/O error, nilfs_warning() or the printk()
* function should be used instead.
* *
* The segment constructor must not call this function because it can * This implements the body of nilfs_error() macro. Normally,
* kill itself. * 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.
*
* Callers should not add a trailing newline since this will do it.
*/ */
void nilfs_error(struct super_block *sb, const char *function, void __nilfs_error(struct super_block *sb, const char *function,
const char *fmt, ...) const char *fmt, ...)
{ {
struct the_nilfs *nilfs = sb->s_fs_info; struct the_nilfs *nilfs = sb->s_fs_info;
struct va_format vaf; struct va_format vaf;