gfs2: Add glockfd debugfs file

When a process has a gfs2 file open, the file is keeping a reference on the
underlying gfs2 inode, and the inode is keeping the inode's iopen glock held in
shared mode.  In other words, the process depends on the iopen glock of each
open gfs2 file.  Expose those dependencies in a new "glockfd" debugfs file.

The new debugfs file contains one line for each gfs2 file descriptor,
specifying the tgid, file descriptor number, and glock name, e.g.,

  1601 6 5/816d

This list is compiled by iterating all tasks on the system using find_ge_pid(),
and all file descriptors of each task using task_lookup_next_fd_rcu().  To make
that work from gfs2, export those two functions.

Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>

diff --git a/fs/file.c b/fs/file.c
index 3bcc1ecc314a78e90daedecf6a7ec575c642504a..5f9c802a5d8d34454f2382196ef9d81b43e76bd9 100644 (file)
--- a/fs/file.c
+++ b/fs/file.c
@@ -980,6 +980,7 @@ struct file *task_lookup_next_fd_rcu(struct task_struct *task, unsigned int *ret
        *ret_fd = fd;
        return file;
 }
+EXPORT_SYMBOL(task_lookup_next_fd_rcu);
 
 /*
  * Lightweight file lookup - no refcnt increment if fd table isn't shared.

diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index c992d53013d31dc7a8d679d266338b58bc3bf2dc..85352126e662cdf31c904ad0ab64455557d2c16a 100644 (file)
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -33,6 +33,9 @@
 #include <linux/list_sort.h>
 #include <linux/lockref.h>
 #include <linux/rhashtable.h>
+#include <linux/pid_namespace.h>
+#include <linux/fdtable.h>
+#include <linux/file.h>
 
 #include "gfs2.h"
 #include "incore.h"
@@ -2745,6 +2748,149 @@ static const struct file_operations gfs2_glstats_fops = {
        .release = gfs2_glocks_release,
 };
 
+struct gfs2_glockfd_iter {
+       struct super_block *sb;
+       unsigned int tgid;
+       struct task_struct *task;
+       unsigned int fd;
+       struct file *file;
+};
+
+static struct task_struct *gfs2_glockfd_next_task(struct gfs2_glockfd_iter *i)
+{
+       struct pid_namespace *ns = task_active_pid_ns(current);
+       struct pid *pid;
+
+       if (i->task)
+               put_task_struct(i->task);
+
+       rcu_read_lock();
+retry:
+       i->task = NULL;
+       pid = find_ge_pid(i->tgid, ns);
+       if (pid) {
+               i->tgid = pid_nr_ns(pid, ns);
+               i->task = pid_task(pid, PIDTYPE_TGID);
+               if (!i->task) {
+                       i->tgid++;
+                       goto retry;
+               }
+               get_task_struct(i->task);
+       }
+       rcu_read_unlock();
+       return i->task;
+}
+
+static struct file *gfs2_glockfd_next_file(struct gfs2_glockfd_iter *i)
+{
+       if (i->file) {
+               fput(i->file);
+               i->file = NULL;
+       }
+
+       rcu_read_lock();
+       for(;; i->fd++) {
+               struct inode *inode;
+
+               i->file = task_lookup_next_fd_rcu(i->task, &i->fd);
+               if (!i->file) {
+                       i->fd = 0;
+                       break;
+               }
+               inode = file_inode(i->file);
+               if (inode->i_sb != i->sb)
+                       continue;
+               if (get_file_rcu(i->file))
+                       break;
+       }
+       rcu_read_unlock();
+       return i->file;
+}
+
+static void *gfs2_glockfd_seq_start(struct seq_file *seq, loff_t *pos)
+{
+       struct gfs2_glockfd_iter *i = seq->private;
+
+       if (*pos)
+               return NULL;
+       while (gfs2_glockfd_next_task(i)) {
+               if (gfs2_glockfd_next_file(i))
+                       return i;
+               i->tgid++;
+       }
+       return NULL;
+}
+
+static void *gfs2_glockfd_seq_next(struct seq_file *seq, void *iter_ptr,
+                                  loff_t *pos)
+{
+       struct gfs2_glockfd_iter *i = seq->private;
+
+       (*pos)++;
+       i->fd++;
+       do {
+               if (gfs2_glockfd_next_file(i))
+                       return i;
+               i->tgid++;
+       } while (gfs2_glockfd_next_task(i));
+       return NULL;
+}
+
+static void gfs2_glockfd_seq_stop(struct seq_file *seq, void *iter_ptr)
+{
+       struct gfs2_glockfd_iter *i = seq->private;
+
+       if (i->file)
+               fput(i->file);
+       if (i->task)
+               put_task_struct(i->task);
+}
+
+static int gfs2_glockfd_seq_show(struct seq_file *seq, void *iter_ptr)
+{
+       struct gfs2_glockfd_iter *i = seq->private;
+       struct inode *inode = file_inode(i->file);
+       struct gfs2_glock *gl;
+
+       inode_lock_shared(inode);
+       gl = GFS2_I(inode)->i_iopen_gh.gh_gl;
+       if (gl) {
+               seq_printf(seq, "%d %u %u/%llx\n",
+                          i->tgid, i->fd, gl->gl_name.ln_type,
+                          (unsigned long long)gl->gl_name.ln_number);
+       }
+       inode_unlock_shared(inode);
+       return 0;
+}
+
+static const struct seq_operations gfs2_glockfd_seq_ops = {
+       .start = gfs2_glockfd_seq_start,
+       .next  = gfs2_glockfd_seq_next,
+       .stop  = gfs2_glockfd_seq_stop,
+       .show  = gfs2_glockfd_seq_show,
+};
+
+static int gfs2_glockfd_open(struct inode *inode, struct file *file)
+{
+       struct gfs2_glockfd_iter *i;
+       struct gfs2_sbd *sdp = inode->i_private;
+
+       i = __seq_open_private(file, &gfs2_glockfd_seq_ops,
+                              sizeof(struct gfs2_glockfd_iter));
+       if (!i)
+               return -ENOMEM;
+       i->sb = sdp->sd_vfs;
+       return 0;
+}
+
+static const struct file_operations gfs2_glockfd_fops = {
+       .owner   = THIS_MODULE,
+       .open    = gfs2_glockfd_open,
+       .read    = seq_read,
+       .llseek  = seq_lseek,
+       .release = seq_release_private,
+};
+
 DEFINE_SEQ_ATTRIBUTE(gfs2_sbstats);
 
 void gfs2_create_debugfs_file(struct gfs2_sbd *sdp)
@@ -2754,6 +2900,9 @@ void gfs2_create_debugfs_file(struct gfs2_sbd *sdp)
        debugfs_create_file("glocks", S_IFREG | S_IRUGO, sdp->debugfs_dir, sdp,
                            &gfs2_glocks_fops);
 
+       debugfs_create_file("glockfd", S_IFREG | S_IRUGO, sdp->debugfs_dir, sdp,
+                           &gfs2_glockfd_fops);
+
        debugfs_create_file("glstats", S_IFREG | S_IRUGO, sdp->debugfs_dir, sdp,
                            &gfs2_glstats_fops);
 

diff --git a/kernel/pid.c b/kernel/pid.c
index 2fc0a16ec77b1d9b6efe3b6e098f7f23921abe17..3fbc5e46b72173cf216850ea85afc24ace98fd3c 100644 (file)
--- a/kernel/pid.c
+++ b/kernel/pid.c
@@ -519,6 +519,7 @@ struct pid *find_ge_pid(int nr, struct pid_namespace *ns)
 {
        return idr_get_next(&ns->idr, &nr);
 }
+EXPORT_SYMBOL_GPL(find_ge_pid);
 
 struct pid *pidfd_get_pid(unsigned int fd, unsigned int *flags)
 {