/*      $NetBSD: procfs_vfsops.c,v 1.120 2024/09/14 01:37:42 pgoyette Exp $     */

/*
* Copyright (c) 1993
*      The Regents of the University of California.  All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Jan-Simon Pendry.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*      @(#)procfs_vfsops.c     8.7 (Berkeley) 5/10/95
*/

/*
* Copyright (c) 1993 Jan-Simon Pendry
*
* This code is derived from software contributed to Berkeley by
* Jan-Simon Pendry.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed by the University of
*      California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*      @(#)procfs_vfsops.c     8.7 (Berkeley) 5/10/95
*/

/*
* procfs VFS interface
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: procfs_vfsops.c,v 1.120 2024/09/14 01:37:42 pgoyette Exp $");

#if defined(_KERNEL_OPT)
#include "opt_compat_netbsd.h"
#include "opt_sysv_ipc.h"
#include "opt_mqueue.h"
#endif

#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/buf.h>
#include <sys/dirent.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/fstrans.h>
#include <sys/kauth.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/mount.h>
#include <sys/proc.h>
#include <sys/signalvar.h>
#include <sys/sysctl.h>
#include <sys/syslog.h>
#include <sys/systm.h>
#include <sys/time.h>
#include <sys/vnode.h>

#include <miscfs/genfs/genfs.h>

#include <miscfs/procfs/procfs.h>

#include <uvm/uvm_extern.h>                     /* for PAGE_SIZE */

MODULE(MODULE_CLASS_VFS, procfs, "ptrace_common"
#if defined(MQUEUE)
                                ",mqueue"
#endif
#if defined(SYSVSHM) || defined(SYSVSEM) || defined(SYSVMSG)
                                ",sysv_ipc"
#endif
);

VFS_PROTOS(procfs);

#define PROCFS_HASHSIZE 256
#define PROCFS_EXEC_HOOK ((void *)1)
#define PROCFS_EXIT_HOOK ((void *)2)

static kauth_listener_t procfs_listener;
static void *procfs_exechook;
static void *procfs_exithook;
LIST_HEAD(hashhead, pfsnode);
static u_long procfs_hashmask;
static struct hashhead *procfs_hashtab;
static kmutex_t procfs_hashlock;

static struct hashhead *
procfs_hashhead(pid_t pid)
{

       return &procfs_hashtab[pid & procfs_hashmask];
}

void
procfs_hashrem(struct pfsnode *pfs)
{

       mutex_enter(&procfs_hashlock);
       LIST_REMOVE(pfs, pfs_hash);
       mutex_exit(&procfs_hashlock);
}

/*
* VFS Operations.
*
* mount system call
*/
/* ARGSUSED */
int
procfs_mount(
   struct mount *mp,
   const char *path,
   void *data,
   size_t *data_len)
{
       struct lwp *l = curlwp;
       struct procfsmount *pmnt;
       struct procfs_args *args = data;
       int error;

       if (args == NULL)
               return EINVAL;

       if (UIO_MX & (UIO_MX-1)) {
               log(LOG_ERR, "procfs: invalid directory entry size");
               return (EINVAL);
       }

       if (mp->mnt_flag & MNT_GETARGS) {
               if (*data_len < sizeof *args)
                       return EINVAL;

               pmnt = VFSTOPROC(mp);
               if (pmnt == NULL)
                       return EIO;
               args->version = PROCFS_ARGSVERSION;
               args->flags = pmnt->pmnt_flags;
               *data_len = sizeof *args;
               return 0;
       }

       if (mp->mnt_flag & MNT_UPDATE)
               return (EOPNOTSUPP);

       if (*data_len >= sizeof *args && args->version != PROCFS_ARGSVERSION)
               return EINVAL;

       pmnt = kmem_zalloc(sizeof(struct procfsmount), KM_SLEEP);

       mp->mnt_stat.f_namemax = PROCFS_MAXNAMLEN;
       mp->mnt_flag |= MNT_LOCAL;
       mp->mnt_data = pmnt;
       vfs_getnewfsid(mp);

       error = set_statvfs_info(path, UIO_USERSPACE, "procfs", UIO_SYSSPACE,
           mp->mnt_op->vfs_name, mp, l);
       if (*data_len >= sizeof *args)
               pmnt->pmnt_flags = args->flags;
       else
               pmnt->pmnt_flags = 0;

       mp->mnt_iflag |= IMNT_MPSAFE | IMNT_SHRLOOKUP;
       return error;
}

/*
* unmount system call
*/
int
procfs_unmount(struct mount *mp, int mntflags)
{
       int error;
       int flags = 0;

       if (mntflags & MNT_FORCE)
               flags |= FORCECLOSE;

       if ((error = vflush(mp, 0, flags)) != 0)
               return (error);

       kmem_free(mp->mnt_data, sizeof(struct procfsmount));
       mp->mnt_data = NULL;

       return 0;
}

int
procfs_root(struct mount *mp, int lktype, struct vnode **vpp)
{
       int error;

       error = procfs_allocvp(mp, vpp, 0, PFSroot, -1);
       if (error == 0) {
               error = vn_lock(*vpp, lktype);
               if (error != 0) {
                       vrele(*vpp);
                       *vpp = NULL;
               }
       }

       return error;
}

/* ARGSUSED */
int
procfs_start(struct mount *mp, int flags)
{

       return (0);
}

/*
* Get file system statistics.
*/
int
procfs_statvfs(struct mount *mp, struct statvfs *sbp)
{

       genfs_statvfs(mp, sbp);

       sbp->f_bsize = PAGE_SIZE;
       sbp->f_frsize = PAGE_SIZE;
       sbp->f_iosize = PAGE_SIZE;
       sbp->f_blocks = 1;
       sbp->f_files = maxproc;                                 /* approx */
       sbp->f_ffree = maxproc - atomic_load_relaxed(&nprocs);  /* approx */
       sbp->f_favail = maxproc - atomic_load_relaxed(&nprocs); /* approx */

       return (0);
}

/*ARGSUSED*/
int
procfs_sync(
   struct mount *mp,
   int waitfor,
   kauth_cred_t uc)
{

       return (0);
}

/*ARGSUSED*/
int
procfs_vget(struct mount *mp, ino_t ino, int lktype,
   struct vnode **vpp)
{
       return (EOPNOTSUPP);
}

int
procfs_loadvnode(struct mount *mp, struct vnode *vp,
   const void *key, size_t key_len, const void **new_key)
{
       int error;
       struct pfskey pfskey;
       struct pfsnode *pfs;

       KASSERT(key_len == sizeof(pfskey));
       memcpy(&pfskey, key, key_len);

       pfs = kmem_alloc(sizeof(*pfs), KM_SLEEP);
       pfs->pfs_pid = pfskey.pk_pid;
       pfs->pfs_type = pfskey.pk_type;
       pfs->pfs_fd = pfskey.pk_fd;
       pfs->pfs_vnode = vp;
       pfs->pfs_mount = mp;
       pfs->pfs_flags = 0;
       pfs->pfs_fileno =
           PROCFS_FILENO(pfs->pfs_pid, pfs->pfs_type, pfs->pfs_fd);
       vp->v_tag = VT_PROCFS;
       vp->v_op = procfs_vnodeop_p;
       vp->v_data = pfs;

       switch (pfs->pfs_type) {
       case PFSroot:   /* /proc = dr-xr-xr-x */
               vp->v_vflag |= VV_ROOT;
               /*FALLTHROUGH*/
       case PFSproc:   /* /proc/N = dr-xr-xr-x */
               pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
               vp->v_type = VDIR;
               break;

       case PFStask:   /* /proc/N/task = dr-xr-xr-x */
               if (pfs->pfs_fd == -1) {
                       pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|
                           S_IROTH|S_IXOTH;
                       vp->v_type = VDIR;
                       break;
               }
               /*FALLTHROUGH*/
       case PFScurproc:        /* /proc/curproc = lr-xr-xr-x */
       case PFSself:   /* /proc/self    = lr-xr-xr-x */
       case PFScwd:    /* /proc/N/cwd = lr-xr-xr-x */
       case PFSchroot: /* /proc/N/chroot = lr-xr-xr-x */
       case PFSexe:    /* /proc/N/exe = lr-xr-xr-x */
               pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
               vp->v_type = VLNK;
               break;

       case PFSfd:
               if (pfs->pfs_fd == -1) {        /* /proc/N/fd = dr-x------ */
                       pfs->pfs_mode = S_IRUSR|S_IXUSR;
                       vp->v_type = VDIR;
               } else {        /* /proc/N/fd/M = [ps-]rw------- */
                       file_t *fp;
                       vnode_t *vxp;
                       struct proc *p;

                       mutex_enter(&proc_lock);
                       p = procfs_proc_find(mp, pfs->pfs_pid);
                       mutex_exit(&proc_lock);
                       if (p == NULL) {
                               error = ENOENT;
                               goto bad;
                       }
                       KASSERT(rw_read_held(&p->p_reflock));
                       if ((fp = fd_getfile2(p, pfs->pfs_fd)) == NULL) {
                               error = EBADF;
                               goto bad;
                       }

                       pfs->pfs_mode = S_IRUSR|S_IWUSR;
                       switch (fp->f_type) {
                       case DTYPE_VNODE:
                               vxp = fp->f_vnode;

                               /*
                                * We make symlinks for directories
                                * to avoid cycles.
                                */
                               if (vxp->v_type == VDIR ||
                                   procfs_proc_is_linux_compat())
                                       goto symlink;
                               vp->v_type = vxp->v_type;
                               break;
                       case DTYPE_PIPE:
                               vp->v_type = VFIFO;
                               break;
                       case DTYPE_SOCKET:
                               vp->v_type = VSOCK;
                               break;
                       case DTYPE_KQUEUE:
                       case DTYPE_MISC:
                       case DTYPE_SEM:
                       symlink:
                               pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|
                                   S_IXGRP|S_IROTH|S_IXOTH;
                               vp->v_type = VLNK;
                               break;
                       default:
                               error = EOPNOTSUPP;
                               closef(fp);
                               goto bad;
                       }
                       closef(fp);
               }
               break;

       case PFSfile:   /* /proc/N/file = -rw------- */
       case PFSmem:    /* /proc/N/mem = -rw------- */
       case PFSregs:   /* /proc/N/regs = -rw------- */
       case PFSfpregs: /* /proc/N/fpregs = -rw------- */
               pfs->pfs_mode = S_IRUSR|S_IWUSR;
               vp->v_type = VREG;
               break;

       case PFSnote:   /* /proc/N/note = --w------ */
       case PFSnotepg: /* /proc/N/notepg = --w------ */
               pfs->pfs_mode = S_IWUSR;
               vp->v_type = VREG;
               break;

       case PFSmap:            /* /proc/N/map = -r-------- */
       case PFSmaps:           /* /proc/N/maps = -r-------- */
       case PFSauxv:           /* /proc/N/auxv = -r-------- */
       case PFSenviron:        /* /proc/N/environ = -r-------- */
               pfs->pfs_mode = S_IRUSR;
               vp->v_type = VREG;
               break;

       case PFSstatus:         /* /proc/N/status = -r--r--r-- */
       case PFSstat:           /* /proc/N/stat = -r--r--r-- */
       case PFScmdline:        /* /proc/N/cmdline = -r--r--r-- */
       case PFSemul:           /* /proc/N/emul = -r--r--r-- */
       case PFSmeminfo:        /* /proc/meminfo = -r--r--r-- */
       case PFScpustat:        /* /proc/stat = -r--r--r-- */
       case PFSdevices:        /* /proc/devices = -r--r--r-- */
       case PFScpuinfo:        /* /proc/cpuinfo = -r--r--r-- */
       case PFSuptime:         /* /proc/uptime = -r--r--r-- */
       case PFSmounts:         /* /proc/mounts = -r--r--r-- */
       case PFSloadavg:        /* /proc/loadavg = -r--r--r-- */
       case PFSstatm:          /* /proc/N/statm = -r--r--r-- */
       case PFSversion:        /* /proc/version = -r--r--r-- */
       case PFSlimit:          /* /proc/N/limit = -r--r--r-- */
       case PFSlimits:         /* /proc/N/limits = -r--r--r-- */
               pfs->pfs_mode = S_IRUSR|S_IRGRP|S_IROTH;
               vp->v_type = VREG;
               break;

       case PFSsys:    /* /proc/sys = dr-xr-xr-x */
       case PFSsysfs:  /* /proc/sys/fs = dr-xr-xr-x */
       case PFSmqueue: /* /proc/sys/fs/mqueue = dr-xr-xr-x */
       case PFSsysvipc:/* /proc/sysvipc = dr-xr-xr-x */
               if (pfs->pfs_fd == -1) {
                       pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|
                           S_IROTH|S_IXOTH;
                       vp->v_type = VDIR;
                       break;
               }
               /*FALLTHROUGH*/
       case PFSmq_msg_def:     /* /proc/sys/fs/mqueue/msg_default = -r--r--r-- */
       case PFSmq_msg_max:     /* /proc/sys/fs/mqueue/msg_max = -r--r--r-- */
       case PFSmq_siz_def:     /* /proc/sys/fs/mqueue/msgsize_default = -r--r--r-- */
       case PFSmq_siz_max:     /* /proc/sys/fs/mqueue/msgsize_max = -r--r--r-- */
       case PFSmq_qmax:        /* /proc/sys/fs/mqueue/queues_max = -r--r--r-- */
       case PFSsysvipc_msg:    /* /proc/sysvipc/msg = -r--r--r-- */
       case PFSsysvipc_sem:    /* /proc/sysvipc/sem = -r--r--r-- */
       case PFSsysvipc_shm:    /* /proc/sysvipc/shm = -r--r--r-- */
               pfs->pfs_mode = S_IRUSR|S_IRGRP|S_IROTH;
               vp->v_type = VREG;
               break;

#ifdef __HAVE_PROCFS_MACHDEP
       PROCFS_MACHDEP_NODETYPE_CASES
               procfs_machdep_allocvp(vp);
               break;
#endif

       default:
               panic("procfs_allocvp");
       }

       mutex_enter(&procfs_hashlock);
       LIST_INSERT_HEAD(procfs_hashhead(pfs->pfs_pid), pfs, pfs_hash);
       mutex_exit(&procfs_hashlock);

       uvm_vnp_setsize(vp, 0);
       *new_key = &pfs->pfs_key;

       return 0;

bad:
       vp->v_tag =VT_NON;
       vp->v_type = VNON;
       vp->v_op = NULL;
       vp->v_data = NULL;
       kmem_free(pfs, sizeof(*pfs));
       return error;
}

void
procfs_init(void)
{

}

void
procfs_reinit(void)
{

}

void
procfs_done(void)
{

}

extern const struct vnodeopv_desc procfs_vnodeop_opv_desc;

const struct vnodeopv_desc * const procfs_vnodeopv_descs[] = {
       &procfs_vnodeop_opv_desc,
       NULL,
};

struct vfsops procfs_vfsops = {
       .vfs_name = MOUNT_PROCFS,
       .vfs_min_mount_data = sizeof (struct procfs_args),
       .vfs_mount = procfs_mount,
       .vfs_start = procfs_start,
       .vfs_unmount = procfs_unmount,
       .vfs_root = procfs_root,
       .vfs_quotactl = (void *)eopnotsupp,
       .vfs_statvfs = procfs_statvfs,
       .vfs_sync = procfs_sync,
       .vfs_vget = procfs_vget,
       .vfs_loadvnode = procfs_loadvnode,
       .vfs_fhtovp = (void *)eopnotsupp,
       .vfs_vptofh = (void *)eopnotsupp,
       .vfs_init = procfs_init,
       .vfs_reinit = procfs_reinit,
       .vfs_done = procfs_done,
       .vfs_snapshot = (void *)eopnotsupp,
       .vfs_extattrctl = vfs_stdextattrctl,
       .vfs_suspendctl = genfs_suspendctl,
       .vfs_renamelock_enter = genfs_renamelock_enter,
       .vfs_renamelock_exit = genfs_renamelock_exit,
       .vfs_fsync = (void *)eopnotsupp,
       .vfs_opv_descs = procfs_vnodeopv_descs
};

static void
procfs_exechook_cb(struct proc *p, void *arg)
{
       struct hashhead *head;
       struct pfsnode *pfs;
       struct mount *mp;
       struct pfskey key;
       struct vnode *vp;
       int error;

       if (arg == PROCFS_EXEC_HOOK && !(p->p_flag & PK_SUGID))
               return;

       head = procfs_hashhead(p->p_pid);

again:
       mutex_enter(&procfs_hashlock);
       LIST_FOREACH(pfs, head, pfs_hash) {
               if (pfs->pfs_pid != p->p_pid)
                       continue;
               mp = pfs->pfs_mount;
               key = pfs->pfs_key;
               vfs_ref(mp);
               mutex_exit(&procfs_hashlock);

               error = vcache_get(mp, &key, sizeof(key), &vp);
               vfs_rele(mp);
               if (error != 0)
                       goto again;
               if (vrecycle(vp))
                       goto again;
               do {
                       error = vfs_suspend(mp, 0);
               } while (error == EINTR || error == ERESTART);
               vgone(vp);
               if (error == 0)
                       vfs_resume(mp);
               goto again;
       }
       mutex_exit(&procfs_hashlock);
}

static int
procfs_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
   void *arg0, void *arg1, void *arg2, void *arg3)
{
       struct proc *p;
       struct pfsnode *pfs;
       int result;

       result = KAUTH_RESULT_DEFER;
       p = arg0;
       pfs = arg1;

       if (action != KAUTH_PROCESS_PROCFS)
               return result;

       switch (pfs->pfs_type) {
       case PFSregs:
       case PFSfpregs:
       case PFSmem:
               if (kauth_cred_getuid(cred) != kauth_cred_getuid(p->p_cred) ||
                   ISSET(p->p_flag, PK_SUGID))
                       break;

               /*FALLTHROUGH*/
       default:
               result = KAUTH_RESULT_ALLOW;
               break;
       }

       return result;
}

SYSCTL_SETUP(procfs_sysctl_setup, "procfs sysctl")
{

       sysctl_createv(clog, 0, NULL, NULL,
                      CTLFLAG_PERMANENT,
                      CTLTYPE_NODE, "procfs",
                      SYSCTL_DESCR("Process file system"),
                      NULL, 0, NULL, 0,
                      CTL_VFS, 12, CTL_EOL);
       /*
        * XXX the "12" above could be dynamic, thereby eliminating
        * one more instance of the "number to vfs" mapping problem,
        * but "12" is the order as taken from sys/mount.h
        */
}

static int
procfs_modcmd(modcmd_t cmd, void *arg)
{
       int error;

       switch (cmd) {
       case MODULE_CMD_INIT:
               error = vfs_attach(&procfs_vfsops);
               if (error != 0)
                       break;

               procfs_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS,
                   procfs_listener_cb, NULL);

               procfs_exechook = exechook_establish(procfs_exechook_cb,
                   PROCFS_EXEC_HOOK);
               procfs_exithook = exithook_establish(procfs_exechook_cb,
                   PROCFS_EXIT_HOOK);

               mutex_init(&procfs_hashlock, MUTEX_DEFAULT, IPL_NONE);
               procfs_hashtab = hashinit(PROCFS_HASHSIZE, HASH_LIST, true,
                   &procfs_hashmask);

               break;
       case MODULE_CMD_FINI:
               error = vfs_detach(&procfs_vfsops);
               if (error != 0)
                       break;
               kauth_unlisten_scope(procfs_listener);
               exechook_disestablish(procfs_exechook);
               exithook_disestablish(procfs_exithook);
               mutex_destroy(&procfs_hashlock);
               hashdone(procfs_hashtab, HASH_LIST, procfs_hashmask);
               break;
       default:
               error = ENOTTY;
               break;
       }

       return (error);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.