cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

fdinfo.c (4054B)

      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/exportfs.h>
     15
     16#include "inotify/inotify.h"
     17#include "fanotify/fanotify.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
     25static void show_fdinfo(struct seq_file *m, struct file *f,
     26			void (*show)(struct seq_file *m,
     27				     struct fsnotify_mark *mark))
     28{
     29	struct fsnotify_group *group = f->private_data;
     30	struct fsnotify_mark *mark;
     31
     32	fsnotify_group_lock(group);
     33	list_for_each_entry(mark, &group->marks_list, g_list) {
     34		show(m, mark);
     35		if (seq_has_overflowed(m))
     36			break;
     37	}
     38	fsnotify_group_unlock(group);
     39}
     40
     41#if defined(CONFIG_EXPORTFS)
     42static 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	f.handle.handle_bytes = sizeof(f.pad);
     51	size = f.handle.handle_bytes >> 2;
     52
     53	ret = exportfs_encode_inode_fh(inode, (struct fid *)f.handle.f_handle, &size, NULL);
     54	if ((ret == FILEID_INVALID) || (ret < 0)) {
     55		WARN_ONCE(1, "Can't encode file handler for inotify: %d\n", ret);
     56		return;
     57	}
     58
     59	f.handle.handle_type = ret;
     60	f.handle.handle_bytes = size * sizeof(u32);
     61
     62	seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:",
     63		   f.handle.handle_bytes, f.handle.handle_type);
     64
     65	for (i = 0; i < f.handle.handle_bytes; i++)
     66		seq_printf(m, "%02x", (int)f.handle.f_handle[i]);
     67}
     68#else
     69static void show_mark_fhandle(struct seq_file *m, struct inode *inode)
     70{
     71}
     72#endif
     73
     74#ifdef CONFIG_INOTIFY_USER
     75
     76static 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	if (mark->connector->type != FSNOTIFY_OBJ_TYPE_INODE)
     82		return;
     83
     84	inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
     85	inode = igrab(fsnotify_conn_inode(mark->connector));
     86	if (inode) {
     87		seq_printf(m, "inotify wd:%x ino:%lx sdev:%x mask:%x ignored_mask:0 ",
     88			   inode_mark->wd, inode->i_ino, inode->i_sb->s_dev,
     89			   inotify_mark_user_mask(mark));
     90		show_mark_fhandle(m, inode);
     91		seq_putc(m, '\n');
     92		iput(inode);
     93	}
     94}
     95
     96void inotify_show_fdinfo(struct seq_file *m, struct file *f)
     97{
     98	show_fdinfo(m, f, inotify_fdinfo);
     99}
    100
    101#endif /* CONFIG_INOTIFY_USER */
    102
    103#ifdef CONFIG_FANOTIFY
    104
    105static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
    106{
    107	unsigned int mflags = fanotify_mark_user_flags(mark);
    108	struct inode *inode;
    109
    110	if (mark->connector->type == FSNOTIFY_OBJ_TYPE_INODE) {
    111		inode = igrab(fsnotify_conn_inode(mark->connector));
    112		if (!inode)
    113			return;
    114		seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
    115			   inode->i_ino, inode->i_sb->s_dev,
    116			   mflags, mark->mask, mark->ignored_mask);
    117		show_mark_fhandle(m, inode);
    118		seq_putc(m, '\n');
    119		iput(inode);
    120	} else if (mark->connector->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
    121		struct mount *mnt = fsnotify_conn_mount(mark->connector);
    122
    123		seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n",
    124			   mnt->mnt_id, mflags, mark->mask, mark->ignored_mask);
    125	} else if (mark->connector->type == FSNOTIFY_OBJ_TYPE_SB) {
    126		struct super_block *sb = fsnotify_conn_sb(mark->connector);
    127
    128		seq_printf(m, "fanotify sdev:%x mflags:%x mask:%x ignored_mask:%x\n",
    129			   sb->s_dev, mflags, mark->mask, mark->ignored_mask);
    130	}
    131}
    132
    133void fanotify_show_fdinfo(struct seq_file *m, struct file *f)
    134{
    135	struct fsnotify_group *group = f->private_data;
    136
    137	seq_printf(m, "fanotify flags:%x event-flags:%x\n",
    138		   group->fanotify_data.flags & FANOTIFY_INIT_FLAGS,
    139		   group->fanotify_data.f_flags);
    140
    141	show_fdinfo(m, f, fanotify_fdinfo);
    142}
    143
    144#endif /* CONFIG_FANOTIFY */
    145
    146#endif /* CONFIG_INOTIFY_USER || CONFIG_FANOTIFY */
    147
    148#endif /* CONFIG_PROC_FS */