// SPDX-License-Identifier: GPL-2.0

  #include <linux/sched/signal.h>

  #include <linux/errno.h>
  #include <linux/dcache.h>
  #include <linux/path.h>
  #include <linux/fdtable.h>
  #include <linux/namei.h>
  #include <linux/pid.h>
  #include <linux/security.h>

  #include <linux/file.h>
  #include <linux/seq_file.h>

  #include <linux/fs.h>

  
  #include <linux/proc_fs.h>

  #include "../mount.h"

  #include "internal.h"
  #include "fd.h"

  static int seq_show(struct seq_file *m, void *v)

  {

  	struct files_struct *files = NULL;

  	int f_flags = 0, ret = -ENOENT;
  	struct file *file = NULL;
  	struct task_struct *task;
  
  	task = get_proc_task(m->private);
  	if (!task)
  		return -ENOENT;
  
  	files = get_files_struct(task);
  	put_task_struct(task);

  	if (files) {

  		unsigned int fd = proc_fd(m->private);

  		spin_lock(&files->file_lock);
  		file = fcheck_files(files, fd);
  		if (file) {

  			struct fdtable *fdt = files_fdtable(files);

  			f_flags = file->f_flags;

  			if (close_on_exec(fd, fdt))
  				f_flags |= O_CLOEXEC;

  			get_file(file);
  			ret = 0;

  		}
  		spin_unlock(&files->file_lock);
  		put_files_struct(files);
  	}

  	if (ret)
  		return ret;
  
  	seq_printf(m, "pos:\t%lli
  flags:\t0%o
  mnt_id:\t%i
  ",
  		   (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)
  {
  	return single_open(file, seq_show, inode);
  }
  
  static const struct file_operations proc_fdinfo_file_operations = {
  	.open		= seq_fdinfo_open,
  	.read		= seq_read,
  	.llseek		= seq_lseek,
  	.release	= single_release,
  };

  static bool tid_fd_mode(struct task_struct *task, unsigned fd, fmode_t *mode)
  {
  	struct files_struct *files = get_files_struct(task);
  	struct file *file;
  
  	if (!files)
  		return false;
  
  	rcu_read_lock();
  	file = fcheck_files(files, fd);
  	if (file)
  		*mode = file->f_mode;
  	rcu_read_unlock();
  	put_files_struct(files);
  	return !!file;
  }

  static void tid_fd_update_inode(struct task_struct *task, struct inode *inode,
  				fmode_t f_mode)
  {
  	task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid);
  
  	if (S_ISLNK(inode->i_mode)) {
  		unsigned i_mode = S_IFLNK;
  		if (f_mode & FMODE_READ)
  			i_mode |= S_IRUSR | S_IXUSR;
  		if (f_mode & FMODE_WRITE)
  			i_mode |= S_IWUSR | S_IXUSR;
  		inode->i_mode = i_mode;
  	}
  	security_task_to_inode(task, inode);
  }

  static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
  {

  	struct task_struct *task;

  	struct inode *inode;

  	unsigned int fd;

  
  	if (flags & LOOKUP_RCU)
  		return -ECHILD;

  	inode = d_inode(dentry);

  	task = get_proc_task(inode);
  	fd = proc_fd(inode);
  
  	if (task) {

  		fmode_t f_mode;

  		if (tid_fd_mode(task, fd, &f_mode)) {

  			tid_fd_update_inode(task, inode, f_mode);

  			put_task_struct(task);
  			return 1;

  		}
  		put_task_struct(task);
  	}

  	return 0;
  }
  
  static const struct dentry_operations tid_fd_dentry_operations = {
  	.d_revalidate	= tid_fd_revalidate,
  	.d_delete	= pid_delete_dentry,
  };
  
  static int proc_fd_link(struct dentry *dentry, struct path *path)
  {

  	struct files_struct *files = NULL;
  	struct task_struct *task;
  	int ret = -ENOENT;

  	task = get_proc_task(d_inode(dentry));

  	if (task) {
  		files = get_files_struct(task);
  		put_task_struct(task);
  	}
  
  	if (files) {

  		unsigned int fd = proc_fd(d_inode(dentry));

  		struct file *fd_file;
  
  		spin_lock(&files->file_lock);
  		fd_file = fcheck_files(files, fd);
  		if (fd_file) {
  			*path = fd_file->f_path;
  			path_get(&fd_file->f_path);
  			ret = 0;
  		}
  		spin_unlock(&files->file_lock);
  		put_files_struct(files);
  	}
  
  	return ret;

  }

  struct fd_data {
  	fmode_t mode;
  	unsigned fd;
  };

  static struct dentry *proc_fd_instantiate(struct dentry *dentry,
  	struct task_struct *task, const void *ptr)

  {

  	const struct fd_data *data = ptr;

  	struct proc_inode *ei;
  	struct inode *inode;

  	inode = proc_pid_make_inode(dentry->d_sb, task, S_IFLNK);

  	if (!inode)

  		return ERR_PTR(-ENOENT);

  
  	ei = PROC_I(inode);

  	ei->fd = data->fd;

  	inode->i_op = &proc_pid_link_inode_operations;
  	inode->i_size = 64;
  
  	ei->op.proc_get_link = proc_fd_link;

  	tid_fd_update_inode(task, inode, data->mode);

  
  	d_set_d_op(dentry, &tid_fd_dentry_operations);

  	return d_splice_alias(inode, dentry);

  }
  
  static struct dentry *proc_lookupfd_common(struct inode *dir,
  					   struct dentry *dentry,
  					   instantiate_t instantiate)
  {
  	struct task_struct *task = get_proc_task(dir);

  	struct fd_data data = {.fd = name_to_int(&dentry->d_name)};

  	struct dentry *result = ERR_PTR(-ENOENT);

  
  	if (!task)
  		goto out_no_task;

  	if (data.fd == ~0U)

  		goto out;

  	if (!tid_fd_mode(task, data.fd, &data.mode))

  		goto out;

  	result = instantiate(dentry, task, &data);

  out:
  	put_task_struct(task);
  out_no_task:

  	return result;

  }

  static int proc_readfd_common(struct file *file, struct dir_context *ctx,
  			      instantiate_t instantiate)

  {

  	struct task_struct *p = get_proc_task(file_inode(file));

  	struct files_struct *files;

  	unsigned int fd;

  	if (!p)

  		return -ENOENT;

  	if (!dir_emit_dots(file, ctx))
  		goto out;

  	files = get_files_struct(p);
  	if (!files)
  		goto out;
  
  	rcu_read_lock();
  	for (fd = ctx->pos - 2;
  	     fd < files_fdtable(files)->max_fds;
  	     fd++, ctx->pos++) {

  		struct file *f;
  		struct fd_data data;

  		char name[10 + 1];

  		unsigned int len;

  		f = fcheck_files(files, fd);
  		if (!f)

  			continue;

  		data.mode = f->f_mode;

  		rcu_read_unlock();

  		data.fd = fd;

  		len = snprintf(name, sizeof(name), "%u", fd);

  		if (!proc_fill_cache(file, ctx,
  				     name, len, instantiate, p,

  				     &data))

  			goto out_fd_loop;

  		cond_resched();

  		rcu_read_lock();

  	}

  	rcu_read_unlock();
  out_fd_loop:
  	put_files_struct(files);

  out:
  	put_task_struct(p);

  	return 0;

  }

  static int proc_readfd(struct file *file, struct dir_context *ctx)

  {

  	return proc_readfd_common(file, ctx, proc_fd_instantiate);

  }
  
  const struct file_operations proc_fd_operations = {
  	.read		= generic_read_dir,

  	.iterate_shared	= proc_readfd,
  	.llseek		= generic_file_llseek,

  };
  
  static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
  				    unsigned int flags)
  {
  	return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
  }
  
  /*
   * /proc/pid/fd needs a special permission handler so that a process can still
   * access /proc/self/fd after it has executed a setuid().
   */
  int proc_fd_permission(struct inode *inode, int mask)
  {

  	struct task_struct *p;
  	int rv;
  
  	rv = generic_permission(inode, mask);

  	if (rv == 0)

  		return rv;
  
  	rcu_read_lock();
  	p = pid_task(proc_pid(inode), PIDTYPE_PID);
  	if (p && same_thread_group(p, current))

  		rv = 0;

  	rcu_read_unlock();

  	return rv;
  }
  
  const struct inode_operations proc_fd_inode_operations = {
  	.lookup		= proc_lookupfd,
  	.permission	= proc_fd_permission,
  	.setattr	= proc_setattr,
  };

  static struct dentry *proc_fdinfo_instantiate(struct dentry *dentry,
  	struct task_struct *task, const void *ptr)

  {

  	const struct fd_data *data = ptr;

  	struct proc_inode *ei;
  	struct inode *inode;

  	inode = proc_pid_make_inode(dentry->d_sb, task, S_IFREG | S_IRUSR);

  	if (!inode)

  		return ERR_PTR(-ENOENT);

  
  	ei = PROC_I(inode);

  	ei->fd = data->fd;

  	inode->i_fop = &proc_fdinfo_file_operations;

  	tid_fd_update_inode(task, inode, 0);

  
  	d_set_d_op(dentry, &tid_fd_dentry_operations);

  	return d_splice_alias(inode, dentry);

  }
  
  static struct dentry *
  proc_lookupfdinfo(struct inode *dir, struct dentry *dentry, unsigned int flags)
  {
  	return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
  }

  static int proc_readfdinfo(struct file *file, struct dir_context *ctx)

  {

  	return proc_readfd_common(file, ctx,

  				  proc_fdinfo_instantiate);
  }
  
  const struct inode_operations proc_fdinfo_inode_operations = {
  	.lookup		= proc_lookupfdinfo,
  	.setattr	= proc_setattr,
  };
  
  const struct file_operations proc_fdinfo_operations = {
  	.read		= generic_read_dir,

  	.iterate_shared	= proc_readfdinfo,
  	.llseek		= generic_file_llseek,

  };