mirrors/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-10-31 08:38:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

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
repo.diff.show_diff_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 {