![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vfs_syscalls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to vfs_syscalls.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution is only permitted until one year after the first shipment
6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
7: * binary forms are permitted provided that: (1) source distributions retain
8: * this entire copyright notice and comment, and (2) distributions including
9: * binaries display the following acknowledgement: This product includes
10: * software developed by the University of California, Berkeley and its
11: * contributors'' in the documentation or other materials provided with the
12: * distribution and in all advertising materials mentioning features or use
13: * of this software. Neither the name of the University nor the names of
14: * its contributors may be used to endorse or promote products derived from
15: * this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)vfs_syscalls.c 7.57 (Berkeley) 7/28/90
21: */
22:
23: #include "param.h"
24: #include "systm.h"
25: #include "user.h"
26: #include "kernel.h"
27: #include "file.h"
28: #include "stat.h"
29: #include "vnode.h"
30: #include "mount.h"
31: #include "proc.h"
32: #include "uio.h"
33: #include "malloc.h"
34:
35: #define RETURN(val) {if (u.u_spare[0] != 0) panic("lock count"); return (val);}
36:
37: /*
38: * Virtual File System System Calls
39: */
40:
41: /*
42: * mount system call
43: */
44: /* ARGSUSED */
45: mount(p, uap, retval)
46: register struct proc *p;
47: register struct args {
48: int type;
49: char *dir;
50: int flags;
51: caddr_t data;
52: } *uap;
53: int *retval;
54: {
55: register struct nameidata *ndp = &u.u_nd;
56: register struct vnode *vp;
57: register struct mount *mp;
58: int error, flag;
59:
60: /*
61: * Must be super user
62: */
63: if (error = suser(ndp->ni_cred, &u.u_acflag))
64: RETURN (error);
65: /*
66: * Get vnode to be covered
67: */
68: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
69: ndp->ni_segflg = UIO_USERSPACE;
70: ndp->ni_dirp = uap->dir;
71: if (error = namei(ndp))
72: RETURN (error);
73: vp = ndp->ni_vp;
74: if (uap->flags & MNT_UPDATE) {
75: if ((vp->v_flag & VROOT) == 0) {
76: vput(vp);
77: RETURN (EINVAL);
78: }
79: mp = vp->v_mount;
80: /*
81: * We allow going from read-only to read-write,
82: * but not from read-write to read-only.
83: */
84: if ((mp->mnt_flag & MNT_RDONLY) == 0 &&
85: (uap->flags & MNT_RDONLY) != 0) {
86: vput(vp);
87: RETURN (EOPNOTSUPP); /* Needs translation */
88: }
89: flag = mp->mnt_flag;
90: mp->mnt_flag |= MNT_UPDATE;
91: VOP_UNLOCK(vp);
92: goto update;
93: }
94: vinvalbuf(vp, 1);
95: if (vp->v_usecount != 1) {
96: vput(vp);
97: RETURN (EBUSY);
98: }
99: if (vp->v_type != VDIR) {
100: vput(vp);
101: RETURN (ENOTDIR);
102: }
103: if ((unsigned long)uap->type > MOUNT_MAXTYPE ||
104: vfssw[uap->type] == (struct vfsops *)0) {
105: vput(vp);
106: RETURN (ENODEV);
107: }
108:
109: /*
110: * Allocate and initialize the file system.
111: */
112: mp = (struct mount *)malloc((u_long)sizeof(struct mount),
113: M_MOUNT, M_WAITOK);
114: mp->mnt_op = vfssw[uap->type];
115: mp->mnt_flag = 0;
116: mp->mnt_exroot = 0;
117: mp->mnt_mounth = NULLVP;
118: if (error = vfs_lock(mp)) {
119: free((caddr_t)mp, M_MOUNT);
120: vput(vp);
121: RETURN (error);
122: }
123: if (vp->v_mountedhere != (struct mount *)0) {
124: vfs_unlock(mp);
125: free((caddr_t)mp, M_MOUNT);
126: vput(vp);
127: RETURN (EBUSY);
128: }
129: vp->v_mountedhere = mp;
130: mp->mnt_vnodecovered = vp;
131: update:
132: /*
133: * Set the mount level flags.
134: */
135: if (uap->flags & MNT_RDONLY)
136: mp->mnt_flag |= MNT_RDONLY;
137: else
138: mp->mnt_flag &= ~MNT_RDONLY;
139: if (uap->flags & MNT_NOSUID)
140: mp->mnt_flag |= MNT_NOSUID;
141: else
142: mp->mnt_flag &= ~MNT_NOSUID;
143: if (uap->flags & MNT_NOEXEC)
144: mp->mnt_flag |= MNT_NOEXEC;
145: else
146: mp->mnt_flag &= ~MNT_NOEXEC;
147: if (uap->flags & MNT_NODEV)
148: mp->mnt_flag |= MNT_NODEV;
149: else
150: mp->mnt_flag &= ~MNT_NODEV;
151: if (uap->flags & MNT_SYNCHRONOUS)
152: mp->mnt_flag |= MNT_SYNCHRONOUS;
153: else
154: mp->mnt_flag &= ~MNT_SYNCHRONOUS;
155: /*
156: * Mount the filesystem.
157: */
158: error = VFS_MOUNT(mp, uap->dir, uap->data, ndp);
159: if (mp->mnt_flag & MNT_UPDATE) {
160: mp->mnt_flag &= ~MNT_UPDATE;
161: vrele(vp);
162: if (error)
163: mp->mnt_flag = flag;
164: RETURN (error);
165: }
166: /*
167: * Put the new filesystem on the mount list after root.
168: */
169: mp->mnt_next = rootfs->mnt_next;
170: mp->mnt_prev = rootfs;
171: rootfs->mnt_next = mp;
172: mp->mnt_next->mnt_prev = mp;
173: cache_purge(vp);
174: if (!error) {
175: VOP_UNLOCK(vp);
176: vfs_unlock(mp);
177: error = VFS_START(mp, 0);
178: } else {
179: vfs_remove(mp);
180: free((caddr_t)mp, M_MOUNT);
181: vput(vp);
182: }
183: RETURN (error);
184: }
185:
186: /*
187: * Unmount system call.
188: *
189: * Note: unmount takes a path to the vnode mounted on as argument,
190: * not special file (as before).
191: */
192: /* ARGSUSED */
193: unmount(p, uap, retval)
194: register struct proc *p;
195: register struct args {
196: char *pathp;
197: int flags;
198: } *uap;
199: int *retval;
200: {
201: register struct vnode *vp;
202: register struct nameidata *ndp = &u.u_nd;
203: struct mount *mp;
204: int error;
205:
206: /*
207: * Must be super user
208: */
209: if (error = suser(ndp->ni_cred, &u.u_acflag))
210: RETURN (error);
211:
212: ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
213: ndp->ni_segflg = UIO_USERSPACE;
214: ndp->ni_dirp = uap->pathp;
215: if (error = namei(ndp))
216: RETURN (error);
217: vp = ndp->ni_vp;
218: /*
219: * Must be the root of the filesystem
220: */
221: if ((vp->v_flag & VROOT) == 0) {
222: vput(vp);
223: RETURN (EINVAL);
224: }
225: mp = vp->v_mount;
226: vput(vp);
227: RETURN (dounmount(mp, uap->flags));
228: }
229:
230: /*
231: * Do an unmount.
232: */
233: dounmount(mp, flags)
234: register struct mount *mp;
235: int flags;
236: {
237: struct vnode *coveredvp;
238: int error;
239:
240: coveredvp = mp->mnt_vnodecovered;
241: if (vfs_busy(mp))
242: return (EBUSY);
243: mp->mnt_flag |= MNT_UNMOUNT;
244: if (error = vfs_lock(mp))
245: return (error);
246:
247: xumount(mp); /* remove unused sticky files from text table */
248: cache_purgevfs(mp); /* remove cache entries for this file sys */
249: if ((error = VFS_SYNC(mp, MNT_WAIT)) == 0 || (flags & MNT_FORCE))
250: error = VFS_UNMOUNT(mp, flags);
251: mp->mnt_flag &= ~MNT_UNMOUNT;
252: vfs_unbusy(mp);
253: if (error) {
254: vfs_unlock(mp);
255: } else {
256: vrele(coveredvp);
257: vfs_remove(mp);
258: free((caddr_t)mp, M_MOUNT);
259: }
260: return (error);
261: }
262:
263: /*
264: * Sync system call.
265: * Sync each mounted filesystem.
266: */
267: /* ARGSUSED */
268: sync(p, uap, retval)
269: register struct proc *p;
270: struct args *uap;
271: int *retval;
272: {
273: register struct mount *mp;
274: struct mount *omp;
275:
276: mp = rootfs;
277: do {
278: /*
279: * The lock check below is to avoid races with mount
280: * and unmount.
281: */
282: if ((mp->mnt_flag & (MNT_MLOCK|MNT_RDONLY|MNT_MPBUSY)) == 0 &&
283: !vfs_busy(mp)) {
284: VFS_SYNC(mp, MNT_NOWAIT);
285: omp = mp;
286: mp = mp->mnt_next;
287: vfs_unbusy(omp);
288: } else
289: mp = mp->mnt_next;
290: } while (mp != rootfs);
291: }
292:
293: /*
294: * operate on filesystem quotas
295: */
296: /* ARGSUSED */
297: quotactl(p, uap, retval)
298: register struct proc *p;
299: register struct args {
300: char *path;
301: int cmd;
302: int uid;
303: caddr_t arg;
304: } *uap;
305: int *retval;
306: {
307: register struct mount *mp;
308: register struct nameidata *ndp = &u.u_nd;
309: int error;
310:
311: ndp->ni_nameiop = LOOKUP | FOLLOW;
312: ndp->ni_segflg = UIO_USERSPACE;
313: ndp->ni_dirp = uap->path;
314: if (error = namei(ndp))
315: RETURN (error);
316: mp = ndp->ni_vp->v_mount;
317: vrele(ndp->ni_vp);
318: RETURN (VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg));
319: }
320:
321: /*
322: * get filesystem statistics
323: */
324: /* ARGSUSED */
325: statfs(p, uap, retval)
326: register struct proc *p;
327: register struct args {
328: char *path;
329: struct statfs *buf;
330: } *uap;
331: int *retval;
332: {
333: register struct mount *mp;
334: register struct nameidata *ndp = &u.u_nd;
335: register struct statfs *sp;
336: int error;
337:
338: ndp->ni_nameiop = LOOKUP | FOLLOW;
339: ndp->ni_segflg = UIO_USERSPACE;
340: ndp->ni_dirp = uap->path;
341: if (error = namei(ndp))
342: RETURN (error);
343: mp = ndp->ni_vp->v_mount;
344: sp = &mp->mnt_stat;
345: vrele(ndp->ni_vp);
346: if (error = VFS_STATFS(mp, sp))
347: RETURN (error);
348: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
349: RETURN (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
350: }
351:
352: /*
353: * get filesystem statistics
354: */
355: /* ARGSUSED */
356: fstatfs(p, uap, retval)
357: register struct proc *p;
358: register struct args {
359: int fd;
360: struct statfs *buf;
361: } *uap;
362: int *retval;
363: {
364: struct file *fp;
365: struct mount *mp;
366: register struct statfs *sp;
367: int error;
368:
369: if (error = getvnode(u.u_ofile, uap->fd, &fp))
370: RETURN (error);
371: mp = ((struct vnode *)fp->f_data)->v_mount;
372: sp = &mp->mnt_stat;
373: if (error = VFS_STATFS(mp, sp))
374: RETURN (error);
375: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
376: RETURN (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
377: }
378:
379: /*
380: * get statistics on all filesystems
381: */
382: getfsstat(p, uap, retval)
383: register struct proc *p;
384: register struct args {
385: struct statfs *buf;
386: long bufsize;
387: int flags;
388: } *uap;
389: int *retval;
390: {
391: register struct mount *mp;
392: register struct statfs *sp;
393: caddr_t sfsp;
394: long count, maxcount, error;
395:
396: maxcount = uap->bufsize / sizeof(struct statfs);
397: sfsp = (caddr_t)uap->buf;
398: mp = rootfs;
399: count = 0;
400: do {
401: if (sfsp && count < maxcount &&
402: ((mp->mnt_flag & MNT_MLOCK) == 0)) {
403: sp = &mp->mnt_stat;
404: /*
405: * If MNT_NOWAIT is specified, do not refresh the
406: * fsstat cache. MNT_WAIT overrides MNT_NOWAIT.
407: */
408: if (((uap->flags & MNT_NOWAIT) == 0 ||
409: (uap->flags & MNT_WAIT)) &&
410: (error = VFS_STATFS(mp, sp))) {
411: mp = mp->mnt_prev;
412: continue;
413: }
414: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
415: if (error = copyout((caddr_t)sp, sfsp, sizeof(*sp)))
416: RETURN (error);
417: sfsp += sizeof(*sp);
418: }
419: count++;
420: mp = mp->mnt_prev;
421: } while (mp != rootfs);
422: if (sfsp && count > maxcount)
423: *retval = maxcount;
424: else
425: *retval = count;
426: RETURN (0);
427: }
428:
429: /*
430: * Change current working directory to a given file descriptor.
431: */
432: /* ARGSUSED */
433: fchdir(p, uap, retval)
434: register struct proc *p;
435: struct args {
436: int fd;
437: } *uap;
438: int *retval;
439: {
440: register struct nameidata *ndp = &u.u_nd;
441: register struct vnode *vp;
442: struct file *fp;
443: int error;
444:
445: if (error = getvnode(u.u_ofile, uap->fd, &fp))
446: RETURN (error);
447: vp = (struct vnode *)fp->f_data;
448: VOP_LOCK(vp);
449: if (vp->v_type != VDIR)
450: error = ENOTDIR;
451: else
452: error = VOP_ACCESS(vp, VEXEC, ndp->ni_cred);
453: VOP_UNLOCK(vp);
454: if (error)
455: RETURN (error);
456: VREF(vp);
457: vrele(ndp->ni_cdir);
458: ndp->ni_cdir = vp;
459: RETURN (0);
460: }
461:
462: /*
463: * Change current working directory (``.'').
464: */
465: /* ARGSUSED */
466: chdir(p, uap, retval)
467: register struct proc *p;
468: struct args {
469: char *fname;
470: } *uap;
471: int *retval;
472: {
473: register struct nameidata *ndp = &u.u_nd;
474: int error;
475:
476: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
477: ndp->ni_segflg = UIO_USERSPACE;
478: ndp->ni_dirp = uap->fname;
479: if (error = chdirec(ndp))
480: RETURN (error);
481: vrele(ndp->ni_cdir);
482: ndp->ni_cdir = ndp->ni_vp;
483: RETURN (0);
484: }
485:
486: /*
487: * Change notion of root (``/'') directory.
488: */
489: /* ARGSUSED */
490: chroot(p, uap, retval)
491: register struct proc *p;
492: struct args {
493: char *fname;
494: } *uap;
495: int *retval;
496: {
497: register struct nameidata *ndp = &u.u_nd;
498: int error;
499:
500: if (error = suser(ndp->ni_cred, &u.u_acflag))
501: RETURN (error);
502: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
503: ndp->ni_segflg = UIO_USERSPACE;
504: ndp->ni_dirp = uap->fname;
505: if (error = chdirec(ndp))
506: RETURN (error);
507: if (ndp->ni_rdir != NULL)
508: vrele(ndp->ni_rdir);
509: ndp->ni_rdir = ndp->ni_vp;
510: RETURN (0);
511: }
512:
513: /*
514: * Common routine for chroot and chdir.
515: */
516: chdirec(ndp)
517: register struct nameidata *ndp;
518: {
519: struct vnode *vp;
520: int error;
521:
522: if (error = namei(ndp))
523: return (error);
524: vp = ndp->ni_vp;
525: if (vp->v_type != VDIR)
526: error = ENOTDIR;
527: else
528: error = VOP_ACCESS(vp, VEXEC, ndp->ni_cred);
529: VOP_UNLOCK(vp);
530: if (error)
531: vrele(vp);
532: return (error);
533: }
534:
535: /*
536: * Open system call.
537: * Check permissions, allocate an open file structure,
538: * and call the device open routine if any.
539: */
540: open(p, uap, retval)
541: register struct proc *p;
542: register struct args {
543: char *fname;
544: int mode;
545: int crtmode;
546: } *uap;
547: int *retval;
548: {
549: struct nameidata *ndp = &u.u_nd;
550: register struct file *fp;
551: int fmode, cmode;
552: struct file *nfp;
553: int indx, error;
554: extern struct fileops vnops;
555:
556: if (error = falloc(&nfp, &indx))
557: RETURN (error);
558: fp = nfp;
559: fmode = uap->mode - FOPEN;
560: cmode = ((uap->crtmode &~ u.u_cmask) & 07777) &~ S_ISVTX;
561: ndp->ni_segflg = UIO_USERSPACE;
562: ndp->ni_dirp = uap->fname;
563: p->p_dupfd = (u_char)-1; /* XXX check for fdopen */
564: if (error = vn_open(ndp, fmode, cmode)) {
565: crfree(fp->f_cred);
566: fp->f_count--;
567: if (error == ENODEV && /* XXX from fdopen */
568: p->p_dupfd != (u_char)-1 &&
569: (error = dupfdopen(indx, p->p_dupfd, fmode)) == 0) {
570: *retval = indx;
571: RETURN (0);
572: }
573: if (error == ERESTART)
574: error = EINTR;
575: u.u_ofile[indx] = NULL;
576: RETURN (error);
577: }
578: fp->f_flag = fmode & FMASK;
579: fp->f_type = DTYPE_VNODE;
580: fp->f_ops = &vnops;
581: fp->f_data = (caddr_t)ndp->ni_vp;
582: *retval = indx;
583: RETURN (0);
584: }
585:
586: #ifdef COMPAT_43
587: /*
588: * Creat system call.
589: */
590: ocreat(p, uap, retval)
591: struct proc *p;
592: register struct args {
593: char *fname;
594: int fmode;
595: } *uap;
596: int *retval;
597: {
598: struct args {
599: char *fname;
600: int mode;
601: int crtmode;
602: } openuap;
603:
604: openuap.fname = uap->fname;
605: openuap.crtmode = uap->fmode;
606: openuap.mode = O_WRONLY | O_CREAT | O_TRUNC;
607: RETURN (open(p, &openuap, retval));
608: }
609: #endif /* COMPAT_43 */
610:
611: /*
612: * Mknod system call
613: */
614: /* ARGSUSED */
615: mknod(p, uap, retval)
616: register struct proc *p;
617: register struct args {
618: char *fname;
619: int fmode;
620: int dev;
621: } *uap;
622: int *retval;
623: {
624: register struct nameidata *ndp = &u.u_nd;
625: register struct vnode *vp;
626: struct vattr vattr;
627: int error;
628:
629: if (error = suser(ndp->ni_cred, &u.u_acflag))
630: RETURN (error);
631: ndp->ni_nameiop = CREATE | LOCKPARENT;
632: ndp->ni_segflg = UIO_USERSPACE;
633: ndp->ni_dirp = uap->fname;
634: if (error = namei(ndp))
635: RETURN (error);
636: vp = ndp->ni_vp;
637: if (vp != NULL) {
638: error = EEXIST;
639: goto out;
640: }
641: VATTR_NULL(&vattr);
642: switch (uap->fmode & S_IFMT) {
643:
644: case S_IFMT: /* used by badsect to flag bad sectors */
645: vattr.va_type = VBAD;
646: break;
647: case S_IFCHR:
648: vattr.va_type = VCHR;
649: break;
650: case S_IFBLK:
651: vattr.va_type = VBLK;
652: break;
653: default:
654: error = EINVAL;
655: goto out;
656: }
657: vattr.va_mode = (uap->fmode & 07777) &~ u.u_cmask;
658: vattr.va_rdev = uap->dev;
659: out:
660: if (!error) {
661: error = VOP_MKNOD(ndp, &vattr, ndp->ni_cred);
662: } else {
663: VOP_ABORTOP(ndp);
664: if (ndp->ni_dvp == vp)
665: vrele(ndp->ni_dvp);
666: else
667: vput(ndp->ni_dvp);
668: if (vp)
669: vrele(vp);
670: }
671: RETURN (error);
672: }
673:
674: /*
675: * Mkfifo system call
676: */
677: /* ARGSUSED */
678: mkfifo(p, uap, retval)
679: register struct proc *p;
680: register struct args {
681: char *fname;
682: int fmode;
683: } *uap;
684: int *retval;
685: {
686: register struct nameidata *ndp = &u.u_nd;
687: struct vattr vattr;
688: int error;
689:
690: #ifndef FIFO
691: RETURN (EOPNOTSUPP);
692: #else
693: ndp->ni_nameiop = CREATE | LOCKPARENT;
694: ndp->ni_segflg = UIO_USERSPACE;
695: ndp->ni_dirp = uap->fname;
696: if (error = namei(ndp))
697: RETURN (error);
698: if (ndp->ni_vp != NULL) {
699: VOP_ABORTOP(ndp);
700: if (ndp->ni_dvp == ndp->ni_vp)
701: vrele(ndp->ni_dvp);
702: else
703: vput(ndp->ni_dvp);
704: vrele(ndp->ni_vp);
705: RETURN (EEXIST);
706: } else {
707: VATTR_NULL(&vattr);
708: vattr.va_type = VFIFO;
709: vattr.va_mode = (uap->fmode & 07777) &~ u.u_cmask;
710: }
711: RETURN (VOP_MKNOD(ndp, &vattr, ndp->ni_cred));
712: #endif /* FIFO */
713: }
714:
715: /*
716: * link system call
717: */
718: /* ARGSUSED */
719: link(p, uap, retval)
720: register struct proc *p;
721: register struct args {
722: char *target;
723: char *linkname;
724: } *uap;
725: int *retval;
726: {
727: register struct nameidata *ndp = &u.u_nd;
728: register struct vnode *vp, *xp;
729: int error;
730:
731: ndp->ni_nameiop = LOOKUP | FOLLOW;
732: ndp->ni_segflg = UIO_USERSPACE;
733: ndp->ni_dirp = uap->target;
734: if (error = namei(ndp))
735: RETURN (error);
736: vp = ndp->ni_vp;
737: if (vp->v_type == VDIR &&
738: (error = suser(ndp->ni_cred, &u.u_acflag)))
739: goto out1;
740: ndp->ni_nameiop = CREATE | LOCKPARENT;
741: ndp->ni_dirp = (caddr_t)uap->linkname;
742: if (error = namei(ndp))
743: goto out1;
744: xp = ndp->ni_vp;
745: if (xp != NULL) {
746: error = EEXIST;
747: goto out;
748: }
749: xp = ndp->ni_dvp;
750: if (vp->v_mount != xp->v_mount)
751: error = EXDEV;
752: out:
753: if (!error) {
754: error = VOP_LINK(vp, ndp);
755: } else {
756: VOP_ABORTOP(ndp);
757: if (ndp->ni_dvp == ndp->ni_vp)
758: vrele(ndp->ni_dvp);
759: else
760: vput(ndp->ni_dvp);
761: if (ndp->ni_vp)
762: vrele(ndp->ni_vp);
763: }
764: out1:
765: vrele(vp);
766: RETURN (error);
767: }
768:
769: /*
770: * symlink -- make a symbolic link
771: */
772: /* ARGSUSED */
773: symlink(p, uap, retval)
774: register struct proc *p;
775: register struct args {
776: char *target;
777: char *linkname;
778: } *uap;
779: int *retval;
780: {
781: register struct nameidata *ndp = &u.u_nd;
782: struct vattr vattr;
783: char *target;
784: int error;
785:
786: ndp->ni_segflg = UIO_USERSPACE;
787: ndp->ni_dirp = uap->linkname;
788: MALLOC(target, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
789: if (error = copyinstr(uap->target, target, MAXPATHLEN, (u_int *)0))
790: goto out;
791: ndp->ni_nameiop = CREATE | LOCKPARENT;
792: if (error = namei(ndp))
793: goto out;
794: if (ndp->ni_vp) {
795: VOP_ABORTOP(ndp);
796: if (ndp->ni_dvp == ndp->ni_vp)
797: vrele(ndp->ni_dvp);
798: else
799: vput(ndp->ni_dvp);
800: vrele(ndp->ni_vp);
801: error = EEXIST;
802: goto out;
803: }
804: VATTR_NULL(&vattr);
805: vattr.va_mode = 0777 &~ u.u_cmask;
806: error = VOP_SYMLINK(ndp, &vattr, target);
807: out:
808: FREE(target, M_NAMEI);
809: RETURN (error);
810: }
811:
812: /*
813: * Unlink system call.
814: * Hard to avoid races here, especially
815: * in unlinking directories.
816: */
817: /* ARGSUSED */
818: unlink(p, uap, retval)
819: register struct proc *p;
820: struct args {
821: char *fname;
822: } *uap;
823: int *retval;
824: {
825: register struct nameidata *ndp = &u.u_nd;
826: register struct vnode *vp;
827: int error;
828:
829: ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
830: ndp->ni_segflg = UIO_USERSPACE;
831: ndp->ni_dirp = uap->fname;
832: if (error = namei(ndp))
833: RETURN (error);
834: vp = ndp->ni_vp;
835: if (vp->v_type == VDIR &&
836: (error = suser(ndp->ni_cred, &u.u_acflag)))
837: goto out;
838: /*
839: * Don't unlink a mounted file.
840: */
841: if (vp->v_flag & VROOT) {
842: error = EBUSY;
843: goto out;
844: }
845: if (vp->v_flag & VTEXT)
846: xrele(vp); /* try once to free text */
847: out:
848: if (!error) {
849: error = VOP_REMOVE(ndp);
850: } else {
851: VOP_ABORTOP(ndp);
852: if (ndp->ni_dvp == vp)
853: vrele(ndp->ni_dvp);
854: else
855: vput(ndp->ni_dvp);
856: vput(vp);
857: }
858: RETURN (error);
859: }
860:
861: /*
862: * Seek system call
863: */
864: lseek(p, uap, retval)
865: register struct proc *p;
866: register struct args {
867: int fdes;
868: off_t off;
869: int sbase;
870: } *uap;
871: off_t *retval;
872: {
873: struct ucred *cred = u.u_nd.ni_cred;
874: register struct file *fp;
875: struct vattr vattr;
876: int error;
877:
878: if ((unsigned)uap->fdes >= NOFILE ||
879: (fp = u.u_ofile[uap->fdes]) == NULL)
880: RETURN (EBADF);
881: if (fp->f_type != DTYPE_VNODE)
882: RETURN (ESPIPE);
883: switch (uap->sbase) {
884:
885: case L_INCR:
886: fp->f_offset += uap->off;
887: break;
888:
889: case L_XTND:
890: if (error = VOP_GETATTR((struct vnode *)fp->f_data,
891: &vattr, cred))
892: RETURN (error);
893: fp->f_offset = uap->off + vattr.va_size;
894: break;
895:
896: case L_SET:
897: fp->f_offset = uap->off;
898: break;
899:
900: default:
901: RETURN (EINVAL);
902: }
903: *retval = fp->f_offset;
904: RETURN (0);
905: }
906:
907: /*
908: * Access system call
909: */
910: /* ARGSUSED */
911: saccess(p, uap, retval)
912: register struct proc *p;
913: register struct args {
914: char *fname;
915: int fmode;
916: } *uap;
917: int *retval;
918: {
919: register struct nameidata *ndp = &u.u_nd;
920: register struct ucred *cred = ndp->ni_cred;
921: register struct vnode *vp;
922: int error, mode, svuid, svgid;
923:
924: svuid = cred->cr_uid;
925: svgid = cred->cr_groups[0];
926: cred->cr_uid = p->p_ruid;
927: cred->cr_groups[0] = p->p_rgid;
928: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
929: ndp->ni_segflg = UIO_USERSPACE;
930: ndp->ni_dirp = uap->fname;
931: if (error = namei(ndp))
932: goto out1;
933: vp = ndp->ni_vp;
934: /*
935: * fmode == 0 means only check for exist
936: */
937: if (uap->fmode) {
938: mode = 0;
939: if (uap->fmode & R_OK)
940: mode |= VREAD;
941: if (uap->fmode & W_OK)
942: mode |= VWRITE;
943: if (uap->fmode & X_OK)
944: mode |= VEXEC;
945: if ((mode & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
946: error = VOP_ACCESS(vp, mode, ndp->ni_cred);
947: }
948: vput(vp);
949: out1:
950: cred->cr_uid = svuid;
951: cred->cr_groups[0] = svgid;
952: RETURN (error);
953: }
954:
955: /*
956: * Stat system call. This version follows links.
957: */
958: /* ARGSUSED */
959: stat(p, uap, retval)
960: register struct proc *p;
961: register struct args {
962: char *fname;
963: struct stat *ub;
964: } *uap;
965: int *retval;
966: {
967: register struct nameidata *ndp = &u.u_nd;
968: struct stat sb;
969: int error;
970:
971: ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
972: ndp->ni_segflg = UIO_USERSPACE;
973: ndp->ni_dirp = uap->fname;
974: if (error = namei(ndp))
975: RETURN (error);
976: error = vn_stat(ndp->ni_vp, &sb);
977: vput(ndp->ni_vp);
978: if (error)
979: RETURN (error);
980: error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
981: RETURN (error);
982: }
983:
984: /*
985: * Lstat system call. This version does not follow links.
986: */
987: /* ARGSUSED */
988: lstat(p, uap, retval)
989: register struct proc *p;
990: register struct args {
991: char *fname;
992: struct stat *ub;
993: } *uap;
994: int *retval;
995: {
996: register struct nameidata *ndp = &u.u_nd;
997: struct stat sb;
998: int error;
999:
1000: ndp->ni_nameiop = LOOKUP | LOCKLEAF | NOFOLLOW;
1001: ndp->ni_segflg = UIO_USERSPACE;
1002: ndp->ni_dirp = uap->fname;
1003: if (error = namei(ndp))
1004: RETURN (error);
1005: error = vn_stat(ndp->ni_vp, &sb);
1006: vput(ndp->ni_vp);
1007: if (error)
1008: RETURN (error);
1009: error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
1010: RETURN (error);
1011: }
1012:
1013: /*
1014: * Return target name of a symbolic link
1015: */
1016: /* ARGSUSED */
1017: readlink(p, uap, retval)
1018: register struct proc *p;
1019: register struct args {
1020: char *name;
1021: char *buf;
1022: int count;
1023: } *uap;
1024: int *retval;
1025: {
1026: register struct nameidata *ndp = &u.u_nd;
1027: register struct vnode *vp;
1028: struct iovec aiov;
1029: struct uio auio;
1030: int error;
1031:
1032: ndp->ni_nameiop = LOOKUP | LOCKLEAF;
1033: ndp->ni_segflg = UIO_USERSPACE;
1034: ndp->ni_dirp = uap->name;
1035: if (error = namei(ndp))
1036: RETURN (error);
1037: vp = ndp->ni_vp;
1038: if (vp->v_type != VLNK) {
1039: error = EINVAL;
1040: goto out;
1041: }
1042: aiov.iov_base = uap->buf;
1043: aiov.iov_len = uap->count;
1044: auio.uio_iov = &aiov;
1045: auio.uio_iovcnt = 1;
1046: auio.uio_offset = 0;
1047: auio.uio_rw = UIO_READ;
1048: auio.uio_segflg = UIO_USERSPACE;
1049: auio.uio_resid = uap->count;
1050: error = VOP_READLINK(vp, &auio, ndp->ni_cred);
1051: out:
1052: vput(vp);
1053: *retval = uap->count - auio.uio_resid;
1054: RETURN (error);
1055: }
1056:
1057: /*
1058: * Change flags of a file given path name.
1059: */
1060: /* ARGSUSED */
1061: chflags(p, uap, retval)
1062: register struct proc *p;
1063: register struct args {
1064: char *fname;
1065: int flags;
1066: } *uap;
1067: int *retval;
1068: {
1069: register struct nameidata *ndp = &u.u_nd;
1070: register struct vnode *vp;
1071: struct vattr vattr;
1072: int error;
1073:
1074: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
1075: ndp->ni_segflg = UIO_USERSPACE;
1076: ndp->ni_dirp = uap->fname;
1077: VATTR_NULL(&vattr);
1078: vattr.va_flags = uap->flags;
1079: if (error = namei(ndp))
1080: RETURN (error);
1081: vp = ndp->ni_vp;
1082: if (vp->v_mount->mnt_flag & MNT_RDONLY) {
1083: error = EROFS;
1084: goto out;
1085: }
1086: error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
1087: out:
1088: vput(vp);
1089: RETURN (error);
1090: }
1091:
1092: /*
1093: * Change flags of a file given a file descriptor.
1094: */
1095: /* ARGSUSED */
1096: fchflags(p, uap, retval)
1097: register struct proc *p;
1098: register struct args {
1099: int fd;
1100: int flags;
1101: } *uap;
1102: int *retval;
1103: {
1104: struct vattr vattr;
1105: struct vnode *vp;
1106: struct file *fp;
1107: int error;
1108:
1109: if (error = getvnode(u.u_ofile, uap->fd, &fp))
1110: RETURN (error);
1111: VATTR_NULL(&vattr);
1112: vattr.va_flags = uap->flags;
1113: vp = (struct vnode *)fp->f_data;
1114: VOP_LOCK(vp);
1115: if (vp->v_mount->mnt_flag & MNT_RDONLY) {
1116: error = EROFS;
1117: goto out;
1118: }
1119: error = VOP_SETATTR(vp, &vattr, fp->f_cred);
1120: out:
1121: VOP_UNLOCK(vp);
1122: RETURN (error);
1123: }
1124:
1125: /*
1126: * Change mode of a file given path name.
1127: */
1128: /* ARGSUSED */
1129: chmod(p, uap, retval)
1130: register struct proc *p;
1131: register struct args {
1132: char *fname;
1133: int fmode;
1134: } *uap;
1135: int *retval;
1136: {
1137: register struct nameidata *ndp = &u.u_nd;
1138: register struct vnode *vp;
1139: struct vattr vattr;
1140: int error;
1141:
1142: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
1143: ndp->ni_segflg = UIO_USERSPACE;
1144: ndp->ni_dirp = uap->fname;
1145: VATTR_NULL(&vattr);
1146: vattr.va_mode = uap->fmode & 07777;
1147: if (error = namei(ndp))
1148: RETURN (error);
1149: vp = ndp->ni_vp;
1150: if (vp->v_mount->mnt_flag & MNT_RDONLY) {
1151: error = EROFS;
1152: goto out;
1153: }
1154: error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
1155: out:
1156: vput(vp);
1157: RETURN (error);
1158: }
1159:
1160: /*
1161: * Change mode of a file given a file descriptor.
1162: */
1163: /* ARGSUSED */
1164: fchmod(p, uap, retval)
1165: register struct proc *p;
1166: register struct args {
1167: int fd;
1168: int fmode;
1169: } *uap;
1170: int *retval;
1171: {
1172: struct vattr vattr;
1173: struct vnode *vp;
1174: struct file *fp;
1175: int error;
1176:
1177: if (error = getvnode(u.u_ofile, uap->fd, &fp))
1178: RETURN (error);
1179: VATTR_NULL(&vattr);
1180: vattr.va_mode = uap->fmode & 07777;
1181: vp = (struct vnode *)fp->f_data;
1182: VOP_LOCK(vp);
1183: if (vp->v_mount->mnt_flag & MNT_RDONLY) {
1184: error = EROFS;
1185: goto out;
1186: }
1187: error = VOP_SETATTR(vp, &vattr, fp->f_cred);
1188: out:
1189: VOP_UNLOCK(vp);
1190: RETURN (error);
1191: }
1192:
1193: /*
1194: * Set ownership given a path name.
1195: */
1196: /* ARGSUSED */
1197: chown(p, uap, retval)
1198: register struct proc *p;
1199: register struct args {
1200: char *fname;
1201: int uid;
1202: int gid;
1203: } *uap;
1204: int *retval;
1205: {
1206: register struct nameidata *ndp = &u.u_nd;
1207: register struct vnode *vp;
1208: struct vattr vattr;
1209: int error;
1210:
1211: ndp->ni_nameiop = LOOKUP | NOFOLLOW | LOCKLEAF;
1212: ndp->ni_segflg = UIO_USERSPACE;
1213: ndp->ni_dirp = uap->fname;
1214: VATTR_NULL(&vattr);
1215: vattr.va_uid = uap->uid;
1216: vattr.va_gid = uap->gid;
1217: if (error = namei(ndp))
1218: RETURN (error);
1219: vp = ndp->ni_vp;
1220: if (vp->v_mount->mnt_flag & MNT_RDONLY) {
1221: error = EROFS;
1222: goto out;
1223: }
1224: error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
1225: out:
1226: vput(vp);
1227: RETURN (error);
1228: }
1229:
1230: /*
1231: * Set ownership given a file descriptor.
1232: */
1233: /* ARGSUSED */
1234: fchown(p, uap, retval)
1235: register struct proc *p;
1236: register struct args {
1237: int fd;
1238: int uid;
1239: int gid;
1240: } *uap;
1241: int *retval;
1242: {
1243: struct vattr vattr;
1244: struct vnode *vp;
1245: struct file *fp;
1246: int error;
1247:
1248: if (error = getvnode(u.u_ofile, uap->fd, &fp))
1249: RETURN (error);
1250: VATTR_NULL(&vattr);
1251: vattr.va_uid = uap->uid;
1252: vattr.va_gid = uap->gid;
1253: vp = (struct vnode *)fp->f_data;
1254: VOP_LOCK(vp);
1255: if (vp->v_mount->mnt_flag & MNT_RDONLY) {
1256: error = EROFS;
1257: goto out;
1258: }
1259: error = VOP_SETATTR(vp, &vattr, fp->f_cred);
1260: out:
1261: VOP_UNLOCK(vp);
1262: RETURN (error);
1263: }
1264:
1265: /*
1266: * Set the access and modification times of a file.
1267: */
1268: /* ARGSUSED */
1269: utimes(p, uap, retval)
1270: register struct proc *p;
1271: register struct args {
1272: char *fname;
1273: struct timeval *tptr;
1274: } *uap;
1275: int *retval;
1276: {
1277: register struct nameidata *ndp = &u.u_nd;
1278: register struct vnode *vp;
1279: struct timeval tv[2];
1280: struct vattr vattr;
1281: int error;
1282:
1283: if (error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv)))
1284: RETURN (error);
1285: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
1286: ndp->ni_segflg = UIO_USERSPACE;
1287: ndp->ni_dirp = uap->fname;
1288: VATTR_NULL(&vattr);
1289: vattr.va_atime = tv[0];
1290: vattr.va_mtime = tv[1];
1291: if (error = namei(ndp))
1292: RETURN (error);
1293: vp = ndp->ni_vp;
1294: if (vp->v_mount->mnt_flag & MNT_RDONLY) {
1295: error = EROFS;
1296: goto out;
1297: }
1298: error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
1299: out:
1300: vput(vp);
1301: RETURN (error);
1302: }
1303:
1304: /*
1305: * Truncate a file given its path name.
1306: */
1307: /* ARGSUSED */
1308: truncate(p, uap, retval)
1309: register struct proc *p;
1310: register struct args {
1311: char *fname;
1312: off_t length;
1313: } *uap;
1314: int *retval;
1315: {
1316: register struct nameidata *ndp = &u.u_nd;
1317: register struct vnode *vp;
1318: struct vattr vattr;
1319: int error;
1320:
1321: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
1322: ndp->ni_segflg = UIO_USERSPACE;
1323: ndp->ni_dirp = uap->fname;
1324: VATTR_NULL(&vattr);
1325: vattr.va_size = uap->length;
1326: if (error = namei(ndp))
1327: RETURN (error);
1328: vp = ndp->ni_vp;
1329: if (vp->v_type == VDIR) {
1330: error = EISDIR;
1331: goto out;
1332: }
1333: if ((error = vn_writechk(vp)) ||
1334: (error = VOP_ACCESS(vp, VWRITE, ndp->ni_cred)))
1335: goto out;
1336: error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
1337: out:
1338: vput(vp);
1339: RETURN (error);
1340: }
1341:
1342: /*
1343: * Truncate a file given a file descriptor.
1344: */
1345: /* ARGSUSED */
1346: ftruncate(p, uap, retval)
1347: register struct proc *p;
1348: register struct args {
1349: int fd;
1350: off_t length;
1351: } *uap;
1352: int *retval;
1353: {
1354: struct vattr vattr;
1355: struct vnode *vp;
1356: struct file *fp;
1357: int error;
1358:
1359: if (error = getvnode(u.u_ofile, uap->fd, &fp))
1360: RETURN (error);
1361: if ((fp->f_flag & FWRITE) == 0)
1362: RETURN (EINVAL);
1363: VATTR_NULL(&vattr);
1364: vattr.va_size = uap->length;
1365: vp = (struct vnode *)fp->f_data;
1366: VOP_LOCK(vp);
1367: if (vp->v_type == VDIR) {
1368: error = EISDIR;
1369: goto out;
1370: }
1371: if (error = vn_writechk(vp))
1372: goto out;
1373: error = VOP_SETATTR(vp, &vattr, fp->f_cred);
1374: out:
1375: VOP_UNLOCK(vp);
1376: RETURN (error);
1377: }
1378:
1379: /*
1380: * Synch an open file.
1381: */
1382: /* ARGSUSED */
1383: fsync(p, uap, retval)
1384: register struct proc *p;
1385: struct args {
1386: int fd;
1387: } *uap;
1388: int *retval;
1389: {
1390: register struct vnode *vp;
1391: struct file *fp;
1392: int error;
1393:
1394: if (error = getvnode(u.u_ofile, uap->fd, &fp))
1395: RETURN (error);
1396: vp = (struct vnode *)fp->f_data;
1397: VOP_LOCK(vp);
1398: error = VOP_FSYNC(vp, fp->f_flag, fp->f_cred, MNT_WAIT);
1399: VOP_UNLOCK(vp);
1400: RETURN (error);
1401: }
1402:
1403: /*
1404: * Rename system call.
1405: *
1406: * Source and destination must either both be directories, or both
1407: * not be directories. If target is a directory, it must be empty.
1408: */
1409: /* ARGSUSED */
1410: rename(p, uap, retval)
1411: register struct proc *p;
1412: register struct args {
1413: char *from;
1414: char *to;
1415: } *uap;
1416: int *retval;
1417: {
1418: register struct vnode *tvp, *fvp, *tdvp;
1419: register struct nameidata *ndp = &u.u_nd;
1420: struct nameidata tond;
1421: int error;
1422:
1423: ndp->ni_nameiop = DELETE | WANTPARENT;
1424: ndp->ni_segflg = UIO_USERSPACE;
1425: ndp->ni_dirp = uap->from;
1426: if (error = namei(ndp))
1427: RETURN (error);
1428: fvp = ndp->ni_vp;
1429: nddup(ndp, &tond);
1430: tond.ni_nameiop = RENAME | LOCKPARENT | LOCKLEAF | NOCACHE;
1431: tond.ni_segflg = UIO_USERSPACE;
1432: tond.ni_dirp = uap->to;
1433: if (error = namei(&tond)) {
1434: VOP_ABORTOP(ndp);
1435: vrele(ndp->ni_dvp);
1436: vrele(fvp);
1437: goto out1;
1438: }
1439: tdvp = tond.ni_dvp;
1440: tvp = tond.ni_vp;
1441: if (tvp != NULL) {
1442: if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
1443: error = ENOTDIR;
1444: goto out;
1445: } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
1446: error = EISDIR;
1447: goto out;
1448: }
1449: }
1450: if (fvp->v_mount != tdvp->v_mount) {
1451: error = EXDEV;
1452: goto out;
1453: }
1454: if (fvp == tdvp)
1455: error = EINVAL;
1456: /*
1457: * If source is the same as the destination,
1458: * then there is nothing to do.
1459: */
1460: if (fvp == tvp)
1461: error = -1;
1462: out:
1463: if (!error) {
1464: error = VOP_RENAME(ndp, &tond);
1465: } else {
1466: VOP_ABORTOP(&tond);
1467: if (tdvp == tvp)
1468: vrele(tdvp);
1469: else
1470: vput(tdvp);
1471: if (tvp)
1472: vput(tvp);
1473: VOP_ABORTOP(ndp);
1474: vrele(ndp->ni_dvp);
1475: vrele(fvp);
1476: }
1477: out1:
1478: ndrele(&tond);
1479: if (error == -1)
1480: RETURN (0);
1481: RETURN (error);
1482: }
1483:
1484: /*
1485: * Mkdir system call
1486: */
1487: /* ARGSUSED */
1488: mkdir(p, uap, retval)
1489: register struct proc *p;
1490: register struct args {
1491: char *name;
1492: int dmode;
1493: } *uap;
1494: int *retval;
1495: {
1496: register struct nameidata *ndp = &u.u_nd;
1497: register struct vnode *vp;
1498: struct vattr vattr;
1499: int error;
1500:
1501: ndp->ni_nameiop = CREATE | LOCKPARENT;
1502: ndp->ni_segflg = UIO_USERSPACE;
1503: ndp->ni_dirp = uap->name;
1504: if (error = namei(ndp))
1505: RETURN (error);
1506: vp = ndp->ni_vp;
1507: if (vp != NULL) {
1508: VOP_ABORTOP(ndp);
1509: if (ndp->ni_dvp == vp)
1510: vrele(ndp->ni_dvp);
1511: else
1512: vput(ndp->ni_dvp);
1513: vrele(vp);
1514: RETURN (EEXIST);
1515: }
1516: VATTR_NULL(&vattr);
1517: vattr.va_type = VDIR;
1518: vattr.va_mode = (uap->dmode & 0777) &~ u.u_cmask;
1519: error = VOP_MKDIR(ndp, &vattr);
1520: if (!error)
1521: vput(ndp->ni_vp);
1522: RETURN (error);
1523: }
1524:
1525: /*
1526: * Rmdir system call.
1527: */
1528: /* ARGSUSED */
1529: rmdir(p, uap, retval)
1530: register struct proc *p;
1531: struct args {
1532: char *name;
1533: } *uap;
1534: int *retval;
1535: {
1536: register struct nameidata *ndp = &u.u_nd;
1537: register struct vnode *vp;
1538: int error;
1539:
1540: ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
1541: ndp->ni_segflg = UIO_USERSPACE;
1542: ndp->ni_dirp = uap->name;
1543: if (error = namei(ndp))
1544: RETURN (error);
1545: vp = ndp->ni_vp;
1546: if (vp->v_type != VDIR) {
1547: error = ENOTDIR;
1548: goto out;
1549: }
1550: /*
1551: * No rmdir "." please.
1552: */
1553: if (ndp->ni_dvp == vp) {
1554: error = EINVAL;
1555: goto out;
1556: }
1557: /*
1558: * Don't unlink a mounted file.
1559: */
1560: if (vp->v_flag & VROOT)
1561: error = EBUSY;
1562: out:
1563: if (!error) {
1564: error = VOP_RMDIR(ndp);
1565: } else {
1566: VOP_ABORTOP(ndp);
1567: if (ndp->ni_dvp == vp)
1568: vrele(ndp->ni_dvp);
1569: else
1570: vput(ndp->ni_dvp);
1571: vput(vp);
1572: }
1573: RETURN (error);
1574: }
1575:
1576: /*
1577: * Read a block of directory entries in a file system independent format
1578: */
1579: getdirentries(p, uap, retval)
1580: register struct proc *p;
1581: register struct args {
1582: int fd;
1583: char *buf;
1584: unsigned count;
1585: long *basep;
1586: } *uap;
1587: int *retval;
1588: {
1589: register struct vnode *vp;
1590: struct file *fp;
1591: struct uio auio;
1592: struct iovec aiov;
1593: off_t off;
1594: int error, eofflag;
1595:
1596: if (error = getvnode(u.u_ofile, uap->fd, &fp))
1597: RETURN (error);
1598: if ((fp->f_flag & FREAD) == 0)
1599: RETURN (EBADF);
1600: vp = (struct vnode *)fp->f_data;
1601: if (vp->v_type != VDIR)
1602: RETURN (EINVAL);
1603: aiov.iov_base = uap->buf;
1604: aiov.iov_len = uap->count;
1605: auio.uio_iov = &aiov;
1606: auio.uio_iovcnt = 1;
1607: auio.uio_rw = UIO_READ;
1608: auio.uio_segflg = UIO_USERSPACE;
1609: auio.uio_resid = uap->count;
1610: VOP_LOCK(vp);
1611: auio.uio_offset = off = fp->f_offset;
1612: error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag);
1613: fp->f_offset = auio.uio_offset;
1614: VOP_UNLOCK(vp);
1615: if (error)
1616: RETURN (error);
1617: error = copyout((caddr_t)&off, (caddr_t)uap->basep, sizeof(long));
1618: *retval = uap->count - auio.uio_resid;
1619: RETURN (error);
1620: }
1621:
1622: /*
1623: * mode mask for creation of files
1624: */
1625: mode_t
1626: umask(p, uap, retval)
1627: register struct proc *p;
1628: struct args {
1629: int mask;
1630: } *uap;
1631: int *retval;
1632: {
1633:
1634: *retval = u.u_cmask;
1635: u.u_cmask = uap->mask & 07777;
1636: RETURN (0);
1637: }
1638:
1639: /*
1640: * Void all references to file by ripping underlying filesystem
1641: * away from vnode.
1642: */
1643: /* ARGSUSED */
1644: revoke(p, uap, retval)
1645: register struct proc *p;
1646: register struct args {
1647: char *fname;
1648: } *uap;
1649: int *retval;
1650: {
1651: register struct nameidata *ndp = &u.u_nd;
1652: register struct vnode *vp;
1653: struct vattr vattr;
1654: int error;
1655:
1656: ndp->ni_nameiop = LOOKUP | FOLLOW;
1657: ndp->ni_segflg = UIO_USERSPACE;
1658: ndp->ni_dirp = uap->fname;
1659: if (error = namei(ndp))
1660: RETURN (error);
1661: vp = ndp->ni_vp;
1662: if (vp->v_type != VCHR && vp->v_type != VBLK) {
1663: error = EINVAL;
1664: goto out;
1665: }
1666: if (error = VOP_GETATTR(vp, &vattr, ndp->ni_cred))
1667: goto out;
1668: if (ndp->ni_cred->cr_uid != vattr.va_uid &&
1669: (error = suser(ndp->ni_cred, &u.u_acflag)))
1670: goto out;
1671: if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
1672: vgoneall(vp);
1673: out:
1674: vrele(vp);
1675: RETURN (error);
1676: }
1677:
1678: getvnode(ofile, fdes, fpp)
1679: struct file *ofile[];
1680: struct file **fpp;
1681: int fdes;
1682: {
1683: struct file *fp;
1684:
1685: if ((unsigned)fdes >= NOFILE || (fp = ofile[fdes]) == NULL)
1686: return (EBADF);
1687: if (fp->f_type != DTYPE_VNODE)
1688: return (EINVAL);
1689: *fpp = fp;
1690: return (0);
1691: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.