[BACK]Return to kernfs_vnops.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / miscfs / kernfs

Annotation of src/sys/miscfs/kernfs/kernfs_vnops.c, Revision 1.158

1.158   ! riastrad    1: /*     $NetBSD: kernfs_vnops.c,v 1.157 2017/04/11 14:25:01 riastradh Exp $     */
1.27      cgd         2:
1.1       cgd         3: /*
1.23      mycroft     4:  * Copyright (c) 1992, 1993
                      5:  *     The Regents of the University of California.  All rights reserved.
1.1       cgd         6:  *
1.17      cgd         7:  * This code is derived from software donated to Berkeley by
1.1       cgd         8:  * Jan-Simon Pendry.
                      9:  *
1.2       cgd        10:  * Redistribution and use in source and binary forms, with or without
                     11:  * modification, are permitted provided that the following conditions
                     12:  * are met:
                     13:  * 1. Redistributions of source code must retain the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer.
                     15:  * 2. Redistributions in binary form must reproduce the above copyright
                     16:  *    notice, this list of conditions and the following disclaimer in the
                     17:  *    documentation and/or other materials provided with the distribution.
1.89      agc        18:  * 3. Neither the name of the University nor the names of its contributors
1.2       cgd        19:  *    may be used to endorse or promote products derived from this software
                     20:  *    without specific prior written permission.
1.1       cgd        21:  *
1.2       cgd        22:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     23:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     24:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     25:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     26:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     27:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     28:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     29:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     30:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     31:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     32:  * SUCH DAMAGE.
1.1       cgd        33:  *
1.57      fvdl       34:  *     @(#)kernfs_vnops.c      8.15 (Berkeley) 5/21/95
1.1       cgd        35:  */
                     36:
                     37: /*
1.23      mycroft    38:  * Kernel parameter filesystem (/kern)
1.1       cgd        39:  */
1.77      lukem      40:
                     41: #include <sys/cdefs.h>
1.158   ! riastrad   42: __KERNEL_RCSID(0, "$NetBSD: kernfs_vnops.c,v 1.157 2017/04/11 14:25:01 riastradh Exp $");
1.55      mrg        43:
1.14      mycroft    44: #include <sys/param.h>
                     45: #include <sys/systm.h>
                     46: #include <sys/kernel.h>
1.23      mycroft    47: #include <sys/vmmeter.h>
1.14      mycroft    48: #include <sys/time.h>
                     49: #include <sys/proc.h>
1.23      mycroft    50: #include <sys/vnode.h>
                     51: #include <sys/malloc.h>
1.14      mycroft    52: #include <sys/file.h>
                     53: #include <sys/stat.h>
                     54: #include <sys/mount.h>
                     55: #include <sys/namei.h>
                     56: #include <sys/buf.h>
1.23      mycroft    57: #include <sys/dirent.h>
1.28      mycroft    58: #include <sys/msgbuf.h>
1.44      mycroft    59:
                     60: #include <miscfs/genfs/genfs.h>
1.17      cgd        61: #include <miscfs/kernfs/kernfs.h>
1.151     christos   62: #include <miscfs/specfs/specdev.h>
1.63      mrg        63:
1.54      mrg        64: #include <uvm/uvm_extern.h>
                     65:
1.17      cgd        66: #define KSTRING        256             /* Largest I/O available via this filesystem */
                     67: #define        UIO_MX 32
1.1       cgd        68:
1.23      mycroft    69: #define        READ_MODE       (S_IRUSR|S_IRGRP|S_IROTH)
                     70: #define        WRITE_MODE      (S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH)
1.101     cl         71: #define        UREAD_MODE      (S_IRUSR)
1.102     cl         72: #define        DIR_MODE        (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
                     73: #define        UDIR_MODE       (S_IRUSR|S_IXUSR)
1.23      mycroft    74:
1.90      itojun     75: #define N(s) sizeof(s)-1, s
1.75      jdolecek   76: const struct kern_target kern_targets[] = {
1.1       cgd        77: /* NOTE: The name must be less than UIO_MX-16 chars in length */
1.23      mycroft    78:      /*        name            data          tag           type  ro/rw */
1.98      darcy      79:      { DT_DIR, N("."),         0,            KFSkern,        VDIR, DIR_MODE   },
                     80:      { DT_DIR, N(".."),        0,            KFSroot,        VDIR, DIR_MODE   },
                     81:      { DT_REG, N("boottime"),  &boottime.tv_sec, KFSint,     VREG, READ_MODE  },
1.109     christos   82:                        /* XXXUNCONST */
                     83:      { DT_REG, N("copyright"), __UNCONST(copyright),
1.98      darcy      84:                                             KFSstring,      VREG, READ_MODE  },
                     85:      { DT_REG, N("hostname"),  0,            KFShostname,    VREG, WRITE_MODE },
                     86:      { DT_REG, N("hz"),        &hz,          KFSint,         VREG, READ_MODE  },
                     87:      { DT_REG, N("loadavg"),   0,            KFSavenrun,     VREG, READ_MODE  },
                     88:      { DT_REG, N("msgbuf"),    0,           KFSmsgbuf,      VREG, READ_MODE  },
                     89:      { DT_REG, N("pagesize"),  &uvmexp.pagesize, KFSint,     VREG, READ_MODE  },
                     90:      { DT_REG, N("physmem"),   &physmem,     KFSint,         VREG, READ_MODE  },
1.17      cgd        91: #if 0
1.98      darcy      92:      { DT_DIR, N("root"),      0,            KFSnull,        VDIR, DIR_MODE   },
1.17      cgd        93: #endif
1.98      darcy      94:      { DT_BLK, N("rootdev"),   &rootdev,     KFSdevice,      VBLK, READ_MODE  },
                     95:      { DT_CHR, N("rrootdev"),  &rrootdev,    KFSdevice,      VCHR, READ_MODE  },
                     96:      { DT_REG, N("time"),      0,            KFStime,        VREG, READ_MODE  },
1.109     christos   97:                        /* XXXUNCONST */
                     98:      { DT_REG, N("version"),   __UNCONST(version),
1.98      darcy      99:                                             KFSstring,      VREG, READ_MODE  },
1.90      itojun    100: };
1.102     cl        101: const struct kern_target subdir_targets[] = {
                    102: /* NOTE: The name must be less than UIO_MX-16 chars in length */
                    103:      /*        name            data          tag           type  ro/rw */
                    104:      { DT_DIR, N("."),         0,            KFSsubdir,      VDIR, DIR_MODE   },
                    105:      { DT_DIR, N(".."),        0,            KFSkern,        VDIR, DIR_MODE   },
                    106: };
1.23      mycroft   107: #undef N
1.102     cl        108: SIMPLEQ_HEAD(,dyn_kern_target) dyn_kern_targets =
                    109:        SIMPLEQ_HEAD_INITIALIZER(dyn_kern_targets);
1.90      itojun    110: int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]);
1.102     cl        111: const int static_nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]);
                    112: int nkern_dirs = 2;
1.90      itojun    113:
1.102     cl        114: int kernfs_try_fileop(kfstype, kfsfileop, void *, int);
1.124     bouyer    115: int kernfs_try_xread(kfstype, const struct kernfs_node *, char **,
1.123     bouyer    116:     size_t, int);
1.102     cl        117: int kernfs_try_xwrite(kfstype, const struct kernfs_node *, char *,
                    118:     size_t, int);
                    119:
1.123     bouyer    120: static int kernfs_default_xread(void *v);
1.102     cl        121: static int kernfs_default_xwrite(void *v);
                    122: static int kernfs_default_fileop_getattr(void *);
                    123:
                    124: /* must include all fileop's */
                    125: const struct kernfs_fileop kernfs_default_fileops[] = {
1.123     bouyer    126:   { .kf_fileop = KERNFS_XREAD },
1.102     cl        127:   { .kf_fileop = KERNFS_XWRITE },
                    128:   { .kf_fileop = KERNFS_FILEOP_OPEN },
                    129:   { .kf_fileop = KERNFS_FILEOP_GETATTR,
1.125     christos  130:     .kf_vop = kernfs_default_fileop_getattr },
1.102     cl        131:   { .kf_fileop = KERNFS_FILEOP_IOCTL },
                    132:   { .kf_fileop = KERNFS_FILEOP_CLOSE },
1.125     christos  133:   { .kf_fileop = KERNFS_FILEOP_READ,
                    134:     .kf_vop = kernfs_default_xread },
                    135:   { .kf_fileop = KERNFS_FILEOP_WRITE,
                    136:     .kf_vop = kernfs_default_xwrite },
1.102     cl        137: };
1.1       cgd       138:
1.110     xtraeme   139: int    kernfs_lookup(void *);
1.85      jdolecek  140: #define        kernfs_create   genfs_eopnotsupp
                    141: #define        kernfs_mknod    genfs_eopnotsupp
1.110     xtraeme   142: int    kernfs_open(void *);
                    143: int    kernfs_close(void *);
                    144: int    kernfs_access(void *);
                    145: int    kernfs_getattr(void *);
                    146: int    kernfs_setattr(void *);
                    147: int    kernfs_read(void *);
                    148: int    kernfs_write(void *);
1.65      wrstuden  149: #define        kernfs_fcntl    genfs_fcntl
1.110     xtraeme   150: int    kernfs_ioctl(void *);
1.45      mycroft   151: #define        kernfs_poll     genfs_poll
1.57      fvdl      152: #define kernfs_revoke  genfs_revoke
1.44      mycroft   153: #define        kernfs_fsync    genfs_nullop
                    154: #define        kernfs_seek     genfs_nullop
1.85      jdolecek  155: #define        kernfs_remove   genfs_eopnotsupp
1.110     xtraeme   156: int    kernfs_link(void *);
1.85      jdolecek  157: #define        kernfs_rename   genfs_eopnotsupp
                    158: #define        kernfs_mkdir    genfs_eopnotsupp
                    159: #define        kernfs_rmdir    genfs_eopnotsupp
1.110     xtraeme   160: int    kernfs_symlink(void *);
                    161: int    kernfs_readdir(void *);
1.44      mycroft   162: #define        kernfs_readlink genfs_eopnotsupp
                    163: #define        kernfs_abortop  genfs_abortop
1.110     xtraeme   164: int    kernfs_inactive(void *);
                    165: int    kernfs_reclaim(void *);
1.64      wrstuden  166: #define        kernfs_lock     genfs_lock
                    167: #define        kernfs_unlock   genfs_unlock
1.44      mycroft   168: #define        kernfs_bmap     genfs_badop
                    169: #define        kernfs_strategy genfs_badop
1.110     xtraeme   170: int    kernfs_print(void *);
1.64      wrstuden  171: #define        kernfs_islocked genfs_islocked
1.110     xtraeme   172: int    kernfs_pathconf(void *);
1.62      kleink    173: #define        kernfs_advlock  genfs_einval
1.44      mycroft   174: #define        kernfs_bwrite   genfs_eopnotsupp
1.79      chs       175: #define        kernfs_putpages genfs_putpages
1.41      christos  176:
1.110     xtraeme   177: static int     kernfs_xread(struct kernfs_node *, int, char **,
                    178:                                size_t, size_t *);
                    179: static int     kernfs_xwrite(const struct kernfs_node *, char *, size_t);
1.41      christos  180:
1.110     xtraeme   181: int (**kernfs_vnodeop_p)(void *);
1.71      jdolecek  182: const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = {
1.41      christos  183:        { &vop_default_desc, vn_default_error },
1.44      mycroft   184:        { &vop_lookup_desc, kernfs_lookup },            /* lookup */
                    185:        { &vop_create_desc, kernfs_create },            /* create */
                    186:        { &vop_mknod_desc, kernfs_mknod },              /* mknod */
                    187:        { &vop_open_desc, kernfs_open },                /* open */
                    188:        { &vop_close_desc, kernfs_close },              /* close */
                    189:        { &vop_access_desc, kernfs_access },            /* access */
                    190:        { &vop_getattr_desc, kernfs_getattr },          /* getattr */
                    191:        { &vop_setattr_desc, kernfs_setattr },          /* setattr */
                    192:        { &vop_read_desc, kernfs_read },                /* read */
                    193:        { &vop_write_desc, kernfs_write },              /* write */
1.154     dholland  194:        { &vop_fallocate_desc, genfs_eopnotsupp },      /* fallocate */
                    195:        { &vop_fdiscard_desc, genfs_eopnotsupp },       /* fdiscard */
1.65      wrstuden  196:        { &vop_fcntl_desc, kernfs_fcntl },              /* fcntl */
1.44      mycroft   197:        { &vop_ioctl_desc, kernfs_ioctl },              /* ioctl */
1.45      mycroft   198:        { &vop_poll_desc, kernfs_poll },                /* poll */
1.57      fvdl      199:        { &vop_revoke_desc, kernfs_revoke },            /* revoke */
1.44      mycroft   200:        { &vop_fsync_desc, kernfs_fsync },              /* fsync */
                    201:        { &vop_seek_desc, kernfs_seek },                /* seek */
                    202:        { &vop_remove_desc, kernfs_remove },            /* remove */
                    203:        { &vop_link_desc, kernfs_link },                /* link */
                    204:        { &vop_rename_desc, kernfs_rename },            /* rename */
                    205:        { &vop_mkdir_desc, kernfs_mkdir },              /* mkdir */
                    206:        { &vop_rmdir_desc, kernfs_rmdir },              /* rmdir */
                    207:        { &vop_symlink_desc, kernfs_symlink },          /* symlink */
                    208:        { &vop_readdir_desc, kernfs_readdir },          /* readdir */
                    209:        { &vop_readlink_desc, kernfs_readlink },        /* readlink */
                    210:        { &vop_abortop_desc, kernfs_abortop },          /* abortop */
                    211:        { &vop_inactive_desc, kernfs_inactive },        /* inactive */
                    212:        { &vop_reclaim_desc, kernfs_reclaim },          /* reclaim */
                    213:        { &vop_lock_desc, kernfs_lock },                /* lock */
                    214:        { &vop_unlock_desc, kernfs_unlock },            /* unlock */
                    215:        { &vop_bmap_desc, kernfs_bmap },                /* bmap */
                    216:        { &vop_strategy_desc, kernfs_strategy },        /* strategy */
                    217:        { &vop_print_desc, kernfs_print },              /* print */
                    218:        { &vop_islocked_desc, kernfs_islocked },        /* islocked */
                    219:        { &vop_pathconf_desc, kernfs_pathconf },        /* pathconf */
                    220:        { &vop_advlock_desc, kernfs_advlock },          /* advlock */
                    221:        { &vop_bwrite_desc, kernfs_bwrite },            /* bwrite */
1.79      chs       222:        { &vop_putpages_desc, kernfs_putpages },        /* putpages */
1.76      chs       223:        { NULL, NULL }
1.41      christos  224: };
1.71      jdolecek  225: const struct vnodeopv_desc kernfs_vnodeop_opv_desc =
1.41      christos  226:        { &kernfs_vnodeop_p, kernfs_vnodeop_entries };
                    227:
1.116     perry     228: static inline int
1.102     cl        229: kernfs_fileop_compare(struct kernfs_fileop *a, struct kernfs_fileop *b)
                    230: {
                    231:        if (a->kf_type < b->kf_type)
                    232:                return -1;
                    233:        if (a->kf_type > b->kf_type)
                    234:                return 1;
                    235:        if (a->kf_fileop < b->kf_fileop)
                    236:                return -1;
                    237:        if (a->kf_fileop > b->kf_fileop)
                    238:                return 1;
                    239:        return (0);
                    240: }
                    241:
                    242: SPLAY_HEAD(kfsfileoptree, kernfs_fileop) kfsfileoptree =
                    243:        SPLAY_INITIALIZER(kfsfileoptree);
                    244: SPLAY_PROTOTYPE(kfsfileoptree, kernfs_fileop, kf_node, kernfs_fileop_compare);
                    245: SPLAY_GENERATE(kfsfileoptree, kernfs_fileop, kf_node, kernfs_fileop_compare);
                    246:
                    247: kfstype
                    248: kernfs_alloctype(int nkf, const struct kernfs_fileop *kf)
                    249: {
                    250:        static u_char nextfreetype = KFSlasttype;
                    251:        struct kernfs_fileop *dkf, *fkf, skf;
                    252:        int i;
                    253:
                    254:        /* XXX need to keep track of dkf's memory if we support
                    255:            deallocating types */
                    256:        dkf = malloc(sizeof(kernfs_default_fileops), M_TEMP, M_WAITOK);
                    257:        memcpy(dkf, kernfs_default_fileops, sizeof(kernfs_default_fileops));
                    258:
                    259:        for (i = 0; i < sizeof(kernfs_default_fileops) /
                    260:                     sizeof(kernfs_default_fileops[0]); i++) {
                    261:                dkf[i].kf_type = nextfreetype;
                    262:                SPLAY_INSERT(kfsfileoptree, &kfsfileoptree, &dkf[i]);
                    263:        }
                    264:
                    265:        for (i = 0; i < nkf; i++) {
                    266:                skf.kf_type = nextfreetype;
                    267:                skf.kf_fileop = kf[i].kf_fileop;
                    268:                if ((fkf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
1.125     christos  269:                        fkf->kf_vop = kf[i].kf_vop;
1.102     cl        270:        }
                    271:
                    272:        return nextfreetype++;
                    273: }
                    274:
                    275: int
                    276: kernfs_try_fileop(kfstype type, kfsfileop fileop, void *v, int error)
                    277: {
                    278:        struct kernfs_fileop *kf, skf;
                    279:
                    280:        skf.kf_type = type;
                    281:        skf.kf_fileop = fileop;
                    282:        if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
                    283:                if (kf->kf_vop)
                    284:                        return kf->kf_vop(v);
                    285:        return error;
                    286: }
                    287:
                    288: int
1.124     bouyer    289: kernfs_try_xread(kfstype type, const struct kernfs_node *kfs, char **bfp,
                    290:     size_t len, int error)
                    291: {
                    292:        struct kernfs_fileop *kf, skf;
                    293:
                    294:        skf.kf_type = type;
                    295:        skf.kf_fileop = KERNFS_XREAD;
                    296:        if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
                    297:                if (kf->kf_xread)
                    298:                        return kf->kf_xread(kfs, bfp, len);
                    299:        return error;
                    300: }
                    301:
                    302: int
1.109     christos  303: kernfs_try_xwrite(kfstype type, const struct kernfs_node *kfs, char *bf,
1.102     cl        304:     size_t len, int error)
                    305: {
                    306:        struct kernfs_fileop *kf, skf;
                    307:
                    308:        skf.kf_type = type;
                    309:        skf.kf_fileop = KERNFS_XWRITE;
                    310:        if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
                    311:                if (kf->kf_xwrite)
1.109     christos  312:                        return kf->kf_xwrite(kfs, bf, len);
1.102     cl        313:        return error;
                    314: }
                    315:
                    316: int
                    317: kernfs_addentry(kernfs_parentdir_t *pkt, kernfs_entry_t *dkt)
                    318: {
                    319:        struct kernfs_subdir *ks, *parent;
                    320:
                    321:        if (pkt == NULL) {
                    322:                SIMPLEQ_INSERT_TAIL(&dyn_kern_targets, dkt, dkt_queue);
                    323:                nkern_targets++;
                    324:                if (dkt->dkt_kt.kt_vtype == VDIR)
                    325:                        nkern_dirs++;
                    326:        } else {
                    327:                parent = (struct kernfs_subdir *)pkt->kt_data;
                    328:                SIMPLEQ_INSERT_TAIL(&parent->ks_entries, dkt, dkt_queue);
                    329:                parent->ks_nentries++;
                    330:                if (dkt->dkt_kt.kt_vtype == VDIR)
                    331:                        parent->ks_dirs++;
                    332:        }
                    333:        if (dkt->dkt_kt.kt_vtype == VDIR && dkt->dkt_kt.kt_data == NULL) {
                    334:                ks = malloc(sizeof(struct kernfs_subdir),
                    335:                    M_TEMP, M_WAITOK);
                    336:                SIMPLEQ_INIT(&ks->ks_entries);
                    337:                ks->ks_nentries = 2; /* . and .. */
                    338:                ks->ks_dirs = 2;
                    339:                ks->ks_parent = pkt ? pkt : &kern_targets[0];
                    340:                dkt->dkt_kt.kt_data = ks;
                    341:        }
                    342:        return 0;
                    343: }
                    344:
1.82      jdolecek  345: static int
1.136     dsl       346: kernfs_xread(struct kernfs_node *kfs, int off, char **bufp, size_t len, size_t *wrlen)
1.1       cgd       347: {
1.90      itojun    348:        const struct kern_target *kt;
1.124     bouyer    349:        int err;
1.90      itojun    350:
                    351:        kt = kfs->kfs_kt;
1.1       cgd       352:
1.90      itojun    353:        switch (kfs->kfs_type) {
1.98      darcy     354:        case KFStime: {
1.1       cgd       355:                struct timeval tv;
1.28      mycroft   356:
1.1       cgd       357:                microtime(&tv);
1.135     christos  358:                snprintf(*bufp, len, "%lld %ld\n", (long long)tv.tv_sec,
                    359:                    (long)tv.tv_usec);
1.1       cgd       360:                break;
                    361:        }
                    362:
1.98      darcy     363:        case KFSint: {
1.1       cgd       364:                int *ip = kt->kt_data;
1.28      mycroft   365:
1.90      itojun    366:                snprintf(*bufp, len, "%d\n", *ip);
1.1       cgd       367:                break;
                    368:        }
                    369:
1.98      darcy     370:        case KFSstring: {
1.1       cgd       371:                char *cp = kt->kt_data;
                    372:
1.28      mycroft   373:                *bufp = cp;
                    374:                break;
                    375:        }
1.1       cgd       376:
1.98      darcy     377:        case KFSmsgbuf: {
1.28      mycroft   378:                long n;
                    379:
1.52      leo       380:                /*
                    381:                 * deal with cases where the message buffer has
                    382:                 * become corrupted.
                    383:                 */
                    384:                if (!msgbufenabled || msgbufp->msg_magic != MSG_MAGIC) {
                    385:                        msgbufenabled = 0;
                    386:                        return (ENXIO);
                    387:                }
                    388:
                    389:                /*
                    390:                 * Note that reads of /kern/msgbuf won't necessarily yield
                    391:                 * consistent results, if the message buffer is modified
                    392:                 * while the read is in progress.  The worst that can happen
                    393:                 * is that incorrect data will be read.  There's no way
                    394:                 * that this can crash the system unless the values in the
                    395:                 * message buffer header are corrupted, but that'll cause
                    396:                 * the system to die anyway.
                    397:                 */
1.82      jdolecek  398:                if (off >= msgbufp->msg_bufs) {
                    399:                        *wrlen = 0;
1.28      mycroft   400:                        return (0);
1.82      jdolecek  401:                }
1.28      mycroft   402:                n = msgbufp->msg_bufx + off;
1.52      leo       403:                if (n >= msgbufp->msg_bufs)
                    404:                        n -= msgbufp->msg_bufs;
                    405:                len = min(msgbufp->msg_bufs - n, msgbufp->msg_bufs - off);
1.28      mycroft   406:                *bufp = msgbufp->msg_bufc + n;
1.82      jdolecek  407:                *wrlen = len;
                    408:                return (0);
1.1       cgd       409:        }
                    410:
1.98      darcy     411:        case KFShostname: {
1.1       cgd       412:                char *cp = hostname;
1.127     jmmv      413:                size_t xlen = hostnamelen;
1.1       cgd       414:
1.90      itojun    415:                if (xlen >= (len - 2))
1.1       cgd       416:                        return (EINVAL);
                    417:
1.60      perry     418:                memcpy(*bufp, cp, xlen);
1.28      mycroft   419:                (*bufp)[xlen] = '\n';
                    420:                (*bufp)[xlen+1] = '\0';
1.1       cgd       421:                break;
                    422:        }
                    423:
1.98      darcy     424:        case KFSavenrun:
1.31      mycroft   425:                averunnable.fscale = FSCALE;
1.90      itojun    426:                snprintf(*bufp, len, "%d %d %d %ld\n",
1.23      mycroft   427:                    averunnable.ldavg[0], averunnable.ldavg[1],
                    428:                    averunnable.ldavg[2], averunnable.fscale);
1.1       cgd       429:                break;
                    430:
                    431:        default:
1.124     bouyer    432:                err = kernfs_try_xread(kfs->kfs_type, kfs, bufp, len,
                    433:                    EOPNOTSUPP);
                    434:                if (err)
                    435:                        return err;
1.1       cgd       436:        }
                    437:
1.28      mycroft   438:        len = strlen(*bufp);
                    439:        if (len <= off)
1.82      jdolecek  440:                *wrlen = 0;
                    441:        else {
                    442:                *bufp += off;
                    443:                *wrlen = len - off;
                    444:        }
                    445:        return (0);
1.1       cgd       446: }
                    447:
1.82      jdolecek  448: static int
1.136     dsl       449: kernfs_xwrite(const struct kernfs_node *kfs, char *bf, size_t len)
1.1       cgd       450: {
1.23      mycroft   451:
1.90      itojun    452:        switch (kfs->kfs_type) {
1.98      darcy     453:        case KFShostname:
1.109     christos  454:                if (bf[len-1] == '\n')
1.1       cgd       455:                        --len;
1.109     christos  456:                memcpy(hostname, bf, len);
1.17      cgd       457:                hostname[len] = '\0';
1.82      jdolecek  458:                hostnamelen = (size_t) len;
1.1       cgd       459:                return (0);
                    460:
                    461:        default:
1.109     christos  462:                return kernfs_try_xwrite(kfs->kfs_type, kfs, bf, len, EIO);
1.1       cgd       463:        }
                    464: }
                    465:
1.17      cgd       466:
                    467: /*
1.1       cgd       468:  * vp is the current namei directory
                    469:  * ndp is the name to locate in that directory...
                    470:  */
1.41      christos  471: int
1.136     dsl       472: kernfs_lookup(void *v)
1.41      christos  473: {
1.150     hannken   474:        struct vop_lookup_v2_args /* {
1.23      mycroft   475:                struct vnode * a_dvp;
                    476:                struct vnode ** a_vpp;
                    477:                struct componentname * a_cnp;
1.41      christos  478:        } */ *ap = v;
1.23      mycroft   479:        struct componentname *cnp = ap->a_cnp;
                    480:        struct vnode **vpp = ap->a_vpp;
                    481:        struct vnode *dvp = ap->a_dvp;
1.48      cgd       482:        const char *pname = cnp->cn_nameptr;
1.90      itojun    483:        const struct kernfs_node *kfs;
1.75      jdolecek  484:        const struct kern_target *kt;
1.102     cl        485:        const struct dyn_kern_target *dkt;
                    486:        const struct kernfs_subdir *ks;
1.129     chs       487:        int error, i;
1.23      mycroft   488:
1.35      mycroft   489:        *vpp = NULLVP;
                    490:
                    491:        if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
                    492:                return (EROFS);
                    493:
1.23      mycroft   494:        if (cnp->cn_namelen == 1 && *pname == '.') {
                    495:                *vpp = dvp;
1.139     pooka     496:                vref(dvp);
1.1       cgd       497:                return (0);
                    498:        }
1.13      cgd       499:
1.90      itojun    500:        kfs = VTOKERN(dvp);
                    501:        switch (kfs->kfs_type) {
1.98      darcy     502:        case KFSkern:
1.90      itojun    503:                /*
                    504:                 * Shouldn't get here with .. in the root node.
                    505:                 */
                    506:                if (cnp->cn_flags & ISDOTDOT)
                    507:                        return (EIO);
1.64      wrstuden  508:
1.102     cl        509:                for (i = 0; i < static_nkern_targets; i++) {
1.90      itojun    510:                        kt = &kern_targets[i];
                    511:                        if (cnp->cn_namelen == kt->kt_namlen &&
                    512:                            memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0)
                    513:                                goto found;
                    514:                }
1.102     cl        515:                SIMPLEQ_FOREACH(dkt, &dyn_kern_targets, dkt_queue) {
                    516:                        if (cnp->cn_namelen == dkt->dkt_kt.kt_namlen &&
                    517:                            memcmp(dkt->dkt_kt.kt_name, pname, cnp->cn_namelen) == 0) {
                    518:                                kt = &dkt->dkt_kt;
                    519:                                goto found;
                    520:                        }
                    521:                }
1.90      itojun    522:                break;
1.25      mycroft   523:
1.90      itojun    524:        found:
1.153     hannken   525:                error = vcache_get(dvp->v_mount, &kt, sizeof(kt), vpp);
                    526:                return error;
1.64      wrstuden  527:
1.102     cl        528:        case KFSsubdir:
                    529:                ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data;
                    530:                if (cnp->cn_flags & ISDOTDOT) {
                    531:                        kt = ks->ks_parent;
                    532:                        goto found;
                    533:                }
                    534:
                    535:                SIMPLEQ_FOREACH(dkt, &ks->ks_entries, dkt_queue) {
                    536:                        if (cnp->cn_namelen == dkt->dkt_kt.kt_namlen &&
                    537:                            memcmp(dkt->dkt_kt.kt_name, pname, cnp->cn_namelen) == 0) {
                    538:                                kt = &dkt->dkt_kt;
                    539:                                goto found;
                    540:                        }
                    541:                }
                    542:                break;
                    543:
1.90      itojun    544:        default:
                    545:                return (ENOTDIR);
                    546:        }
                    547:
                    548:        return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS);
                    549: }
                    550:
                    551: int
1.136     dsl       552: kernfs_open(void *v)
1.90      itojun    553: {
                    554:        struct vop_open_args /* {
                    555:                struct vnode *a_vp;
                    556:                int a_mode;
1.120     elad      557:                kauth_cred_t a_cred;
1.90      itojun    558:        } */ *ap = v;
                    559:        struct kernfs_node *kfs = VTOKERN(ap->a_vp);
                    560:
1.146     drochner  561:        return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_OPEN, v, 0);
1.90      itojun    562: }
1.1       cgd       563:
1.90      itojun    564: int
1.136     dsl       565: kernfs_close(void *v)
1.90      itojun    566: {
                    567:        struct vop_close_args /* {
                    568:                struct vnode *a_vp;
                    569:                int a_fflag;
1.120     elad      570:                kauth_cred_t a_cred;
1.90      itojun    571:        } */ *ap = v;
                    572:        struct kernfs_node *kfs = VTOKERN(ap->a_vp);
                    573:
1.146     drochner  574:        return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_CLOSE, v, 0);
1.1       cgd       575: }
                    576:
1.28      mycroft   577: int
1.136     dsl       578: kernfs_access(void *v)
1.41      christos  579: {
1.23      mycroft   580:        struct vop_access_args /* {
                    581:                struct vnode *a_vp;
1.34      mycroft   582:                int a_mode;
1.120     elad      583:                kauth_cred_t a_cred;
1.41      christos  584:        } */ *ap = v;
1.90      itojun    585:        struct vattr va;
                    586:        int error;
1.17      cgd       587:
1.133     pooka     588:        if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0)
1.90      itojun    589:                return (error);
1.49      mycroft   590:
1.145     elad      591:        return kauth_authorize_vnode(ap->a_cred,
1.147     plunky    592:            KAUTH_ACCESS_ACTION(ap->a_mode, ap->a_vp->v_type, va.va_mode),
1.145     elad      593:            ap->a_vp, NULL, genfs_can_access(va.va_type, va.va_mode,
                    594:            va.va_uid, va.va_gid, ap->a_mode, ap->a_cred));
1.23      mycroft   595: }
                    596:
1.102     cl        597: static int
1.136     dsl       598: kernfs_default_fileop_getattr(void *v)
1.102     cl        599: {
                    600:        struct vop_getattr_args /* {
                    601:                struct vnode *a_vp;
                    602:                struct vattr *a_vap;
1.120     elad      603:                kauth_cred_t a_cred;
1.102     cl        604:        } */ *ap = v;
                    605:        struct vattr *vap = ap->a_vap;
                    606:
                    607:        vap->va_nlink = 1;
                    608:        vap->va_bytes = vap->va_size = 0;
                    609:
                    610:        return 0;
                    611: }
                    612:
1.41      christos  613: int
1.136     dsl       614: kernfs_getattr(void *v)
1.41      christos  615: {
1.23      mycroft   616:        struct vop_getattr_args /* {
                    617:                struct vnode *a_vp;
                    618:                struct vattr *a_vap;
1.120     elad      619:                kauth_cred_t a_cred;
1.41      christos  620:        } */ *ap = v;
1.90      itojun    621:        struct kernfs_node *kfs = VTOKERN(ap->a_vp);
1.102     cl        622:        struct kernfs_subdir *ks;
1.23      mycroft   623:        struct vattr *vap = ap->a_vap;
1.1       cgd       624:        int error = 0;
1.109     christos  625:        char strbuf[KSTRING], *bf;
1.90      itojun    626:        size_t nread, total;
1.1       cgd       627:
1.139     pooka     628:        vattr_null(vap);
1.90      itojun    629:        vap->va_type = ap->a_vp->v_type;
1.17      cgd       630:        vap->va_uid = 0;
                    631:        vap->va_gid = 0;
1.90      itojun    632:        vap->va_mode = kfs->kfs_mode;
                    633:        vap->va_fileid = kfs->kfs_fileno;
                    634:        vap->va_flags = 0;
1.23      mycroft   635:        vap->va_size = 0;
1.1       cgd       636:        vap->va_blocksize = DEV_BSIZE;
1.121     kardel    637:        /* Make all times be current TOD, except for the "boottime" node. */
1.132     elad      638:        if (kfs->kfs_kt->kt_namlen == 8 &&
1.92      dan       639:            !memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) {
1.135     christos  640:                vap->va_ctime = boottime;
1.92      dan       641:        } else {
1.121     kardel    642:                getnanotime(&vap->va_ctime);
1.92      dan       643:        }
1.81      lukem     644:        vap->va_atime = vap->va_mtime = vap->va_ctime;
1.1       cgd       645:        vap->va_gen = 0;
                    646:        vap->va_flags = 0;
                    647:        vap->va_rdev = 0;
                    648:        vap->va_bytes = 0;
                    649:
1.90      itojun    650:        switch (kfs->kfs_type) {
1.98      darcy     651:        case KFSkern:
1.102     cl        652:                vap->va_nlink = nkern_dirs;
1.90      itojun    653:                vap->va_bytes = vap->va_size = DEV_BSIZE;
                    654:                break;
                    655:
1.151     christos  656:        case KFSdevice:
                    657:                vap->va_nlink = 1;
                    658:                vap->va_rdev = ap->a_vp->v_rdev;
                    659:                break;
                    660:
1.98      darcy     661:        case KFSroot:
1.90      itojun    662:                vap->va_nlink = 1;
                    663:                vap->va_bytes = vap->va_size = DEV_BSIZE;
                    664:                break;
                    665:
1.102     cl        666:        case KFSsubdir:
                    667:                ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data;
                    668:                vap->va_nlink = ks->ks_dirs;
                    669:                vap->va_bytes = vap->va_size = DEV_BSIZE;
                    670:                break;
                    671:
1.98      darcy     672:        case KFSnull:
                    673:        case KFStime:
                    674:        case KFSint:
                    675:        case KFSstring:
                    676:        case KFShostname:
                    677:        case KFSavenrun:
                    678:        case KFSmsgbuf:
1.1       cgd       679:                vap->va_nlink = 1;
1.84      jdolecek  680:                total = 0;
                    681:                do {
1.109     christos  682:                        bf = strbuf;
                    683:                        error = kernfs_xread(kfs, total, &bf,
1.90      itojun    684:                            sizeof(strbuf), &nread);
1.84      jdolecek  685:                        total += nread;
                    686:                } while (error == 0 && nread != 0);
1.90      itojun    687:                vap->va_bytes = vap->va_size = total;
                    688:                break;
                    689:
                    690:        default:
1.102     cl        691:                error = kernfs_try_fileop(kfs->kfs_type,
                    692:                    KERNFS_FILEOP_GETATTR, v, EINVAL);
1.90      itojun    693:                break;
1.1       cgd       694:        }
                    695:
                    696:        return (error);
                    697: }
                    698:
1.41      christos  699: /*ARGSUSED*/
                    700: int
1.128     christos  701: kernfs_setattr(void *v)
1.1       cgd       702: {
1.90      itojun    703:
1.1       cgd       704:        /*
1.17      cgd       705:         * Silently ignore attribute changes.
                    706:         * This allows for open with truncate to have no
                    707:         * effect until some data is written.  I want to
                    708:         * do it this way because all writes are atomic.
1.1       cgd       709:         */
1.17      cgd       710:        return (0);
1.1       cgd       711: }
                    712:
1.28      mycroft   713: int
1.136     dsl       714: kernfs_default_xread(void *v)
1.41      christos  715: {
1.23      mycroft   716:        struct vop_read_args /* {
                    717:                struct vnode *a_vp;
                    718:                struct uio *a_uio;
                    719:                int  a_ioflag;
1.120     elad      720:                kauth_cred_t a_cred;
1.41      christos  721:        } */ *ap = v;
1.23      mycroft   722:        struct uio *uio = ap->a_uio;
1.90      itojun    723:        struct kernfs_node *kfs = VTOKERN(ap->a_vp);
1.109     christos  724:        char strbuf[KSTRING], *bf;
1.114     christos  725:        int off;
1.82      jdolecek  726:        size_t len;
1.28      mycroft   727:        int error;
1.23      mycroft   728:
1.90      itojun    729:        if (ap->a_vp->v_type == VDIR)
1.144     njoly     730:                return EISDIR;
1.23      mycroft   731:
1.114     christos  732:        off = (int)uio->uio_offset;
1.112     christos  733:        /* Don't allow negative offsets */
1.114     christos  734:        if (off < 0)
1.112     christos  735:                return EINVAL;
                    736:
1.109     christos  737:        bf = strbuf;
                    738:        if ((error = kernfs_xread(kfs, off, &bf, sizeof(strbuf), &len)) == 0)
                    739:                error = uiomove(bf, len, uio);
1.82      jdolecek  740:        return (error);
1.1       cgd       741: }
                    742:
1.123     bouyer    743: int
1.136     dsl       744: kernfs_read(void *v)
1.123     bouyer    745: {
                    746:        struct vop_read_args /* {
                    747:                struct vnode *a_vp;
                    748:                struct uio *a_uio;
                    749:                int  a_ioflag;
                    750:                struct ucred *a_cred;
                    751:        } */ *ap = v;
                    752:        struct kernfs_node *kfs = VTOKERN(ap->a_vp);
                    753:
1.124     bouyer    754:        if (kfs->kfs_type < KFSlasttype) {
                    755:                /* use default function */
                    756:                return kernfs_default_xread(v);
                    757:        }
                    758:        return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_READ, v,
                    759:           EOPNOTSUPP);
1.123     bouyer    760: }
                    761:
1.102     cl        762: static int
1.136     dsl       763: kernfs_default_xwrite(void *v)
1.41      christos  764: {
1.23      mycroft   765:        struct vop_write_args /* {
                    766:                struct vnode *a_vp;
                    767:                struct uio *a_uio;
                    768:                int  a_ioflag;
1.120     elad      769:                kauth_cred_t a_cred;
1.41      christos  770:        } */ *ap = v;
1.90      itojun    771:        struct kernfs_node *kfs = VTOKERN(ap->a_vp);
1.23      mycroft   772:        struct uio *uio = ap->a_uio;
1.127     jmmv      773:        int error;
                    774:        size_t xlen;
1.1       cgd       775:        char strbuf[KSTRING];
1.23      mycroft   776:
1.1       cgd       777:        if (uio->uio_offset != 0)
                    778:                return (EINVAL);
                    779:
                    780:        xlen = min(uio->uio_resid, KSTRING-1);
1.41      christos  781:        if ((error = uiomove(strbuf, xlen, uio)) != 0)
1.1       cgd       782:                return (error);
                    783:
                    784:        if (uio->uio_resid != 0)
                    785:                return (EIO);
                    786:
                    787:        strbuf[xlen] = '\0';
1.17      cgd       788:        xlen = strlen(strbuf);
1.90      itojun    789:        return (kernfs_xwrite(kfs, strbuf, xlen));
1.1       cgd       790: }
                    791:
1.102     cl        792: int
1.136     dsl       793: kernfs_write(void *v)
1.102     cl        794: {
                    795:        struct vop_write_args /* {
                    796:                struct vnode *a_vp;
                    797:                struct uio *a_uio;
                    798:                int  a_ioflag;
1.120     elad      799:                kauth_cred_t a_cred;
1.102     cl        800:        } */ *ap = v;
                    801:        struct kernfs_node *kfs = VTOKERN(ap->a_vp);
                    802:
1.124     bouyer    803:        if (kfs->kfs_type < KFSlasttype) {
                    804:                /* use default function */
                    805:                return kernfs_default_xwrite(v);
                    806:        }
                    807:        return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_WRITE, v,
                    808:            EOPNOTSUPP);
1.102     cl        809: }
                    810:
                    811: int
1.136     dsl       812: kernfs_ioctl(void *v)
1.102     cl        813: {
                    814:        struct vop_ioctl_args /* {
                    815:                const struct vnodeop_desc *a_desc;
                    816:                struct vnode *a_vp;
                    817:                u_long a_command;
                    818:                void *a_data;
                    819:                int a_fflag;
1.120     elad      820:                kauth_cred_t a_cred;
1.102     cl        821:        } */ *ap = v;
                    822:        struct kernfs_node *kfs = VTOKERN(ap->a_vp);
                    823:
                    824:        return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_IOCTL, v,
                    825:            EPASSTHROUGH);
                    826: }
                    827:
1.101     cl        828: static int
                    829: kernfs_setdirentfileno_kt(struct dirent *d, const struct kern_target *kt,
1.152     hannken   830:     struct vop_readdir_args *ap)
1.101     cl        831: {
                    832:        struct kernfs_node *kfs;
                    833:        struct vnode *vp;
                    834:        int error;
                    835:
1.153     hannken   836:        if ((error = vcache_get(ap->a_vp->v_mount, &kt, sizeof(kt), &vp)) != 0)
1.101     cl        837:                return error;
1.151     christos  838:        kfs = VTOKERN(vp);
                    839:        d->d_fileno = kfs->kfs_fileno;
1.153     hannken   840:        vrele(vp);
1.101     cl        841:        return 0;
                    842: }
                    843:
                    844: static int
                    845: kernfs_setdirentfileno(struct dirent *d, off_t entry,
                    846:     struct kernfs_node *thisdir_kfs, const struct kern_target *parent_kt,
                    847:     const struct kern_target *kt, struct vop_readdir_args *ap)
                    848: {
                    849:        const struct kern_target *ikt;
                    850:        int error;
                    851:
                    852:        switch (entry) {
                    853:        case 0:
                    854:                d->d_fileno = thisdir_kfs->kfs_fileno;
                    855:                return 0;
                    856:        case 1:
                    857:                ikt = parent_kt;
                    858:                break;
                    859:        default:
                    860:                ikt = kt;
                    861:                break;
                    862:        }
                    863:        if (ikt != thisdir_kfs->kfs_kt) {
1.152     hannken   864:                if ((error = kernfs_setdirentfileno_kt(d, ikt, ap)) != 0)
1.101     cl        865:                        return error;
                    866:        } else
                    867:                d->d_fileno = thisdir_kfs->kfs_fileno;
                    868:        return 0;
                    869: }
                    870:
1.41      christos  871: int
1.136     dsl       872: kernfs_readdir(void *v)
1.41      christos  873: {
1.23      mycroft   874:        struct vop_readdir_args /* {
                    875:                struct vnode *a_vp;
                    876:                struct uio *a_uio;
1.120     elad      877:                kauth_cred_t a_cred;
1.26      mycroft   878:                int *a_eofflag;
1.57      fvdl      879:                off_t **a_cookies;
                    880:                int a_*ncookies;
1.41      christos  881:        } */ *ap = v;
1.23      mycroft   882:        struct uio *uio = ap->a_uio;
1.37      mycroft   883:        struct dirent d;
1.90      itojun    884:        struct kernfs_node *kfs = VTOKERN(ap->a_vp);
1.75      jdolecek  885:        const struct kern_target *kt;
1.102     cl        886:        const struct dyn_kern_target *dkt = NULL;
                    887:        const struct kernfs_subdir *ks;
                    888:        off_t i, j;
1.1       cgd       889:        int error;
1.57      fvdl      890:        off_t *cookies = NULL;
1.90      itojun    891:        int ncookies = 0, n;
1.23      mycroft   892:
1.37      mycroft   893:        if (uio->uio_resid < UIO_MX)
                    894:                return (EINVAL);
1.38      mycroft   895:        if (uio->uio_offset < 0)
1.37      mycroft   896:                return (EINVAL);
1.26      mycroft   897:
1.1       cgd       898:        error = 0;
1.38      mycroft   899:        i = uio->uio_offset;
1.90      itojun    900:        memset(&d, 0, sizeof(d));
                    901:        d.d_reclen = UIO_MX;
                    902:        ncookies = uio->uio_resid / UIO_MX;
                    903:
                    904:        switch (kfs->kfs_type) {
1.98      darcy     905:        case KFSkern:
1.90      itojun    906:                if (i >= nkern_targets)
                    907:                        return (0);
1.66      sommerfe  908:
1.90      itojun    909:                if (ap->a_ncookies) {
                    910:                        ncookies = min(ncookies, (nkern_targets - i));
                    911:                        cookies = malloc(ncookies * sizeof(off_t), M_TEMP,
                    912:                            M_WAITOK);
                    913:                        *ap->a_cookies = cookies;
                    914:                }
                    915:
                    916:                n = 0;
                    917:                for (; i < nkern_targets && uio->uio_resid >= UIO_MX; i++) {
1.102     cl        918:                        if (i < static_nkern_targets)
                    919:                                kt = &kern_targets[i];
                    920:                        else {
                    921:                                if (dkt == NULL) {
                    922:                                        dkt = SIMPLEQ_FIRST(&dyn_kern_targets);
                    923:                                        for (j = static_nkern_targets; j < i &&
                    924:                                                     dkt != NULL; j++)
                    925:                                                dkt = SIMPLEQ_NEXT(dkt, dkt_queue);
                    926:                                        if (j != i)
                    927:                                                break;
                    928:                                } else {
                    929:                                        dkt = SIMPLEQ_NEXT(dkt, dkt_queue);
                    930:                                }
1.119     christos  931:                                if (dkt == NULL)
                    932:                                        break;
1.102     cl        933:                                kt = &dkt->dkt_kt;
                    934:                        }
1.98      darcy     935:                        if (kt->kt_tag == KFSdevice) {
1.94      itojun    936:                                dev_t *dp = kt->kt_data;
                    937:                                struct vnode *fvp;
                    938:
                    939:                                if (*dp == NODEV ||
                    940:                                    !vfinddev(*dp, kt->kt_vtype, &fvp))
                    941:                                        continue;
1.143     hannken   942:                                vrele(fvp);
1.94      itojun    943:                        }
1.141     pooka     944:                        if (kt->kt_tag == KFSmsgbuf) {
                    945:                                if (!msgbufenabled
                    946:                                    || msgbufp->msg_magic != MSG_MAGIC) {
                    947:                                        continue;
                    948:                                }
                    949:                        }
1.90      itojun    950:                        d.d_namlen = kt->kt_namlen;
1.101     cl        951:                        if ((error = kernfs_setdirentfileno(&d, i, kfs,
                    952:                            &kern_targets[0], kt, ap)) != 0)
                    953:                                break;
1.90      itojun    954:                        memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1);
                    955:                        d.d_type = kt->kt_type;
1.99      jrf       956:                        if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1.90      itojun    957:                                break;
                    958:                        if (cookies)
                    959:                                *cookies++ = i + 1;
                    960:                        n++;
                    961:                }
                    962:                ncookies = n;
                    963:                break;
                    964:
1.98      darcy     965:        case KFSroot:
1.90      itojun    966:                if (i >= 2)
                    967:                        return 0;
                    968:
                    969:                if (ap->a_ncookies) {
                    970:                        ncookies = min(ncookies, (2 - i));
                    971:                        cookies = malloc(ncookies * sizeof(off_t), M_TEMP,
                    972:                            M_WAITOK);
                    973:                        *ap->a_cookies = cookies;
                    974:                }
                    975:
                    976:                n = 0;
                    977:                for (; i < 2 && uio->uio_resid >= UIO_MX; i++) {
                    978:                        kt = &kern_targets[i];
                    979:                        d.d_namlen = kt->kt_namlen;
                    980:                        d.d_fileno = KERNFS_FILENO(kt, kt->kt_tag, 0);
                    981:                        memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1);
                    982:                        d.d_type = kt->kt_type;
1.99      jrf       983:                        if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1.90      itojun    984:                                break;
                    985:                        if (cookies)
                    986:                                *cookies++ = i + 1;
                    987:                        n++;
                    988:                }
                    989:                ncookies = n;
                    990:                break;
                    991:
1.102     cl        992:        case KFSsubdir:
                    993:                ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data;
                    994:                if (i >= ks->ks_nentries)
                    995:                        return (0);
                    996:
                    997:                if (ap->a_ncookies) {
                    998:                        ncookies = min(ncookies, (ks->ks_nentries - i));
                    999:                        cookies = malloc(ncookies * sizeof(off_t), M_TEMP,
                   1000:                            M_WAITOK);
                   1001:                        *ap->a_cookies = cookies;
                   1002:                }
                   1003:
                   1004:                dkt = SIMPLEQ_FIRST(&ks->ks_entries);
                   1005:                for (j = 0; j < i && dkt != NULL; j++)
                   1006:                        dkt = SIMPLEQ_NEXT(dkt, dkt_queue);
                   1007:                n = 0;
                   1008:                for (; i < ks->ks_nentries && uio->uio_resid >= UIO_MX; i++) {
                   1009:                        if (i < 2)
                   1010:                                kt = &subdir_targets[i];
                   1011:                        else {
                   1012:                                /* check if ks_nentries lied to us */
                   1013:                                if (dkt == NULL)
                   1014:                                        break;
                   1015:                                kt = &dkt->dkt_kt;
                   1016:                                dkt = SIMPLEQ_NEXT(dkt, dkt_queue);
                   1017:                        }
                   1018:                        if (kt->kt_tag == KFSdevice) {
                   1019:                                dev_t *dp = kt->kt_data;
                   1020:                                struct vnode *fvp;
                   1021:
                   1022:                                if (*dp == NODEV ||
                   1023:                                    !vfinddev(*dp, kt->kt_vtype, &fvp))
                   1024:                                        continue;
1.143     hannken  1025:                                vrele(fvp);
1.102     cl       1026:                        }
                   1027:                        d.d_namlen = kt->kt_namlen;
                   1028:                        if ((error = kernfs_setdirentfileno(&d, i, kfs,
                   1029:                            ks->ks_parent, kt, ap)) != 0)
                   1030:                                break;
                   1031:                        memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1);
                   1032:                        d.d_type = kt->kt_type;
1.103     jrf      1033:                        if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1.102     cl       1034:                                break;
                   1035:                        if (cookies)
                   1036:                                *cookies++ = i + 1;
                   1037:                        n++;
                   1038:                }
                   1039:                ncookies = n;
                   1040:                break;
                   1041:
1.90      itojun   1042:        default:
                   1043:                error = ENOTDIR;
                   1044:                break;
1.57      fvdl     1045:        }
                   1046:
                   1047:        if (ap->a_ncookies) {
                   1048:                if (error) {
1.90      itojun   1049:                        if (cookies)
                   1050:                                free(*ap->a_cookies, M_TEMP);
1.57      fvdl     1051:                        *ap->a_ncookies = 0;
                   1052:                        *ap->a_cookies = NULL;
                   1053:                } else
                   1054:                        *ap->a_ncookies = ncookies;
1.1       cgd      1055:        }
                   1056:
1.38      mycroft  1057:        uio->uio_offset = i;
1.1       cgd      1058:        return (error);
                   1059: }
                   1060:
1.41      christos 1061: int
1.136     dsl      1062: kernfs_inactive(void *v)
1.41      christos 1063: {
1.157     riastrad 1064:        struct vop_inactive_v2_args /* {
1.23      mycroft  1065:                struct vnode *a_vp;
1.134     ad       1066:                bool *a_recycle;
1.41      christos 1067:        } */ *ap = v;
1.23      mycroft  1068:
1.134     ad       1069:        *ap->a_recycle = false;
1.157     riastrad 1070:
1.23      mycroft  1071:        return (0);
                   1072: }
                   1073:
1.41      christos 1074: int
1.136     dsl      1075: kernfs_reclaim(void *v)
1.41      christos 1076: {
1.158   ! riastrad 1077:        struct vop_reclaim_v2_args /* {
1.23      mycroft  1078:                struct vnode *a_vp;
1.41      christos 1079:        } */ *ap = v;
1.153     hannken  1080:        struct vnode *vp = ap->a_vp;
                   1081:        struct kernfs_node *kfs = VTOKERN(vp);
                   1082:
1.158   ! riastrad 1083:        VOP_UNLOCK(vp);
        !          1084:
1.153     hannken  1085:        vp->v_data = NULL;
                   1086:        mutex_enter(&kfs_lock);
                   1087:        TAILQ_REMOVE(&VFSTOKERNFS(vp->v_mount)->nodelist, kfs, kfs_list);
                   1088:        mutex_exit(&kfs_lock);
                   1089:        kmem_free(kfs, sizeof(struct kernfs_node));
1.23      mycroft  1090:
1.153     hannken  1091:        return 0;
1.1       cgd      1092: }
                   1093:
                   1094: /*
1.23      mycroft  1095:  * Return POSIX pathconf information applicable to special devices.
                   1096:  */
1.41      christos 1097: int
1.136     dsl      1098: kernfs_pathconf(void *v)
1.41      christos 1099: {
1.23      mycroft  1100:        struct vop_pathconf_args /* {
                   1101:                struct vnode *a_vp;
                   1102:                int a_name;
1.29      cgd      1103:                register_t *a_retval;
1.41      christos 1104:        } */ *ap = v;
1.23      mycroft  1105:
                   1106:        switch (ap->a_name) {
                   1107:        case _PC_LINK_MAX:
                   1108:                *ap->a_retval = LINK_MAX;
                   1109:                return (0);
                   1110:        case _PC_MAX_CANON:
                   1111:                *ap->a_retval = MAX_CANON;
                   1112:                return (0);
                   1113:        case _PC_MAX_INPUT:
                   1114:                *ap->a_retval = MAX_INPUT;
                   1115:                return (0);
                   1116:        case _PC_PIPE_BUF:
                   1117:                *ap->a_retval = PIPE_BUF;
                   1118:                return (0);
                   1119:        case _PC_CHOWN_RESTRICTED:
                   1120:                *ap->a_retval = 1;
                   1121:                return (0);
                   1122:        case _PC_VDISABLE:
                   1123:                *ap->a_retval = _POSIX_VDISABLE;
1.59      kleink   1124:                return (0);
                   1125:        case _PC_SYNC_IO:
                   1126:                *ap->a_retval = 1;
1.23      mycroft  1127:                return (0);
                   1128:        default:
                   1129:                return (EINVAL);
                   1130:        }
                   1131:        /* NOTREACHED */
                   1132: }
                   1133:
                   1134: /*
                   1135:  * Print out the contents of a /dev/fd vnode.
1.1       cgd      1136:  */
                   1137: /* ARGSUSED */
1.41      christos 1138: int
1.128     christos 1139: kernfs_print(void *v)
1.23      mycroft  1140: {
                   1141:
1.47      christos 1142:        printf("tag VT_KERNFS, kernfs vnode\n");
1.23      mycroft  1143:        return (0);
                   1144: }
                   1145:
1.40      mycroft  1146: int
1.136     dsl      1147: kernfs_link(void *v)
1.41      christos 1148: {
1.155     riastrad 1149:        struct vop_link_v2_args /* {
1.40      mycroft  1150:                struct vnode *a_dvp;
1.107     perry    1151:                struct vnode *a_vp;
1.40      mycroft  1152:                struct componentname *a_cnp;
1.41      christos 1153:        } */ *ap = v;
1.107     perry    1154:
1.40      mycroft  1155:        VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
                   1156:        return (EROFS);
                   1157: }
                   1158:
                   1159: int
1.136     dsl      1160: kernfs_symlink(void *v)
1.41      christos 1161: {
1.149     hannken  1162:        struct vop_symlink_v3_args /* {
1.40      mycroft  1163:                struct vnode *a_dvp;
                   1164:                struct vnode **a_vpp;
                   1165:                struct componentname *a_cnp;
                   1166:                struct vattr *a_vap;
                   1167:                char *a_target;
1.41      christos 1168:        } */ *ap = v;
1.107     perry    1169:
1.40      mycroft  1170:        VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
                   1171:        return (EROFS);
1.1       cgd      1172: }

CVSweb <webmaster@jp.NetBSD.org>