Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : #include <linux/file.h>
       3                 :            : #include <linux/fs.h>
       4                 :            : #include <linux/fsnotify_backend.h>
       5                 :            : #include <linux/idr.h>
       6                 :            : #include <linux/init.h>
       7                 :            : #include <linux/inotify.h>
       8                 :            : #include <linux/fanotify.h>
       9                 :            : #include <linux/kernel.h>
      10                 :            : #include <linux/namei.h>
      11                 :            : #include <linux/sched.h>
      12                 :            : #include <linux/types.h>
      13                 :            : #include <linux/seq_file.h>
      14                 :            : #include <linux/proc_fs.h>
      15                 :            : #include <linux/exportfs.h>
      16                 :            : 
      17                 :            : #include "inotify/inotify.h"
      18                 :            : #include "fdinfo.h"
      19                 :            : #include "fsnotify.h"
      20                 :            : 
      21                 :            : #if defined(CONFIG_PROC_FS)
      22                 :            : 
      23                 :            : #if defined(CONFIG_INOTIFY_USER) || defined(CONFIG_FANOTIFY)
      24                 :            : 
      25                 :          0 : static void show_fdinfo(struct seq_file *m, struct file *f,
      26                 :            :                         void (*show)(struct seq_file *m,
      27                 :            :                                      struct fsnotify_mark *mark))
      28                 :            : {
      29                 :          0 :         struct fsnotify_group *group = f->private_data;
      30                 :            :         struct fsnotify_mark *mark;
      31                 :            : 
      32                 :          0 :         mutex_lock(&group->mark_mutex);
      33                 :          0 :         list_for_each_entry(mark, &group->marks_list, g_list) {
      34                 :          0 :                 show(m, mark);
      35                 :          0 :                 if (seq_has_overflowed(m))
      36                 :            :                         break;
      37                 :            :         }
      38                 :          0 :         mutex_unlock(&group->mark_mutex);
      39                 :          0 : }
      40                 :            : 
      41                 :            : #if defined(CONFIG_EXPORTFS)
      42                 :          0 : static void show_mark_fhandle(struct seq_file *m, struct inode *inode)
      43                 :            : {
      44                 :            :         struct {
      45                 :            :                 struct file_handle handle;
      46                 :            :                 u8 pad[MAX_HANDLE_SZ];
      47                 :            :         } f;
      48                 :            :         int size, ret, i;
      49                 :            : 
      50                 :          0 :         f.handle.handle_bytes = sizeof(f.pad);
      51                 :          0 :         size = f.handle.handle_bytes >> 2;
      52                 :            : 
      53                 :          0 :         ret = exportfs_encode_inode_fh(inode, (struct fid *)f.handle.f_handle, &size, 0);
      54                 :          0 :         if ((ret == FILEID_INVALID) || (ret < 0)) {
      55                 :          0 :                 WARN_ONCE(1, "Can't encode file handler for inotify: %d\n", ret);
      56                 :          0 :                 return;
      57                 :            :         }
      58                 :            : 
      59                 :          0 :         f.handle.handle_type = ret;
      60                 :          0 :         f.handle.handle_bytes = size * sizeof(u32);
      61                 :            : 
      62                 :          0 :         seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:",
      63                 :            :                    f.handle.handle_bytes, f.handle.handle_type);
      64                 :            : 
      65                 :          0 :         for (i = 0; i < f.handle.handle_bytes; i++)
      66                 :          0 :                 seq_printf(m, "%02x", (int)f.handle.f_handle[i]);
      67                 :            : }
      68                 :            : #else
      69                 :            : static void show_mark_fhandle(struct seq_file *m, struct inode *inode)
      70                 :            : {
      71                 :            : }
      72                 :            : #endif
      73                 :            : 
      74                 :            : #ifdef CONFIG_INOTIFY_USER
      75                 :            : 
      76                 :          0 : static void inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
      77                 :            : {
      78                 :            :         struct inotify_inode_mark *inode_mark;
      79                 :            :         struct inode *inode;
      80                 :            : 
      81                 :          0 :         if (mark->connector->type != FSNOTIFY_OBJ_TYPE_INODE)
      82                 :          0 :                 return;
      83                 :            : 
      84                 :            :         inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
      85                 :          0 :         inode = igrab(fsnotify_conn_inode(mark->connector));
      86                 :          0 :         if (inode) {
      87                 :            :                 /*
      88                 :            :                  * IN_ALL_EVENTS represents all of the mask bits
      89                 :            :                  * that we expose to userspace.  There is at
      90                 :            :                  * least one bit (FS_EVENT_ON_CHILD) which is
      91                 :            :                  * used only internally to the kernel.
      92                 :            :                  */
      93                 :          0 :                 u32 mask = mark->mask & IN_ALL_EVENTS;
      94                 :          0 :                 seq_printf(m, "inotify wd:%x ino:%lx sdev:%x mask:%x ignored_mask:%x ",
      95                 :          0 :                            inode_mark->wd, inode->i_ino, inode->i_sb->s_dev,
      96                 :            :                            mask, mark->ignored_mask);
      97                 :          0 :                 show_mark_fhandle(m, inode);
      98                 :          0 :                 seq_putc(m, '\n');
      99                 :          0 :                 iput(inode);
     100                 :            :         }
     101                 :            : }
     102                 :            : 
     103                 :          0 : void inotify_show_fdinfo(struct seq_file *m, struct file *f)
     104                 :            : {
     105                 :          0 :         show_fdinfo(m, f, inotify_fdinfo);
     106                 :          0 : }
     107                 :            : 
     108                 :            : #endif /* CONFIG_INOTIFY_USER */
     109                 :            : 
     110                 :            : #ifdef CONFIG_FANOTIFY
     111                 :            : 
     112                 :          0 : static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
     113                 :            : {
     114                 :            :         unsigned int mflags = 0;
     115                 :            :         struct inode *inode;
     116                 :            : 
     117                 :          0 :         if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
     118                 :            :                 mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
     119                 :            : 
     120                 :          0 :         if (mark->connector->type == FSNOTIFY_OBJ_TYPE_INODE) {
     121                 :          0 :                 inode = igrab(fsnotify_conn_inode(mark->connector));
     122                 :          0 :                 if (!inode)
     123                 :          0 :                         return;
     124                 :          0 :                 seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
     125                 :          0 :                            inode->i_ino, inode->i_sb->s_dev,
     126                 :            :                            mflags, mark->mask, mark->ignored_mask);
     127                 :          0 :                 show_mark_fhandle(m, inode);
     128                 :          0 :                 seq_putc(m, '\n');
     129                 :          0 :                 iput(inode);
     130                 :          0 :         } else if (mark->connector->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
     131                 :            :                 struct mount *mnt = fsnotify_conn_mount(mark->connector);
     132                 :            : 
     133                 :          0 :                 seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n",
     134                 :            :                            mnt->mnt_id, mflags, mark->mask, mark->ignored_mask);
     135                 :          0 :         } else if (mark->connector->type == FSNOTIFY_OBJ_TYPE_SB) {
     136                 :            :                 struct super_block *sb = fsnotify_conn_sb(mark->connector);
     137                 :            : 
     138                 :          0 :                 seq_printf(m, "fanotify sdev:%x mflags:%x mask:%x ignored_mask:%x\n",
     139                 :            :                            sb->s_dev, mflags, mark->mask, mark->ignored_mask);
     140                 :            :         }
     141                 :            : }
     142                 :            : 
     143                 :          0 : void fanotify_show_fdinfo(struct seq_file *m, struct file *f)
     144                 :            : {
     145                 :          0 :         struct fsnotify_group *group = f->private_data;
     146                 :            : 
     147                 :          0 :         seq_printf(m, "fanotify flags:%x event-flags:%x\n",
     148                 :            :                    group->fanotify_data.flags, group->fanotify_data.f_flags);
     149                 :            : 
     150                 :          0 :         show_fdinfo(m, f, fanotify_fdinfo);
     151                 :          0 : }
     152                 :            : 
     153                 :            : #endif /* CONFIG_FANOTIFY */
     154                 :            : 
     155                 :            : #endif /* CONFIG_INOTIFY_USER || CONFIG_FANOTIFY */
     156                 :            : 
     157                 :            : #endif /* CONFIG_PROC_FS */