iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fs: Convert show_fdinfo functions to void

Browse Source 
seq_printf functions shouldn't really check the return value.
Checking seq_has_overflowed() occasionally is used instead.

Update vfs documentation.

Link: http://lkml.kernel.org/p/e37e6e7b76acbdcc3bb4ab2a57c8f8ca1ae11b9a.1412031505.git.joe@perches.com

Cc: David S. Miller <davem@davemloft.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Joe Perches <joe@perches.com>
[ did a few clean ups ]
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
This commit is contained in:
Joe Perches 2014-09-29 16:08:25 -07:00 committed by Steven Rostedt
parent f365ef9b79
commit a3816ab0e8
10 changed files with 63 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Documentation/filesystems/vfs.txt
View File

@ -828,7 +828,7 @@ struct file_operations {
ssize_t (*splice_read)(struct file *, struct pipe_inode_info *, size_t, unsigned int); ssize_t (*splice_read)(struct file *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long arg, struct file_lock **, void **); int (*setlease)(struct file *, long arg, struct file_lock **, void **);
long (*fallocate)(struct file *, int mode, loff_t offset, loff_t len); long (*fallocate)(struct file *, int mode, loff_t offset, loff_t len);
int (*show_fdinfo)(struct seq_file *m, struct file *f); void (*show_fdinfo)(struct seq_file *m, struct file *f);
}; };
Again, all methods are called without any locks being held, unless Again, all methods are called without any locks being held, unless

4
drivers/net/tun.c
View File

@ -2209,7 +2209,7 @@ static int tun_chr_close(struct inode *inode, struct file *file)
} }
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static int tun_chr_show_fdinfo(struct seq_file *m, struct file *f) static void tun_chr_show_fdinfo(struct seq_file *m, struct file *f)
{ {
struct tun_struct *tun; struct tun_struct *tun;
struct ifreq ifr; struct ifreq ifr;
@ -2225,7 +2225,7 @@ static int tun_chr_show_fdinfo(struct seq_file *m, struct file *f)
if (tun) if (tun)
tun_put(tun); tun_put(tun);
return seq_printf(m, "iff:\t%s\n", ifr.ifr_name); seq_printf(m, "iff:\t%s\n", ifr.ifr_name);
} }
#endif #endif

9
fs/eventfd.c
View File

@ -287,17 +287,14 @@ static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t c
} }
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static int eventfd_show_fdinfo(struct seq_file *m, struct file *f) static void eventfd_show_fdinfo(struct seq_file *m, struct file *f)
{ {
struct eventfd_ctx *ctx = f->private_data; struct eventfd_ctx *ctx = f->private_data;
int ret;
spin_lock_irq(&ctx->wqh.lock); spin_lock_irq(&ctx->wqh.lock);
ret = seq_printf(m, "eventfd-count: %16llx\n", seq_printf(m, "eventfd-count: %16llx\n",
(unsigned long long)ctx->count); (unsigned long long)ctx->count);
spin_unlock_irq(&ctx->wqh.lock); spin_unlock_irq(&ctx->wqh.lock);
return ret;
} }
#endif #endif

13
fs/eventpoll.c
View File

@ -870,25 +870,22 @@ static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
} }
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static int ep_show_fdinfo(struct seq_file *m, struct file *f) static void ep_show_fdinfo(struct seq_file *m, struct file *f)
{ {
struct eventpoll *ep = f->private_data; struct eventpoll *ep = f->private_data;
struct rb_node *rbp; struct rb_node *rbp;
int ret = 0;
mutex_lock(&ep->mtx); mutex_lock(&ep->mtx);
for (rbp = rb_first(&ep->rbr); rbp; rbp = rb_next(rbp)) { for (rbp = rb_first(&ep->rbr); rbp; rbp = rb_next(rbp)) {
struct epitem *epi = rb_entry(rbp, struct epitem, rbn); struct epitem *epi = rb_entry(rbp, struct epitem, rbn);
ret = seq_printf(m, "tfd: %8d events: %8x data: %16llx\n", seq_printf(m, "tfd: %8d events: %8x data: %16llx\n",
epi->ffd.fd, epi->event.events, epi->ffd.fd, epi->event.events,
(long long)epi->event.data); (long long)epi->event.data);
if (ret) if (seq_has_overflowed(m))
break; break;
} }
mutex_unlock(&ep->mtx); mutex_unlock(&ep->mtx);
return ret;
} }
#endif #endif

78
fs/notify/fdinfo.c
View File

@ -20,25 +20,24 @@
#if defined(CONFIG_INOTIFY_USER) || defined(CONFIG_FANOTIFY) #if defined(CONFIG_INOTIFY_USER) || defined(CONFIG_FANOTIFY)
static int show_fdinfo(struct seq_file *m, struct file *f, static void show_fdinfo(struct seq_file *m, struct file *f,
int (*show)(struct seq_file *m, struct fsnotify_mark *mark)) void (*show)(struct seq_file *m,
struct fsnotify_mark *mark))
{ {
struct fsnotify_group *group = f->private_data; struct fsnotify_group *group = f->private_data;
struct fsnotify_mark *mark; struct fsnotify_mark *mark;
int ret = 0;
mutex_lock(&group->mark_mutex); mutex_lock(&group->mark_mutex);
list_for_each_entry(mark, &group->marks_list, g_list) { list_for_each_entry(mark, &group->marks_list, g_list) {
ret = show(m, mark); show(m, mark);
if (ret) if (seq_has_overflowed(m))
break; break;
} }
mutex_unlock(&group->mark_mutex); mutex_unlock(&group->mark_mutex);
return ret;
} }
#if defined(CONFIG_EXPORTFS) #if defined(CONFIG_EXPORTFS)
static int show_mark_fhandle(struct seq_file *m, struct inode *inode) static void show_mark_fhandle(struct seq_file *m, struct inode *inode)
{ {
struct { struct {
struct file_handle handle; struct file_handle handle;
@ -52,71 +51,62 @@ static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
ret = exportfs_encode_inode_fh(inode, (struct fid *)f.handle.f_handle, &size, 0); ret = exportfs_encode_inode_fh(inode, (struct fid *)f.handle.f_handle, &size, 0);
if ((ret == FILEID_INVALID) || (ret < 0)) { if ((ret == FILEID_INVALID) || (ret < 0)) {
WARN_ONCE(1, "Can't encode file handler for inotify: %d\n", ret); WARN_ONCE(1, "Can't encode file handler for inotify: %d\n", ret);
return 0; return;
} }
f.handle.handle_type = ret; f.handle.handle_type = ret;
f.handle.handle_bytes = size * sizeof(u32); f.handle.handle_bytes = size * sizeof(u32);
ret = seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:", seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:",
f.handle.handle_bytes, f.handle.handle_type); f.handle.handle_bytes, f.handle.handle_type);
for (i = 0; i < f.handle.handle_bytes; i++) for (i = 0; i < f.handle.handle_bytes; i++)
ret |= seq_printf(m, "%02x", (int)f.handle.f_handle[i]); seq_printf(m, "%02x", (int)f.handle.f_handle[i]);
return ret;
} }
#else #else
static int show_mark_fhandle(struct seq_file *m, struct inode *inode) static void show_mark_fhandle(struct seq_file *m, struct inode *inode)
{ {
return 0;
} }
#endif #endif
#ifdef CONFIG_INOTIFY_USER #ifdef CONFIG_INOTIFY_USER
static int inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark) static void inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
{ {
struct inotify_inode_mark *inode_mark; struct inotify_inode_mark *inode_mark;
struct inode *inode; struct inode *inode;
int ret = 0;
if (!(mark->flags & (FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_INODE))) if (!(mark->flags & (FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_INODE)))
return 0; return;
inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark); inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
inode = igrab(mark->i.inode); inode = igrab(mark->i.inode);
if (inode) { if (inode) {
ret = seq_printf(m, "inotify wd:%x ino:%lx sdev:%x " seq_printf(m, "inotify wd:%x ino:%lx sdev:%x mask:%x ignored_mask:%x ",
"mask:%x ignored_mask:%x ", inode_mark->wd, inode->i_ino, inode->i_sb->s_dev,
inode_mark->wd, inode->i_ino, mark->mask, mark->ignored_mask);
inode->i_sb->s_dev, show_mark_fhandle(m, inode);
mark->mask, mark->ignored_mask); seq_putc(m, '\n');
ret |= show_mark_fhandle(m, inode);
ret |= seq_putc(m, '\n');
iput(inode); iput(inode);
} }
return ret;
} }
int inotify_show_fdinfo(struct seq_file *m, struct file *f) void inotify_show_fdinfo(struct seq_file *m, struct file *f)
{ {
return show_fdinfo(m, f, inotify_fdinfo); show_fdinfo(m, f, inotify_fdinfo);
} }
#endif /* CONFIG_INOTIFY_USER */ #endif /* CONFIG_INOTIFY_USER */
#ifdef CONFIG_FANOTIFY #ifdef CONFIG_FANOTIFY
static int fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark) static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
{ {
unsigned int mflags = 0; unsigned int mflags = 0;
struct inode *inode; struct inode *inode;
int ret = 0;
if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE)) if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE))
return 0; return;
if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY) if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
mflags |= FAN_MARK_IGNORED_SURV_MODIFY; mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
@ -124,26 +114,22 @@ static int fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) { if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) {
inode = igrab(mark->i.inode); inode = igrab(mark->i.inode);
if (!inode) if (!inode)
goto out; return;
ret = seq_printf(m, "fanotify ino:%lx sdev:%x " seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
"mflags:%x mask:%x ignored_mask:%x ", inode->i_ino, inode->i_sb->s_dev,
inode->i_ino, inode->i_sb->s_dev, mflags, mark->mask, mark->ignored_mask);
mflags, mark->mask, mark->ignored_mask); show_mark_fhandle(m, inode);
ret |= show_mark_fhandle(m, inode); seq_putc(m, '\n');
ret |= seq_putc(m, '\n');
iput(inode); iput(inode);
} else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) { } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) {
struct mount *mnt = real_mount(mark->m.mnt); struct mount *mnt = real_mount(mark->m.mnt);
ret = seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x " seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n",
"ignored_mask:%x\n", mnt->mnt_id, mflags, mnt->mnt_id, mflags, mark->mask, mark->ignored_mask);
mark->mask, mark->ignored_mask);
} }
out:
return ret;
} }
int fanotify_show_fdinfo(struct seq_file *m, struct file *f) void fanotify_show_fdinfo(struct seq_file *m, struct file *f)
{ {
struct fsnotify_group *group = f->private_data; struct fsnotify_group *group = f->private_data;
unsigned int flags = 0; unsigned int flags = 0;
@ -169,7 +155,7 @@ int fanotify_show_fdinfo(struct seq_file *m, struct file *f)
seq_printf(m, "fanotify flags:%x event-flags:%x\n", seq_printf(m, "fanotify flags:%x event-flags:%x\n",
flags, group->fanotify_data.f_flags); flags, group->fanotify_data.f_flags);
return show_fdinfo(m, f, fanotify_fdinfo); show_fdinfo(m, f, fanotify_fdinfo);
} }
#endif /* CONFIG_FANOTIFY */ #endif /* CONFIG_FANOTIFY */

4
fs/notify/fdinfo.h
View File

@ -10,11 +10,11 @@ struct file;
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
#ifdef CONFIG_INOTIFY_USER #ifdef CONFIG_INOTIFY_USER
extern int inotify_show_fdinfo(struct seq_file *m, struct file *f); void inotify_show_fdinfo(struct seq_file *m, struct file *f);
#endif #endif
#ifdef CONFIG_FANOTIFY #ifdef CONFIG_FANOTIFY
extern int fanotify_show_fdinfo(struct seq_file *m, struct file *f); void fanotify_show_fdinfo(struct seq_file *m, struct file *f);
#endif #endif
#else /* CONFIG_PROC_FS */ #else /* CONFIG_PROC_FS */

3
fs/proc/fd.c
View File

@ -53,7 +53,8 @@ static int seq_show(struct seq_file *m, void *v)
(long long)file->f_pos, f_flags, (long long)file->f_pos, f_flags,
real_mount(file->f_path.mnt)->mnt_id); real_mount(file->f_path.mnt)->mnt_id);
if (file->f_op->show_fdinfo) if (file->f_op->show_fdinfo)
ret = file->f_op->show_fdinfo(m, file); file->f_op->show_fdinfo(m, file);
ret = seq_has_overflowed(m);
fput(file); fput(file);
} }

4
fs/signalfd.c
View File

@ -230,7 +230,7 @@ static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
} }
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static int signalfd_show_fdinfo(struct seq_file *m, struct file *f) static void signalfd_show_fdinfo(struct seq_file *m, struct file *f)
{ {
struct signalfd_ctx *ctx = f->private_data; struct signalfd_ctx *ctx = f->private_data;
sigset_t sigmask; sigset_t sigmask;
@ -238,8 +238,6 @@ static int signalfd_show_fdinfo(struct seq_file *m, struct file *f)
sigmask = ctx->sigmask; sigmask = ctx->sigmask;
signotset(&sigmask); signotset(&sigmask);
render_sigset_t(m, "sigmask:\t", &sigmask); render_sigset_t(m, "sigmask:\t", &sigmask);
return 0;
} }
#endif #endif

27
fs/timerfd.c
View File

@ -288,7 +288,7 @@ static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count,
} }
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static int timerfd_show(struct seq_file *m, struct file *file) static void timerfd_show(struct seq_file *m, struct file *file)
{ {
struct timerfd_ctx *ctx = file->private_data; struct timerfd_ctx *ctx = file->private_data;
struct itimerspec t; struct itimerspec t;
@ -298,18 +298,19 @@ static int timerfd_show(struct seq_file *m, struct file *file)
t.it_interval = ktime_to_timespec(ctx->tintv); t.it_interval = ktime_to_timespec(ctx->tintv);
spin_unlock_irq(&ctx->wqh.lock); spin_unlock_irq(&ctx->wqh.lock);
return seq_printf(m, seq_printf(m,
"clockid: %d\n" "clockid: %d\n"
"ticks: %llu\n" "ticks: %llu\n"
"settime flags: 0%o\n" "settime flags: 0%o\n"
"it_value: (%llu, %llu)\n" "it_value: (%llu, %llu)\n"
"it_interval: (%llu, %llu)\n", "it_interval: (%llu, %llu)\n",
ctx->clockid, (unsigned long long)ctx->ticks, ctx->clockid,
ctx->settime_flags, (unsigned long long)ctx->ticks,
(unsigned long long)t.it_value.tv_sec, ctx->settime_flags,
(unsigned long long)t.it_value.tv_nsec, (unsigned long long)t.it_value.tv_sec,
(unsigned long long)t.it_interval.tv_sec, (unsigned long long)t.it_value.tv_nsec,
(unsigned long long)t.it_interval.tv_nsec); (unsigned long long)t.it_interval.tv_sec,
(unsigned long long)t.it_interval.tv_nsec);
} }
#else #else
#define timerfd_show NULL #define timerfd_show NULL

2
include/linux/fs.h
View File

@ -1491,7 +1491,7 @@ struct file_operations {
int (*setlease)(struct file *, long, struct file_lock **, void **); int (*setlease)(struct file *, long, struct file_lock **, void **);
long (*fallocate)(struct file *file, int mode, loff_t offset, long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len); loff_t len);
int (*show_fdinfo)(struct seq_file *m, struct file *f); void (*show_fdinfo)(struct seq_file *m, struct file *f);
}; };
struct inode_operations { struct inode_operations {