// 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 int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
  {
  	struct files_struct *files;
  	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) {
  		files = get_files_struct(task);
  		if (files) {
  			struct file *file;
  
  			rcu_read_lock();
  			file = fcheck_files(files, fd);
  			if (file) {
  				unsigned f_mode = file->f_mode;
  
  				rcu_read_unlock();
  				put_files_struct(files);

  				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);
  				put_task_struct(task);
  				return 1;
  			}
  			rcu_read_unlock();
  			put_files_struct(files);
  		}
  		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;

  }

  static int

  proc_fd_instantiate(struct inode *dir, struct dentry *dentry,
  		    struct task_struct *task, const void *ptr)
  {

  	unsigned fd = (unsigned long)ptr;
  	struct proc_inode *ei;
  	struct inode *inode;

  	inode = proc_pid_make_inode(dir->i_sb, task, S_IFLNK);

  	if (!inode)
  		goto out;
  
  	ei = PROC_I(inode);
  	ei->fd = fd;

  	inode->i_op = &proc_pid_link_inode_operations;
  	inode->i_size = 64;
  
  	ei->op.proc_get_link = proc_fd_link;
  
  	d_set_d_op(dentry, &tid_fd_dentry_operations);
  	d_add(dentry, inode);
  
  	/* Close the race of the process dying before we return the dentry */
  	if (tid_fd_revalidate(dentry, 0))

  		return 0;

   out:

  	return -ENOENT;

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

  	int result = -ENOENT;

  	unsigned fd = name_to_int(&dentry->d_name);

  
  	if (!task)
  		goto out_no_task;
  	if (fd == ~0U)
  		goto out;
  
  	result = instantiate(dir, dentry, task, (void *)(unsigned long)fd);
  out:
  	put_task_struct(task);
  out_no_task:

  	return ERR_PTR(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++) {
  		char name[PROC_NUMBUF];
  		int len;
  
  		if (!fcheck_files(files, fd))
  			continue;
  		rcu_read_unlock();

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

  		if (!proc_fill_cache(file, ctx,
  				     name, len, instantiate, p,
  				     (void *)(unsigned long)fd))
  			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 int

  proc_fdinfo_instantiate(struct inode *dir, struct dentry *dentry,
  			struct task_struct *task, const void *ptr)
  {

  	unsigned fd = (unsigned long)ptr;
  	struct proc_inode *ei;
  	struct inode *inode;

  	inode = proc_pid_make_inode(dir->i_sb, task, S_IFREG | S_IRUSR);

  	if (!inode)
  		goto out;
  
  	ei = PROC_I(inode);
  	ei->fd = fd;

  	inode->i_fop = &proc_fdinfo_file_operations;
  
  	d_set_d_op(dentry, &tid_fd_dentry_operations);
  	d_add(dentry, inode);
  
  	/* Close the race of the process dying before we return the dentry */
  	if (tid_fd_revalidate(dentry, 0))

  		return 0;

   out:

  	return -ENOENT;

  }
  
  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,

  };