From patchwork Thu Mar 12 15:54:42 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew Vagin X-Patchwork-Id: 5996881 Return-Path: X-Original-To: patchwork-linux-fsdevel@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 7066F9F444 for ; Thu, 12 Mar 2015 15:55:17 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 6D04F20375 for ; Thu, 12 Mar 2015 15:55:16 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id F13BA2035D for ; Thu, 12 Mar 2015 15:55:14 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1161081AbbCLPzK (ORCPT ); Thu, 12 Mar 2015 11:55:10 -0400 Received: from relay.parallels.com ([195.214.232.42]:50327 "EHLO relay.parallels.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754113AbbCLPzF (ORCPT ); Thu, 12 Mar 2015 11:55:05 -0400 Received: from [10.30.3.11] (helo=mail.sw.ru) by relay.parallels.com with esmtps (TLSv1:AES128-SHA:128) (Exim 4.85) (envelope-from ) id 1YW5Rg-0003nN-7j; Thu, 12 Mar 2015 18:54:48 +0300 Received: from paralelels.com (10.30.16.48) by MSK-EXCH.sw.swsoft.com (10.30.3.11) with Microsoft SMTP Server (TLS) id 14.3.210.2; Thu, 12 Mar 2015 18:54:47 +0300 Date: Thu, 12 Mar 2015 18:54:42 +0300 From: Andrew Vagin To: Andrew Morton CC: Andrey Vagin , , , , Jonathan Corbet , Alexander Viro , Jeff Layton , "J. Bruce Fields" , "Cyrill Gorcunov" , Pavel Emelyanov , "Joe Perches" Subject: Re: [PATCH] proc: show locks in /proc/pid/fdinfo/X Message-ID: <20150312155441.GA19139@paralelels.com> References: <1425569838-20416-1-git-send-email-avagin@openvz.org> <20150311150853.492fee52def529e86506976b@linux-foundation.org> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20150311150853.492fee52def529e86506976b@linux-foundation.org> User-Agent: Mutt/1.5.23 (2014-03-12) X-Originating-IP: [10.30.16.48] Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Spam-Status: No, score=-6.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, T_RP_MATCHES_RCVD, T_TVD_MIME_EPI, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP On Wed, Mar 11, 2015 at 03:08:53PM -0700, Andrew Morton wrote: > On Thu, 5 Mar 2015 18:37:18 +0300 Andrey Vagin wrote: > > > Let's show locks which are associated with a file descriptor in > > its fdinfo file. > > > > Currently we don't have a reliable way to determine who holds a lock. > > We can find some information in /proc/locks, but PID which is reported > > there can be wrong. For example, a process takes a lock, then forks a > > child and dies. In this case /proc/locks contains the parent pid, which > > can be reused by another process. > > > > $ cat /proc/locks > > ... > > 6: FLOCK ADVISORY WRITE 324 00:13:13431 0 EOF > > ... > > > > $ ps -C rpcbind > > PID TTY TIME CMD > > 332 ? 00:00:00 rpcbind > > > > $ cat /proc/332/fdinfo/4 > > pos: 0 > > flags: 0100000 > > mnt_id: 22 > > lock: 1: FLOCK ADVISORY WRITE 324 00:13:13431 0 EOF > > > > $ ls -l /proc/332/fd/4 > > lr-x------ 1 root root 64 Mar 5 14:43 /proc/332/fd/4 -> /run/rpcbind.lock > > > > $ ls -l /proc/324/fd/ > > total 0 > > lrwx------ 1 root root 64 Feb 27 14:50 0 -> /dev/pts/0 > > lrwx------ 1 root root 64 Feb 27 14:50 1 -> /dev/pts/0 > > lrwx------ 1 root root 64 Feb 27 14:49 2 -> /dev/pts/0 > > > > You can see that the process with the 324 pid doesn't hold the lock. > > > > This information is required for proper dumping and restoring file > > locks. > > > > ... > > > > --- a/fs/proc/fd.c > > +++ b/fs/proc/fd.c > > @@ -8,6 +8,7 @@ > > #include > > #include > > #include > > +#include > > > > #include > > > > @@ -48,16 +49,24 @@ static int seq_show(struct seq_file *m, void *v) > > put_files_struct(files); > > } > > > > - if (!ret) { > > - seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\n", > > - (long long)file->f_pos, f_flags, > > - real_mount(file->f_path.mnt)->mnt_id); > > - if (file->f_op->show_fdinfo) > > - file->f_op->show_fdinfo(m, file); > > - ret = seq_has_overflowed(m); > > - fput(file); > > - } > > + if (ret) > > + return ret; > > + > > + seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\n", > > + (long long)file->f_pos, f_flags, > > + real_mount(file->f_path.mnt)->mnt_id); > > + > > + show_fd_locks(m, file, files); > > + ret = seq_has_overflowed(m); > > + if (ret) > > + goto out; > > seq_has_overflowed() returns a boolean, but fs/seq_file.c:traverse() is > looking for a -ve errno from ->show(). > > Documentation/filesystems/seq_file.txt says > > If all is well, the show() function should return zero. A negative error > code in the usual manner indicates that something went wrong; it will be > passed back to user space. This function can also return SEQ_SKIP, which > causes the current item to be skipped; if the show() function has already > generated output before returning SEQ_SKIP, that output will be dropped. You are right. The updated version of this patch is attached. Thank you for the review. > > > > + if (file->f_op->show_fdinfo) > > + file->f_op->show_fdinfo(m, file); > > + ret = seq_has_overflowed(m); > > > > +out: > > + fput(file); > > return ret; > > } > From 29fcabc8a9d9c8bea4a7ec6202a7c0f6e98a518e Mon Sep 17 00:00:00 2001 From: Andrey Vagin Date: Thu, 26 Feb 2015 15:46:02 +0300 Subject: [PATCH] proc: show locks in /proc/pid/fdinfo/X (v2) Let's show locks which are associated with a file descriptor in its fdinfo file. Currently we don't have a reliable way to determine who holds a lock. We can find some information in /proc/locks, but PID which is reported there can be wrong. For example, a process takes a lock, then forks a child and dies. In this case /proc/locks contains the parent pid, which can be reused by another process. $ cat /proc/locks ... 6: FLOCK ADVISORY WRITE 324 00:13:13431 0 EOF ... $ ps -C rpcbind PID TTY TIME CMD 332 ? 00:00:00 rpcbind $ cat /proc/332/fdinfo/4 pos: 0 flags: 0100000 mnt_id: 22 lock: 1: FLOCK ADVISORY WRITE 324 00:13:13431 0 EOF $ ls -l /proc/332/fd/4 lr-x------ 1 root root 64 Mar 5 14:43 /proc/332/fd/4 -> /run/rpcbind.lock $ ls -l /proc/324/fd/ total 0 lrwx------ 1 root root 64 Feb 27 14:50 0 -> /dev/pts/0 lrwx------ 1 root root 64 Feb 27 14:50 1 -> /dev/pts/0 lrwx------ 1 root root 64 Feb 27 14:49 2 -> /dev/pts/0 You can see that the process with the 324 pid doesn't hold the lock. This information is required for proper dumping and restoring file locks. v1: Acked-by: Jeff Layton Acked-by: Cyrill Gorcunov Acked-by: "J. Bruce Fields" v2: use seq_has_overflowed() properly Cc: Jonathan Corbet Cc: Alexander Viro Cc: Andrew Morton Cc: Pavel Emelyanov Signed-off-by: Andrey Vagin --- Documentation/filesystems/proc.txt | 4 ++++ fs/locks.c | 38 ++++++++++++++++++++++++++++++++++++++ fs/proc/fd.c | 27 +++++++++++++++++---------- include/linux/fs.h | 7 +++++++ 4 files changed, 66 insertions(+), 10 deletions(-) diff --git a/Documentation/filesystems/proc.txt b/Documentation/filesystems/proc.txt index a07ba61..6331623 100644 --- a/Documentation/filesystems/proc.txt +++ b/Documentation/filesystems/proc.txt @@ -1704,6 +1704,10 @@ A typical output is flags: 0100002 mnt_id: 19 +All locks associated with a file descriptor are shown in its fdinfo too. + +lock: 1: FLOCK ADVISORY WRITE 359 00:13:11691 0 EOF + The files such as eventfd, fsnotify, signalfd, epoll among the regular pos/flags pair provide additional information particular to the objects they represent. diff --git a/fs/locks.c b/fs/locks.c index f1bad68..89a0540 100644 --- a/fs/locks.c +++ b/fs/locks.c @@ -2593,6 +2593,44 @@ static int locks_show(struct seq_file *f, void *v) return 0; } +static void __show_fd_locks(struct seq_file *f, + struct list_head *head, int *id, + struct file *filp, struct files_struct *files) +{ + struct file_lock *fl; + + list_for_each_entry(fl, head, fl_list) { + + if (filp != fl->fl_file) + continue; + if (fl->fl_owner != files && + fl->fl_owner != filp) + continue; + + (*id)++; + seq_puts(f, "lock:\t"); + lock_get_status(f, fl, *id, ""); + } +} + +void show_fd_locks(struct seq_file *f, + struct file *filp, struct files_struct *files) +{ + struct inode *inode = file_inode(filp); + struct file_lock_context *ctx; + int id = 0; + + ctx = inode->i_flctx; + if (!ctx) + return; + + spin_lock(&ctx->flc_lock); + __show_fd_locks(f, &ctx->flc_flock, &id, filp, files); + __show_fd_locks(f, &ctx->flc_posix, &id, filp, files); + __show_fd_locks(f, &ctx->flc_lease, &id, filp, files); + spin_unlock(&ctx->flc_lock); +} + static void *locks_start(struct seq_file *f, loff_t *pos) __acquires(&blocked_lock_lock) { diff --git a/fs/proc/fd.c b/fs/proc/fd.c index 8e5ad83..af84ad0 100644 --- a/fs/proc/fd.c +++ b/fs/proc/fd.c @@ -8,6 +8,7 @@ #include #include #include +#include #include @@ -48,17 +49,23 @@ static int seq_show(struct seq_file *m, void *v) put_files_struct(files); } - if (!ret) { - seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\n", - (long long)file->f_pos, f_flags, - real_mount(file->f_path.mnt)->mnt_id); - if (file->f_op->show_fdinfo) - file->f_op->show_fdinfo(m, file); - ret = seq_has_overflowed(m); - fput(file); - } + if (ret) + return ret; - return ret; + seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\n", + (long long)file->f_pos, f_flags, + real_mount(file->f_path.mnt)->mnt_id); + + show_fd_locks(m, file, files); + if (seq_has_overflowed(m)) + goto out; + + if (file->f_op->show_fdinfo) + file->f_op->show_fdinfo(m, file); + +out: + fput(file); + return 0; } static int seq_fdinfo_open(struct inode *inode, struct file *file) diff --git a/include/linux/fs.h b/include/linux/fs.h index b4d71b5..ba0bd2a 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -1018,6 +1018,9 @@ extern void lease_get_mtime(struct inode *, struct timespec *time); extern int generic_setlease(struct file *, long, struct file_lock **, void **priv); extern int vfs_setlease(struct file *, long, struct file_lock **, void **); extern int lease_modify(struct file_lock *, int, struct list_head *); +struct files_struct; +extern void show_fd_locks(struct seq_file *f, + struct file *filp, struct files_struct *files); #else /* !CONFIG_FILE_LOCKING */ static inline int fcntl_getlk(struct file *file, unsigned int cmd, struct flock __user *user) @@ -1154,6 +1157,10 @@ static inline int lease_modify(struct file_lock *fl, int arg, { return -EINVAL; } + +struct files_struct; +static inline void show_fd_locks(struct seq_file *f, + struct file *filp, struct files_struct *files) {} #endif /* !CONFIG_FILE_LOCKING */