Annotation of src/sys/miscfs/kernfs/kernfs_vnops.c, Revision 1.157
1.157 ! riastrad 1: /* $NetBSD: kernfs_vnops.c,v 1.156 2016/08/20 12:37:09 hannken 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.157 ! riastrad 42: __KERNEL_RCSID(0, "$NetBSD: kernfs_vnops.c,v 1.156 2016/08/20 12:37:09 hannken 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.23 mycroft 1077: struct vop_reclaim_args /* {
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:
1083: vp->v_data = NULL;
1084: mutex_enter(&kfs_lock);
1085: TAILQ_REMOVE(&VFSTOKERNFS(vp->v_mount)->nodelist, kfs, kfs_list);
1086: mutex_exit(&kfs_lock);
1087: kmem_free(kfs, sizeof(struct kernfs_node));
1.23 mycroft 1088:
1.153 hannken 1089: return 0;
1.1 cgd 1090: }
1091:
1092: /*
1.23 mycroft 1093: * Return POSIX pathconf information applicable to special devices.
1094: */
1.41 christos 1095: int
1.136 dsl 1096: kernfs_pathconf(void *v)
1.41 christos 1097: {
1.23 mycroft 1098: struct vop_pathconf_args /* {
1099: struct vnode *a_vp;
1100: int a_name;
1.29 cgd 1101: register_t *a_retval;
1.41 christos 1102: } */ *ap = v;
1.23 mycroft 1103:
1104: switch (ap->a_name) {
1105: case _PC_LINK_MAX:
1106: *ap->a_retval = LINK_MAX;
1107: return (0);
1108: case _PC_MAX_CANON:
1109: *ap->a_retval = MAX_CANON;
1110: return (0);
1111: case _PC_MAX_INPUT:
1112: *ap->a_retval = MAX_INPUT;
1113: return (0);
1114: case _PC_PIPE_BUF:
1115: *ap->a_retval = PIPE_BUF;
1116: return (0);
1117: case _PC_CHOWN_RESTRICTED:
1118: *ap->a_retval = 1;
1119: return (0);
1120: case _PC_VDISABLE:
1121: *ap->a_retval = _POSIX_VDISABLE;
1.59 kleink 1122: return (0);
1123: case _PC_SYNC_IO:
1124: *ap->a_retval = 1;
1.23 mycroft 1125: return (0);
1126: default:
1127: return (EINVAL);
1128: }
1129: /* NOTREACHED */
1130: }
1131:
1132: /*
1133: * Print out the contents of a /dev/fd vnode.
1.1 cgd 1134: */
1135: /* ARGSUSED */
1.41 christos 1136: int
1.128 christos 1137: kernfs_print(void *v)
1.23 mycroft 1138: {
1139:
1.47 christos 1140: printf("tag VT_KERNFS, kernfs vnode\n");
1.23 mycroft 1141: return (0);
1142: }
1143:
1.40 mycroft 1144: int
1.136 dsl 1145: kernfs_link(void *v)
1.41 christos 1146: {
1.155 riastrad 1147: struct vop_link_v2_args /* {
1.40 mycroft 1148: struct vnode *a_dvp;
1.107 perry 1149: struct vnode *a_vp;
1.40 mycroft 1150: struct componentname *a_cnp;
1.41 christos 1151: } */ *ap = v;
1.107 perry 1152:
1.40 mycroft 1153: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
1154: return (EROFS);
1155: }
1156:
1157: int
1.136 dsl 1158: kernfs_symlink(void *v)
1.41 christos 1159: {
1.149 hannken 1160: struct vop_symlink_v3_args /* {
1.40 mycroft 1161: struct vnode *a_dvp;
1162: struct vnode **a_vpp;
1163: struct componentname *a_cnp;
1164: struct vattr *a_vap;
1165: char *a_target;
1.41 christos 1166: } */ *ap = v;
1.107 perry 1167:
1.40 mycroft 1168: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
1169: return (EROFS);
1.1 cgd 1170: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to kernfs_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / miscfs / kernfs