![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devfs_vnops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / miscfs / devfs|
Return to devfs_vnops.c CVS log | Up to [Apple XNU] / XNU / bsd / miscfs / devfs |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright 1997,1998 Julian Elischer. All rights reserved.
24: * [email protected]
25: *
26: * Redistribution and use in source and binary forms, with or without
27: * modification, are permitted provided that the following conditions are
28: * met:
29: * 1. Redistributions of source code must retain the above copyright
30: * notice, this list of conditions and the following disclaimer.
31: * 2. Redistributions in binary form must reproduce the above copyright notice,
32: * this list of conditions and the following disclaimer in the documentation
33: * and/or other materials provided with the distribution.
34: *
35: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS
36: * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
37: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
38: * DISCLAIMED. IN NO EVENT SHALL THE HOLDER OR CONTRIBUTORS BE LIABLE FOR
39: * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
40: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
41: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
42: * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
43: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
44: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
45: * SUCH DAMAGE.
46: *
47: * devfs_vnops.c
48: */
49:
50: /*
51: * HISTORY
52: * Clark Warner ([email protected]) Tue Feb 10 2000
53: * - Added err_copyfile to the vnode operations table
54: * Dieter Siegmund ([email protected]) Thu Apr 8 14:08:19 PDT 1999
55: * - instead of duplicating specfs here, created a vnode-ops table
56: * that redirects most operations to specfs (as is done with ufs);
57: * - removed routines that made no sense
58: * - cleaned up reclaim: replaced devfs_vntodn() with a macro VTODN()
59: * - cleaned up symlink, link locking
60: * - added the devfs_lock to protect devfs data structures against
61: * driver's calling devfs_add_devswf()/etc.
62: * Dieter Siegmund ([email protected]) Wed Jul 14 13:37:59 PDT 1999
63: * - free the devfs devnode in devfs_inactive(), not just in devfs_reclaim()
64: * to free up kernel memory as soon as it's available
65: * - got rid of devfsspec_{read, write}
66: * Dieter Siegmund ([email protected]) Fri Sep 17 09:58:38 PDT 1999
67: * - update the mod/access times
68: */
69:
70: #include <sys/param.h>
71: #include <sys/systm.h>
72: #include <sys/buf.h>
73: #include <sys/namei.h>
74: #include <sys/kernel.h>
75: #include <sys/fcntl.h>
76: #include <sys/conf.h>
77: #include <sys/disklabel.h>
78: #include <sys/lock.h>
79: #include <sys/stat.h>
80: #include <sys/mount.h>
81: #include <sys/proc.h>
82: #include <sys/time.h>
83: #include <sys/vnode.h>
84: #include <miscfs/specfs/specdev.h>
85: #include <sys/dirent.h>
86: #include <sys/vmmeter.h>
87: #include <sys/vm.h>
88:
89: #include "devfsdefs.h"
90:
91: /*
92: * Convert a component of a pathname into a pointer to a locked node.
93: * This is a very central and rather complicated routine.
94: * If the file system is not maintained in a strict tree hierarchy,
95: * this can result in a deadlock situation (see comments in code below).
96: *
97: * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
98: * whether the name is to be looked up, created, renamed, or deleted.
99: * When CREATE, RENAME, or DELETE is specified, information usable in
100: * creating, renaming, or deleting a directory entry may be calculated.
101: * If flag has LOCKPARENT or'ed into it and the target of the pathname
102: * exists, lookup returns both the target and its parent directory locked.
103: * When creating or renaming and LOCKPARENT is specified, the target may
104: * not be ".". When deleting and LOCKPARENT is specified, the target may
105: * be "."., but the caller must check to ensure it does an vrele and DNUNLOCK
106: * instead of two DNUNLOCKs.
107: *
108: * Overall outline of devfs_lookup:
109: *
110: * check accessibility of directory
111: * null terminate the component (lookup leaves the whole string alone)
112: * look for name in cache, if found, then if at end of path
113: * and deleting or creating, drop it, else return name
114: * search for name in directory, to found or notfound
115: * notfound:
116: * if creating, return locked directory,
117: * else return error
118: * found:
119: * if at end of path and deleting, return information to allow delete
120: * if at end of path and rewriting (RENAME and LOCKPARENT), lock target
121: * node and return info to allow rewrite
122: * if not at end, add name to cache; if at end and neither creating
123: * nor deleting, add name to cache
124: * On return to lookup, remove the null termination we put in at the start.
125: *
126: * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent node unlocked.
127: */
128: static int
129: devfs_lookup(struct vop_lookup_args *ap)
130: /*struct vop_lookup_args {
131: struct vnode * a_dvp; directory vnode ptr
132: struct vnode ** a_vpp; where to put the result
133: struct componentname * a_cnp; the name we want
134: };*/
135: {
136: struct componentname *cnp = ap->a_cnp;
137: struct vnode *dir_vnode = ap->a_dvp;
138: struct vnode **result_vnode = ap->a_vpp;
139: devnode_t * dir_node; /* the directory we are searching */
140: devnode_t * node = NULL; /* the node we are searching for */
141: devdirent_t * nodename;
142: int flags = cnp->cn_flags;
143: int op = cnp->cn_nameiop; /* LOOKUP, CREATE, RENAME, or DELETE */
144: int lockparent = flags & LOCKPARENT;
145: int wantparent = flags & (LOCKPARENT|WANTPARENT);
146: int error = 0;
147: struct proc *p = cnp->cn_proc;
148: char heldchar; /* the char at the end of the name componet */
149:
150: *result_vnode = NULL; /* safe not sorry */ /*XXX*/
151:
152: if (dir_vnode->v_usecount == 0)
153: printf("devfs_lookup: dir had no refs ");
154: dir_node = VTODN(dir_vnode);
155:
156: /*
157: * Check accessiblity of directory.
158: */
159: if (dir_node->dn_type != DEV_DIR) {
160: return (ENOTDIR);
161: }
162:
163: if ((error = VOP_ACCESS(dir_vnode, VEXEC, cnp->cn_cred, p)) != 0) {
164: return (error);
165: }
166:
167: /* temporarily terminate string component */
168: heldchar = cnp->cn_nameptr[cnp->cn_namelen];
169: cnp->cn_nameptr[cnp->cn_namelen] = '\0';
170: DEVFS_LOCK(p);
171: nodename = dev_findname(dir_node,cnp->cn_nameptr);
172: if (nodename) {
173: /* entry exists */
174: node = nodename->de_dnp;
175: node->dn_last_lookup = nodename; /* for unlink */
176: /* Do potential vnode allocation here inside the lock
177: * to make sure that our device node has a non-NULL dn_vn
178: * associated with it. The device node might otherwise
179: * get deleted out from under us (see devfs_dn_free()).
180: */
181: error = devfs_dntovn(node, result_vnode, p);
182: }
183: DEVFS_UNLOCK(p);
184: /* restore saved character */
185: cnp->cn_nameptr[cnp->cn_namelen] = heldchar;
186:
187: if (error)
188: return (error);
189:
190: if (!nodename) { /* no entry */
191: /* If it doesn't exist and we're not the last component,
192: * or we're at the last component, but we're not creating
193: * or renaming, return ENOENT.
194: */
195: if (!(flags & ISLASTCN) || !(op == CREATE || op == RENAME)) {
196: return ENOENT;
197: }
198: /*
199: * Access for write is interpreted as allowing
200: * creation of files in the directory.
201: */
202: if ((error = VOP_ACCESS(dir_vnode, VWRITE,
203: cnp->cn_cred, p)) != 0)
204: {
205: return (error);
206: }
207: /*
208: * We return with the directory locked, so that
209: * the parameters we set up above will still be
210: * valid if we actually decide to add a new entry.
211: * We return ni_vp == NULL to indicate that the entry
212: * does not currently exist; we leave a pointer to
213: * the (locked) directory vnode in namei_data->ni_dvp.
214: * The pathname buffer is saved so that the name
215: * can be obtained later.
216: *
217: * NB - if the directory is unlocked, then this
218: * information cannot be used.
219: */
220: cnp->cn_flags |= SAVENAME;
221: if (!lockparent)
222: VOP_UNLOCK(dir_vnode, 0, p);
223: return (EJUSTRETURN);
224: }
225:
226: /*
227: * If deleting, and at end of pathname, return
228: * parameters which can be used to remove file.
229: * If the wantparent flag isn't set, we return only
230: * the directory (in namei_data->ni_dvp), otherwise we go
231: * on and lock the node, being careful with ".".
232: */
233: if (op == DELETE && (flags & ISLASTCN)) {
234: /*
235: * Write access to directory required to delete files.
236: */
237: if ((error = VOP_ACCESS(dir_vnode, VWRITE,
238: cnp->cn_cred, p)) != 0)
239: return (error);
240: /*
241: * we are trying to delete '.'. What does this mean? XXX
242: */
243: if (dir_node == node) {
244: VREF(dir_vnode);
245: *result_vnode = dir_vnode;
246: return (0);
247: }
248: #ifdef NOTYET
249: /*
250: * If directory is "sticky", then user must own
251: * the directory, or the file in it, else she
252: * may not delete it (unless she's root). This
253: * implements append-only directories.
254: */
255: if ((dir_node->mode & ISVTX) &&
256: cnp->cn_cred->cr_uid != 0 &&
257: cnp->cn_cred->cr_uid != dir_node->uid &&
258: cnp->cn_cred->cr_uid != node->uid) {
259: VOP_UNLOCK(*result_vnode, 0, p);
260: return (EPERM);
261: }
262: #endif
263: if (!lockparent)
264: VOP_UNLOCK(dir_vnode, 0, p);
265: return (0);
266: }
267:
268: /*
269: * If rewriting (RENAME), return the vnode and the
270: * information required to rewrite the present directory
271: * Must get node of directory entry to verify it's a
272: * regular file, or empty directory.
273: */
274: if (op == RENAME && wantparent && (flags & ISLASTCN)) {
275: /*
276: * Are we allowed to change the holding directory?
277: */
278: if ((error = VOP_ACCESS(dir_vnode, VWRITE,
279: cnp->cn_cred, p)) != 0)
280: return (error);
281: /*
282: * Careful about locking second node.
283: * This can only occur if the target is ".".
284: */
285: if (dir_node == node)
286: return (EISDIR);
287: /* hmm save the 'from' name (we need to delete it) */
288: cnp->cn_flags |= SAVENAME;
289: if (!lockparent)
290: VOP_UNLOCK(dir_vnode, 0, p);
291: return (0);
292: }
293:
294: /*
295: * Step through the translation in the name. We do not unlock the
296: * directory because we may need it again if a symbolic link
297: * is relative to the current directory. Instead we save it
298: * unlocked as "saved_dir_node" XXX. We must get the target
299: * node before unlocking
300: * the directory to insure that the node will not be removed
301: * before we get it. We prevent deadlock by always fetching
302: * nodes from the root, moving down the directory tree. Thus
303: * when following backward pointers ".." we must unlock the
304: * parent directory before getting the requested directory.
305: * There is a potential race condition here if both the current
306: * and parent directories are removed before the lock for the
307: * node associated with ".." returns. We hope that this occurs
308: * infrequently since we cannot avoid this race condition without
309: * implementing a sophisticated deadlock detection algorithm.
310: * Note also that this simple deadlock detection scheme will not
311: * work if the file system has any hard links other than ".."
312: * that point backwards in the directory structure.
313: */
314: if (flags & ISDOTDOT) {
315: VOP_UNLOCK(dir_vnode, 0, p); /* race to get the node */
316: if (lockparent && (flags & ISLASTCN))
317: vn_lock(dir_vnode, LK_EXCLUSIVE | LK_RETRY, p);
318: } else if (dir_node == node) {
319: #if 0
320: /*
321: * this next statement is wrong: we already did a vget in
322: * devfs_dntovn(); DWS 4/16/1999
323: */
324: VREF(dir_vnode); /* we want ourself, ie "." */
325: #endif
326: *result_vnode = dir_vnode;
327: } else {
328: if (!lockparent || (flags & ISLASTCN))
329: VOP_UNLOCK(dir_vnode, 0, p);
330: }
331:
332: return (0);
333: }
334:
335: static int
336: devfs_access(struct vop_access_args *ap)
337: /*struct vop_access_args {
338: struct vnode *a_vp;
339: int a_mode;
340: struct ucred *a_cred;
341: struct proc *a_p;
342: } */
343: {
344: /*
345: * mode is filled with a combination of VREAD, VWRITE,
346: * and/or VEXEC bits turned on. In an octal number these
347: * are the Y in 0Y00.
348: */
349: struct vnode *vp = ap->a_vp;
350: int mode = ap->a_mode;
351: struct ucred *cred = ap->a_cred;
352: devnode_t * file_node;
353: gid_t *gp;
354: int i;
355: struct proc *p = ap->a_p;
356:
357: file_node = VTODN(vp);
358: /*
359: * if we are not running as a process, we are in the
360: * kernel and we DO have permission
361: */
362: if (p == NULL)
363: return 0;
364:
365: /*
366: * Access check is based on only one of owner, group, public.
367: * If not owner, then check group. If not a member of the
368: * group, then check public access.
369: */
370: if (cred->cr_uid != file_node->dn_uid)
371: {
372: /* failing that.. try groups */
373: mode >>= 3;
374: gp = cred->cr_groups;
375: for (i = 0; i < cred->cr_ngroups; i++, gp++)
376: {
377: if (file_node->dn_gid == *gp)
378: {
379: goto found;
380: }
381: }
382: /* failing that.. try general access */
383: mode >>= 3;
384: found:
385: ;
386: }
387: if ((file_node->dn_mode & mode) == mode)
388: return (0);
389: /*
390: * Root gets to do anything.
391: * but only use suser prives as a last resort
392: * (Use of super powers is recorded in ap->a_p->p_acflag)
393: */
394: if( suser(cred, &ap->a_p->p_acflag) == 0) /* XXX what if no proc? */
395: return 0;
396: return (EACCES);
397: }
398:
399: static int
400: devfs_getattr(struct vop_getattr_args *ap)
401: /*struct vop_getattr_args {
402: struct vnode *a_vp;
403: struct vattr *a_vap;
404: struct ucred *a_cred;
405: struct proc *a_p;
406: } */
407: {
408: struct vnode *vp = ap->a_vp;
409: struct vattr *vap = ap->a_vap;
410: devnode_t * file_node;
411: struct timeval tv;
412:
413: file_node = VTODN(vp);
414: tv = time;
415: dn_times(file_node, tv, tv);
416: vap->va_rdev = 0;/* default value only */
417: vap->va_mode = file_node->dn_mode;
418: switch (file_node->dn_type)
419: {
420: case DEV_DIR:
421: vap->va_rdev = (dev_t)file_node->dn_dvm;
422: vap->va_mode |= (S_IFDIR);
423: break;
424: case DEV_CDEV:
425: vap->va_rdev = file_node->dn_typeinfo.dev;
426: vap->va_mode |= (S_IFCHR);
427: break;
428: case DEV_BDEV:
429: vap->va_rdev = file_node->dn_typeinfo.dev;
430: vap->va_mode |= (S_IFBLK);
431: break;
432: case DEV_SLNK:
433: vap->va_mode |= (S_IFLNK);
434: break;
435: }
436: vap->va_type = vp->v_type;
437: vap->va_nlink = file_node->dn_links;
438: vap->va_uid = file_node->dn_uid;
439: vap->va_gid = file_node->dn_gid;
440: vap->va_fsid = (int32_t)(void *)file_node->dn_dvm;
441: vap->va_fileid = (int32_t)(void *)file_node;
442: vap->va_size = file_node->dn_len; /* now a u_quad_t */
443: /* this doesn't belong here */
444: if (vp->v_type == VBLK)
445: vap->va_blocksize = BLKDEV_IOSIZE;
446: else if (vp->v_type == VCHR)
447: vap->va_blocksize = MAXPHYSIO;
448: else
449: vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
450: /* if the time is bogus, set it to the boot time */
451: if (file_node->dn_ctime.tv_sec == 0)
452: file_node->dn_ctime.tv_sec = boottime.tv_sec;
453: if (file_node->dn_mtime.tv_sec == 0)
454: file_node->dn_mtime.tv_sec = boottime.tv_sec;
455: if (file_node->dn_atime.tv_sec == 0)
456: file_node->dn_atime.tv_sec = boottime.tv_sec;
457: vap->va_ctime = file_node->dn_ctime;
458: vap->va_mtime = file_node->dn_mtime;
459: vap->va_atime = file_node->dn_atime;
460: vap->va_gen = 0;
461: vap->va_flags = 0;
462: vap->va_bytes = file_node->dn_len; /* u_quad_t */
463: vap->va_filerev = 0; /* XXX */ /* u_quad_t */
464: vap->va_vaflags = 0; /* XXX */
465: return 0;
466: }
467:
468: static int
469: devfs_setattr(struct vop_setattr_args *ap)
470: /*struct vop_setattr_args {
471: struct vnode *a_vp;
472: struct vattr *a_vap;
473: struct ucred *a_cred;
474: struct proc *a_p;
475: } */
476: {
477: struct vnode *vp = ap->a_vp;
478: struct vattr *vap = ap->a_vap;
479: struct ucred *cred = ap->a_cred;
480: struct proc *p = ap->a_p;
481: int error = 0;
482: gid_t *gp;
483: int i;
484: devnode_t * file_node;
485: struct timeval atimeval, mtimeval;
486:
487: if (vap->va_flags != VNOVAL) /* XXX needs to be implemented */
488: return (EOPNOTSUPP);
489:
490: file_node = VTODN(vp);
491:
492: if ((vap->va_type != VNON) ||
493: (vap->va_nlink != VNOVAL) ||
494: (vap->va_fsid != VNOVAL) ||
495: (vap->va_fileid != VNOVAL) ||
496: (vap->va_blocksize != VNOVAL) ||
497: (vap->va_rdev != VNOVAL) ||
498: (vap->va_bytes != VNOVAL) ||
499: (vap->va_gen != VNOVAL ))
500: {
501: return EINVAL;
502: }
503:
504: /*
505: * Go through the fields and update iff not VNOVAL.
506: */
507: if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
508: if (cred->cr_uid != file_node->dn_uid &&
509: (error = suser(cred, &p->p_acflag)) &&
510: ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
511: (error = VOP_ACCESS(vp, VWRITE, cred, p))))
512: return (error);
513: if (vap->va_atime.tv_sec != VNOVAL)
514: file_node->dn_flags |= DN_ACCESS;
515: if (vap->va_mtime.tv_sec != VNOVAL)
516: file_node->dn_flags |= DN_CHANGE | DN_UPDATE;
517: atimeval.tv_sec = vap->va_atime.tv_sec;
518: atimeval.tv_usec = vap->va_atime.tv_nsec / 1000;
519: mtimeval.tv_sec = vap->va_mtime.tv_sec;
520: mtimeval.tv_usec = vap->va_mtime.tv_nsec / 1000;
521: if (error = VOP_UPDATE(vp, &atimeval, &mtimeval, 1))
522: return (error);
523: }
524:
525: /*
526: * Change the permissions.. must be root or owner to do this.
527: */
528: if (vap->va_mode != (u_short)VNOVAL) {
529: if ((cred->cr_uid != file_node->dn_uid)
530: && (error = suser(cred, &p->p_acflag)))
531: return (error);
532: file_node->dn_mode &= ~07777;
533: file_node->dn_mode |= vap->va_mode & 07777;
534: }
535:
536: /*
537: * Change the owner.. must be root to do this.
538: */
539: if (vap->va_uid != (uid_t)VNOVAL) {
540: if (error = suser(cred, &p->p_acflag))
541: return (error);
542: file_node->dn_uid = vap->va_uid;
543: }
544:
545: /*
546: * Change the group.. must be root or owner to do this.
547: * If we are the owner, we must be in the target group too.
548: * don't use suser() unless you have to as it reports
549: * whether you needed suser powers or not.
550: */
551: if (vap->va_gid != (gid_t)VNOVAL) {
552: if (cred->cr_uid == file_node->dn_uid){
553: gp = cred->cr_groups;
554: for (i = 0; i < cred->cr_ngroups; i++, gp++) {
555: if (vap->va_gid == *gp)
556: goto cando;
557: }
558: }
559: /*
560: * we can't do it with normal privs,
561: * do we have an ace up our sleeve?
562: */
563: if (error = suser(cred, &p->p_acflag))
564: return (error);
565: cando:
566: file_node->dn_gid = vap->va_gid;
567: }
568: #if 0
569: /*
570: * Copied from somewhere else
571: * but only kept as a marker and reminder of the fact that
572: * flags should be handled some day
573: */
574: if (vap->va_flags != VNOVAL) {
575: if (error = suser(cred, &p->p_acflag))
576: return error;
577: if (cred->cr_uid == 0)
578: ;
579: else {
580: }
581: }
582: #endif
583: return error;
584: }
585:
586: static int
587: devfs_read(struct vop_read_args *ap)
588: /*struct vop_read_args {
589: struct vnode *a_vp;
590: struct uio *a_uio;
591: int a_ioflag;
592: struct ucred *a_cred;
593: } */
594: {
595: devnode_t * dn_p = VTODN(ap->a_vp);
596:
597: switch (ap->a_vp->v_type) {
598: case VDIR: {
599: dn_p->dn_flags |= DN_ACCESS;
600: return VOP_READDIR(ap->a_vp, ap->a_uio, ap->a_cred,
601: NULL, NULL, NULL);
602: }
603: default: {
604: printf("devfs_read(): bad file type %d", ap->a_vp->v_type);
605: return(EINVAL);
606: break;
607: }
608: }
609: return (0); /* not reached */
610: }
611:
612: static int
613: devfs_close(ap)
614: struct vop_close_args /* {
615: struct vnode *a_vp;
616: int a_fflag;
617: struct ucred *a_cred;
618: struct proc *a_p;
619: } */ *ap;
620: {
621: struct vnode * vp = ap->a_vp;
622: register devnode_t * dnp = VTODN(vp);
623:
624: simple_lock(&vp->v_interlock);
625: if (vp->v_usecount > 1)
626: dn_times(dnp, time, time);
627: simple_unlock(&vp->v_interlock);
628: return (0);
629: }
630:
631: static int
632: devfsspec_close(ap)
633: struct vop_close_args /* {
634: struct vnode *a_vp;
635: int a_fflag;
636: struct ucred *a_cred;
637: struct proc *a_p;
638: } */ *ap;
639: {
640: struct vnode * vp = ap->a_vp;
641: register devnode_t * dnp = VTODN(vp);
642:
643: simple_lock(&vp->v_interlock);
644: if (vp->v_usecount > 1)
645: dn_times(dnp, time, time);
646: simple_unlock(&vp->v_interlock);
647: return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap));
648: }
649:
650: static int
651: devfsspec_read(struct vop_read_args *ap)
652: /*struct vop_read_args {
653: struct vnode *a_vp;
654: struct uio *a_uio;
655: int a_ioflag;
656: struct ucred *a_cred;
657: } */
658: {
659: VTODN(ap->a_vp)->dn_flags |= DN_ACCESS;
660: return (VOCALL (spec_vnodeop_p, VOFFSET(vop_read), ap));
661: }
662:
663: static int
664: devfsspec_write(struct vop_write_args *ap)
665: /*struct vop_write_args {
666: struct vnode *a_vp;
667: struct uio *a_uio;
668: int a_ioflag;
669: struct ucred *a_cred;
670: } */
671: {
672: VTODN(ap->a_vp)->dn_flags |= DN_CHANGE | DN_UPDATE;
673: return (VOCALL (spec_vnodeop_p, VOFFSET(vop_write), ap));
674: }
675:
676: /*
677: * Write data to a file or directory.
678: */
679: static int
680: devfs_write(struct vop_write_args *ap)
681: /*struct vop_write_args {
682: struct vnode *a_vp;
683: struct uio *a_uio;
684: int a_ioflag;
685: struct ucred *a_cred;
686: } */
687: {
688: switch (ap->a_vp->v_type) {
689: case VDIR:
690: return(EISDIR);
691: default:
692: printf("devfs_write(): bad file type %d", ap->a_vp->v_type);
693: return (EINVAL);
694: }
695: return 0; /* not reached */
696: }
697:
698: static int
699: devfs_remove(struct vop_remove_args *ap)
700: /*struct vop_remove_args {
701: struct vnode *a_dvp;
702: struct vnode *a_vp;
703: struct componentname *a_cnp;
704: } */
705: {
706: struct vnode *vp = ap->a_vp;
707: struct vnode *dvp = ap->a_dvp;
708: struct componentname *cnp = ap->a_cnp;
709: devnode_t * tp;
710: devnode_t * tdp;
711: devdirent_t * tnp;
712: int doingdirectory = 0;
713: int error = 0;
714: uid_t ouruid = cnp->cn_cred->cr_uid;
715: struct proc *p = cnp->cn_proc;
716:
717: /*
718: * Lock our directories and get our name pointers
719: * assume that the names are null terminated as they
720: * are the end of the path. Get pointers to all our
721: * devfs structures.
722: */
723: tp = VTODN(vp);
724: tdp = VTODN(dvp);
725: /*
726: * Assuming we are atomic, dev_lookup left this for us
727: */
728: tnp = tp->dn_last_lookup;
729:
730: /*
731: * Check we are doing legal things WRT the new flags
732: */
733: if ((tp->dn_flags & (IMMUTABLE | APPEND))
734: || (tdp->dn_flags & APPEND) /*XXX eh?*/ ) {
735: error = EPERM;
736: goto abort;
737: }
738:
739: /*
740: * Make sure that we don't try do something stupid
741: */
742: if ((tp->dn_type) == DEV_DIR) {
743: /*
744: * Avoid ".", "..", and aliases of "." for obvious reasons.
745: */
746: if ( (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.')
747: || (cnp->cn_flags&ISDOTDOT) ) {
748: error = EINVAL;
749: goto abort;
750: }
751: doingdirectory++;
752: }
753:
754: /***********************************
755: * Start actually doing things.... *
756: ***********************************/
757: tdp->dn_flags |= DN_CHANGE | DN_UPDATE;
758:
759: /*
760: * own the parent directory, or the destination of the rename,
761: * otherwise the destination may not be changed (except by
762: * root). This implements append-only directories.
763: * XXX shoudn't this be in generic code?
764: */
765: if ((tdp->dn_mode & S_ISTXT)
766: && ouruid != 0
767: && ouruid != tdp->dn_uid
768: && ouruid != tp->dn_uid ) {
769: error = EPERM;
770: goto abort;
771: }
772: /*
773: * Target must be empty if a directory and have no links
774: * to it. Also, ensure source and target are compatible
775: * (both directories, or both not directories).
776: */
777: if (( doingdirectory) && (tp->dn_links > 2)) {
778: error = ENOTEMPTY;
779: goto abort;
780: }
781: DEVFS_LOCK(p);
782: dev_free_name(tnp);
783: DEVFS_UNLOCK(p);
784: abort:
785: if (dvp == vp)
786: vrele(vp);
787: else
788: vput(vp);
789: vput(dvp);
790: return (error);
791: }
792:
793: /*
794: */
795: static int
796: devfs_link(struct vop_link_args *ap)
797: /*struct vop_link_args {
798: struct vnode *a_tdvp;
799: struct vnode *a_vp;
800: struct componentname *a_cnp;
801: } */
802: {
803: struct vnode *vp = ap->a_vp;
804: struct vnode *tdvp = ap->a_tdvp;
805: struct componentname *cnp = ap->a_cnp;
806: struct proc *p = cnp->cn_proc;
807: devnode_t * fp;
808: devnode_t * tdp;
809: devdirent_t * tnp;
810: int error = 0;
811: struct timeval tv;
812:
813: /*
814: * First catch an arbitrary restriction for this FS
815: */
816: if (cnp->cn_namelen > DEVMAXNAMESIZE) {
817: error = ENAMETOOLONG;
818: goto out1;
819: }
820:
821: /*
822: * Lock our directories and get our name pointers
823: * assume that the names are null terminated as they
824: * are the end of the path. Get pointers to all our
825: * devfs structures.
826: */
827: tdp = VTODN(tdvp);
828: fp = VTODN(vp);
829:
830: if (tdvp->v_mount != vp->v_mount) {
831: error = EXDEV;
832: VOP_ABORTOP(tdvp, cnp);
833: goto out2;
834: }
835: if (tdvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, p))) {
836: VOP_ABORTOP(tdvp, cnp);
837: goto out2;
838: }
839:
840: /*
841: * Check we are doing legal things WRT the new flags
842: */
843: if (fp->dn_flags & (IMMUTABLE | APPEND)) {
844: VOP_ABORTOP(tdvp, cnp);
845: error = EPERM;
846: goto out1;
847: }
848:
849: /***********************************
850: * Start actually doing things.... *
851: ***********************************/
852: fp->dn_flags |= DN_CHANGE;
853: tv = time;
854: error = VOP_UPDATE(vp, &tv, &tv, 1);
855: if (!error) {
856: DEVFS_LOCK(p);
857: error = dev_add_name(cnp->cn_nameptr, tdp, NULL, fp, &tnp);
858: DEVFS_UNLOCK(p);
859: }
860: out1:
861: if (tdvp != vp)
862: VOP_UNLOCK(vp, 0, p);
863: out2:
864: vput(tdvp);
865: return (error);
866: }
867:
868: /*
869: * Check if source directory is in the path of the target directory.
870: * Target is supplied locked, source is unlocked.
871: * The target is always vput before returning.
872: */
873: int
874: devfs_checkpath(source, target)
875: devnode_t *source, *target;
876: {
877: int error = 0;
878: devnode_t * ntmp;
879: devnode_t * tmp;
880: struct vnode *vp;
881:
882: vp = target->dn_vn;
883: tmp = target;
884:
885: do {
886: if (tmp == source) {
887: error = EINVAL;
888: break;
889: }
890: ntmp = tmp;
891: } while ((tmp = tmp->dn_typeinfo.Dir.parent) != ntmp);
892:
893: if (vp != NULL)
894: vput(vp);
895: return (error);
896: }
897:
898: /*
899: * Rename system call. Seems overly complicated to me...
900: * rename("foo", "bar");
901: * is essentially
902: * unlink("bar");
903: * link("foo", "bar");
904: * unlink("foo");
905: * but ``atomically''.
906: *
907: * When the target exists, both the directory
908: * and target vnodes are locked.
909: * the source and source-parent vnodes are referenced
910: *
911: *
912: * Basic algorithm is:
913: *
914: * 1) Bump link count on source while we're linking it to the
915: * target. This also ensure the inode won't be deleted out
916: * from underneath us while we work (it may be truncated by
917: * a concurrent `trunc' or `open' for creation).
918: * 2) Link source to destination. If destination already exists,
919: * delete it first.
920: * 3) Unlink source reference to node if still around. If a
921: * directory was moved and the parent of the destination
922: * is different from the source, patch the ".." entry in the
923: * directory.
924: */
925: static int
926: devfs_rename(struct vop_rename_args *ap)
927: /*struct vop_rename_args {
928: struct vnode *a_fdvp;
929: struct vnode *a_fvp;
930: struct componentname *a_fcnp;
931: struct vnode *a_tdvp;
932: struct vnode *a_tvp;
933: struct componentname *a_tcnp;
934: } */
935: {
936: struct vnode *tvp = ap->a_tvp;
937: struct vnode *tdvp = ap->a_tdvp;
938: struct vnode *fvp = ap->a_fvp;
939: struct vnode *fdvp = ap->a_fdvp;
940: struct componentname *tcnp = ap->a_tcnp;
941: struct componentname *fcnp = ap->a_fcnp;
942: struct proc *p = fcnp->cn_proc;
943: devnode_t *fp, *fdp, *tp, *tdp;
944: devdirent_t *fnp,*tnp;
945: int doingdirectory = 0;
946: int error = 0;
947: struct timeval tv;
948:
949: /*
950: * First catch an arbitrary restriction for this FS
951: */
952: if(tcnp->cn_namelen > DEVMAXNAMESIZE) {
953: error = ENAMETOOLONG;
954: goto abortit;
955: }
956:
957: /*
958: * Lock our directories and get our name pointers
959: * assume that the names are null terminated as they
960: * are the end of the path. Get pointers to all our
961: * devfs structures.
962: */
963: tdp = VTODN(tdvp);
964: fdp = VTODN(fdvp);
965: fp = VTODN(fvp);
966: fnp = fp->dn_last_lookup;
967: tp = NULL;
968: tnp = NULL;
969: if (tvp) {
970: tp = VTODN(tvp);
971: tnp = tp->dn_last_lookup;
972: }
973:
974: /*
975: * trying to move it out of devfs?
976: * if we move a dir across mnt points. we need to fix all
977: * the mountpoint pointers! XXX
978: * so for now keep dirs within the same mount
979: */
980: if ((fvp->v_mount != tdvp->v_mount) ||
981: (tvp && (fvp->v_mount != tvp->v_mount))) {
982: error = EXDEV;
983: abortit:
984: VOP_ABORTOP(tdvp, tcnp);
985: if (tdvp == tvp) /* eh? */
986: vrele(tdvp);
987: else
988: vput(tdvp);
989: if (tvp)
990: vput(tvp);
991: VOP_ABORTOP(fdvp, fcnp); /* XXX, why not in NFS? */
992: vrele(fdvp);
993: vrele(fvp);
994: return (error);
995: }
996:
997: /*
998: * Check we are doing legal things WRT the new flags
999: */
1000: if ((tp && (tp->dn_flags & (IMMUTABLE | APPEND)))
1001: || (fp->dn_flags & (IMMUTABLE | APPEND))
1002: || (fdp->dn_flags & APPEND)) {
1003: error = EPERM;
1004: goto abortit;
1005: }
1006:
1007: /*
1008: * Make sure that we don't try do something stupid
1009: */
1010: if ((fp->dn_type) == DEV_DIR) {
1011: /*
1012: * Avoid ".", "..", and aliases of "." for obvious reasons.
1013: */
1014: if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.')
1015: || (fcnp->cn_flags&ISDOTDOT)
1016: || (tcnp->cn_namelen == 1 && tcnp->cn_nameptr[0] == '.')
1017: || (tcnp->cn_flags&ISDOTDOT)
1018: || (tdp == fp )) {
1019: error = EINVAL;
1020: goto abortit;
1021: }
1022: doingdirectory++;
1023: }
1024:
1025: /*
1026: * If ".." must be changed (ie the directory gets a new
1027: * parent) then the source directory must not be in the
1028: * directory hierarchy above the target, as this would
1029: * orphan everything below the source directory. Also
1030: * the user must have write permission in the source so
1031: * as to be able to change "..".
1032: */
1033: if (doingdirectory && (tdp != fdp)) {
1034: devnode_t * tmp, *ntmp;
1035: error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc);
1036: tmp = tdp;
1037: do {
1038: if(tmp == fp) {
1039: /* XXX unlock stuff here probably */
1040: error = EINVAL;
1041: goto out;
1042: }
1043: ntmp = tmp;
1044: } while ((tmp = tmp->dn_typeinfo.Dir.parent) != ntmp);
1045: }
1046:
1047: /***********************************
1048: * Start actually doing things.... *
1049: ***********************************/
1050: fp->dn_flags |= DN_CHANGE;
1051: tv = time;
1052: if (error = VOP_UPDATE(fvp, &tv, &tv, 1)) {
1053: VOP_UNLOCK(fvp, 0, p);
1054: goto bad;
1055: }
1056: /*
1057: * Check if just deleting a link name.
1058: */
1059: if (fvp == tvp) {
1060: if (fvp->v_type == VDIR) {
1061: error = EINVAL;
1062: goto abortit;
1063: }
1064:
1065: /* Release destination completely. */
1066: VOP_ABORTOP(tdvp, tcnp);
1067: vput(tdvp);
1068: vput(tvp);
1069:
1070: /* Delete source. */
1071: VOP_ABORTOP(fdvp, fcnp); /*XXX*/
1072: vrele(fdvp);
1073: vrele(fvp);
1074: dev_free_name(fnp);
1075: return 0;
1076: }
1077:
1078: vrele(fdvp);
1079:
1080: /*
1081: * 1) Bump link count while we're moving stuff
1082: * around. If we crash somewhere before
1083: * completing our work, too bad :)
1084: */
1085: fp->dn_links++;
1086: /*
1087: * If the target exists zap it (unless it's a non-empty directory)
1088: * We could do that as well but won't
1089: */
1090: if (tp) {
1091: int ouruid = tcnp->cn_cred->cr_uid;
1092: /*
1093: * If the parent directory is "sticky", then the user must
1094: * own the parent directory, or the destination of the rename,
1095: * otherwise the destination may not be changed (except by
1096: * root). This implements append-only directories.
1097: * XXX shoudn't this be in generic code?
1098: */
1099: if ((tdp->dn_mode & S_ISTXT)
1100: && ouruid != 0
1101: && ouruid != tdp->dn_uid
1102: && ouruid != tp->dn_uid ) {
1103: error = EPERM;
1104: goto bad;
1105: }
1106: /*
1107: * Target must be empty if a directory and have no links
1108: * to it. Also, ensure source and target are compatible
1109: * (both directories, or both not directories).
1110: */
1111: if (( doingdirectory) && (tp->dn_links > 2)) {
1112: error = ENOTEMPTY;
1113: goto bad;
1114: }
1115: dev_free_name(tnp);
1116: tp = NULL;
1117: }
1118: dev_add_name(tcnp->cn_nameptr,tdp,NULL,fp,&tnp);
1119: fnp->de_dnp = NULL;
1120: fp->dn_links--; /* one less link to it.. */
1121: dev_free_name(fnp);
1122: fp->dn_links--; /* we added one earlier*/
1123: if (tdp)
1124: vput(tdvp);
1125: if (tp)
1126: vput(fvp);
1127: vrele(fvp);
1128: return (error);
1129:
1130: bad:
1131: if (tp)
1132: vput(tvp);
1133: vput(tdvp);
1134: out:
1135: if (vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, p) == 0) {
1136: fp->dn_links--; /* we added one earlier*/
1137: vput(fvp);
1138: } else
1139: vrele(fvp);
1140: return (error);
1141: }
1142:
1143: static int
1144: devfs_symlink(struct vop_symlink_args *ap)
1145: /*struct vop_symlink_args {
1146: struct vnode *a_dvp;
1147: struct vnode **a_vpp;
1148: struct componentname *a_cnp;
1149: struct vattr *a_vap;
1150: char *a_target;
1151: } */
1152: {
1153: struct componentname * cnp = ap->a_cnp;
1154: struct vnode *vp = NULL;
1155: int error = 0;
1156: devnode_t * dir_p;
1157: devnode_type_t typeinfo;
1158: devdirent_t * nm_p;
1159: devnode_t * dev_p;
1160: struct vattr * vap = ap->a_vap;
1161: struct vnode * * vpp = ap->a_vpp;
1162: struct proc *p = cnp->cn_proc;
1163: struct timeval tv;
1164:
1165: dir_p = VTODN(ap->a_dvp);
1166: typeinfo.Slnk.name = ap->a_target;
1167: typeinfo.Slnk.namelen = strlen(ap->a_target);
1168: DEVFS_LOCK(p);
1169: error = dev_add_entry(cnp->cn_nameptr, dir_p, DEV_SLNK,
1170: &typeinfo, NULL, NULL, &nm_p);
1171: DEVFS_UNLOCK(p);
1172: if (error) {
1173: goto failure;
1174: }
1175:
1176: dev_p = nm_p->de_dnp;
1177: dev_p->dn_uid = dir_p->dn_uid;
1178: dev_p->dn_gid = dir_p->dn_gid;
1179: dev_p->dn_mode = vap->va_mode;
1180: dn_copy_times(dev_p, dir_p);
1181: error = devfs_dntovn(dev_p, vpp, p);
1182: if (error)
1183: goto failure;
1184: vp = *vpp;
1185: vput(vp);
1186: failure:
1187: if ((cnp->cn_flags & SAVESTART) == 0)
1188: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1189: vput(ap->a_dvp);
1190: return error;
1191: }
1192:
1193: /*
1194: * Mknod vnode call
1195: */
1196: /* ARGSUSED */
1197: int
1198: devfs_mknod(ap)
1199: struct vop_mknod_args /* {
1200: struct vnode *a_dvp;
1201: struct vnode **a_vpp;
1202: struct componentname *a_cnp;
1203: struct vattr *a_vap;
1204: } */ *ap;
1205: {
1206: struct componentname * cnp = ap->a_cnp;
1207: devnode_t * dev_p;
1208: devdirent_t * devent;
1209: devnode_t * dir_p; /* devnode for parent directory */
1210: struct vnode * dvp = ap->a_dvp;
1211: int error = 0;
1212: devnode_type_t typeinfo;
1213: struct vattr * vap = ap->a_vap;
1214: struct vnode ** vpp = ap->a_vpp;
1215: struct proc * p = cnp->cn_proc;
1216:
1217: *vpp = NULL;
1218: if (!vap->va_type == VBLK && !vap->va_type == VCHR) {
1219: error = EINVAL; /* only support mknod of special files */
1220: goto failure;
1221: }
1222: dir_p = VTODN(dvp);
1223: typeinfo.dev = vap->va_rdev;
1224: DEVFS_LOCK(p);
1225: error = dev_add_entry(cnp->cn_nameptr, dir_p,
1226: (vap->va_type == VBLK) ? DEV_BDEV : DEV_CDEV,
1227: &typeinfo, NULL, NULL, &devent);
1228: DEVFS_UNLOCK(p);
1229: if (error) {
1230: goto failure;
1231: }
1232: dev_p = devent->de_dnp;
1233: error = devfs_dntovn(dev_p, vpp, p);
1234: if (error)
1235: goto failure;
1236: dev_p->dn_uid = cnp->cn_cred->cr_uid;
1237: dev_p->dn_gid = dir_p->dn_gid;
1238: dev_p->dn_mode = vap->va_mode;
1239: failure:
1240: if (*vpp) {
1241: vput(*vpp);
1242: *vpp = 0;
1243: }
1244: if ((cnp->cn_flags & SAVESTART) == 0)
1245: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1246: vput(dvp);
1247: return (error);
1248: }
1249:
1250: /*
1251: * Vnode op for readdir
1252: */
1253: static int
1254: devfs_readdir(struct vop_readdir_args *ap)
1255: /*struct vop_readdir_args {
1256: struct vnode *a_vp;
1257: struct uio *a_uio;
1258: struct ucred *a_cred;
1259: int *eofflag;
1260: int *ncookies;
1261: u_int **cookies;
1262: } */
1263: {
1264: struct vnode *vp = ap->a_vp;
1265: struct uio *uio = ap->a_uio;
1266: struct dirent dirent;
1267: devnode_t * dir_node;
1268: devdirent_t * name_node;
1269: char *name;
1270: int error = 0;
1271: int reclen;
1272: int nodenumber;
1273: int startpos,pos;
1274: struct proc * p = uio->uio_procp;
1275:
1276: /* set up refs to dir */
1277: dir_node = VTODN(vp);
1278: if(dir_node->dn_type != DEV_DIR)
1279: return(ENOTDIR);
1280:
1281: pos = 0;
1282: startpos = uio->uio_offset;
1283: DEVFS_LOCK(p);
1284: name_node = dir_node->dn_typeinfo.Dir.dirlist;
1285: nodenumber = 0;
1286: dir_node->dn_flags |= DN_ACCESS;
1287:
1288: while ((name_node || (nodenumber < 2)) && (uio->uio_resid > 0))
1289: {
1290: switch(nodenumber)
1291: {
1292: case 0:
1293: dirent.d_fileno = (int32_t)(void *)dir_node;
1294: name = ".";
1295: dirent.d_namlen = 1;
1296: dirent.d_type = DT_DIR;
1297: break;
1298: case 1:
1299: if(dir_node->dn_typeinfo.Dir.parent)
1300: dirent.d_fileno
1301: = (int32_t)dir_node->dn_typeinfo.Dir.parent;
1302: else
1303: dirent.d_fileno = (u_int32_t)dir_node;
1304: name = "..";
1305: dirent.d_namlen = 2;
1306: dirent.d_type = DT_DIR;
1307: break;
1308: default:
1309: dirent.d_fileno = (int32_t)(void *)name_node->de_dnp;
1310: dirent.d_namlen = strlen(name_node->de_name);
1311: name = name_node->de_name;
1312: switch(name_node->de_dnp->dn_type) {
1313: case DEV_BDEV:
1314: dirent.d_type = DT_BLK;
1315: break;
1316: case DEV_CDEV:
1317: dirent.d_type = DT_CHR;
1318: break;
1319: case DEV_DIR:
1320: dirent.d_type = DT_DIR;
1321: break;
1322: case DEV_SLNK:
1323: dirent.d_type = DT_LNK;
1324: break;
1325: default:
1326: dirent.d_type = DT_UNKNOWN;
1327: }
1328: }
1329: #define GENERIC_DIRSIZ(dp) \
1330: ((sizeof (struct dirent) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))
1331:
1332: reclen = dirent.d_reclen = GENERIC_DIRSIZ(&dirent);
1333:
1334: if(pos >= startpos) /* made it to the offset yet? */
1335: {
1336: if (uio->uio_resid < reclen) /* will it fit? */
1337: break;
1338: strcpy( dirent.d_name,name);
1339: if ((error = uiomove ((caddr_t)&dirent,
1340: dirent.d_reclen, uio)) != 0)
1341: break;
1342: }
1343: pos += reclen;
1344: if((nodenumber >1) && name_node)
1345: name_node = name_node->de_next;
1346: nodenumber++;
1347: }
1348: DEVFS_UNLOCK(p);
1349: uio->uio_offset = pos;
1350:
1351: return (error);
1352: }
1353:
1354:
1355: /*
1356: */
1357: static int
1358: devfs_readlink(struct vop_readlink_args *ap)
1359: /*struct vop_readlink_args {
1360: struct vnode *a_vp;
1361: struct uio *a_uio;
1362: struct ucred *a_cred;
1363: } */
1364: {
1365: struct vnode *vp = ap->a_vp;
1366: struct uio *uio = ap->a_uio;
1367: devnode_t * lnk_node;
1368: int error = 0;
1369:
1370: /* set up refs to dir */
1371: lnk_node = VTODN(vp);
1372: if(lnk_node->dn_type != DEV_SLNK)
1373: return(EINVAL);
1374: if ((error = VOP_ACCESS(vp, VREAD, ap->a_cred, NULL)) != 0) { /* XXX */
1375: return error;
1376: }
1377: error = uiomove(lnk_node->dn_typeinfo.Slnk.name,
1378: lnk_node->dn_typeinfo.Slnk.namelen, uio);
1379: return error;
1380: }
1381:
1382: static int
1383: devfs_abortop(struct vop_abortop_args *ap)
1384: /*struct vop_abortop_args {
1385: struct vnode *a_dvp;
1386: struct componentname *a_cnp;
1387: } */
1388: {
1389: if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) {
1390: FREE_ZONE(ap->a_cnp->cn_pnbuf, ap->a_cnp->cn_pnlen, M_NAMEI);
1391: }
1392: return 0;
1393: }
1394:
1395:
1396: static int
1397: devfs_reclaim(struct vop_reclaim_args *ap)
1398: /*struct vop_reclaim_args {
1399: struct vnode *a_vp;
1400: } */
1401: {
1402: struct vnode * vp = ap->a_vp;
1403: devnode_t * dnp = VTODN(vp);
1404:
1405: if (dnp) {
1406: /*
1407: * do the same as devfs_inactive in case it is not called
1408: * before us (can that ever happen?)
1409: */
1410: dnp->dn_vn = NULL;
1411: vp->v_data = NULL;
1412: if (dnp->dn_delete) {
1413: devnode_free(dnp);
1414: }
1415: }
1416: return(0);
1417: }
1418:
1419: /*
1420: * Print out the contents of a /devfs vnode.
1421: */
1422: static int
1423: devfs_print(struct vop_print_args *ap)
1424: /*struct vop_print_args {
1425: struct vnode *a_vp;
1426: } */
1427: {
1428:
1429: return (0);
1430: }
1431:
1432: /**************************************************************************\
1433: * pseudo ops *
1434: \**************************************************************************/
1435:
1436: /*
1437: *
1438: * struct vop_inactive_args {
1439: * struct vnode *a_vp;
1440: * struct proc *a_p;
1441: * }
1442: */
1443:
1444: static int
1445: devfs_inactive(struct vop_inactive_args *ap)
1446: {
1447: struct vnode * vp = ap->a_vp;
1448: devnode_t * dnp = VTODN(vp);
1449:
1450: if (dnp) {
1451: dnp->dn_vn = NULL;
1452: vp->v_data = NULL;
1453: if (dnp->dn_delete) {
1454: devnode_free(dnp);
1455: }
1456: }
1457: VOP_UNLOCK(vp, 0, ap->a_p);
1458: return (0);
1459: }
1460:
1461: int
1462: devfs_update(ap)
1463: struct vop_update_args /* {
1464: struct vnode *a_vp;
1465: struct timeval *a_access;
1466: struct timeval *a_modify;
1467: int a_waitfor;
1468: } */ *ap;
1469: {
1470: register struct fs *fs;
1471: int error;
1472: devnode_t * ip;
1473:
1474: ip = VTODN(ap->a_vp);
1475: if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) {
1476: ip->dn_flags &=
1477: ~(DN_ACCESS | DN_CHANGE | DN_MODIFIED | DN_UPDATE);
1478: return (0);
1479: }
1480: if ((ip->dn_flags &
1481: (DN_ACCESS | DN_CHANGE | DN_MODIFIED | DN_UPDATE)) == 0)
1482: return (0);
1483: dn_times(ip, time, time);
1484: return (0);
1485: }
1486:
1487: /* The following ops are used by directories and symlinks */
1488: int (**devfs_vnodeop_p)();
1489: static struct vnodeopv_entry_desc devfs_vnodeop_entries[] = {
1490: { &vop_default_desc, vn_default_error },
1491: { &vop_lookup_desc, devfs_lookup }, /* lookup */
1492: { &vop_create_desc, err_create }, /* create */
1493: { &vop_whiteout_desc, err_whiteout }, /* whiteout */
1494: { &vop_mknod_desc, devfs_mknod }, /* mknod */
1495: { &vop_open_desc, nop_open }, /* open */
1496: { &vop_close_desc, devfs_close }, /* close */
1497: { &vop_access_desc, devfs_access }, /* access */
1498: { &vop_getattr_desc, devfs_getattr }, /* getattr */
1499: { &vop_setattr_desc, devfs_setattr }, /* setattr */
1500: { &vop_read_desc, devfs_read }, /* read */
1501: { &vop_write_desc, devfs_write }, /* write */
1502: { &vop_lease_desc, nop_lease }, /* lease */
1503: { &vop_ioctl_desc, err_ioctl }, /* ioctl */
1504: { &vop_select_desc, err_select }, /* select */
1505: { &vop_revoke_desc, err_revoke }, /* revoke */
1506: { &vop_mmap_desc, err_mmap }, /* mmap */
1507: { &vop_fsync_desc, nop_fsync }, /* fsync */
1508: { &vop_seek_desc, err_seek }, /* seek */
1509: { &vop_remove_desc, devfs_remove }, /* remove */
1510: { &vop_link_desc, devfs_link }, /* link */
1511: { &vop_rename_desc, devfs_rename }, /* rename */
1512: { &vop_mkdir_desc, err_mkdir }, /* mkdir */
1513: { &vop_rmdir_desc, err_rmdir }, /* rmdir */
1514: { &vop_symlink_desc, devfs_symlink }, /* symlink */
1515: { &vop_readdir_desc, devfs_readdir }, /* readdir */
1516: { &vop_readlink_desc, devfs_readlink }, /* readlink */
1517: { &vop_abortop_desc, devfs_abortop }, /* abortop */
1518: { &vop_inactive_desc, devfs_inactive }, /* inactive */
1519: { &vop_reclaim_desc, devfs_reclaim }, /* reclaim */
1520: { &vop_lock_desc, nop_lock }, /* lock */
1521: { &vop_unlock_desc, nop_unlock }, /* unlock */
1522: { &vop_bmap_desc, err_bmap }, /* bmap */
1523: { &vop_strategy_desc, err_strategy }, /* strategy */
1524: { &vop_print_desc, err_print }, /* print */
1525: { &vop_islocked_desc, nop_islocked }, /* islocked */
1526: { &vop_pathconf_desc, err_pathconf }, /* pathconf */
1527: { &vop_advlock_desc, err_advlock }, /* advlock */
1528: { &vop_blkatoff_desc, err_blkatoff }, /* blkatoff */
1529: { &vop_valloc_desc, err_valloc }, /* valloc */
1530: { &vop_reallocblks_desc, err_reallocblks }, /* reallocblks */
1531: { &vop_vfree_desc, err_vfree }, /* vfree */
1532: { &vop_truncate_desc, err_truncate }, /* truncate */
1533: { &vop_update_desc, devfs_update }, /* update */
1534: { &vop_bwrite_desc, err_bwrite },
1535: { &vop_pagein_desc, err_pagein }, /* Pagein */
1536: { &vop_pageout_desc, err_pageout }, /* Pageout */
1537: { &vop_copyfile_desc, err_copyfile }, /* Copyfile */
1538: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
1539: };
1540: struct vnodeopv_desc devfs_vnodeop_opv_desc =
1541: { &devfs_vnodeop_p, devfs_vnodeop_entries };
1542:
1543: /* The following ops are used by the device nodes */
1544: int (**devfs_spec_vnodeop_p)();
1545: static struct vnodeopv_entry_desc devfs_spec_vnodeop_entries[] = {
1546: { &vop_default_desc, vn_default_error },
1547: { &vop_lookup_desc, spec_lookup }, /* lookup */
1548: { &vop_create_desc, spec_create }, /* create */
1549: { &vop_mknod_desc, spec_mknod }, /* mknod */
1550: { &vop_open_desc, spec_open }, /* open */
1551: { &vop_close_desc, devfsspec_close }, /* close */
1552: { &vop_access_desc, devfs_access }, /* access */
1553: { &vop_getattr_desc, devfs_getattr }, /* getattr */
1554: { &vop_setattr_desc, devfs_setattr }, /* setattr */
1555: { &vop_read_desc, devfsspec_read }, /* read */
1556: { &vop_write_desc, devfsspec_write }, /* write */
1557: { &vop_lease_desc, spec_lease_check }, /* lease */
1558: { &vop_ioctl_desc, spec_ioctl }, /* ioctl */
1559: { &vop_select_desc, spec_select }, /* select */
1560: { &vop_revoke_desc, spec_revoke }, /* revoke */
1561: { &vop_mmap_desc, spec_mmap }, /* mmap */
1562: { &vop_fsync_desc, spec_fsync }, /* fsync */
1563: { &vop_seek_desc, spec_seek }, /* seek */
1564: { &vop_remove_desc, devfs_remove }, /* remove */
1565: { &vop_link_desc, devfs_link }, /* link */
1566: { &vop_rename_desc, spec_rename }, /* rename */
1567: { &vop_mkdir_desc, spec_mkdir }, /* mkdir */
1568: { &vop_rmdir_desc, spec_rmdir }, /* rmdir */
1569: { &vop_symlink_desc, spec_symlink }, /* symlink */
1570: { &vop_readdir_desc, spec_readdir }, /* readdir */
1571: { &vop_readlink_desc, spec_readlink }, /* readlink */
1572: { &vop_abortop_desc, spec_abortop }, /* abortop */
1573: { &vop_inactive_desc, devfs_inactive }, /* inactive */
1574: { &vop_reclaim_desc, devfs_reclaim }, /* reclaim */
1575: { &vop_lock_desc, nop_lock }, /* lock */
1576: { &vop_unlock_desc, nop_unlock }, /* unlock */
1577: { &vop_bmap_desc, spec_bmap }, /* bmap */
1578: { &vop_strategy_desc, spec_strategy }, /* strategy */
1579: { &vop_print_desc, devfs_print }, /* print */
1580: { &vop_islocked_desc, nop_islocked }, /* islocked */
1581: { &vop_pathconf_desc, spec_pathconf }, /* pathconf */
1582: { &vop_advlock_desc, spec_advlock }, /* advlock */
1583: { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */
1584: { &vop_valloc_desc, spec_valloc }, /* valloc */
1585: { &vop_reallocblks_desc, spec_reallocblks }, /* reallocblks */
1586: { &vop_vfree_desc, nop_vfree }, /* vfree */
1587: { &vop_truncate_desc, spec_truncate }, /* truncate */
1588: { &vop_update_desc, devfs_update }, /* update */
1589: { &vop_bwrite_desc, vn_bwrite },
1590: #ifdef NeXT
1591: { &vop_devblocksize_desc, spec_devblocksize }, /* devblocksize */
1592: #endif /* NeXT */
1593: { &vop_pagein_desc, spec_pagein }, /* Pagein */
1594: { &vop_pageout_desc, spec_pageout }, /* Pageout */
1595: { &vop_copyfile_desc, err_copyfile }, /* Copyfile */
1596: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
1597: };
1598: struct vnodeopv_desc devfs_spec_vnodeop_opv_desc =
1599: { &devfs_spec_vnodeop_p, devfs_spec_vnodeop_entries };
1600:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.