/*      $NetBSD: kernfs_vnops.c,v 1.174 2022/03/27 17:10:56 christos Exp $      */

/*
* Copyright (c) 1992, 1993
*      The Regents of the University of California.  All rights reserved.
*
* This code is derived from software donated 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.
*
*      @(#)kernfs_vnops.c      8.15 (Berkeley) 5/21/95
*/

/*
* Kernel parameter filesystem (/kern)
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: kernfs_vnops.c,v 1.174 2022/03/27 17:10:56 christos Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/vmmeter.h>
#include <sys/time.h>
#include <sys/proc.h>
#include <sys/vnode.h>
#include <sys/malloc.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/buf.h>
#include <sys/dirent.h>
#include <sys/msgbuf.h>

#include <miscfs/genfs/genfs.h>
#include <miscfs/kernfs/kernfs.h>
#include <miscfs/specfs/specdev.h>

#include <uvm/uvm_extern.h>

#define KSTRING 256             /* Largest I/O available via this filesystem */
#define UIO_MX 32

#define READ_MODE       (S_IRUSR|S_IRGRP|S_IROTH)
#define WRITE_MODE      (S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH)
#define UREAD_MODE      (S_IRUSR)
#define DIR_MODE        (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
#define UDIR_MODE       (S_IRUSR|S_IXUSR)

#define N(s) sizeof(s)-1, s
const struct kern_target kern_targets[] = {
/* NOTE: The name must be less than UIO_MX-16 chars in length */
    /*        name            data          tag           type  ro/rw */
    { DT_DIR, N("."),         0,            KFSkern,        VDIR, DIR_MODE   },
    { DT_DIR, N(".."),        0,            KFSroot,        VDIR, DIR_MODE   },
    { DT_REG, N("boottime"),  0,            KFSboottime,    VREG, READ_MODE  },
                       /* XXXUNCONST */
    { DT_REG, N("copyright"), __UNCONST(copyright),
                                            KFSstring,      VREG, READ_MODE  },
    { DT_REG, N("hostname"),  0,            KFShostname,    VREG, WRITE_MODE },
    { DT_REG, N("hz"),        &hz,          KFSint,         VREG, READ_MODE  },
    { DT_REG, N("loadavg"),   0,            KFSavenrun,     VREG, READ_MODE  },
    { DT_REG, N("msgbuf"),    0,            KFSmsgbuf,      VREG, READ_MODE  },
    { DT_REG, N("pagesize"),  &uvmexp.pagesize, KFSint,     VREG, READ_MODE  },
    { DT_REG, N("physmem"),   &physmem,     KFSint,         VREG, READ_MODE  },
#if 0
    { DT_DIR, N("root"),      0,            KFSnull,        VDIR, DIR_MODE   },
#endif
    { DT_BLK, N("rootdev"),   &rootdev,     KFSdevice,      VBLK, UREAD_MODE  },
    { DT_CHR, N("rrootdev"),  &rrootdev,    KFSdevice,      VCHR, UREAD_MODE  },
    { DT_REG, N("time"),      0,            KFStime,        VREG, READ_MODE  },
                       /* XXXUNCONST */
    { DT_REG, N("version"),   __UNCONST(version),
                                            KFSstring,      VREG, READ_MODE  },
};
const struct kern_target subdir_targets[] = {
/* NOTE: The name must be less than UIO_MX-16 chars in length */
    /*        name            data          tag           type  ro/rw */
    { DT_DIR, N("."),         0,            KFSsubdir,      VDIR, DIR_MODE   },
    { DT_DIR, N(".."),        0,            KFSkern,        VDIR, DIR_MODE   },
};
#undef N
SIMPLEQ_HEAD(,dyn_kern_target) dyn_kern_targets =
       SIMPLEQ_HEAD_INITIALIZER(dyn_kern_targets);
int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]);
const int static_nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]);
int nkern_dirs = 2;

int kernfs_try_fileop(kfstype, kfsfileop, void *, int);
int kernfs_try_xread(kfstype, const struct kernfs_node *, char **,
   size_t, int);
int kernfs_try_xwrite(kfstype, const struct kernfs_node *, char *,
   size_t, int);

static int kernfs_default_xread(void *v);
static int kernfs_default_xwrite(void *v);
static int kernfs_default_fileop_getattr(void *);

/* must include all fileop's */
const struct kernfs_fileop kernfs_default_fileops[] = {
 { .kf_fileop = KERNFS_XREAD },
 { .kf_fileop = KERNFS_XWRITE },
 { .kf_fileop = KERNFS_FILEOP_OPEN },
 { .kf_fileop = KERNFS_FILEOP_GETATTR,
   .kf_vop = kernfs_default_fileop_getattr },
 { .kf_fileop = KERNFS_FILEOP_IOCTL },
 { .kf_fileop = KERNFS_FILEOP_CLOSE },
 { .kf_fileop = KERNFS_FILEOP_READ,
   .kf_vop = kernfs_default_xread },
 { .kf_fileop = KERNFS_FILEOP_WRITE,
   .kf_vop = kernfs_default_xwrite },
};

int     kernfs_lookup(void *);
int     kernfs_open(void *);
int     kernfs_close(void *);
int     kernfs_access(void *);
int     kernfs_getattr(void *);
int     kernfs_setattr(void *);
int     kernfs_read(void *);
int     kernfs_write(void *);
int     kernfs_ioctl(void *);
int     kernfs_readdir(void *);
int     kernfs_inactive(void *);
int     kernfs_reclaim(void *);
int     kernfs_print(void *);
int     kernfs_pathconf(void *);
int     kernfs_getpages(void *);

static int      kernfs_xread(struct kernfs_node *, int, char **,
                               size_t, size_t *);
static int      kernfs_xwrite(const struct kernfs_node *, char *, size_t);

int (**kernfs_vnodeop_p)(void *);
const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = {
       { &vop_default_desc, vn_default_error },
       { &vop_parsepath_desc, genfs_parsepath },       /* parsepath */
       { &vop_lookup_desc, kernfs_lookup },            /* lookup */
       { &vop_create_desc, genfs_eopnotsupp },         /* create */
       { &vop_mknod_desc, genfs_eopnotsupp },          /* mknod */
       { &vop_open_desc, kernfs_open },                /* open */
       { &vop_close_desc, kernfs_close },              /* close */
       { &vop_access_desc, kernfs_access },            /* access */
       { &vop_accessx_desc, genfs_accessx },           /* accessx */
       { &vop_getattr_desc, kernfs_getattr },          /* getattr */
       { &vop_setattr_desc, kernfs_setattr },          /* setattr */
       { &vop_read_desc, kernfs_read },                /* read */
       { &vop_write_desc, kernfs_write },              /* write */
       { &vop_fallocate_desc, genfs_eopnotsupp },      /* fallocate */
       { &vop_fdiscard_desc, genfs_eopnotsupp },       /* fdiscard */
       { &vop_fcntl_desc, genfs_fcntl },               /* fcntl */
       { &vop_ioctl_desc, kernfs_ioctl },              /* ioctl */
       { &vop_poll_desc, genfs_poll },                 /* poll */
       { &vop_kqfilter_desc, genfs_kqfilter },         /* kqfilter */
       { &vop_revoke_desc, genfs_revoke },             /* revoke */
       { &vop_fsync_desc, genfs_nullop },              /* fsync */
       { &vop_seek_desc, genfs_nullop },               /* seek */
       { &vop_remove_desc, genfs_eopnotsupp },         /* remove */
       { &vop_link_desc, genfs_erofs_link },           /* link */
       { &vop_rename_desc, genfs_eopnotsupp },         /* rename */
       { &vop_mkdir_desc, genfs_eopnotsupp },          /* mkdir */
       { &vop_rmdir_desc, genfs_eopnotsupp },          /* rmdir */
       { &vop_symlink_desc, genfs_erofs_symlink },     /* symlink */
       { &vop_readdir_desc, kernfs_readdir },          /* readdir */
       { &vop_readlink_desc, genfs_eopnotsupp },       /* readlink */
       { &vop_abortop_desc, genfs_abortop },           /* abortop */
       { &vop_inactive_desc, kernfs_inactive },        /* inactive */
       { &vop_reclaim_desc, kernfs_reclaim },          /* reclaim */
       { &vop_lock_desc, genfs_lock },                 /* lock */
       { &vop_unlock_desc, genfs_unlock },             /* unlock */
       { &vop_bmap_desc, genfs_eopnotsupp },           /* bmap */
       { &vop_strategy_desc, genfs_eopnotsupp },       /* strategy */
       { &vop_print_desc, kernfs_print },              /* print */
       { &vop_islocked_desc, genfs_islocked },         /* islocked */
       { &vop_pathconf_desc, kernfs_pathconf },        /* pathconf */
       { &vop_advlock_desc, genfs_einval },            /* advlock */
       { &vop_bwrite_desc, genfs_eopnotsupp },         /* bwrite */
       { &vop_getpages_desc, kernfs_getpages },        /* getpages */
       { &vop_putpages_desc, genfs_putpages },         /* putpages */
       { NULL, NULL }
};
const struct vnodeopv_desc kernfs_vnodeop_opv_desc =
       { &kernfs_vnodeop_p, kernfs_vnodeop_entries };

int (**kernfs_specop_p)(void *);
const struct vnodeopv_entry_desc kernfs_specop_entries[] = {
       { &vop_default_desc, vn_default_error },
       GENFS_SPECOP_ENTRIES,
       { &vop_close_desc, spec_close },                /* close */
       { &vop_access_desc, kernfs_access },            /* access */
       { &vop_accessx_desc, genfs_accessx },           /* accessx */
       { &vop_getattr_desc, kernfs_getattr },          /* getattr */
       { &vop_setattr_desc, kernfs_setattr },          /* setattr */
       { &vop_read_desc, spec_read },                  /* read */
       { &vop_write_desc, spec_write },                /* write */
       { &vop_fcntl_desc, genfs_fcntl },               /* fcntl */
       { &vop_fsync_desc, spec_fsync },                /* fsync */
       { &vop_inactive_desc, kernfs_inactive },        /* inactive */
       { &vop_reclaim_desc, kernfs_reclaim },          /* reclaim */
       { &vop_lock_desc, genfs_lock },                 /* lock */
       { &vop_unlock_desc, genfs_unlock },             /* unlock */
       { &vop_print_desc, kernfs_print },              /* print */
       { &vop_islocked_desc, genfs_islocked },         /* islocked */
       { &vop_bwrite_desc, vn_bwrite },                /* bwrite */
       { NULL, NULL }
};
const struct vnodeopv_desc kernfs_specop_opv_desc =
       { &kernfs_specop_p, kernfs_specop_entries };

static inline int
kernfs_fileop_compare(struct kernfs_fileop *a, struct kernfs_fileop *b)
{
       if (a->kf_type < b->kf_type)
               return -1;
       if (a->kf_type > b->kf_type)
               return 1;
       if (a->kf_fileop < b->kf_fileop)
               return -1;
       if (a->kf_fileop > b->kf_fileop)
               return 1;
       return (0);
}

SPLAY_HEAD(kfsfileoptree, kernfs_fileop) kfsfileoptree =
       SPLAY_INITIALIZER(kfsfileoptree);
SPLAY_PROTOTYPE(kfsfileoptree, kernfs_fileop, kf_node, kernfs_fileop_compare);
SPLAY_GENERATE(kfsfileoptree, kernfs_fileop, kf_node, kernfs_fileop_compare);

kfstype
kernfs_alloctype(int nkf, const struct kernfs_fileop *kf)
{
       static u_char nextfreetype = KFSlasttype;
       struct kernfs_fileop *dkf, *fkf, skf;
       int i;

       /* XXX need to keep track of dkf's memory if we support
          deallocating types */
       dkf = malloc(sizeof(kernfs_default_fileops), M_TEMP, M_WAITOK);
       memcpy(dkf, kernfs_default_fileops, sizeof(kernfs_default_fileops));

       for (i = 0; i < sizeof(kernfs_default_fileops) /
                    sizeof(kernfs_default_fileops[0]); i++) {
               dkf[i].kf_type = nextfreetype;
               SPLAY_INSERT(kfsfileoptree, &kfsfileoptree, &dkf[i]);
       }

       for (i = 0; i < nkf; i++) {
               skf.kf_type = nextfreetype;
               skf.kf_fileop = kf[i].kf_fileop;
               if ((fkf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
                       fkf->kf_vop = kf[i].kf_vop;
       }

       return nextfreetype++;
}

int
kernfs_try_fileop(kfstype type, kfsfileop fileop, void *v, int error)
{
       struct kernfs_fileop *kf, skf;

       skf.kf_type = type;
       skf.kf_fileop = fileop;
       if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
               if (kf->kf_vop)
                       return kf->kf_vop(v);
       return error;
}

int
kernfs_try_xread(kfstype type, const struct kernfs_node *kfs, char **bfp,
   size_t len, int error)
{
       struct kernfs_fileop *kf, skf;

       skf.kf_type = type;
       skf.kf_fileop = KERNFS_XREAD;
       if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
               if (kf->kf_xread)
                       return kf->kf_xread(kfs, bfp, len);
       return error;
}

int
kernfs_try_xwrite(kfstype type, const struct kernfs_node *kfs, char *bf,
   size_t len, int error)
{
       struct kernfs_fileop *kf, skf;

       skf.kf_type = type;
       skf.kf_fileop = KERNFS_XWRITE;
       if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
               if (kf->kf_xwrite)
                       return kf->kf_xwrite(kfs, bf, len);
       return error;
}

int
kernfs_addentry(kernfs_parentdir_t *pkt, kernfs_entry_t *dkt)
{
       struct kernfs_subdir *ks, *parent;

       if (pkt == NULL) {
               SIMPLEQ_INSERT_TAIL(&dyn_kern_targets, dkt, dkt_queue);
               nkern_targets++;
               if (dkt->dkt_kt.kt_vtype == VDIR)
                       nkern_dirs++;
       } else {
               parent = (struct kernfs_subdir *)pkt->kt_data;
               SIMPLEQ_INSERT_TAIL(&parent->ks_entries, dkt, dkt_queue);
               parent->ks_nentries++;
               if (dkt->dkt_kt.kt_vtype == VDIR)
                       parent->ks_dirs++;
       }
       if (dkt->dkt_kt.kt_vtype == VDIR && dkt->dkt_kt.kt_data == NULL) {
               ks = malloc(sizeof(struct kernfs_subdir),
                   M_TEMP, M_WAITOK);
               SIMPLEQ_INIT(&ks->ks_entries);
               ks->ks_nentries = 2; /* . and .. */
               ks->ks_dirs = 2;
               ks->ks_parent = pkt ? pkt : &kern_targets[0];
               dkt->dkt_kt.kt_data = ks;
       }
       return 0;
}

static int
kernfs_xread(struct kernfs_node *kfs, int off, char **bufp, size_t len, size_t *wrlen)
{
       const struct kern_target *kt;
       int err;

       kt = kfs->kfs_kt;

       switch (kfs->kfs_type) {
       case KFStime: {
               struct timeval tv;

               microtime(&tv);
               snprintf(*bufp, len, "%lld %ld\n", (long long)tv.tv_sec,
                   (long)tv.tv_usec);
               break;
       }

       case KFSboottime: {
               struct timeval tv;

               /*
                * Historically, /kern/boottime only contained seconds.
                */
               getmicroboottime(&tv);
               snprintf(*bufp, len, "%lld\n", (long long)tv.tv_sec);
               break;
       }

       case KFSint: {
               int *ip = kt->kt_data;

               snprintf(*bufp, len, "%d\n", *ip);
               break;
       }

       case KFSstring: {
               char *cp = kt->kt_data;

               *bufp = cp;
               break;
       }

       case KFSmsgbuf: {
               long n;

               /*
                * deal with cases where the message buffer has
                * become corrupted.
                */
               if (!logenabled(msgbufp)) {
                       msgbufenabled = 0;
                       return (ENXIO);
               }

               /*
                * Note that reads of /kern/msgbuf won't necessarily yield
                * consistent results, if the message buffer is modified
                * while the read is in progress.  The worst that can happen
                * is that incorrect data will be read.  There's no way
                * that this can crash the system unless the values in the
                * message buffer header are corrupted, but that'll cause
                * the system to die anyway.
                */
               if (off >= msgbufp->msg_bufs) {
                       *wrlen = 0;
                       return (0);
               }
               n = msgbufp->msg_bufx + off;
               if (n >= msgbufp->msg_bufs)
                       n -= msgbufp->msg_bufs;
               len = uimin(msgbufp->msg_bufs - n, msgbufp->msg_bufs - off);
               *bufp = msgbufp->msg_bufc + n;
               *wrlen = len;
               return (0);
       }

       case KFShostname: {
               char *cp = hostname;
               size_t xlen = hostnamelen;

               if (xlen >= (len - 2))
                       return (EINVAL);

               memcpy(*bufp, cp, xlen);
               (*bufp)[xlen] = '\n';
               (*bufp)[xlen+1] = '\0';
               break;
       }

       case KFSavenrun:
               averunnable.fscale = FSCALE;
               snprintf(*bufp, len, "%d %d %d %ld\n",
                   averunnable.ldavg[0], averunnable.ldavg[1],
                   averunnable.ldavg[2], averunnable.fscale);
               break;

       default:
               err = kernfs_try_xread(kfs->kfs_type, kfs, bufp, len,
                   EOPNOTSUPP);
               if (err)
                       return err;
       }

       len = strlen(*bufp);
       if (len <= off)
               *wrlen = 0;
       else {
               *bufp += off;
               *wrlen = len - off;
       }
       return (0);
}

static int
kernfs_xwrite(const struct kernfs_node *kfs, char *bf, size_t len)
{

       switch (kfs->kfs_type) {
       case KFShostname:
               if (bf[len-1] == '\n')
                       --len;
               memcpy(hostname, bf, len);
               hostname[len] = '\0';
               hostnamelen = (size_t) len;
               return (0);

       default:
               return kernfs_try_xwrite(kfs->kfs_type, kfs, bf, len, EIO);
       }
}


/*
* vp is the current namei directory
* ndp is the name to locate in that directory...
*/
int
kernfs_lookup(void *v)
{
       struct vop_lookup_v2_args /* {
               struct vnode * a_dvp;
               struct vnode ** a_vpp;
               struct componentname * a_cnp;
       } */ *ap = v;
       struct componentname *cnp = ap->a_cnp;
       struct vnode **vpp = ap->a_vpp;
       struct vnode *dvp = ap->a_dvp;
       const char *pname = cnp->cn_nameptr;
       const struct kernfs_node *kfs;
       const struct kern_target *kt;
       const struct dyn_kern_target *dkt;
       const struct kernfs_subdir *ks;
       int error, i;

       *vpp = NULLVP;

       if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
               return (EROFS);

       if (cnp->cn_namelen == 1 && *pname == '.') {
               *vpp = dvp;
               vref(dvp);
               return (0);
       }

       kfs = VTOKERN(dvp);
       switch (kfs->kfs_type) {
       case KFSkern:
               /*
                * Shouldn't get here with .. in the root node.
                */
               if (cnp->cn_flags & ISDOTDOT)
                       return (EIO);

               for (i = 0; i < static_nkern_targets; i++) {
                       kt = &kern_targets[i];
                       if (cnp->cn_namelen == kt->kt_namlen &&
                           memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0)
                               goto found;
               }
               SIMPLEQ_FOREACH(dkt, &dyn_kern_targets, dkt_queue) {
                       if (cnp->cn_namelen == dkt->dkt_kt.kt_namlen &&
                           memcmp(dkt->dkt_kt.kt_name, pname, cnp->cn_namelen) == 0) {
                               kt = &dkt->dkt_kt;
                               goto found;
                       }
               }
               break;

       found:
               error = vcache_get(dvp->v_mount, &kt, sizeof(kt), vpp);
               return error;

       case KFSsubdir:
               ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data;
               if (cnp->cn_flags & ISDOTDOT) {
                       kt = ks->ks_parent;
                       goto found;
               }

               SIMPLEQ_FOREACH(dkt, &ks->ks_entries, dkt_queue) {
                       if (cnp->cn_namelen == dkt->dkt_kt.kt_namlen &&
                           memcmp(dkt->dkt_kt.kt_name, pname, cnp->cn_namelen) == 0) {
                               kt = &dkt->dkt_kt;
                               goto found;
                       }
               }
               break;

       default:
               return (ENOTDIR);
       }

       return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS);
}

int
kernfs_open(void *v)
{
       struct vop_open_args /* {
               struct vnode *a_vp;
               int a_mode;
               kauth_cred_t a_cred;
       } */ *ap = v;
       struct kernfs_node *kfs = VTOKERN(ap->a_vp);

       return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_OPEN, v, 0);
}

int
kernfs_close(void *v)
{
       struct vop_close_args /* {
               struct vnode *a_vp;
               int a_fflag;
               kauth_cred_t a_cred;
       } */ *ap = v;
       struct kernfs_node *kfs = VTOKERN(ap->a_vp);

       return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_CLOSE, v, 0);
}

int
kernfs_access(void *v)
{
       struct vop_access_args /* {
               struct vnode *a_vp;
               accmode_t a_accmode;
               kauth_cred_t a_cred;
       } */ *ap = v;
       struct vattr va;
       int error;

       if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0)
               return (error);

       return kauth_authorize_vnode(ap->a_cred,
           KAUTH_ACCESS_ACTION(ap->a_accmode, ap->a_vp->v_type, va.va_mode),
           ap->a_vp, NULL, genfs_can_access(ap->a_vp, ap->a_cred,
           va.va_uid, va.va_gid, va.va_mode, NULL, ap->a_accmode));
}

static int
kernfs_default_fileop_getattr(void *v)
{
       struct vop_getattr_args /* {
               struct vnode *a_vp;
               struct vattr *a_vap;
               kauth_cred_t a_cred;
       } */ *ap = v;
       struct vattr *vap = ap->a_vap;

       vap->va_nlink = 1;
       vap->va_bytes = vap->va_size = 0;

       return 0;
}

int
kernfs_getattr(void *v)
{
       struct vop_getattr_args /* {
               struct vnode *a_vp;
               struct vattr *a_vap;
               kauth_cred_t a_cred;
       } */ *ap = v;
       struct kernfs_node *kfs = VTOKERN(ap->a_vp);
       struct kernfs_subdir *ks;
       struct vattr *vap = ap->a_vap;
       int error = 0;
       char strbuf[KSTRING], *bf;
       size_t nread, total;

       vattr_null(vap);
       vap->va_type = ap->a_vp->v_type;
       vap->va_uid = 0;
       vap->va_gid = 0;
       vap->va_mode = kfs->kfs_mode;
       vap->va_fileid = kfs->kfs_fileno;
       vap->va_flags = 0;
       vap->va_size = 0;
       vap->va_blocksize = DEV_BSIZE;
       /* Make all times be current TOD, except for the "boottime" node. */
       if (kfs->kfs_kt->kt_namlen == 8 &&
           !memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) {
               getnanoboottime(&vap->va_ctime);
       } else {
               getnanotime(&vap->va_ctime);
       }
       vap->va_atime = vap->va_mtime = vap->va_ctime;
       vap->va_gen = 0;
       vap->va_flags = 0;
       vap->va_rdev = 0;
       vap->va_bytes = 0;

       switch (kfs->kfs_type) {
       case KFSkern:
               vap->va_nlink = nkern_dirs;
               vap->va_bytes = vap->va_size = DEV_BSIZE;
               break;

       case KFSdevice:
               vap->va_nlink = 1;
               vap->va_rdev = ap->a_vp->v_rdev;
               break;

       case KFSroot:
               vap->va_nlink = 1;
               vap->va_bytes = vap->va_size = DEV_BSIZE;
               break;

       case KFSsubdir:
               ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data;
               vap->va_nlink = ks->ks_dirs;
               vap->va_bytes = vap->va_size = DEV_BSIZE;
               break;

       case KFSnull:
       case KFStime:
       case KFSboottime:
       case KFSint:
       case KFSstring:
       case KFShostname:
       case KFSavenrun:
       case KFSmsgbuf:
               vap->va_nlink = 1;
               total = 0;
               do {
                       bf = strbuf;
                       error = kernfs_xread(kfs, total, &bf,
                           sizeof(strbuf), &nread);
                       total += nread;
               } while (error == 0 && nread != 0);
               vap->va_bytes = vap->va_size = total;
               break;

       default:
               error = kernfs_try_fileop(kfs->kfs_type,
                   KERNFS_FILEOP_GETATTR, v, EINVAL);
               break;
       }

       return (error);
}

/*ARGSUSED*/
int
kernfs_setattr(void *v)
{

       /*
        * Silently ignore attribute changes.
        * This allows for open with truncate to have no
        * effect until some data is written.  I want to
        * do it this way because all writes are atomic.
        */
       return (0);
}

int
kernfs_default_xread(void *v)
{
       struct vop_read_args /* {
               struct vnode *a_vp;
               struct uio *a_uio;
               int  a_ioflag;
               kauth_cred_t a_cred;
       } */ *ap = v;
       struct uio *uio = ap->a_uio;
       struct kernfs_node *kfs = VTOKERN(ap->a_vp);
       char strbuf[KSTRING], *bf;
       int off;
       size_t len;
       int error;

       if (ap->a_vp->v_type == VDIR)
               return EISDIR;

       off = (int)uio->uio_offset;
       /* Don't allow negative offsets */
       if (off < 0)
               return EINVAL;

       bf = strbuf;
       if ((error = kernfs_xread(kfs, off, &bf, sizeof(strbuf), &len)) == 0)
               error = uiomove(bf, len, uio);
       return (error);
}

int
kernfs_read(void *v)
{
       struct vop_read_args /* {
               struct vnode *a_vp;
               struct uio *a_uio;
               int  a_ioflag;
               struct ucred *a_cred;
       } */ *ap = v;
       struct kernfs_node *kfs = VTOKERN(ap->a_vp);

       if (kfs->kfs_type < KFSlasttype) {
               /* use default function */
               return kernfs_default_xread(v);
       }
       return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_READ, v,
          EOPNOTSUPP);
}

static int
kernfs_default_xwrite(void *v)
{
       struct vop_write_args /* {
               struct vnode *a_vp;
               struct uio *a_uio;
               int  a_ioflag;
               kauth_cred_t a_cred;
       } */ *ap = v;
       struct kernfs_node *kfs = VTOKERN(ap->a_vp);
       struct uio *uio = ap->a_uio;
       int error;
       size_t xlen;
       char strbuf[KSTRING];

       if (uio->uio_offset != 0)
               return (EINVAL);

       xlen = uimin(uio->uio_resid, KSTRING-1);
       if ((error = uiomove(strbuf, xlen, uio)) != 0)
               return (error);

       if (uio->uio_resid != 0)
               return (EIO);

       strbuf[xlen] = '\0';
       xlen = strlen(strbuf);
       return (kernfs_xwrite(kfs, strbuf, xlen));
}

int
kernfs_write(void *v)
{
       struct vop_write_args /* {
               struct vnode *a_vp;
               struct uio *a_uio;
               int  a_ioflag;
               kauth_cred_t a_cred;
       } */ *ap = v;
       struct kernfs_node *kfs = VTOKERN(ap->a_vp);

       if (kfs->kfs_type < KFSlasttype) {
               /* use default function */
               return kernfs_default_xwrite(v);
       }
       return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_WRITE, v,
           EOPNOTSUPP);
}

int
kernfs_ioctl(void *v)
{
       struct vop_ioctl_args /* {
               const struct vnodeop_desc *a_desc;
               struct vnode *a_vp;
               u_long a_command;
               void *a_data;
               int a_fflag;
               kauth_cred_t a_cred;
       } */ *ap = v;
       struct kernfs_node *kfs = VTOKERN(ap->a_vp);

       return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_IOCTL, v,
           EPASSTHROUGH);
}

static int
kernfs_setdirentfileno_kt(struct dirent *d, const struct kern_target *kt,
   struct vop_readdir_args *ap)
{
       struct kernfs_node *kfs;
       struct vnode *vp;
       int error;

       if ((error = vcache_get(ap->a_vp->v_mount, &kt, sizeof(kt), &vp)) != 0)
               return error;
       kfs = VTOKERN(vp);
       d->d_fileno = kfs->kfs_fileno;
       vrele(vp);
       return 0;
}

static int
kernfs_setdirentfileno(struct dirent *d, off_t entry,
   struct kernfs_node *thisdir_kfs, const struct kern_target *parent_kt,
   const struct kern_target *kt, struct vop_readdir_args *ap)
{
       const struct kern_target *ikt;
       int error;

       switch (entry) {
       case 0:
               d->d_fileno = thisdir_kfs->kfs_fileno;
               return 0;
       case 1:
               ikt = parent_kt;
               break;
       default:
               ikt = kt;
               break;
       }
       if (ikt != thisdir_kfs->kfs_kt) {
               if ((error = kernfs_setdirentfileno_kt(d, ikt, ap)) != 0)
                       return error;
       } else
               d->d_fileno = thisdir_kfs->kfs_fileno;
       return 0;
}

int
kernfs_readdir(void *v)
{
       struct vop_readdir_args /* {
               struct vnode *a_vp;
               struct uio *a_uio;
               kauth_cred_t a_cred;
               int *a_eofflag;
               off_t **a_cookies;
               int a_*ncookies;
       } */ *ap = v;
       struct uio *uio = ap->a_uio;
       struct dirent d;
       struct kernfs_node *kfs = VTOKERN(ap->a_vp);
       const struct kern_target *kt;
       const struct dyn_kern_target *dkt = NULL;
       const struct kernfs_subdir *ks;
       off_t i, j;
       int error;
       off_t *cookies = NULL;
       int ncookies = 0, n;

       if (uio->uio_resid < UIO_MX)
               return (EINVAL);
       if (uio->uio_offset < 0)
               return (EINVAL);

       error = 0;
       i = uio->uio_offset;
       memset(&d, 0, sizeof(d));
       d.d_reclen = UIO_MX;
       ncookies = uio->uio_resid / UIO_MX;

       switch (kfs->kfs_type) {
       case KFSkern:
               if (i >= nkern_targets)
                       return (0);

               if (ap->a_ncookies) {
                       ncookies = uimin(ncookies, (nkern_targets - i));
                       cookies = malloc(ncookies * sizeof(off_t), M_TEMP,
                           M_WAITOK);
                       *ap->a_cookies = cookies;
               }

               n = 0;
               for (; i < nkern_targets && uio->uio_resid >= UIO_MX; i++) {
                       if (i < static_nkern_targets)
                               kt = &kern_targets[i];
                       else {
                               if (dkt == NULL) {
                                       dkt = SIMPLEQ_FIRST(&dyn_kern_targets);
                                       for (j = static_nkern_targets; j < i &&
                                                    dkt != NULL; j++)
                                               dkt = SIMPLEQ_NEXT(dkt, dkt_queue);
                                       if (j != i)
                                               break;
                               } else {
                                       dkt = SIMPLEQ_NEXT(dkt, dkt_queue);
                               }
                               if (dkt == NULL)
                                       break;
                               kt = &dkt->dkt_kt;
                       }
                       if (kt->kt_tag == KFSmsgbuf) {
                               if (!logenabled(msgbufp)) {
                                       continue;
                               }
                       }
                       d.d_namlen = kt->kt_namlen;
                       if ((error = kernfs_setdirentfileno(&d, i, kfs,
                           &kern_targets[0], kt, ap)) != 0)
                               break;
                       memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1);
                       d.d_type = kt->kt_type;
                       if ((error = uiomove(&d, UIO_MX, uio)) != 0)
                               break;
                       if (cookies)
                               *cookies++ = i + 1;
                       n++;
               }
               ncookies = n;
               break;

       case KFSroot:
               if (i >= 2)
                       return 0;

               if (ap->a_ncookies) {
                       ncookies = uimin(ncookies, (2 - i));
                       cookies = malloc(ncookies * sizeof(off_t), M_TEMP,
                           M_WAITOK);
                       *ap->a_cookies = cookies;
               }

               n = 0;
               for (; i < 2 && uio->uio_resid >= UIO_MX; i++) {
                       kt = &kern_targets[i];
                       d.d_namlen = kt->kt_namlen;
                       d.d_fileno = KERNFS_FILENO(kt, kt->kt_tag, 0);
                       memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1);
                       d.d_type = kt->kt_type;
                       if ((error = uiomove(&d, UIO_MX, uio)) != 0)
                               break;
                       if (cookies)
                               *cookies++ = i + 1;
                       n++;
               }
               ncookies = n;
               break;

       case KFSsubdir:
               ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data;
               if (i >= ks->ks_nentries)
                       return (0);

               if (ap->a_ncookies) {
                       ncookies = uimin(ncookies, (ks->ks_nentries - i));
                       cookies = malloc(ncookies * sizeof(off_t), M_TEMP,
                           M_WAITOK);
                       *ap->a_cookies = cookies;
               }

               dkt = SIMPLEQ_FIRST(&ks->ks_entries);
               for (j = 0; j < i && dkt != NULL; j++)
                       dkt = SIMPLEQ_NEXT(dkt, dkt_queue);
               n = 0;
               for (; i < ks->ks_nentries && uio->uio_resid >= UIO_MX; i++) {
                       if (i < 2)
                               kt = &subdir_targets[i];
                       else {
                               /* check if ks_nentries lied to us */
                               if (dkt == NULL)
                                       break;
                               kt = &dkt->dkt_kt;
                               dkt = SIMPLEQ_NEXT(dkt, dkt_queue);
                       }
                       d.d_namlen = kt->kt_namlen;
                       if ((error = kernfs_setdirentfileno(&d, i, kfs,
                           ks->ks_parent, kt, ap)) != 0)
                               break;
                       memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1);
                       d.d_type = kt->kt_type;
                       if ((error = uiomove(&d, UIO_MX, uio)) != 0)
                               break;
                       if (cookies)
                               *cookies++ = i + 1;
                       n++;
               }
               ncookies = n;
               break;

       default:
               error = ENOTDIR;
               break;
       }

       if (ap->a_ncookies) {
               if (error) {
                       if (cookies)
                               free(*ap->a_cookies, M_TEMP);
                       *ap->a_ncookies = 0;
                       *ap->a_cookies = NULL;
               } else
                       *ap->a_ncookies = ncookies;
       }

       uio->uio_offset = i;
       return (error);
}

int
kernfs_inactive(void *v)
{
       struct vop_inactive_v2_args /* {
               struct vnode *a_vp;
               bool *a_recycle;
       } */ *ap = v;

       *ap->a_recycle = false;

       return (0);
}

int
kernfs_reclaim(void *v)
{
       struct vop_reclaim_v2_args /* {
               struct vnode *a_vp;
       } */ *ap = v;
       struct vnode *vp = ap->a_vp;
       struct kernfs_node *kfs = VTOKERN(vp);

       VOP_UNLOCK(vp);

       vp->v_data = NULL;
       mutex_enter(&kfs_lock);
       TAILQ_REMOVE(&VFSTOKERNFS(vp->v_mount)->nodelist, kfs, kfs_list);
       mutex_exit(&kfs_lock);
       kmem_free(kfs, sizeof(struct kernfs_node));

       return 0;
}

/*
* Return POSIX pathconf information applicable to special devices.
*/
int
kernfs_pathconf(void *v)
{
       struct vop_pathconf_args /* {
               struct vnode *a_vp;
               int a_name;
               register_t *a_retval;
       } */ *ap = v;

       switch (ap->a_name) {
       case _PC_LINK_MAX:
               *ap->a_retval = LINK_MAX;
               return (0);
       case _PC_MAX_CANON:
               *ap->a_retval = MAX_CANON;
               return (0);
       case _PC_MAX_INPUT:
               *ap->a_retval = MAX_INPUT;
               return (0);
       case _PC_PIPE_BUF:
               *ap->a_retval = PIPE_BUF;
               return (0);
       case _PC_CHOWN_RESTRICTED:
               *ap->a_retval = 1;
               return (0);
       case _PC_VDISABLE:
               *ap->a_retval = _POSIX_VDISABLE;
               return (0);
       case _PC_SYNC_IO:
               *ap->a_retval = 1;
               return (0);
       default:
               return genfs_pathconf(ap);
       }
       /* NOTREACHED */
}

/*
* Print out the contents of a /dev/fd vnode.
*/
/* ARGSUSED */
int
kernfs_print(void *v)
{

       printf("tag VT_KERNFS, kernfs vnode\n");
       return (0);
}

int
kernfs_getpages(void *v)
{
       struct vop_getpages_args /* {
               struct vnode *a_vp;
               voff_t a_offset;
               struct vm_page **a_m;
               int *a_count;
               int a_centeridx;
               vm_prot_t a_access_type;
               int a_advice;
               int a_flags;
       } */ *ap = v;

       if ((ap->a_flags & PGO_LOCKED) == 0)
               rw_exit(ap->a_vp->v_uobj.vmobjlock);

       return (EFAULT);
}

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.