40 */
41
42/*
43 * XXX - The following is required because of some magic done
44 * in getdirentries() below which is only done if the translucent
45 * filesystem `UNION' is compiled into the kernel. This is broken,
46 * but I don't have time to study the code deeply enough to understand
47 * what's going on and determine an appropriate fix. -GAW
48 */
49#include "opt_union.h"
50
51#include <sys/param.h>
52#include <sys/systm.h>
53#include <sys/sysproto.h>
54#include <sys/namei.h>
55#include <sys/filedesc.h>
56#include <sys/kernel.h>
57#include <sys/file.h>
58#include <sys/stat.h>
59#include <sys/unistd.h>
60#include <sys/vnode.h>
61#include <sys/mount.h>
62#include <sys/proc.h>
63#include <sys/uio.h>
64#include <sys/malloc.h>
65#include <sys/dirent.h>
66
67#ifdef UNION
68#include <miscfs/union/union.h>
69#endif
70
71#include <vm/vm.h>
72#include <vm/vm_param.h>
73#include <vm/vm_object.h>
74#include <vm/vm_extern.h>
75#include <sys/sysctl.h>
76
77static int change_dir __P((struct nameidata *ndp, struct proc *p));
78
79/*
80 * Virtual File System System Calls
81 */
82
83/*
84 * Mount a file system.
85 */
86#ifndef _SYS_SYSPROTO_H_
87struct mount_args {
88 int type;
89 char *path;
90 int flags;
91 caddr_t data;
92};
93#endif
94/* ARGSUSED */
95int
96mount(p, uap, retval)
97 struct proc *p;
98 register struct mount_args *uap;
99 int *retval;
100{
101 register struct vnode *vp;
102 register struct mount *mp;
103 int error, flag = 0;
104 struct nameidata nd;
105
106 /*
107 * Must be super user
108 */
109 error = suser(p->p_ucred, &p->p_acflag);
110 if (error)
111 return (error);
112 /*
113 * Get vnode to be covered
114 */
115 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
116 error = namei(&nd);
117 if (error)
118 return (error);
119 vp = nd.ni_vp;
120 if (uap->flags & MNT_UPDATE) {
121 if ((vp->v_flag & VROOT) == 0) {
122 vput(vp);
123 return (EINVAL);
124 }
125 mp = vp->v_mount;
126 flag = mp->mnt_flag;
127 /*
128 * We only allow the filesystem to be reloaded if it
129 * is currently mounted read-only.
130 */
131 if ((uap->flags & MNT_RELOAD) &&
132 ((mp->mnt_flag & MNT_RDONLY) == 0)) {
133 vput(vp);
134 return (EOPNOTSUPP); /* Needs translation */
135 }
136 mp->mnt_flag |=
137 uap->flags & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE);
138 VOP_UNLOCK(vp);
139 goto update;
140 }
141 error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0);
142 if (error)
143 return (error);
144 if (vp->v_type != VDIR) {
145 vput(vp);
146 return (ENOTDIR);
147 }
148 if ((u_long)uap->type > MOUNT_MAXTYPE || vfssw[uap->type] == NULL) {
149 vput(vp);
150 return (ENODEV);
151 }
152
153 /*
154 * Allocate and initialize the file system.
155 */
156 mp = (struct mount *)malloc((u_long)sizeof(struct mount),
157 M_MOUNT, M_WAITOK);
158 bzero((char *)mp, (u_long)sizeof(struct mount));
159 mp->mnt_op = vfssw[uap->type];
160 mp->mnt_vfc = vfsconf[uap->type];
161 error = vfs_lock(mp);
162 if (error) {
163 free((caddr_t)mp, M_MOUNT);
164 vput(vp);
165 return (error);
166 }
167 if (vp->v_mountedhere != NULL) {
168 vfs_unlock(mp);
169 free((caddr_t)mp, M_MOUNT);
170 vput(vp);
171 return (EBUSY);
172 }
173 vp->v_mountedhere = mp;
174 mp->mnt_vnodecovered = vp;
175 vfsconf[uap->type]->vfc_refcount++;
176
177update:
178 /*
179 * Set the mount level flags.
180 */
181 if (uap->flags & MNT_RDONLY)
182 mp->mnt_flag |= MNT_RDONLY;
183 else if (mp->mnt_flag & MNT_RDONLY)
184 mp->mnt_flag |= MNT_WANTRDWR;
185 mp->mnt_flag &=~ (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV |
186 MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC | MNT_NOATIME);
187 mp->mnt_flag |= uap->flags & (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV |
188 MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC | MNT_FORCE | MNT_NOATIME);
189 /*
190 * Mount the filesystem.
191 */
192 error = VFS_MOUNT(mp, uap->path, uap->data, &nd, p);
193 if (mp->mnt_flag & MNT_UPDATE) {
194 vrele(vp);
195 if (mp->mnt_flag & MNT_WANTRDWR)
196 mp->mnt_flag &= ~MNT_RDONLY;
197 mp->mnt_flag &=~
198 (MNT_UPDATE | MNT_RELOAD | MNT_FORCE | MNT_WANTRDWR);
199 if (error)
200 mp->mnt_flag = flag;
201 return (error);
202 }
203 /*
204 * Put the new filesystem on the mount list after root.
205 */
206 cache_purge(vp);
207 if (!error) {
208 CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
209 VOP_UNLOCK(vp);
210 vfs_unlock(mp);
211 error = VFS_START(mp, 0, p);
212 if (error)
213 vrele(vp);
214 } else {
215 mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
216 vfs_unlock(mp);
217 free((caddr_t)mp, M_MOUNT);
218 vput(vp);
219 vfsconf[uap->type]->vfc_refcount--;
220 }
221 return (error);
222}
223
224/*
225 * Unmount a file system.
226 *
227 * Note: unmount takes a path to the vnode mounted on as argument,
228 * not special file (as before).
229 */
230#ifndef _SYS_SYSPROTO_H_
231struct unmount_args {
232 char *path;
233 int flags;
234};
235#endif
236/* ARGSUSED */
237int
238unmount(p, uap, retval)
239 struct proc *p;
240 register struct unmount_args *uap;
241 int *retval;
242{
243 register struct vnode *vp;
244 struct mount *mp;
245 int error;
246 struct nameidata nd;
247
248 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
249 error = namei(&nd);
250 if (error)
251 return (error);
252 vp = nd.ni_vp;
253
254 /*
255 * Unless this is a user mount, then must
256 * have suser privilege.
257 */
258 if (((vp->v_mount->mnt_flag & MNT_USER) == 0) &&
259 (error = suser(p->p_ucred, &p->p_acflag))) {
260 vput(vp);
261 return (error);
262 }
263
264 /*
265 * Must be the root of the filesystem
266 */
267 if ((vp->v_flag & VROOT) == 0) {
268 vput(vp);
269 return (EINVAL);
270 }
271 mp = vp->v_mount;
272 vput(vp);
273
274 /*
275 * Don't allow unmount of the root filesystem
276 */
277 if (mp->mnt_flag & MNT_ROOTFS)
278 return (EINVAL);
279
280 return (dounmount(mp, uap->flags, p));
281}
282
283/*
284 * Do the actual file system unmount.
285 */
286int
287dounmount(mp, flags, p)
288 register struct mount *mp;
289 int flags;
290 struct proc *p;
291{
292 struct vnode *coveredvp;
293 int error;
294
295 coveredvp = mp->mnt_vnodecovered;
296 if (vfs_busy(mp))
297 return (EBUSY);
298 mp->mnt_flag |= MNT_UNMOUNT;
299 error = vfs_lock(mp);
300 if (error)
301 return (error);
302
303 mp->mnt_flag &=~ MNT_ASYNC;
304 vfs_msync(mp, MNT_NOWAIT);
305 vnode_pager_umount(mp); /* release cached vnodes */
306 cache_purgevfs(mp); /* remove cache entries for this file sys */
307 if ((error = VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p)) == 0 ||
308 (flags & MNT_FORCE))
309 error = VFS_UNMOUNT(mp, flags, p);
310 mp->mnt_flag &= ~MNT_UNMOUNT;
311 vfs_unbusy(mp);
312 if (error) {
313 vfs_unlock(mp);
314 } else {
315 vrele(coveredvp);
316 CIRCLEQ_REMOVE(&mountlist, mp, mnt_list);
317 mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
318 vfs_unlock(mp);
319 mp->mnt_vfc->vfc_refcount--;
320 if (mp->mnt_vnodelist.lh_first != NULL)
321 panic("unmount: dangling vnode");
322 free((caddr_t)mp, M_MOUNT);
323 }
324 return (error);
325}
326
327/*
328 * Sync each mounted filesystem.
329 */
330
331#ifndef _SYS_SYSPROTO_H_
332struct sync_args {
333 int dummy;
334};
335#endif
336
337/* ARGSUSED */
338int
339sync(p, uap, retval)
340 struct proc *p;
341 struct sync_args *uap;
342 int *retval;
343{
344 register struct mount *mp;
345 int asyncflag;
346
347 for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = mp->mnt_list.cqe_next) {
348 /*
349 * The lock check below is to avoid races with mount
350 * and unmount.
351 */
352 if ((mp->mnt_flag & (MNT_MLOCK|MNT_RDONLY|MNT_MPBUSY)) == 0 &&
353 !vfs_busy(mp)) {
354 asyncflag = mp->mnt_flag & MNT_ASYNC;
355 mp->mnt_flag &= ~MNT_ASYNC;
356 vfs_msync(mp, MNT_NOWAIT);
357 VFS_SYNC(mp, MNT_NOWAIT, p != NULL ? p->p_ucred : NOCRED, p);
358 if (asyncflag)
359 mp->mnt_flag |= MNT_ASYNC;
360 vfs_unbusy(mp);
361 }
362 }
363 return (0);
364}
365
366/*
367 * Change filesystem quotas.
368 */
369#ifndef _SYS_SYSPROTO_H_
370struct quotactl_args {
371 char *path;
372 int cmd;
373 int uid;
374 caddr_t arg;
375};
376#endif
377/* ARGSUSED */
378int
379quotactl(p, uap, retval)
380 struct proc *p;
381 register struct quotactl_args *uap;
382 int *retval;
383{
384 register struct mount *mp;
385 int error;
386 struct nameidata nd;
387
388 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
389 error = namei(&nd);
390 if (error)
391 return (error);
392 mp = nd.ni_vp->v_mount;
393 vrele(nd.ni_vp);
394 return (VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg, p));
395}
396
397/*
398 * Get filesystem statistics.
399 */
400#ifndef _SYS_SYSPROTO_H_
401struct statfs_args {
402 char *path;
403 struct statfs *buf;
404};
405#endif
406/* ARGSUSED */
407int
408statfs(p, uap, retval)
409 struct proc *p;
410 register struct statfs_args *uap;
411 int *retval;
412{
413 register struct mount *mp;
414 register struct statfs *sp;
415 int error;
416 struct nameidata nd;
417
418 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
419 error = namei(&nd);
420 if (error)
421 return (error);
422 mp = nd.ni_vp->v_mount;
423 sp = &mp->mnt_stat;
424 vrele(nd.ni_vp);
425 error = VFS_STATFS(mp, sp, p);
426 if (error)
427 return (error);
428 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
429 return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
430}
431
432/*
433 * Get filesystem statistics.
434 */
435#ifndef _SYS_SYSPROTO_H_
436struct fstatfs_args {
437 int fd;
438 struct statfs *buf;
439};
440#endif
441/* ARGSUSED */
442int
443fstatfs(p, uap, retval)
444 struct proc *p;
445 register struct fstatfs_args *uap;
446 int *retval;
447{
448 struct file *fp;
449 struct mount *mp;
450 register struct statfs *sp;
451 int error;
452
453 error = getvnode(p->p_fd, uap->fd, &fp);
454 if (error)
455 return (error);
456 mp = ((struct vnode *)fp->f_data)->v_mount;
457 sp = &mp->mnt_stat;
458 error = VFS_STATFS(mp, sp, p);
459 if (error)
460 return (error);
461 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
462 return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
463}
464
465/*
466 * Get statistics on all filesystems.
467 */
468#ifndef _SYS_SYSPROTO_H_
469struct getfsstat_args {
470 struct statfs *buf;
471 long bufsize;
472 int flags;
473};
474#endif
475int
476getfsstat(p, uap, retval)
477 struct proc *p;
478 register struct getfsstat_args *uap;
479 int *retval;
480{
481 register struct mount *mp, *nmp;
482 register struct statfs *sp;
483 caddr_t sfsp;
484 long count, maxcount, error;
485
486 maxcount = uap->bufsize / sizeof(struct statfs);
487 sfsp = (caddr_t)uap->buf;
488 count = 0;
489 for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
490 if (vfs_busy(mp)) {
491 nmp = mp->mnt_list.cqe_next;
492 continue;
493 }
494 if (sfsp && count < maxcount &&
495 ((mp->mnt_flag & MNT_MLOCK) == 0)) {
496 sp = &mp->mnt_stat;
497 /*
498 * If MNT_NOWAIT is specified, do not refresh the
499 * fsstat cache. MNT_WAIT overrides MNT_NOWAIT.
500 */
501 if (((uap->flags & MNT_NOWAIT) == 0 ||
502 (uap->flags & MNT_WAIT)) &&
503 (error = VFS_STATFS(mp, sp, p))) {
504 nmp = mp->mnt_list.cqe_next;
505 vfs_unbusy(mp);
506 continue;
507 }
508 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
509 error = copyout((caddr_t)sp, sfsp, sizeof(*sp));
510 if (error) {
511 vfs_unbusy(mp);
512 return (error);
513 }
514 sfsp += sizeof(*sp);
515 }
516 count++;
517 nmp = mp->mnt_list.cqe_next;
518 vfs_unbusy(mp);
519 }
520 if (sfsp && count > maxcount)
521 *retval = maxcount;
522 else
523 *retval = count;
524 return (0);
525}
526
527/*
528 * Change current working directory to a given file descriptor.
529 */
530#ifndef _SYS_SYSPROTO_H_
531struct fchdir_args {
532 int fd;
533};
534#endif
535/* ARGSUSED */
536int
537fchdir(p, uap, retval)
538 struct proc *p;
539 struct fchdir_args *uap;
540 int *retval;
541{
542 register struct filedesc *fdp = p->p_fd;
543 register struct vnode *vp;
544 struct file *fp;
545 int error;
546
547 error = getvnode(fdp, uap->fd, &fp);
548 if (error)
549 return (error);
550 vp = (struct vnode *)fp->f_data;
551 VOP_LOCK(vp);
552 if (vp->v_type != VDIR)
553 error = ENOTDIR;
554 else
555 error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
556 VOP_UNLOCK(vp);
557 if (error)
558 return (error);
559 VREF(vp);
560 vrele(fdp->fd_cdir);
561 fdp->fd_cdir = vp;
562 return (0);
563}
564
565/*
566 * Change current working directory (``.'').
567 */
568#ifndef _SYS_SYSPROTO_H_
569struct chdir_args {
570 char *path;
571};
572#endif
573/* ARGSUSED */
574int
575chdir(p, uap, retval)
576 struct proc *p;
577 struct chdir_args *uap;
578 int *retval;
579{
580 register struct filedesc *fdp = p->p_fd;
581 int error;
582 struct nameidata nd;
583
584 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
585 error = change_dir(&nd, p);
586 if (error)
587 return (error);
588 vrele(fdp->fd_cdir);
589 fdp->fd_cdir = nd.ni_vp;
590 return (0);
591}
592
593/*
594 * Change notion of root (``/'') directory.
595 */
596#ifndef _SYS_SYSPROTO_H_
597struct chroot_args {
598 char *path;
599};
600#endif
601/* ARGSUSED */
602int
603chroot(p, uap, retval)
604 struct proc *p;
605 struct chroot_args *uap;
606 int *retval;
607{
608 register struct filedesc *fdp = p->p_fd;
609 int error;
610 struct nameidata nd;
611
612 error = suser(p->p_ucred, &p->p_acflag);
613 if (error)
614 return (error);
615 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
616 error = change_dir(&nd, p);
617 if (error)
618 return (error);
619 if (fdp->fd_rdir != NULL)
620 vrele(fdp->fd_rdir);
621 fdp->fd_rdir = nd.ni_vp;
622 return (0);
623}
624
625/*
626 * Common routine for chroot and chdir.
627 */
628static int
629change_dir(ndp, p)
630 register struct nameidata *ndp;
631 struct proc *p;
632{
633 struct vnode *vp;
634 int error;
635
636 error = namei(ndp);
637 if (error)
638 return (error);
639 vp = ndp->ni_vp;
640 if (vp->v_type != VDIR)
641 error = ENOTDIR;
642 else
643 error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
644 VOP_UNLOCK(vp);
645 if (error)
646 vrele(vp);
647 return (error);
648}
649
650/*
651 * Check permissions, allocate an open file structure,
652 * and call the device open routine if any.
653 */
654#ifndef _SYS_SYSPROTO_H_
655struct open_args {
656 char *path;
657 int flags;
658 int mode;
659};
660#endif
661int
662open(p, uap, retval)
663 struct proc *p;
664 register struct open_args *uap;
665 int *retval;
666{
667 register struct filedesc *fdp = p->p_fd;
668 register struct file *fp;
669 register struct vnode *vp;
670 int flags, cmode;
671 struct file *nfp;
672 int type, indx, error;
673 struct flock lf;
674 struct nameidata nd;
675
676 error = falloc(p, &nfp, &indx);
677 if (error)
678 return (error);
679 fp = nfp;
680 flags = FFLAGS(uap->flags);
681 cmode = ((uap->mode &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT;
682 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
683 p->p_dupfd = -indx - 1; /* XXX check for fdopen */
684 error = vn_open(&nd, flags, cmode);
685 if (error) {
686 ffree(fp);
687 if ((error == ENODEV || error == ENXIO) &&
688 p->p_dupfd >= 0 && /* XXX from fdopen */
689 (error =
690 dupfdopen(fdp, indx, p->p_dupfd, flags, error)) == 0) {
691 *retval = indx;
692 return (0);
693 }
694 if (error == ERESTART)
695 error = EINTR;
696 fdp->fd_ofiles[indx] = NULL;
697 return (error);
698 }
699 p->p_dupfd = 0;
700 vp = nd.ni_vp;
701
702 fp->f_flag = flags & FMASK;
703 fp->f_type = DTYPE_VNODE;
704 fp->f_ops = &vnops;
705 fp->f_data = (caddr_t)vp;
706 if (flags & (O_EXLOCK | O_SHLOCK)) {
707 lf.l_whence = SEEK_SET;
708 lf.l_start = 0;
709 lf.l_len = 0;
710 if (flags & O_EXLOCK)
711 lf.l_type = F_WRLCK;
712 else
713 lf.l_type = F_RDLCK;
714 type = F_FLOCK;
715 if ((flags & FNONBLOCK) == 0)
716 type |= F_WAIT;
717 VOP_UNLOCK(vp);
718 error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type);
719 if (error) {
720 (void) vn_close(vp, fp->f_flag, fp->f_cred, p);
721 ffree(fp);
722 fdp->fd_ofiles[indx] = NULL;
723 return (error);
724 }
725 VOP_LOCK(vp);
726 fp->f_flag |= FHASLOCK;
727 }
728 VOP_UNLOCK(vp);
729 *retval = indx;
730 return (0);
731}
732
733#ifdef COMPAT_43
734/*
735 * Create a file.
736 */
737#ifndef _SYS_SYSPROTO_H_
738struct ocreat_args {
739 char *path;
740 int mode;
741};
742#endif
743int
744ocreat(p, uap, retval)
745 struct proc *p;
746 register struct ocreat_args *uap;
747 int *retval;
748{
749 struct open_args openuap;
750
751 openuap.path = uap->path;
752 openuap.mode = uap->mode;
753 openuap.flags = O_WRONLY | O_CREAT | O_TRUNC;
754 return (open(p, &openuap, retval));
755}
756#endif /* COMPAT_43 */
757
758/*
759 * Create a special file.
760 */
761#ifndef _SYS_SYSPROTO_H_
762struct mknod_args {
763 char *path;
764 int mode;
765 int dev;
766};
767#endif
768/* ARGSUSED */
769int
770mknod(p, uap, retval)
771 struct proc *p;
772 register struct mknod_args *uap;
773 int *retval;
774{
775 register struct vnode *vp;
776 struct vattr vattr;
777 int error;
778 struct nameidata nd;
779
780 error = suser(p->p_ucred, &p->p_acflag);
781 if (error)
782 return (error);
783 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
784 error = namei(&nd);
785 if (error)
786 return (error);
787 vp = nd.ni_vp;
788 if (vp != NULL)
789 error = EEXIST;
790 else {
791 VATTR_NULL(&vattr);
792 vattr.va_mode = (uap->mode & ALLPERMS) &~ p->p_fd->fd_cmask;
793 vattr.va_rdev = uap->dev;
794
795 switch (uap->mode & S_IFMT) {
796 case S_IFMT: /* used by badsect to flag bad sectors */
797 vattr.va_type = VBAD;
798 break;
799 case S_IFCHR:
800 vattr.va_type = VCHR;
801 break;
802 case S_IFBLK:
803 vattr.va_type = VBLK;
804 break;
805 default:
806 error = EINVAL;
807 break;
808 }
809 }
810 if (!error) {
811 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
812 error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
813 } else {
814 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
815 if (nd.ni_dvp == vp)
816 vrele(nd.ni_dvp);
817 else
818 vput(nd.ni_dvp);
819 if (vp)
820 vrele(vp);
821 }
822 return (error);
823}
824
825/*
826 * Create named pipe.
827 */
828#ifndef _SYS_SYSPROTO_H_
829struct mkfifo_args {
830 char *path;
831 int mode;
832};
833#endif
834/* ARGSUSED */
835int
836mkfifo(p, uap, retval)
837 struct proc *p;
838 register struct mkfifo_args *uap;
839 int *retval;
840{
841 struct vattr vattr;
842 int error;
843 struct nameidata nd;
844
845 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
846 error = namei(&nd);
847 if (error)
848 return (error);
849 if (nd.ni_vp != NULL) {
850 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
851 if (nd.ni_dvp == nd.ni_vp)
852 vrele(nd.ni_dvp);
853 else
854 vput(nd.ni_dvp);
855 vrele(nd.ni_vp);
856 return (EEXIST);
857 }
858 VATTR_NULL(&vattr);
859 vattr.va_type = VFIFO;
860 vattr.va_mode = (uap->mode & ALLPERMS) &~ p->p_fd->fd_cmask;
861 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
862 return (VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr));
863}
864
865/*
866 * Make a hard file link.
867 */
868#ifndef _SYS_SYSPROTO_H_
869struct link_args {
870 char *path;
871 char *link;
872};
873#endif
874/* ARGSUSED */
875int
876link(p, uap, retval)
877 struct proc *p;
878 register struct link_args *uap;
879 int *retval;
880{
881 register struct vnode *vp;
882 struct nameidata nd;
883 int error;
884
885 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
886 error = namei(&nd);
887 if (error)
888 return (error);
889 vp = nd.ni_vp;
890 if (vp->v_type == VDIR)
891 error = EPERM; /* POSIX */
892 else {
893 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->link, p);
894 error = namei(&nd);
895 if (!error) {
896 if (nd.ni_vp != NULL) {
897 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
898 if (nd.ni_dvp == nd.ni_vp)
899 vrele(nd.ni_dvp);
900 else
901 vput(nd.ni_dvp);
902 if (nd.ni_vp)
903 vrele(nd.ni_vp);
904 error = EEXIST;
905 } else {
906 LEASE_CHECK(nd.ni_dvp,
907 p, p->p_ucred, LEASE_WRITE);
908 LEASE_CHECK(vp,
909 p, p->p_ucred, LEASE_WRITE);
910 error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);
911 }
912 }
913 }
914 vrele(vp);
915 return (error);
916}
917
918/*
919 * Make a symbolic link.
920 */
921#ifndef _SYS_SYSPROTO_H_
922struct symlink_args {
923 char *path;
924 char *link;
925};
926#endif
927/* ARGSUSED */
928int
929symlink(p, uap, retval)
930 struct proc *p;
931 register struct symlink_args *uap;
932 int *retval;
933{
934 struct vattr vattr;
935 char *path;
936 int error;
937 struct nameidata nd;
938
939 MALLOC(path, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
940 error = copyinstr(uap->path, path, MAXPATHLEN, NULL);
941 if (error)
942 goto out;
943 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->link, p);
944 error = namei(&nd);
945 if (error)
946 goto out;
947 if (nd.ni_vp) {
948 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
949 if (nd.ni_dvp == nd.ni_vp)
950 vrele(nd.ni_dvp);
951 else
952 vput(nd.ni_dvp);
953 vrele(nd.ni_vp);
954 error = EEXIST;
955 goto out;
956 }
957 VATTR_NULL(&vattr);
958 vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask;
959 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
960 error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path);
961out:
962 FREE(path, M_NAMEI);
963 return (error);
964}
965
966/*
967 * Delete a name from the filesystem.
968 */
969#ifndef _SYS_SYSPROTO_H_
970struct unlink_args {
971 char *path;
972};
973#endif
974/* ARGSUSED */
975int
976unlink(p, uap, retval)
977 struct proc *p;
978 struct unlink_args *uap;
979 int *retval;
980{
981 register struct vnode *vp;
982 int error;
983 struct nameidata nd;
984
985 NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
986 error = namei(&nd);
987 if (error)
988 return (error);
989 vp = nd.ni_vp;
990 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
991 VOP_LOCK(vp);
992
993 if (vp->v_type == VDIR)
994 error = EPERM; /* POSIX */
995 else {
996 /*
997 * The root of a mounted filesystem cannot be deleted.
998 *
999 * XXX: can this only be a VDIR case?
1000 */
1001 if (vp->v_flag & VROOT)
1002 error = EBUSY;
1003 else
1004 (void) vnode_pager_uncache(vp);
1005 }
1006
1007 if (!error) {
1008 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
1009 error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
1010 } else {
1011 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1012 if (nd.ni_dvp == vp)
1013 vrele(nd.ni_dvp);
1014 else
1015 vput(nd.ni_dvp);
1016 vput(vp);
1017 }
1018 return (error);
1019}
1020
1021/*
1022 * Reposition read/write file offset.
1023 */
1024#ifndef _SYS_SYSPROTO_H_
1025struct lseek_args {
1026 int fd;
1027 int pad;
1028 off_t offset;
1029 int whence;
1030};
1031#endif
1032int
1033lseek(p, uap, retval)
1034 struct proc *p;
1035 register struct lseek_args *uap;
1036 int *retval;
1037{
1038 struct ucred *cred = p->p_ucred;
1039 register struct filedesc *fdp = p->p_fd;
1040 register struct file *fp;
1041 struct vattr vattr;
1042 int error;
1043
1044 if ((u_int)uap->fd >= fdp->fd_nfiles ||
1045 (fp = fdp->fd_ofiles[uap->fd]) == NULL)
1046 return (EBADF);
1047 if (fp->f_type != DTYPE_VNODE)
1048 return (ESPIPE);
1049 switch (uap->whence) {
1050 case L_INCR:
1051 fp->f_offset += uap->offset;
1052 break;
1053 case L_XTND:
1054 error=VOP_GETATTR((struct vnode *)fp->f_data, &vattr, cred, p);
1055 if (error)
1056 return (error);
1057 fp->f_offset = uap->offset + vattr.va_size;
1058 break;
1059 case L_SET:
1060 fp->f_offset = uap->offset;
1061 break;
1062 default:
1063 return (EINVAL);
1064 }
1065 *(off_t *)retval = fp->f_offset;
1066 return (0);
1067}
1068
1069#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1070/*
1071 * Reposition read/write file offset.
1072 */
1073#ifndef _SYS_SYSPROTO_H_
1074struct olseek_args {
1075 int fd;
1076 long offset;
1077 int whence;
1078};
1079#endif
1080int
1081olseek(p, uap, retval)
1082 struct proc *p;
1083 register struct olseek_args *uap;
1084 int *retval;
1085{
1086 struct lseek_args nuap;
1087 off_t qret;
1088 int error;
1089
1090 nuap.fd = uap->fd;
1091 nuap.offset = uap->offset;
1092 nuap.whence = uap->whence;
1093 error = lseek(p, &nuap, (int *)&qret);
1094 *(long *)retval = qret;
1095 return (error);
1096}
1097#endif /* COMPAT_43 */
1098
1099/*
1100 * Check access permissions.
1101 */
1102#ifndef _SYS_SYSPROTO_H_
1103struct access_args {
1104 char *path;
1105 int flags;
1106};
1107#endif
1108int
1109access(p, uap, retval)
1110 struct proc *p;
1111 register struct access_args *uap;
1112 int *retval;
1113{
1114 register struct ucred *cred = p->p_ucred;
1115 register struct vnode *vp;
1116 int error, flags, t_gid, t_uid;
1117 struct nameidata nd;
1118
1119 t_uid = cred->cr_uid;
1120 t_gid = cred->cr_groups[0];
1121 cred->cr_uid = p->p_cred->p_ruid;
1122 cred->cr_groups[0] = p->p_cred->p_rgid;
1123 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1124 error = namei(&nd);
1125 if (error)
1126 goto out1;
1127 vp = nd.ni_vp;
1128
1129 /* Flags == 0 means only check for existence. */
1130 if (uap->flags) {
1131 flags = 0;
1132 if (uap->flags & R_OK)
1133 flags |= VREAD;
1134 if (uap->flags & W_OK)
1135 flags |= VWRITE;
1136 if (uap->flags & X_OK)
1137 flags |= VEXEC;
1138 if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
1139 error = VOP_ACCESS(vp, flags, cred, p);
1140 }
1141 vput(vp);
1142out1:
1143 cred->cr_uid = t_uid;
1144 cred->cr_groups[0] = t_gid;
1145 return (error);
1146}
1147
1148#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1149/*
1150 * Get file status; this version follows links.
1151 */
1152#ifndef _SYS_SYSPROTO_H_
1153struct ostat_args {
1154 char *path;
1155 struct ostat *ub;
1156};
1157#endif
1158/* ARGSUSED */
1159int
1160ostat(p, uap, retval)
1161 struct proc *p;
1162 register struct ostat_args *uap;
1163 int *retval;
1164{
1165 struct stat sb;
1166 struct ostat osb;
1167 int error;
1168 struct nameidata nd;
1169
1170 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1171 error = namei(&nd);
1172 if (error)
1173 return (error);
1174 error = vn_stat(nd.ni_vp, &sb, p);
1175 vput(nd.ni_vp);
1176 if (error)
1177 return (error);
1178 cvtstat(&sb, &osb);
1179 error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
1180 return (error);
1181}
1182
1183/*
1184 * Get file status; this version does not follow links.
1185 */
1186#ifndef _SYS_SYSPROTO_H_
1187struct olstat_args {
1188 char *path;
1189 struct ostat *ub;
1190};
1191#endif
1192/* ARGSUSED */
1193int
1194olstat(p, uap, retval)
1195 struct proc *p;
1196 register struct olstat_args *uap;
1197 int *retval;
1198{
1199 struct vnode *vp, *dvp;
1200 struct stat sb, sb1;
1201 struct ostat osb;
1202 int error;
1203 struct nameidata nd;
1204
1205 NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | LOCKPARENT, UIO_USERSPACE,
1206 uap->path, p);
1207 error = namei(&nd);
1208 if (error)
1209 return (error);
1210 /*
1211 * For symbolic links, always return the attributes of its
1212 * containing directory, except for mode, size, and links.
1213 */
1214 vp = nd.ni_vp;
1215 dvp = nd.ni_dvp;
1216 if (vp->v_type != VLNK) {
1217 if (dvp == vp)
1218 vrele(dvp);
1219 else
1220 vput(dvp);
1221 error = vn_stat(vp, &sb, p);
1222 vput(vp);
1223 if (error)
1224 return (error);
1225 } else {
1226 error = vn_stat(dvp, &sb, p);
1227 vput(dvp);
1228 if (error) {
1229 vput(vp);
1230 return (error);
1231 }
1232 error = vn_stat(vp, &sb1, p);
1233 vput(vp);
1234 if (error)
1235 return (error);
1236 sb.st_mode &= ~S_IFDIR;
1237 sb.st_mode |= S_IFLNK;
1238 sb.st_nlink = sb1.st_nlink;
1239 sb.st_size = sb1.st_size;
1240 sb.st_blocks = sb1.st_blocks;
1241 }
1242 cvtstat(&sb, &osb);
1243 error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
1244 return (error);
1245}
1246
1247/*
1248 * Convert from an old to a new stat structure.
1249 */
1250void
1251cvtstat(st, ost)
1252 struct stat *st;
1253 struct ostat *ost;
1254{
1255
1256 ost->st_dev = st->st_dev;
1257 ost->st_ino = st->st_ino;
1258 ost->st_mode = st->st_mode;
1259 ost->st_nlink = st->st_nlink;
1260 ost->st_uid = st->st_uid;
1261 ost->st_gid = st->st_gid;
1262 ost->st_rdev = st->st_rdev;
1263 if (st->st_size < (quad_t)1 << 32)
1264 ost->st_size = st->st_size;
1265 else
1266 ost->st_size = -2;
1267 ost->st_atime = st->st_atime;
1268 ost->st_mtime = st->st_mtime;
1269 ost->st_ctime = st->st_ctime;
1270 ost->st_blksize = st->st_blksize;
1271 ost->st_blocks = st->st_blocks;
1272 ost->st_flags = st->st_flags;
1273 ost->st_gen = st->st_gen;
1274}
1275#endif /* COMPAT_43 || COMPAT_SUNOS */
1276
1277/*
1278 * Get file status; this version follows links.
1279 */
1280#ifndef _SYS_SYSPROTO_H_
1281struct stat_args {
1282 char *path;
1283 struct stat *ub;
1284};
1285#endif
1286/* ARGSUSED */
1287int
1288stat(p, uap, retval)
1289 struct proc *p;
1290 register struct stat_args *uap;
1291 int *retval;
1292{
1293 struct stat sb;
1294 int error;
1295 struct nameidata nd;
1296
1297 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1298 error = namei(&nd);
1299 if (error)
1300 return (error);
1301 error = vn_stat(nd.ni_vp, &sb, p);
1302 vput(nd.ni_vp);
1303 if (error)
1304 return (error);
1305 error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
1306 return (error);
1307}
1308
1309/*
1310 * Get file status; this version does not follow links.
1311 */
1312#ifndef _SYS_SYSPROTO_H_
1313struct lstat_args {
1314 char *path;
1315 struct stat *ub;
1316};
1317#endif
1318/* ARGSUSED */
1319int
1320lstat(p, uap, retval)
1321 struct proc *p;
1322 register struct lstat_args *uap;
1323 int *retval;
1324{
1325 int error;
1326 struct vnode *vp, *dvp;
1327 struct stat sb, sb1;
1328 struct nameidata nd;
1329
1330 NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | LOCKPARENT, UIO_USERSPACE,
1331 uap->path, p);
1332 error = namei(&nd);
1333 if (error)
1334 return (error);
1335 /*
1336 * For symbolic links, always return the attributes of its
1337 * containing directory, except for mode, size, and links.
1338 */
1339 vp = nd.ni_vp;
1340 dvp = nd.ni_dvp;
1341 if (vp->v_type != VLNK) {
1342 if (dvp == vp)
1343 vrele(dvp);
1344 else
1345 vput(dvp);
1346 error = vn_stat(vp, &sb, p);
1347 vput(vp);
1348 if (error)
1349 return (error);
1350 } else {
1351 error = vn_stat(dvp, &sb, p);
1352 vput(dvp);
1353 if (error) {
1354 vput(vp);
1355 return (error);
1356 }
1357 error = vn_stat(vp, &sb1, p);
1358 vput(vp);
1359 if (error)
1360 return (error);
1361 sb.st_mode &= ~S_IFDIR;
1362 sb.st_mode |= S_IFLNK;
1363 sb.st_nlink = sb1.st_nlink;
1364 sb.st_size = sb1.st_size;
1365 sb.st_blocks = sb1.st_blocks;
1366 }
1367 error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
1368 return (error);
1369}
1370
1371/*
1372 * Get configurable pathname variables.
1373 */
1374#ifndef _SYS_SYSPROTO_H_
1375struct pathconf_args {
1376 char *path;
1377 int name;
1378};
1379#endif
1380/* ARGSUSED */
1381int
1382pathconf(p, uap, retval)
1383 struct proc *p;
1384 register struct pathconf_args *uap;
1385 int *retval;
1386{
1387 int error;
1388 struct nameidata nd;
1389
1390 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1391 error = namei(&nd);
1392 if (error)
1393 return (error);
1394 error = VOP_PATHCONF(nd.ni_vp, uap->name, retval);
1395 vput(nd.ni_vp);
1396 return (error);
1397}
1398
1399/*
1400 * Return target name of a symbolic link.
1401 */
1402#ifndef _SYS_SYSPROTO_H_
1403struct readlink_args {
1404 char *path;
1405 char *buf;
1406 int count;
1407};
1408#endif
1409/* ARGSUSED */
1410int
1411readlink(p, uap, retval)
1412 struct proc *p;
1413 register struct readlink_args *uap;
1414 int *retval;
1415{
1416 register struct vnode *vp;
1417 struct iovec aiov;
1418 struct uio auio;
1419 int error;
1420 struct nameidata nd;
1421
1422 NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1423 error = namei(&nd);
1424 if (error)
1425 return (error);
1426 vp = nd.ni_vp;
1427 if (vp->v_type != VLNK)
1428 error = EINVAL;
1429 else {
1430 aiov.iov_base = uap->buf;
1431 aiov.iov_len = uap->count;
1432 auio.uio_iov = &aiov;
1433 auio.uio_iovcnt = 1;
1434 auio.uio_offset = 0;
1435 auio.uio_rw = UIO_READ;
1436 auio.uio_segflg = UIO_USERSPACE;
1437 auio.uio_procp = p;
1438 auio.uio_resid = uap->count;
1439 error = VOP_READLINK(vp, &auio, p->p_ucred);
1440 }
1441 vput(vp);
1442 *retval = uap->count - auio.uio_resid;
1443 return (error);
1444}
1445
1446/*
1447 * Change flags of a file given a path name.
1448 */
1449#ifndef _SYS_SYSPROTO_H_
1450struct chflags_args {
1451 char *path;
1452 int flags;
1453};
1454#endif
1455/* ARGSUSED */
1456int
1457chflags(p, uap, retval)
1458 struct proc *p;
1459 register struct chflags_args *uap;
1460 int *retval;
1461{
1462 register struct vnode *vp;
1463 struct vattr vattr;
1464 int error;
1465 struct nameidata nd;
1466
1467 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1468 error = namei(&nd);
1469 if (error)
1470 return (error);
1471 vp = nd.ni_vp;
1472 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1473 VOP_LOCK(vp);
1474 VATTR_NULL(&vattr);
1475 vattr.va_flags = uap->flags;
1476 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1477 vput(vp);
1478 return (error);
1479}
1480
1481/*
1482 * Change flags of a file given a file descriptor.
1483 */
1484#ifndef _SYS_SYSPROTO_H_
1485struct fchflags_args {
1486 int fd;
1487 int flags;
1488};
1489#endif
1490/* ARGSUSED */
1491int
1492fchflags(p, uap, retval)
1493 struct proc *p;
1494 register struct fchflags_args *uap;
1495 int *retval;
1496{
1497 struct vattr vattr;
1498 struct vnode *vp;
1499 struct file *fp;
1500 int error;
1501
1502 error = getvnode(p->p_fd, uap->fd, &fp);
1503 if (error)
1504 return (error);
1505 vp = (struct vnode *)fp->f_data;
1506 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1507 VOP_LOCK(vp);
1508 VATTR_NULL(&vattr);
1509 vattr.va_flags = uap->flags;
1510 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1511 VOP_UNLOCK(vp);
1512 return (error);
1513}
1514
1515/*
1516 * Change mode of a file given path name.
1517 */
1518#ifndef _SYS_SYSPROTO_H_
1519struct chmod_args {
1520 char *path;
1521 int mode;
1522};
1523#endif
1524/* ARGSUSED */
1525int
1526chmod(p, uap, retval)
1527 struct proc *p;
1528 register struct chmod_args *uap;
1529 int *retval;
1530{
1531 register struct vnode *vp;
1532 struct vattr vattr;
1533 int error;
1534 struct nameidata nd;
1535
1536 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1537 error = namei(&nd);
1538 if (error)
1539 return (error);
1540 vp = nd.ni_vp;
1541 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1542 VOP_LOCK(vp);
1543 VATTR_NULL(&vattr);
1544 vattr.va_mode = uap->mode & ALLPERMS;
1545 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1546 vput(vp);
1547 return (error);
1548}
1549
1550/*
1551 * Change mode of a file given a file descriptor.
1552 */
1553#ifndef _SYS_SYSPROTO_H_
1554struct fchmod_args {
1555 int fd;
1556 int mode;
1557};
1558#endif
1559/* ARGSUSED */
1560int
1561fchmod(p, uap, retval)
1562 struct proc *p;
1563 register struct fchmod_args *uap;
1564 int *retval;
1565{
1566 struct vattr vattr;
1567 struct vnode *vp;
1568 struct file *fp;
1569 int error;
1570
1571 error = getvnode(p->p_fd, uap->fd, &fp);
1572 if (error)
1573 return (error);
1574 vp = (struct vnode *)fp->f_data;
1575 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1576 VOP_LOCK(vp);
1577 VATTR_NULL(&vattr);
1578 vattr.va_mode = uap->mode & ALLPERMS;
1579 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1580 VOP_UNLOCK(vp);
1581 return (error);
1582}
1583
1584/*
1585 * Set ownership given a path name.
1586 */
1587#ifndef _SYS_SYSPROTO_H_
1588struct chown_args {
1589 char *path;
1590 int uid;
1591 int gid;
1592};
1593#endif
1594/* ARGSUSED */
1595int
1596chown(p, uap, retval)
1597 struct proc *p;
1598 register struct chown_args *uap;
1599 int *retval;
1600{
1601 register struct vnode *vp;
1602 struct vattr vattr;
1603 int error;
1604 struct nameidata nd;
1605
1606 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1607 error = namei(&nd);
1608 if (error)
1609 return (error);
1610 vp = nd.ni_vp;
1611 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1612 VOP_LOCK(vp);
1613 VATTR_NULL(&vattr);
1614 vattr.va_uid = uap->uid;
1615 vattr.va_gid = uap->gid;
1616 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1617 vput(vp);
1618 return (error);
1619}
1620
1621/*
1622 * Set ownership given a file descriptor.
1623 */
1624#ifndef _SYS_SYSPROTO_H_
1625struct fchown_args {
1626 int fd;
1627 int uid;
1628 int gid;
1629};
1630#endif
1631/* ARGSUSED */
1632int
1633fchown(p, uap, retval)
1634 struct proc *p;
1635 register struct fchown_args *uap;
1636 int *retval;
1637{
1638 struct vattr vattr;
1639 struct vnode *vp;
1640 struct file *fp;
1641 int error;
1642
1643 error = getvnode(p->p_fd, uap->fd, &fp);
1644 if (error)
1645 return (error);
1646 vp = (struct vnode *)fp->f_data;
1647 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1648 VOP_LOCK(vp);
1649 VATTR_NULL(&vattr);
1650 vattr.va_uid = uap->uid;
1651 vattr.va_gid = uap->gid;
1652 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1653 VOP_UNLOCK(vp);
1654 return (error);
1655}
1656
1657/*
1658 * Set the access and modification times of a file.
1659 */
1660#ifndef _SYS_SYSPROTO_H_
1661struct utimes_args {
1662 char *path;
1663 struct timeval *tptr;
1664};
1665#endif
1666/* ARGSUSED */
1667int
1668utimes(p, uap, retval)
1669 struct proc *p;
1670 register struct utimes_args *uap;
1671 int *retval;
1672{
1673 register struct vnode *vp;
1674 struct timeval tv[2];
1675 struct vattr vattr;
1676 int error;
1677 struct nameidata nd;
1678
1679 VATTR_NULL(&vattr);
1680 if (uap->tptr == NULL) {
1681 microtime(&tv[0]);
1682 tv[1] = tv[0];
1683 vattr.va_vaflags |= VA_UTIMES_NULL;
1684 } else {
1685 error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv));
1686 if (error)
1687 return (error);
1688 }
1689 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1690 error = namei(&nd);
1691 if (error)
1692 return (error);
1693 vp = nd.ni_vp;
1694 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1695 VOP_LOCK(vp);
| 40 */
41
42/*
43 * XXX - The following is required because of some magic done
44 * in getdirentries() below which is only done if the translucent
45 * filesystem `UNION' is compiled into the kernel. This is broken,
46 * but I don't have time to study the code deeply enough to understand
47 * what's going on and determine an appropriate fix. -GAW
48 */
49#include "opt_union.h"
50
51#include <sys/param.h>
52#include <sys/systm.h>
53#include <sys/sysproto.h>
54#include <sys/namei.h>
55#include <sys/filedesc.h>
56#include <sys/kernel.h>
57#include <sys/file.h>
58#include <sys/stat.h>
59#include <sys/unistd.h>
60#include <sys/vnode.h>
61#include <sys/mount.h>
62#include <sys/proc.h>
63#include <sys/uio.h>
64#include <sys/malloc.h>
65#include <sys/dirent.h>
66
67#ifdef UNION
68#include <miscfs/union/union.h>
69#endif
70
71#include <vm/vm.h>
72#include <vm/vm_param.h>
73#include <vm/vm_object.h>
74#include <vm/vm_extern.h>
75#include <sys/sysctl.h>
76
77static int change_dir __P((struct nameidata *ndp, struct proc *p));
78
79/*
80 * Virtual File System System Calls
81 */
82
83/*
84 * Mount a file system.
85 */
86#ifndef _SYS_SYSPROTO_H_
87struct mount_args {
88 int type;
89 char *path;
90 int flags;
91 caddr_t data;
92};
93#endif
94/* ARGSUSED */
95int
96mount(p, uap, retval)
97 struct proc *p;
98 register struct mount_args *uap;
99 int *retval;
100{
101 register struct vnode *vp;
102 register struct mount *mp;
103 int error, flag = 0;
104 struct nameidata nd;
105
106 /*
107 * Must be super user
108 */
109 error = suser(p->p_ucred, &p->p_acflag);
110 if (error)
111 return (error);
112 /*
113 * Get vnode to be covered
114 */
115 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
116 error = namei(&nd);
117 if (error)
118 return (error);
119 vp = nd.ni_vp;
120 if (uap->flags & MNT_UPDATE) {
121 if ((vp->v_flag & VROOT) == 0) {
122 vput(vp);
123 return (EINVAL);
124 }
125 mp = vp->v_mount;
126 flag = mp->mnt_flag;
127 /*
128 * We only allow the filesystem to be reloaded if it
129 * is currently mounted read-only.
130 */
131 if ((uap->flags & MNT_RELOAD) &&
132 ((mp->mnt_flag & MNT_RDONLY) == 0)) {
133 vput(vp);
134 return (EOPNOTSUPP); /* Needs translation */
135 }
136 mp->mnt_flag |=
137 uap->flags & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE);
138 VOP_UNLOCK(vp);
139 goto update;
140 }
141 error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0);
142 if (error)
143 return (error);
144 if (vp->v_type != VDIR) {
145 vput(vp);
146 return (ENOTDIR);
147 }
148 if ((u_long)uap->type > MOUNT_MAXTYPE || vfssw[uap->type] == NULL) {
149 vput(vp);
150 return (ENODEV);
151 }
152
153 /*
154 * Allocate and initialize the file system.
155 */
156 mp = (struct mount *)malloc((u_long)sizeof(struct mount),
157 M_MOUNT, M_WAITOK);
158 bzero((char *)mp, (u_long)sizeof(struct mount));
159 mp->mnt_op = vfssw[uap->type];
160 mp->mnt_vfc = vfsconf[uap->type];
161 error = vfs_lock(mp);
162 if (error) {
163 free((caddr_t)mp, M_MOUNT);
164 vput(vp);
165 return (error);
166 }
167 if (vp->v_mountedhere != NULL) {
168 vfs_unlock(mp);
169 free((caddr_t)mp, M_MOUNT);
170 vput(vp);
171 return (EBUSY);
172 }
173 vp->v_mountedhere = mp;
174 mp->mnt_vnodecovered = vp;
175 vfsconf[uap->type]->vfc_refcount++;
176
177update:
178 /*
179 * Set the mount level flags.
180 */
181 if (uap->flags & MNT_RDONLY)
182 mp->mnt_flag |= MNT_RDONLY;
183 else if (mp->mnt_flag & MNT_RDONLY)
184 mp->mnt_flag |= MNT_WANTRDWR;
185 mp->mnt_flag &=~ (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV |
186 MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC | MNT_NOATIME);
187 mp->mnt_flag |= uap->flags & (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV |
188 MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC | MNT_FORCE | MNT_NOATIME);
189 /*
190 * Mount the filesystem.
191 */
192 error = VFS_MOUNT(mp, uap->path, uap->data, &nd, p);
193 if (mp->mnt_flag & MNT_UPDATE) {
194 vrele(vp);
195 if (mp->mnt_flag & MNT_WANTRDWR)
196 mp->mnt_flag &= ~MNT_RDONLY;
197 mp->mnt_flag &=~
198 (MNT_UPDATE | MNT_RELOAD | MNT_FORCE | MNT_WANTRDWR);
199 if (error)
200 mp->mnt_flag = flag;
201 return (error);
202 }
203 /*
204 * Put the new filesystem on the mount list after root.
205 */
206 cache_purge(vp);
207 if (!error) {
208 CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
209 VOP_UNLOCK(vp);
210 vfs_unlock(mp);
211 error = VFS_START(mp, 0, p);
212 if (error)
213 vrele(vp);
214 } else {
215 mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
216 vfs_unlock(mp);
217 free((caddr_t)mp, M_MOUNT);
218 vput(vp);
219 vfsconf[uap->type]->vfc_refcount--;
220 }
221 return (error);
222}
223
224/*
225 * Unmount a file system.
226 *
227 * Note: unmount takes a path to the vnode mounted on as argument,
228 * not special file (as before).
229 */
230#ifndef _SYS_SYSPROTO_H_
231struct unmount_args {
232 char *path;
233 int flags;
234};
235#endif
236/* ARGSUSED */
237int
238unmount(p, uap, retval)
239 struct proc *p;
240 register struct unmount_args *uap;
241 int *retval;
242{
243 register struct vnode *vp;
244 struct mount *mp;
245 int error;
246 struct nameidata nd;
247
248 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
249 error = namei(&nd);
250 if (error)
251 return (error);
252 vp = nd.ni_vp;
253
254 /*
255 * Unless this is a user mount, then must
256 * have suser privilege.
257 */
258 if (((vp->v_mount->mnt_flag & MNT_USER) == 0) &&
259 (error = suser(p->p_ucred, &p->p_acflag))) {
260 vput(vp);
261 return (error);
262 }
263
264 /*
265 * Must be the root of the filesystem
266 */
267 if ((vp->v_flag & VROOT) == 0) {
268 vput(vp);
269 return (EINVAL);
270 }
271 mp = vp->v_mount;
272 vput(vp);
273
274 /*
275 * Don't allow unmount of the root filesystem
276 */
277 if (mp->mnt_flag & MNT_ROOTFS)
278 return (EINVAL);
279
280 return (dounmount(mp, uap->flags, p));
281}
282
283/*
284 * Do the actual file system unmount.
285 */
286int
287dounmount(mp, flags, p)
288 register struct mount *mp;
289 int flags;
290 struct proc *p;
291{
292 struct vnode *coveredvp;
293 int error;
294
295 coveredvp = mp->mnt_vnodecovered;
296 if (vfs_busy(mp))
297 return (EBUSY);
298 mp->mnt_flag |= MNT_UNMOUNT;
299 error = vfs_lock(mp);
300 if (error)
301 return (error);
302
303 mp->mnt_flag &=~ MNT_ASYNC;
304 vfs_msync(mp, MNT_NOWAIT);
305 vnode_pager_umount(mp); /* release cached vnodes */
306 cache_purgevfs(mp); /* remove cache entries for this file sys */
307 if ((error = VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p)) == 0 ||
308 (flags & MNT_FORCE))
309 error = VFS_UNMOUNT(mp, flags, p);
310 mp->mnt_flag &= ~MNT_UNMOUNT;
311 vfs_unbusy(mp);
312 if (error) {
313 vfs_unlock(mp);
314 } else {
315 vrele(coveredvp);
316 CIRCLEQ_REMOVE(&mountlist, mp, mnt_list);
317 mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
318 vfs_unlock(mp);
319 mp->mnt_vfc->vfc_refcount--;
320 if (mp->mnt_vnodelist.lh_first != NULL)
321 panic("unmount: dangling vnode");
322 free((caddr_t)mp, M_MOUNT);
323 }
324 return (error);
325}
326
327/*
328 * Sync each mounted filesystem.
329 */
330
331#ifndef _SYS_SYSPROTO_H_
332struct sync_args {
333 int dummy;
334};
335#endif
336
337/* ARGSUSED */
338int
339sync(p, uap, retval)
340 struct proc *p;
341 struct sync_args *uap;
342 int *retval;
343{
344 register struct mount *mp;
345 int asyncflag;
346
347 for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = mp->mnt_list.cqe_next) {
348 /*
349 * The lock check below is to avoid races with mount
350 * and unmount.
351 */
352 if ((mp->mnt_flag & (MNT_MLOCK|MNT_RDONLY|MNT_MPBUSY)) == 0 &&
353 !vfs_busy(mp)) {
354 asyncflag = mp->mnt_flag & MNT_ASYNC;
355 mp->mnt_flag &= ~MNT_ASYNC;
356 vfs_msync(mp, MNT_NOWAIT);
357 VFS_SYNC(mp, MNT_NOWAIT, p != NULL ? p->p_ucred : NOCRED, p);
358 if (asyncflag)
359 mp->mnt_flag |= MNT_ASYNC;
360 vfs_unbusy(mp);
361 }
362 }
363 return (0);
364}
365
366/*
367 * Change filesystem quotas.
368 */
369#ifndef _SYS_SYSPROTO_H_
370struct quotactl_args {
371 char *path;
372 int cmd;
373 int uid;
374 caddr_t arg;
375};
376#endif
377/* ARGSUSED */
378int
379quotactl(p, uap, retval)
380 struct proc *p;
381 register struct quotactl_args *uap;
382 int *retval;
383{
384 register struct mount *mp;
385 int error;
386 struct nameidata nd;
387
388 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
389 error = namei(&nd);
390 if (error)
391 return (error);
392 mp = nd.ni_vp->v_mount;
393 vrele(nd.ni_vp);
394 return (VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg, p));
395}
396
397/*
398 * Get filesystem statistics.
399 */
400#ifndef _SYS_SYSPROTO_H_
401struct statfs_args {
402 char *path;
403 struct statfs *buf;
404};
405#endif
406/* ARGSUSED */
407int
408statfs(p, uap, retval)
409 struct proc *p;
410 register struct statfs_args *uap;
411 int *retval;
412{
413 register struct mount *mp;
414 register struct statfs *sp;
415 int error;
416 struct nameidata nd;
417
418 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
419 error = namei(&nd);
420 if (error)
421 return (error);
422 mp = nd.ni_vp->v_mount;
423 sp = &mp->mnt_stat;
424 vrele(nd.ni_vp);
425 error = VFS_STATFS(mp, sp, p);
426 if (error)
427 return (error);
428 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
429 return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
430}
431
432/*
433 * Get filesystem statistics.
434 */
435#ifndef _SYS_SYSPROTO_H_
436struct fstatfs_args {
437 int fd;
438 struct statfs *buf;
439};
440#endif
441/* ARGSUSED */
442int
443fstatfs(p, uap, retval)
444 struct proc *p;
445 register struct fstatfs_args *uap;
446 int *retval;
447{
448 struct file *fp;
449 struct mount *mp;
450 register struct statfs *sp;
451 int error;
452
453 error = getvnode(p->p_fd, uap->fd, &fp);
454 if (error)
455 return (error);
456 mp = ((struct vnode *)fp->f_data)->v_mount;
457 sp = &mp->mnt_stat;
458 error = VFS_STATFS(mp, sp, p);
459 if (error)
460 return (error);
461 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
462 return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
463}
464
465/*
466 * Get statistics on all filesystems.
467 */
468#ifndef _SYS_SYSPROTO_H_
469struct getfsstat_args {
470 struct statfs *buf;
471 long bufsize;
472 int flags;
473};
474#endif
475int
476getfsstat(p, uap, retval)
477 struct proc *p;
478 register struct getfsstat_args *uap;
479 int *retval;
480{
481 register struct mount *mp, *nmp;
482 register struct statfs *sp;
483 caddr_t sfsp;
484 long count, maxcount, error;
485
486 maxcount = uap->bufsize / sizeof(struct statfs);
487 sfsp = (caddr_t)uap->buf;
488 count = 0;
489 for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
490 if (vfs_busy(mp)) {
491 nmp = mp->mnt_list.cqe_next;
492 continue;
493 }
494 if (sfsp && count < maxcount &&
495 ((mp->mnt_flag & MNT_MLOCK) == 0)) {
496 sp = &mp->mnt_stat;
497 /*
498 * If MNT_NOWAIT is specified, do not refresh the
499 * fsstat cache. MNT_WAIT overrides MNT_NOWAIT.
500 */
501 if (((uap->flags & MNT_NOWAIT) == 0 ||
502 (uap->flags & MNT_WAIT)) &&
503 (error = VFS_STATFS(mp, sp, p))) {
504 nmp = mp->mnt_list.cqe_next;
505 vfs_unbusy(mp);
506 continue;
507 }
508 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
509 error = copyout((caddr_t)sp, sfsp, sizeof(*sp));
510 if (error) {
511 vfs_unbusy(mp);
512 return (error);
513 }
514 sfsp += sizeof(*sp);
515 }
516 count++;
517 nmp = mp->mnt_list.cqe_next;
518 vfs_unbusy(mp);
519 }
520 if (sfsp && count > maxcount)
521 *retval = maxcount;
522 else
523 *retval = count;
524 return (0);
525}
526
527/*
528 * Change current working directory to a given file descriptor.
529 */
530#ifndef _SYS_SYSPROTO_H_
531struct fchdir_args {
532 int fd;
533};
534#endif
535/* ARGSUSED */
536int
537fchdir(p, uap, retval)
538 struct proc *p;
539 struct fchdir_args *uap;
540 int *retval;
541{
542 register struct filedesc *fdp = p->p_fd;
543 register struct vnode *vp;
544 struct file *fp;
545 int error;
546
547 error = getvnode(fdp, uap->fd, &fp);
548 if (error)
549 return (error);
550 vp = (struct vnode *)fp->f_data;
551 VOP_LOCK(vp);
552 if (vp->v_type != VDIR)
553 error = ENOTDIR;
554 else
555 error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
556 VOP_UNLOCK(vp);
557 if (error)
558 return (error);
559 VREF(vp);
560 vrele(fdp->fd_cdir);
561 fdp->fd_cdir = vp;
562 return (0);
563}
564
565/*
566 * Change current working directory (``.'').
567 */
568#ifndef _SYS_SYSPROTO_H_
569struct chdir_args {
570 char *path;
571};
572#endif
573/* ARGSUSED */
574int
575chdir(p, uap, retval)
576 struct proc *p;
577 struct chdir_args *uap;
578 int *retval;
579{
580 register struct filedesc *fdp = p->p_fd;
581 int error;
582 struct nameidata nd;
583
584 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
585 error = change_dir(&nd, p);
586 if (error)
587 return (error);
588 vrele(fdp->fd_cdir);
589 fdp->fd_cdir = nd.ni_vp;
590 return (0);
591}
592
593/*
594 * Change notion of root (``/'') directory.
595 */
596#ifndef _SYS_SYSPROTO_H_
597struct chroot_args {
598 char *path;
599};
600#endif
601/* ARGSUSED */
602int
603chroot(p, uap, retval)
604 struct proc *p;
605 struct chroot_args *uap;
606 int *retval;
607{
608 register struct filedesc *fdp = p->p_fd;
609 int error;
610 struct nameidata nd;
611
612 error = suser(p->p_ucred, &p->p_acflag);
613 if (error)
614 return (error);
615 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
616 error = change_dir(&nd, p);
617 if (error)
618 return (error);
619 if (fdp->fd_rdir != NULL)
620 vrele(fdp->fd_rdir);
621 fdp->fd_rdir = nd.ni_vp;
622 return (0);
623}
624
625/*
626 * Common routine for chroot and chdir.
627 */
628static int
629change_dir(ndp, p)
630 register struct nameidata *ndp;
631 struct proc *p;
632{
633 struct vnode *vp;
634 int error;
635
636 error = namei(ndp);
637 if (error)
638 return (error);
639 vp = ndp->ni_vp;
640 if (vp->v_type != VDIR)
641 error = ENOTDIR;
642 else
643 error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
644 VOP_UNLOCK(vp);
645 if (error)
646 vrele(vp);
647 return (error);
648}
649
650/*
651 * Check permissions, allocate an open file structure,
652 * and call the device open routine if any.
653 */
654#ifndef _SYS_SYSPROTO_H_
655struct open_args {
656 char *path;
657 int flags;
658 int mode;
659};
660#endif
661int
662open(p, uap, retval)
663 struct proc *p;
664 register struct open_args *uap;
665 int *retval;
666{
667 register struct filedesc *fdp = p->p_fd;
668 register struct file *fp;
669 register struct vnode *vp;
670 int flags, cmode;
671 struct file *nfp;
672 int type, indx, error;
673 struct flock lf;
674 struct nameidata nd;
675
676 error = falloc(p, &nfp, &indx);
677 if (error)
678 return (error);
679 fp = nfp;
680 flags = FFLAGS(uap->flags);
681 cmode = ((uap->mode &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT;
682 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
683 p->p_dupfd = -indx - 1; /* XXX check for fdopen */
684 error = vn_open(&nd, flags, cmode);
685 if (error) {
686 ffree(fp);
687 if ((error == ENODEV || error == ENXIO) &&
688 p->p_dupfd >= 0 && /* XXX from fdopen */
689 (error =
690 dupfdopen(fdp, indx, p->p_dupfd, flags, error)) == 0) {
691 *retval = indx;
692 return (0);
693 }
694 if (error == ERESTART)
695 error = EINTR;
696 fdp->fd_ofiles[indx] = NULL;
697 return (error);
698 }
699 p->p_dupfd = 0;
700 vp = nd.ni_vp;
701
702 fp->f_flag = flags & FMASK;
703 fp->f_type = DTYPE_VNODE;
704 fp->f_ops = &vnops;
705 fp->f_data = (caddr_t)vp;
706 if (flags & (O_EXLOCK | O_SHLOCK)) {
707 lf.l_whence = SEEK_SET;
708 lf.l_start = 0;
709 lf.l_len = 0;
710 if (flags & O_EXLOCK)
711 lf.l_type = F_WRLCK;
712 else
713 lf.l_type = F_RDLCK;
714 type = F_FLOCK;
715 if ((flags & FNONBLOCK) == 0)
716 type |= F_WAIT;
717 VOP_UNLOCK(vp);
718 error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type);
719 if (error) {
720 (void) vn_close(vp, fp->f_flag, fp->f_cred, p);
721 ffree(fp);
722 fdp->fd_ofiles[indx] = NULL;
723 return (error);
724 }
725 VOP_LOCK(vp);
726 fp->f_flag |= FHASLOCK;
727 }
728 VOP_UNLOCK(vp);
729 *retval = indx;
730 return (0);
731}
732
733#ifdef COMPAT_43
734/*
735 * Create a file.
736 */
737#ifndef _SYS_SYSPROTO_H_
738struct ocreat_args {
739 char *path;
740 int mode;
741};
742#endif
743int
744ocreat(p, uap, retval)
745 struct proc *p;
746 register struct ocreat_args *uap;
747 int *retval;
748{
749 struct open_args openuap;
750
751 openuap.path = uap->path;
752 openuap.mode = uap->mode;
753 openuap.flags = O_WRONLY | O_CREAT | O_TRUNC;
754 return (open(p, &openuap, retval));
755}
756#endif /* COMPAT_43 */
757
758/*
759 * Create a special file.
760 */
761#ifndef _SYS_SYSPROTO_H_
762struct mknod_args {
763 char *path;
764 int mode;
765 int dev;
766};
767#endif
768/* ARGSUSED */
769int
770mknod(p, uap, retval)
771 struct proc *p;
772 register struct mknod_args *uap;
773 int *retval;
774{
775 register struct vnode *vp;
776 struct vattr vattr;
777 int error;
778 struct nameidata nd;
779
780 error = suser(p->p_ucred, &p->p_acflag);
781 if (error)
782 return (error);
783 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
784 error = namei(&nd);
785 if (error)
786 return (error);
787 vp = nd.ni_vp;
788 if (vp != NULL)
789 error = EEXIST;
790 else {
791 VATTR_NULL(&vattr);
792 vattr.va_mode = (uap->mode & ALLPERMS) &~ p->p_fd->fd_cmask;
793 vattr.va_rdev = uap->dev;
794
795 switch (uap->mode & S_IFMT) {
796 case S_IFMT: /* used by badsect to flag bad sectors */
797 vattr.va_type = VBAD;
798 break;
799 case S_IFCHR:
800 vattr.va_type = VCHR;
801 break;
802 case S_IFBLK:
803 vattr.va_type = VBLK;
804 break;
805 default:
806 error = EINVAL;
807 break;
808 }
809 }
810 if (!error) {
811 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
812 error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
813 } else {
814 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
815 if (nd.ni_dvp == vp)
816 vrele(nd.ni_dvp);
817 else
818 vput(nd.ni_dvp);
819 if (vp)
820 vrele(vp);
821 }
822 return (error);
823}
824
825/*
826 * Create named pipe.
827 */
828#ifndef _SYS_SYSPROTO_H_
829struct mkfifo_args {
830 char *path;
831 int mode;
832};
833#endif
834/* ARGSUSED */
835int
836mkfifo(p, uap, retval)
837 struct proc *p;
838 register struct mkfifo_args *uap;
839 int *retval;
840{
841 struct vattr vattr;
842 int error;
843 struct nameidata nd;
844
845 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
846 error = namei(&nd);
847 if (error)
848 return (error);
849 if (nd.ni_vp != NULL) {
850 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
851 if (nd.ni_dvp == nd.ni_vp)
852 vrele(nd.ni_dvp);
853 else
854 vput(nd.ni_dvp);
855 vrele(nd.ni_vp);
856 return (EEXIST);
857 }
858 VATTR_NULL(&vattr);
859 vattr.va_type = VFIFO;
860 vattr.va_mode = (uap->mode & ALLPERMS) &~ p->p_fd->fd_cmask;
861 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
862 return (VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr));
863}
864
865/*
866 * Make a hard file link.
867 */
868#ifndef _SYS_SYSPROTO_H_
869struct link_args {
870 char *path;
871 char *link;
872};
873#endif
874/* ARGSUSED */
875int
876link(p, uap, retval)
877 struct proc *p;
878 register struct link_args *uap;
879 int *retval;
880{
881 register struct vnode *vp;
882 struct nameidata nd;
883 int error;
884
885 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
886 error = namei(&nd);
887 if (error)
888 return (error);
889 vp = nd.ni_vp;
890 if (vp->v_type == VDIR)
891 error = EPERM; /* POSIX */
892 else {
893 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->link, p);
894 error = namei(&nd);
895 if (!error) {
896 if (nd.ni_vp != NULL) {
897 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
898 if (nd.ni_dvp == nd.ni_vp)
899 vrele(nd.ni_dvp);
900 else
901 vput(nd.ni_dvp);
902 if (nd.ni_vp)
903 vrele(nd.ni_vp);
904 error = EEXIST;
905 } else {
906 LEASE_CHECK(nd.ni_dvp,
907 p, p->p_ucred, LEASE_WRITE);
908 LEASE_CHECK(vp,
909 p, p->p_ucred, LEASE_WRITE);
910 error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);
911 }
912 }
913 }
914 vrele(vp);
915 return (error);
916}
917
918/*
919 * Make a symbolic link.
920 */
921#ifndef _SYS_SYSPROTO_H_
922struct symlink_args {
923 char *path;
924 char *link;
925};
926#endif
927/* ARGSUSED */
928int
929symlink(p, uap, retval)
930 struct proc *p;
931 register struct symlink_args *uap;
932 int *retval;
933{
934 struct vattr vattr;
935 char *path;
936 int error;
937 struct nameidata nd;
938
939 MALLOC(path, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
940 error = copyinstr(uap->path, path, MAXPATHLEN, NULL);
941 if (error)
942 goto out;
943 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->link, p);
944 error = namei(&nd);
945 if (error)
946 goto out;
947 if (nd.ni_vp) {
948 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
949 if (nd.ni_dvp == nd.ni_vp)
950 vrele(nd.ni_dvp);
951 else
952 vput(nd.ni_dvp);
953 vrele(nd.ni_vp);
954 error = EEXIST;
955 goto out;
956 }
957 VATTR_NULL(&vattr);
958 vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask;
959 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
960 error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path);
961out:
962 FREE(path, M_NAMEI);
963 return (error);
964}
965
966/*
967 * Delete a name from the filesystem.
968 */
969#ifndef _SYS_SYSPROTO_H_
970struct unlink_args {
971 char *path;
972};
973#endif
974/* ARGSUSED */
975int
976unlink(p, uap, retval)
977 struct proc *p;
978 struct unlink_args *uap;
979 int *retval;
980{
981 register struct vnode *vp;
982 int error;
983 struct nameidata nd;
984
985 NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
986 error = namei(&nd);
987 if (error)
988 return (error);
989 vp = nd.ni_vp;
990 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
991 VOP_LOCK(vp);
992
993 if (vp->v_type == VDIR)
994 error = EPERM; /* POSIX */
995 else {
996 /*
997 * The root of a mounted filesystem cannot be deleted.
998 *
999 * XXX: can this only be a VDIR case?
1000 */
1001 if (vp->v_flag & VROOT)
1002 error = EBUSY;
1003 else
1004 (void) vnode_pager_uncache(vp);
1005 }
1006
1007 if (!error) {
1008 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
1009 error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
1010 } else {
1011 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1012 if (nd.ni_dvp == vp)
1013 vrele(nd.ni_dvp);
1014 else
1015 vput(nd.ni_dvp);
1016 vput(vp);
1017 }
1018 return (error);
1019}
1020
1021/*
1022 * Reposition read/write file offset.
1023 */
1024#ifndef _SYS_SYSPROTO_H_
1025struct lseek_args {
1026 int fd;
1027 int pad;
1028 off_t offset;
1029 int whence;
1030};
1031#endif
1032int
1033lseek(p, uap, retval)
1034 struct proc *p;
1035 register struct lseek_args *uap;
1036 int *retval;
1037{
1038 struct ucred *cred = p->p_ucred;
1039 register struct filedesc *fdp = p->p_fd;
1040 register struct file *fp;
1041 struct vattr vattr;
1042 int error;
1043
1044 if ((u_int)uap->fd >= fdp->fd_nfiles ||
1045 (fp = fdp->fd_ofiles[uap->fd]) == NULL)
1046 return (EBADF);
1047 if (fp->f_type != DTYPE_VNODE)
1048 return (ESPIPE);
1049 switch (uap->whence) {
1050 case L_INCR:
1051 fp->f_offset += uap->offset;
1052 break;
1053 case L_XTND:
1054 error=VOP_GETATTR((struct vnode *)fp->f_data, &vattr, cred, p);
1055 if (error)
1056 return (error);
1057 fp->f_offset = uap->offset + vattr.va_size;
1058 break;
1059 case L_SET:
1060 fp->f_offset = uap->offset;
1061 break;
1062 default:
1063 return (EINVAL);
1064 }
1065 *(off_t *)retval = fp->f_offset;
1066 return (0);
1067}
1068
1069#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1070/*
1071 * Reposition read/write file offset.
1072 */
1073#ifndef _SYS_SYSPROTO_H_
1074struct olseek_args {
1075 int fd;
1076 long offset;
1077 int whence;
1078};
1079#endif
1080int
1081olseek(p, uap, retval)
1082 struct proc *p;
1083 register struct olseek_args *uap;
1084 int *retval;
1085{
1086 struct lseek_args nuap;
1087 off_t qret;
1088 int error;
1089
1090 nuap.fd = uap->fd;
1091 nuap.offset = uap->offset;
1092 nuap.whence = uap->whence;
1093 error = lseek(p, &nuap, (int *)&qret);
1094 *(long *)retval = qret;
1095 return (error);
1096}
1097#endif /* COMPAT_43 */
1098
1099/*
1100 * Check access permissions.
1101 */
1102#ifndef _SYS_SYSPROTO_H_
1103struct access_args {
1104 char *path;
1105 int flags;
1106};
1107#endif
1108int
1109access(p, uap, retval)
1110 struct proc *p;
1111 register struct access_args *uap;
1112 int *retval;
1113{
1114 register struct ucred *cred = p->p_ucred;
1115 register struct vnode *vp;
1116 int error, flags, t_gid, t_uid;
1117 struct nameidata nd;
1118
1119 t_uid = cred->cr_uid;
1120 t_gid = cred->cr_groups[0];
1121 cred->cr_uid = p->p_cred->p_ruid;
1122 cred->cr_groups[0] = p->p_cred->p_rgid;
1123 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1124 error = namei(&nd);
1125 if (error)
1126 goto out1;
1127 vp = nd.ni_vp;
1128
1129 /* Flags == 0 means only check for existence. */
1130 if (uap->flags) {
1131 flags = 0;
1132 if (uap->flags & R_OK)
1133 flags |= VREAD;
1134 if (uap->flags & W_OK)
1135 flags |= VWRITE;
1136 if (uap->flags & X_OK)
1137 flags |= VEXEC;
1138 if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
1139 error = VOP_ACCESS(vp, flags, cred, p);
1140 }
1141 vput(vp);
1142out1:
1143 cred->cr_uid = t_uid;
1144 cred->cr_groups[0] = t_gid;
1145 return (error);
1146}
1147
1148#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1149/*
1150 * Get file status; this version follows links.
1151 */
1152#ifndef _SYS_SYSPROTO_H_
1153struct ostat_args {
1154 char *path;
1155 struct ostat *ub;
1156};
1157#endif
1158/* ARGSUSED */
1159int
1160ostat(p, uap, retval)
1161 struct proc *p;
1162 register struct ostat_args *uap;
1163 int *retval;
1164{
1165 struct stat sb;
1166 struct ostat osb;
1167 int error;
1168 struct nameidata nd;
1169
1170 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1171 error = namei(&nd);
1172 if (error)
1173 return (error);
1174 error = vn_stat(nd.ni_vp, &sb, p);
1175 vput(nd.ni_vp);
1176 if (error)
1177 return (error);
1178 cvtstat(&sb, &osb);
1179 error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
1180 return (error);
1181}
1182
1183/*
1184 * Get file status; this version does not follow links.
1185 */
1186#ifndef _SYS_SYSPROTO_H_
1187struct olstat_args {
1188 char *path;
1189 struct ostat *ub;
1190};
1191#endif
1192/* ARGSUSED */
1193int
1194olstat(p, uap, retval)
1195 struct proc *p;
1196 register struct olstat_args *uap;
1197 int *retval;
1198{
1199 struct vnode *vp, *dvp;
1200 struct stat sb, sb1;
1201 struct ostat osb;
1202 int error;
1203 struct nameidata nd;
1204
1205 NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | LOCKPARENT, UIO_USERSPACE,
1206 uap->path, p);
1207 error = namei(&nd);
1208 if (error)
1209 return (error);
1210 /*
1211 * For symbolic links, always return the attributes of its
1212 * containing directory, except for mode, size, and links.
1213 */
1214 vp = nd.ni_vp;
1215 dvp = nd.ni_dvp;
1216 if (vp->v_type != VLNK) {
1217 if (dvp == vp)
1218 vrele(dvp);
1219 else
1220 vput(dvp);
1221 error = vn_stat(vp, &sb, p);
1222 vput(vp);
1223 if (error)
1224 return (error);
1225 } else {
1226 error = vn_stat(dvp, &sb, p);
1227 vput(dvp);
1228 if (error) {
1229 vput(vp);
1230 return (error);
1231 }
1232 error = vn_stat(vp, &sb1, p);
1233 vput(vp);
1234 if (error)
1235 return (error);
1236 sb.st_mode &= ~S_IFDIR;
1237 sb.st_mode |= S_IFLNK;
1238 sb.st_nlink = sb1.st_nlink;
1239 sb.st_size = sb1.st_size;
1240 sb.st_blocks = sb1.st_blocks;
1241 }
1242 cvtstat(&sb, &osb);
1243 error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
1244 return (error);
1245}
1246
1247/*
1248 * Convert from an old to a new stat structure.
1249 */
1250void
1251cvtstat(st, ost)
1252 struct stat *st;
1253 struct ostat *ost;
1254{
1255
1256 ost->st_dev = st->st_dev;
1257 ost->st_ino = st->st_ino;
1258 ost->st_mode = st->st_mode;
1259 ost->st_nlink = st->st_nlink;
1260 ost->st_uid = st->st_uid;
1261 ost->st_gid = st->st_gid;
1262 ost->st_rdev = st->st_rdev;
1263 if (st->st_size < (quad_t)1 << 32)
1264 ost->st_size = st->st_size;
1265 else
1266 ost->st_size = -2;
1267 ost->st_atime = st->st_atime;
1268 ost->st_mtime = st->st_mtime;
1269 ost->st_ctime = st->st_ctime;
1270 ost->st_blksize = st->st_blksize;
1271 ost->st_blocks = st->st_blocks;
1272 ost->st_flags = st->st_flags;
1273 ost->st_gen = st->st_gen;
1274}
1275#endif /* COMPAT_43 || COMPAT_SUNOS */
1276
1277/*
1278 * Get file status; this version follows links.
1279 */
1280#ifndef _SYS_SYSPROTO_H_
1281struct stat_args {
1282 char *path;
1283 struct stat *ub;
1284};
1285#endif
1286/* ARGSUSED */
1287int
1288stat(p, uap, retval)
1289 struct proc *p;
1290 register struct stat_args *uap;
1291 int *retval;
1292{
1293 struct stat sb;
1294 int error;
1295 struct nameidata nd;
1296
1297 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1298 error = namei(&nd);
1299 if (error)
1300 return (error);
1301 error = vn_stat(nd.ni_vp, &sb, p);
1302 vput(nd.ni_vp);
1303 if (error)
1304 return (error);
1305 error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
1306 return (error);
1307}
1308
1309/*
1310 * Get file status; this version does not follow links.
1311 */
1312#ifndef _SYS_SYSPROTO_H_
1313struct lstat_args {
1314 char *path;
1315 struct stat *ub;
1316};
1317#endif
1318/* ARGSUSED */
1319int
1320lstat(p, uap, retval)
1321 struct proc *p;
1322 register struct lstat_args *uap;
1323 int *retval;
1324{
1325 int error;
1326 struct vnode *vp, *dvp;
1327 struct stat sb, sb1;
1328 struct nameidata nd;
1329
1330 NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | LOCKPARENT, UIO_USERSPACE,
1331 uap->path, p);
1332 error = namei(&nd);
1333 if (error)
1334 return (error);
1335 /*
1336 * For symbolic links, always return the attributes of its
1337 * containing directory, except for mode, size, and links.
1338 */
1339 vp = nd.ni_vp;
1340 dvp = nd.ni_dvp;
1341 if (vp->v_type != VLNK) {
1342 if (dvp == vp)
1343 vrele(dvp);
1344 else
1345 vput(dvp);
1346 error = vn_stat(vp, &sb, p);
1347 vput(vp);
1348 if (error)
1349 return (error);
1350 } else {
1351 error = vn_stat(dvp, &sb, p);
1352 vput(dvp);
1353 if (error) {
1354 vput(vp);
1355 return (error);
1356 }
1357 error = vn_stat(vp, &sb1, p);
1358 vput(vp);
1359 if (error)
1360 return (error);
1361 sb.st_mode &= ~S_IFDIR;
1362 sb.st_mode |= S_IFLNK;
1363 sb.st_nlink = sb1.st_nlink;
1364 sb.st_size = sb1.st_size;
1365 sb.st_blocks = sb1.st_blocks;
1366 }
1367 error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
1368 return (error);
1369}
1370
1371/*
1372 * Get configurable pathname variables.
1373 */
1374#ifndef _SYS_SYSPROTO_H_
1375struct pathconf_args {
1376 char *path;
1377 int name;
1378};
1379#endif
1380/* ARGSUSED */
1381int
1382pathconf(p, uap, retval)
1383 struct proc *p;
1384 register struct pathconf_args *uap;
1385 int *retval;
1386{
1387 int error;
1388 struct nameidata nd;
1389
1390 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1391 error = namei(&nd);
1392 if (error)
1393 return (error);
1394 error = VOP_PATHCONF(nd.ni_vp, uap->name, retval);
1395 vput(nd.ni_vp);
1396 return (error);
1397}
1398
1399/*
1400 * Return target name of a symbolic link.
1401 */
1402#ifndef _SYS_SYSPROTO_H_
1403struct readlink_args {
1404 char *path;
1405 char *buf;
1406 int count;
1407};
1408#endif
1409/* ARGSUSED */
1410int
1411readlink(p, uap, retval)
1412 struct proc *p;
1413 register struct readlink_args *uap;
1414 int *retval;
1415{
1416 register struct vnode *vp;
1417 struct iovec aiov;
1418 struct uio auio;
1419 int error;
1420 struct nameidata nd;
1421
1422 NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p);
1423 error = namei(&nd);
1424 if (error)
1425 return (error);
1426 vp = nd.ni_vp;
1427 if (vp->v_type != VLNK)
1428 error = EINVAL;
1429 else {
1430 aiov.iov_base = uap->buf;
1431 aiov.iov_len = uap->count;
1432 auio.uio_iov = &aiov;
1433 auio.uio_iovcnt = 1;
1434 auio.uio_offset = 0;
1435 auio.uio_rw = UIO_READ;
1436 auio.uio_segflg = UIO_USERSPACE;
1437 auio.uio_procp = p;
1438 auio.uio_resid = uap->count;
1439 error = VOP_READLINK(vp, &auio, p->p_ucred);
1440 }
1441 vput(vp);
1442 *retval = uap->count - auio.uio_resid;
1443 return (error);
1444}
1445
1446/*
1447 * Change flags of a file given a path name.
1448 */
1449#ifndef _SYS_SYSPROTO_H_
1450struct chflags_args {
1451 char *path;
1452 int flags;
1453};
1454#endif
1455/* ARGSUSED */
1456int
1457chflags(p, uap, retval)
1458 struct proc *p;
1459 register struct chflags_args *uap;
1460 int *retval;
1461{
1462 register struct vnode *vp;
1463 struct vattr vattr;
1464 int error;
1465 struct nameidata nd;
1466
1467 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1468 error = namei(&nd);
1469 if (error)
1470 return (error);
1471 vp = nd.ni_vp;
1472 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1473 VOP_LOCK(vp);
1474 VATTR_NULL(&vattr);
1475 vattr.va_flags = uap->flags;
1476 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1477 vput(vp);
1478 return (error);
1479}
1480
1481/*
1482 * Change flags of a file given a file descriptor.
1483 */
1484#ifndef _SYS_SYSPROTO_H_
1485struct fchflags_args {
1486 int fd;
1487 int flags;
1488};
1489#endif
1490/* ARGSUSED */
1491int
1492fchflags(p, uap, retval)
1493 struct proc *p;
1494 register struct fchflags_args *uap;
1495 int *retval;
1496{
1497 struct vattr vattr;
1498 struct vnode *vp;
1499 struct file *fp;
1500 int error;
1501
1502 error = getvnode(p->p_fd, uap->fd, &fp);
1503 if (error)
1504 return (error);
1505 vp = (struct vnode *)fp->f_data;
1506 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1507 VOP_LOCK(vp);
1508 VATTR_NULL(&vattr);
1509 vattr.va_flags = uap->flags;
1510 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1511 VOP_UNLOCK(vp);
1512 return (error);
1513}
1514
1515/*
1516 * Change mode of a file given path name.
1517 */
1518#ifndef _SYS_SYSPROTO_H_
1519struct chmod_args {
1520 char *path;
1521 int mode;
1522};
1523#endif
1524/* ARGSUSED */
1525int
1526chmod(p, uap, retval)
1527 struct proc *p;
1528 register struct chmod_args *uap;
1529 int *retval;
1530{
1531 register struct vnode *vp;
1532 struct vattr vattr;
1533 int error;
1534 struct nameidata nd;
1535
1536 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1537 error = namei(&nd);
1538 if (error)
1539 return (error);
1540 vp = nd.ni_vp;
1541 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1542 VOP_LOCK(vp);
1543 VATTR_NULL(&vattr);
1544 vattr.va_mode = uap->mode & ALLPERMS;
1545 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1546 vput(vp);
1547 return (error);
1548}
1549
1550/*
1551 * Change mode of a file given a file descriptor.
1552 */
1553#ifndef _SYS_SYSPROTO_H_
1554struct fchmod_args {
1555 int fd;
1556 int mode;
1557};
1558#endif
1559/* ARGSUSED */
1560int
1561fchmod(p, uap, retval)
1562 struct proc *p;
1563 register struct fchmod_args *uap;
1564 int *retval;
1565{
1566 struct vattr vattr;
1567 struct vnode *vp;
1568 struct file *fp;
1569 int error;
1570
1571 error = getvnode(p->p_fd, uap->fd, &fp);
1572 if (error)
1573 return (error);
1574 vp = (struct vnode *)fp->f_data;
1575 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1576 VOP_LOCK(vp);
1577 VATTR_NULL(&vattr);
1578 vattr.va_mode = uap->mode & ALLPERMS;
1579 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1580 VOP_UNLOCK(vp);
1581 return (error);
1582}
1583
1584/*
1585 * Set ownership given a path name.
1586 */
1587#ifndef _SYS_SYSPROTO_H_
1588struct chown_args {
1589 char *path;
1590 int uid;
1591 int gid;
1592};
1593#endif
1594/* ARGSUSED */
1595int
1596chown(p, uap, retval)
1597 struct proc *p;
1598 register struct chown_args *uap;
1599 int *retval;
1600{
1601 register struct vnode *vp;
1602 struct vattr vattr;
1603 int error;
1604 struct nameidata nd;
1605
1606 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1607 error = namei(&nd);
1608 if (error)
1609 return (error);
1610 vp = nd.ni_vp;
1611 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1612 VOP_LOCK(vp);
1613 VATTR_NULL(&vattr);
1614 vattr.va_uid = uap->uid;
1615 vattr.va_gid = uap->gid;
1616 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1617 vput(vp);
1618 return (error);
1619}
1620
1621/*
1622 * Set ownership given a file descriptor.
1623 */
1624#ifndef _SYS_SYSPROTO_H_
1625struct fchown_args {
1626 int fd;
1627 int uid;
1628 int gid;
1629};
1630#endif
1631/* ARGSUSED */
1632int
1633fchown(p, uap, retval)
1634 struct proc *p;
1635 register struct fchown_args *uap;
1636 int *retval;
1637{
1638 struct vattr vattr;
1639 struct vnode *vp;
1640 struct file *fp;
1641 int error;
1642
1643 error = getvnode(p->p_fd, uap->fd, &fp);
1644 if (error)
1645 return (error);
1646 vp = (struct vnode *)fp->f_data;
1647 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1648 VOP_LOCK(vp);
1649 VATTR_NULL(&vattr);
1650 vattr.va_uid = uap->uid;
1651 vattr.va_gid = uap->gid;
1652 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1653 VOP_UNLOCK(vp);
1654 return (error);
1655}
1656
1657/*
1658 * Set the access and modification times of a file.
1659 */
1660#ifndef _SYS_SYSPROTO_H_
1661struct utimes_args {
1662 char *path;
1663 struct timeval *tptr;
1664};
1665#endif
1666/* ARGSUSED */
1667int
1668utimes(p, uap, retval)
1669 struct proc *p;
1670 register struct utimes_args *uap;
1671 int *retval;
1672{
1673 register struct vnode *vp;
1674 struct timeval tv[2];
1675 struct vattr vattr;
1676 int error;
1677 struct nameidata nd;
1678
1679 VATTR_NULL(&vattr);
1680 if (uap->tptr == NULL) {
1681 microtime(&tv[0]);
1682 tv[1] = tv[0];
1683 vattr.va_vaflags |= VA_UTIMES_NULL;
1684 } else {
1685 error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv));
1686 if (error)
1687 return (error);
1688 }
1689 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1690 error = namei(&nd);
1691 if (error)
1692 return (error);
1693 vp = nd.ni_vp;
1694 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1695 VOP_LOCK(vp);
|
1700 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1701 vput(vp);
1702 return (error);
1703}
1704
1705/*
1706 * Truncate a file given its path name.
1707 */
1708#ifndef _SYS_SYSPROTO_H_
1709struct truncate_args {
1710 char *path;
1711 int pad;
1712 off_t length;
1713};
1714#endif
1715/* ARGSUSED */
1716int
1717truncate(p, uap, retval)
1718 struct proc *p;
1719 register struct truncate_args *uap;
1720 int *retval;
1721{
1722 register struct vnode *vp;
1723 struct vattr vattr;
1724 int error;
1725 struct nameidata nd;
1726
1727 if (uap->length < 0)
1728 return(EINVAL);
1729 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1730 error = namei(&nd);
1731 if (error)
1732 return (error);
1733 vp = nd.ni_vp;
1734 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1735 VOP_LOCK(vp);
1736 if (vp->v_type == VDIR)
1737 error = EISDIR;
1738 else if ((error = vn_writechk(vp)) == 0 &&
1739 (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) == 0) {
1740 VATTR_NULL(&vattr);
1741 vattr.va_size = uap->length;
1742 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1743 }
1744 vput(vp);
1745 return (error);
1746}
1747
1748/*
1749 * Truncate a file given a file descriptor.
1750 */
1751#ifndef _SYS_SYSPROTO_H_
1752struct ftruncate_args {
1753 int fd;
1754 int pad;
1755 off_t length;
1756};
1757#endif
1758/* ARGSUSED */
1759int
1760ftruncate(p, uap, retval)
1761 struct proc *p;
1762 register struct ftruncate_args *uap;
1763 int *retval;
1764{
1765 struct vattr vattr;
1766 struct vnode *vp;
1767 struct file *fp;
1768 int error;
1769
1770 if (uap->length < 0)
1771 return(EINVAL);
1772 error = getvnode(p->p_fd, uap->fd, &fp);
1773 if (error)
1774 return (error);
1775 if ((fp->f_flag & FWRITE) == 0)
1776 return (EINVAL);
1777 vp = (struct vnode *)fp->f_data;
1778 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1779 VOP_LOCK(vp);
1780 if (vp->v_type == VDIR)
1781 error = EISDIR;
1782 else if ((error = vn_writechk(vp)) == 0) {
1783 VATTR_NULL(&vattr);
1784 vattr.va_size = uap->length;
1785 error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
1786 }
1787 VOP_UNLOCK(vp);
1788 return (error);
1789}
1790
1791#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1792/*
1793 * Truncate a file given its path name.
1794 */
1795#ifndef _SYS_SYSPROTO_H_
1796struct otruncate_args {
1797 char *path;
1798 long length;
1799};
1800#endif
1801/* ARGSUSED */
1802int
1803otruncate(p, uap, retval)
1804 struct proc *p;
1805 register struct otruncate_args *uap;
1806 int *retval;
1807{
1808 struct truncate_args nuap;
1809
1810 nuap.path = uap->path;
1811 nuap.length = uap->length;
1812 return (truncate(p, &nuap, retval));
1813}
1814
1815/*
1816 * Truncate a file given a file descriptor.
1817 */
1818#ifndef _SYS_SYSPROTO_H_
1819struct oftruncate_args {
1820 int fd;
1821 long length;
1822};
1823#endif
1824/* ARGSUSED */
1825int
1826oftruncate(p, uap, retval)
1827 struct proc *p;
1828 register struct oftruncate_args *uap;
1829 int *retval;
1830{
1831 struct ftruncate_args nuap;
1832
1833 nuap.fd = uap->fd;
1834 nuap.length = uap->length;
1835 return (ftruncate(p, &nuap, retval));
1836}
1837#endif /* COMPAT_43 || COMPAT_SUNOS */
1838
1839/*
1840 * Sync an open file.
1841 */
1842#ifndef _SYS_SYSPROTO_H_
1843struct fsync_args {
1844 int fd;
1845};
1846#endif
1847/* ARGSUSED */
1848int
1849fsync(p, uap, retval)
1850 struct proc *p;
1851 struct fsync_args *uap;
1852 int *retval;
1853{
1854 register struct vnode *vp;
1855 struct file *fp;
1856 int error;
1857
1858 error = getvnode(p->p_fd, uap->fd, &fp);
1859 if (error)
1860 return (error);
1861 vp = (struct vnode *)fp->f_data;
1862 VOP_LOCK(vp);
1863 if (vp->v_object) {
1864 vm_object_page_clean(vp->v_object, 0, 0 ,0, FALSE);
1865 }
1866 error = VOP_FSYNC(vp, fp->f_cred,
1867 (vp->v_mount->mnt_flag & MNT_ASYNC) ? MNT_NOWAIT : MNT_WAIT, p);
1868 VOP_UNLOCK(vp);
1869 return (error);
1870}
1871
1872/*
1873 * Rename files. Source and destination must either both be directories,
1874 * or both not be directories. If target is a directory, it must be empty.
1875 */
1876#ifndef _SYS_SYSPROTO_H_
1877struct rename_args {
1878 char *from;
1879 char *to;
1880};
1881#endif
1882/* ARGSUSED */
1883int
1884rename(p, uap, retval)
1885 struct proc *p;
1886 register struct rename_args *uap;
1887 int *retval;
1888{
1889 register struct vnode *tvp, *fvp, *tdvp;
1890 struct nameidata fromnd, tond;
1891 int error;
1892
1893 NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE,
1894 uap->from, p);
1895 error = namei(&fromnd);
1896 if (error)
1897 return (error);
1898 fvp = fromnd.ni_vp;
1899 NDINIT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART,
1900 UIO_USERSPACE, uap->to, p);
1901 if (fromnd.ni_vp->v_type == VDIR)
1902 tond.ni_cnd.cn_flags |= WILLBEDIR;
1903 error = namei(&tond);
1904 if (error) {
1905 /* Translate error code for rename("dir1", "dir2/."). */
1906 if (error == EISDIR && fvp->v_type == VDIR)
1907 error = EINVAL;
1908
1909 VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
1910 vrele(fromnd.ni_dvp);
1911 vrele(fvp);
1912 goto out1;
1913 }
1914 tdvp = tond.ni_dvp;
1915 tvp = tond.ni_vp;
1916 if (tvp != NULL) {
1917 if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
1918 error = ENOTDIR;
1919 goto out;
1920 } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
1921 error = EISDIR;
1922 goto out;
1923 }
1924 }
1925 if (fvp == tdvp)
1926 error = EINVAL;
1927 /*
1928 * If source is the same as the destination (that is the
1929 * same inode number with the same name in the same directory),
1930 * then there is nothing to do.
1931 */
1932 if (fvp == tvp && fromnd.ni_dvp == tdvp &&
1933 fromnd.ni_cnd.cn_namelen == tond.ni_cnd.cn_namelen &&
1934 !bcmp(fromnd.ni_cnd.cn_nameptr, tond.ni_cnd.cn_nameptr,
1935 fromnd.ni_cnd.cn_namelen))
1936 error = -1;
1937out:
1938 if (!error) {
1939 LEASE_CHECK(tdvp, p, p->p_ucred, LEASE_WRITE);
1940 if (fromnd.ni_dvp != tdvp) {
1941 LEASE_CHECK(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
1942 }
1943 if (tvp) {
1944 LEASE_CHECK(tvp, p, p->p_ucred, LEASE_WRITE);
1945 (void) vnode_pager_uncache(tvp);
1946 }
1947 error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
1948 tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
1949 } else {
1950 VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
1951 if (tdvp == tvp)
1952 vrele(tdvp);
1953 else
1954 vput(tdvp);
1955 if (tvp)
1956 vput(tvp);
1957 VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
1958 vrele(fromnd.ni_dvp);
1959 vrele(fvp);
1960 }
1961 vrele(tond.ni_startdir);
1962 FREE(tond.ni_cnd.cn_pnbuf, M_NAMEI);
1963out1:
1964 if (fromnd.ni_startdir)
1965 vrele(fromnd.ni_startdir);
1966 FREE(fromnd.ni_cnd.cn_pnbuf, M_NAMEI);
1967 if (error == -1)
1968 return (0);
1969 return (error);
1970}
1971
1972/*
1973 * Make a directory file.
1974 */
1975#ifndef _SYS_SYSPROTO_H_
1976struct mkdir_args {
1977 char *path;
1978 int mode;
1979};
1980#endif
1981/* ARGSUSED */
1982int
1983mkdir(p, uap, retval)
1984 struct proc *p;
1985 register struct mkdir_args *uap;
1986 int *retval;
1987{
1988 register struct vnode *vp;
1989 struct vattr vattr;
1990 int error;
1991 struct nameidata nd;
1992
1993 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
1994 nd.ni_cnd.cn_flags |= WILLBEDIR;
1995 error = namei(&nd);
1996 if (error)
1997 return (error);
1998 vp = nd.ni_vp;
1999 if (vp != NULL) {
2000 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2001 if (nd.ni_dvp == vp)
2002 vrele(nd.ni_dvp);
2003 else
2004 vput(nd.ni_dvp);
2005 vrele(vp);
2006 return (EEXIST);
2007 }
2008 VATTR_NULL(&vattr);
2009 vattr.va_type = VDIR;
2010 vattr.va_mode = (uap->mode & ACCESSPERMS) &~ p->p_fd->fd_cmask;
2011 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
2012 error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
2013 if (!error)
2014 vput(nd.ni_vp);
2015 return (error);
2016}
2017
2018/*
2019 * Remove a directory file.
2020 */
2021#ifndef _SYS_SYSPROTO_H_
2022struct rmdir_args {
2023 char *path;
2024};
2025#endif
2026/* ARGSUSED */
2027int
2028rmdir(p, uap, retval)
2029 struct proc *p;
2030 struct rmdir_args *uap;
2031 int *retval;
2032{
2033 register struct vnode *vp;
2034 int error;
2035 struct nameidata nd;
2036
2037 NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, uap->path, p);
2038 error = namei(&nd);
2039 if (error)
2040 return (error);
2041 vp = nd.ni_vp;
2042 if (vp->v_type != VDIR) {
2043 error = ENOTDIR;
2044 goto out;
2045 }
2046 /*
2047 * No rmdir "." please.
2048 */
2049 if (nd.ni_dvp == vp) {
2050 error = EINVAL;
2051 goto out;
2052 }
2053 /*
2054 * The root of a mounted filesystem cannot be deleted.
2055 */
2056 if (vp->v_flag & VROOT)
2057 error = EBUSY;
2058out:
2059 if (!error) {
2060 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
2061 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
2062 error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
2063 } else {
2064 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2065 if (nd.ni_dvp == vp)
2066 vrele(nd.ni_dvp);
2067 else
2068 vput(nd.ni_dvp);
2069 vput(vp);
2070 }
2071 return (error);
2072}
2073
2074#ifdef COMPAT_43
2075/*
2076 * Read a block of directory entries in a file system independent format.
2077 */
2078#ifndef _SYS_SYSPROTO_H_
2079struct ogetdirentries_args {
2080 int fd;
2081 char *buf;
2082 u_int count;
2083 long *basep;
2084};
2085#endif
2086int
2087ogetdirentries(p, uap, retval)
2088 struct proc *p;
2089 register struct ogetdirentries_args *uap;
2090 int *retval;
2091{
2092 register struct vnode *vp;
2093 struct file *fp;
2094 struct uio auio, kuio;
2095 struct iovec aiov, kiov;
2096 struct dirent *dp, *edp;
2097 caddr_t dirbuf;
2098 int error, readcnt;
2099 long loff;
2100
2101 error = getvnode(p->p_fd, uap->fd, &fp);
2102 if (error)
2103 return (error);
2104 if ((fp->f_flag & FREAD) == 0)
2105 return (EBADF);
2106 vp = (struct vnode *)fp->f_data;
2107 if (vp->v_type != VDIR)
2108 return (EINVAL);
2109 aiov.iov_base = uap->buf;
2110 aiov.iov_len = uap->count;
2111 auio.uio_iov = &aiov;
2112 auio.uio_iovcnt = 1;
2113 auio.uio_rw = UIO_READ;
2114 auio.uio_segflg = UIO_USERSPACE;
2115 auio.uio_procp = p;
2116 auio.uio_resid = uap->count;
2117 VOP_LOCK(vp);
2118 loff = auio.uio_offset = fp->f_offset;
2119# if (BYTE_ORDER != LITTLE_ENDIAN)
2120 if (vp->v_mount->mnt_maxsymlinklen <= 0) {
2121 error = VOP_READDIR(vp, &auio, fp->f_cred, NULL, NULL, NULL);
2122 fp->f_offset = auio.uio_offset;
2123 } else
2124# endif
2125 {
2126 kuio = auio;
2127 kuio.uio_iov = &kiov;
2128 kuio.uio_segflg = UIO_SYSSPACE;
2129 kiov.iov_len = uap->count;
2130 MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK);
2131 kiov.iov_base = dirbuf;
2132 error = VOP_READDIR(vp, &kuio, fp->f_cred, NULL, NULL, NULL);
2133 fp->f_offset = kuio.uio_offset;
2134 if (error == 0) {
2135 readcnt = uap->count - kuio.uio_resid;
2136 edp = (struct dirent *)&dirbuf[readcnt];
2137 for (dp = (struct dirent *)dirbuf; dp < edp; ) {
2138# if (BYTE_ORDER == LITTLE_ENDIAN)
2139 /*
2140 * The expected low byte of
2141 * dp->d_namlen is our dp->d_type.
2142 * The high MBZ byte of dp->d_namlen
2143 * is our dp->d_namlen.
2144 */
2145 dp->d_type = dp->d_namlen;
2146 dp->d_namlen = 0;
2147# else
2148 /*
2149 * The dp->d_type is the high byte
2150 * of the expected dp->d_namlen,
2151 * so must be zero'ed.
2152 */
2153 dp->d_type = 0;
2154# endif
2155 if (dp->d_reclen > 0) {
2156 dp = (struct dirent *)
2157 ((char *)dp + dp->d_reclen);
2158 } else {
2159 error = EIO;
2160 break;
2161 }
2162 }
2163 if (dp >= edp)
2164 error = uiomove(dirbuf, readcnt, &auio);
2165 }
2166 FREE(dirbuf, M_TEMP);
2167 }
2168 VOP_UNLOCK(vp);
2169 if (error)
2170 return (error);
2171 error = copyout((caddr_t)&loff, (caddr_t)uap->basep, sizeof(long));
2172 *retval = uap->count - auio.uio_resid;
2173 return (error);
2174}
2175#endif
2176
2177/*
2178 * Read a block of directory entries in a file system independent format.
2179 */
2180#ifndef _SYS_SYSPROTO_H_
2181struct getdirentries_args {
2182 int fd;
2183 char *buf;
2184 u_int count;
2185 long *basep;
2186};
2187#endif
2188int
2189getdirentries(p, uap, retval)
2190 struct proc *p;
2191 register struct getdirentries_args *uap;
2192 int *retval;
2193{
2194 register struct vnode *vp;
2195 struct file *fp;
2196 struct uio auio;
2197 struct iovec aiov;
2198 long loff;
2199 int error;
2200
2201 error = getvnode(p->p_fd, uap->fd, &fp);
2202 if (error)
2203 return (error);
2204 if ((fp->f_flag & FREAD) == 0)
2205 return (EBADF);
2206 vp = (struct vnode *)fp->f_data;
2207unionread:
2208 if (vp->v_type != VDIR)
2209 return (EINVAL);
2210 aiov.iov_base = uap->buf;
2211 aiov.iov_len = uap->count;
2212 auio.uio_iov = &aiov;
2213 auio.uio_iovcnt = 1;
2214 auio.uio_rw = UIO_READ;
2215 auio.uio_segflg = UIO_USERSPACE;
2216 auio.uio_procp = p;
2217 auio.uio_resid = uap->count;
2218 VOP_LOCK(vp);
2219 loff = auio.uio_offset = fp->f_offset;
2220 error = VOP_READDIR(vp, &auio, fp->f_cred, NULL, NULL, NULL);
2221 fp->f_offset = auio.uio_offset;
2222 VOP_UNLOCK(vp);
2223 if (error)
2224 return (error);
2225
2226#ifdef UNION
2227{
2228 if ((uap->count == auio.uio_resid) &&
2229 (vp->v_op == union_vnodeop_p)) {
2230 struct vnode *tvp = vp;
2231
2232 vp = union_lowervp(vp);
2233 if (vp != NULLVP) {
2234 VOP_LOCK(vp);
2235 error = VOP_OPEN(vp, FREAD, fp->f_cred, p);
2236 VOP_UNLOCK(vp);
2237
2238 if (error) {
2239 vrele(vp);
2240 return (error);
2241 }
2242 fp->f_data = (caddr_t) vp;
2243 fp->f_offset = 0;
2244 error = vn_close(tvp, FREAD, fp->f_cred, p);
2245 if (error)
2246 return (error);
2247 goto unionread;
2248 }
2249 }
2250}
2251#endif
2252
2253 if ((uap->count == auio.uio_resid) &&
2254 vp &&
2255 (vp->v_flag & VROOT) &&
2256 (vp->v_mount->mnt_flag & MNT_UNION)) {
2257 struct vnode *tvp = vp;
2258 vp = vp->v_mount->mnt_vnodecovered;
2259 VREF(vp);
2260 fp->f_data = (caddr_t) vp;
2261 fp->f_offset = 0;
2262 vrele(tvp);
2263 goto unionread;
2264 }
2265 error = copyout((caddr_t)&loff, (caddr_t)uap->basep, sizeof(long));
2266 *retval = uap->count - auio.uio_resid;
2267 return (error);
2268}
2269
2270/*
2271 * Set the mode mask for creation of filesystem nodes.
2272 */
2273#ifndef _SYS_SYSPROTO_H_
2274struct umask_args {
2275 int newmask;
2276};
2277#endif
2278mode_t /* XXX */
2279umask(p, uap, retval)
2280 struct proc *p;
2281 struct umask_args *uap;
2282 int *retval;
2283{
2284 register struct filedesc *fdp;
2285
2286 fdp = p->p_fd;
2287 *retval = fdp->fd_cmask;
2288 fdp->fd_cmask = uap->newmask & ALLPERMS;
2289 return (0);
2290}
2291
2292/*
2293 * Void all references to file by ripping underlying filesystem
2294 * away from vnode.
2295 */
2296#ifndef _SYS_SYSPROTO_H_
2297struct revoke_args {
2298 char *path;
2299};
2300#endif
2301/* ARGSUSED */
2302int
2303revoke(p, uap, retval)
2304 struct proc *p;
2305 register struct revoke_args *uap;
2306 int *retval;
2307{
2308 register struct vnode *vp;
2309 struct vattr vattr;
2310 int error;
2311 struct nameidata nd;
2312
2313 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
2314 error = namei(&nd);
2315 if (error)
2316 return (error);
2317 vp = nd.ni_vp;
2318 if (vp->v_type != VCHR && vp->v_type != VBLK) {
2319 error = EINVAL;
2320 goto out;
2321 }
2322 error = VOP_GETATTR(vp, &vattr, p->p_ucred, p);
2323 if (error)
2324 goto out;
2325 if (p->p_ucred->cr_uid != vattr.va_uid &&
2326 (error = suser(p->p_ucred, &p->p_acflag)))
2327 goto out;
2328 if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
2329 vgoneall(vp);
2330out:
2331 vrele(vp);
2332 return (error);
2333}
2334
2335/*
2336 * Convert a user file descriptor to a kernel file entry.
2337 */
2338int
2339getvnode(fdp, fd, fpp)
2340 struct filedesc *fdp;
2341 int fd;
2342 struct file **fpp;
2343{
2344 struct file *fp;
2345
2346 if ((u_int)fd >= fdp->fd_nfiles ||
2347 (fp = fdp->fd_ofiles[fd]) == NULL)
2348 return (EBADF);
2349 if (fp->f_type != DTYPE_VNODE)
2350 return (EINVAL);
2351 *fpp = fp;
2352 return (0);
2353}
| 1700 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1701 vput(vp);
1702 return (error);
1703}
1704
1705/*
1706 * Truncate a file given its path name.
1707 */
1708#ifndef _SYS_SYSPROTO_H_
1709struct truncate_args {
1710 char *path;
1711 int pad;
1712 off_t length;
1713};
1714#endif
1715/* ARGSUSED */
1716int
1717truncate(p, uap, retval)
1718 struct proc *p;
1719 register struct truncate_args *uap;
1720 int *retval;
1721{
1722 register struct vnode *vp;
1723 struct vattr vattr;
1724 int error;
1725 struct nameidata nd;
1726
1727 if (uap->length < 0)
1728 return(EINVAL);
1729 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1730 error = namei(&nd);
1731 if (error)
1732 return (error);
1733 vp = nd.ni_vp;
1734 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1735 VOP_LOCK(vp);
1736 if (vp->v_type == VDIR)
1737 error = EISDIR;
1738 else if ((error = vn_writechk(vp)) == 0 &&
1739 (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) == 0) {
1740 VATTR_NULL(&vattr);
1741 vattr.va_size = uap->length;
1742 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1743 }
1744 vput(vp);
1745 return (error);
1746}
1747
1748/*
1749 * Truncate a file given a file descriptor.
1750 */
1751#ifndef _SYS_SYSPROTO_H_
1752struct ftruncate_args {
1753 int fd;
1754 int pad;
1755 off_t length;
1756};
1757#endif
1758/* ARGSUSED */
1759int
1760ftruncate(p, uap, retval)
1761 struct proc *p;
1762 register struct ftruncate_args *uap;
1763 int *retval;
1764{
1765 struct vattr vattr;
1766 struct vnode *vp;
1767 struct file *fp;
1768 int error;
1769
1770 if (uap->length < 0)
1771 return(EINVAL);
1772 error = getvnode(p->p_fd, uap->fd, &fp);
1773 if (error)
1774 return (error);
1775 if ((fp->f_flag & FWRITE) == 0)
1776 return (EINVAL);
1777 vp = (struct vnode *)fp->f_data;
1778 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
1779 VOP_LOCK(vp);
1780 if (vp->v_type == VDIR)
1781 error = EISDIR;
1782 else if ((error = vn_writechk(vp)) == 0) {
1783 VATTR_NULL(&vattr);
1784 vattr.va_size = uap->length;
1785 error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
1786 }
1787 VOP_UNLOCK(vp);
1788 return (error);
1789}
1790
1791#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1792/*
1793 * Truncate a file given its path name.
1794 */
1795#ifndef _SYS_SYSPROTO_H_
1796struct otruncate_args {
1797 char *path;
1798 long length;
1799};
1800#endif
1801/* ARGSUSED */
1802int
1803otruncate(p, uap, retval)
1804 struct proc *p;
1805 register struct otruncate_args *uap;
1806 int *retval;
1807{
1808 struct truncate_args nuap;
1809
1810 nuap.path = uap->path;
1811 nuap.length = uap->length;
1812 return (truncate(p, &nuap, retval));
1813}
1814
1815/*
1816 * Truncate a file given a file descriptor.
1817 */
1818#ifndef _SYS_SYSPROTO_H_
1819struct oftruncate_args {
1820 int fd;
1821 long length;
1822};
1823#endif
1824/* ARGSUSED */
1825int
1826oftruncate(p, uap, retval)
1827 struct proc *p;
1828 register struct oftruncate_args *uap;
1829 int *retval;
1830{
1831 struct ftruncate_args nuap;
1832
1833 nuap.fd = uap->fd;
1834 nuap.length = uap->length;
1835 return (ftruncate(p, &nuap, retval));
1836}
1837#endif /* COMPAT_43 || COMPAT_SUNOS */
1838
1839/*
1840 * Sync an open file.
1841 */
1842#ifndef _SYS_SYSPROTO_H_
1843struct fsync_args {
1844 int fd;
1845};
1846#endif
1847/* ARGSUSED */
1848int
1849fsync(p, uap, retval)
1850 struct proc *p;
1851 struct fsync_args *uap;
1852 int *retval;
1853{
1854 register struct vnode *vp;
1855 struct file *fp;
1856 int error;
1857
1858 error = getvnode(p->p_fd, uap->fd, &fp);
1859 if (error)
1860 return (error);
1861 vp = (struct vnode *)fp->f_data;
1862 VOP_LOCK(vp);
1863 if (vp->v_object) {
1864 vm_object_page_clean(vp->v_object, 0, 0 ,0, FALSE);
1865 }
1866 error = VOP_FSYNC(vp, fp->f_cred,
1867 (vp->v_mount->mnt_flag & MNT_ASYNC) ? MNT_NOWAIT : MNT_WAIT, p);
1868 VOP_UNLOCK(vp);
1869 return (error);
1870}
1871
1872/*
1873 * Rename files. Source and destination must either both be directories,
1874 * or both not be directories. If target is a directory, it must be empty.
1875 */
1876#ifndef _SYS_SYSPROTO_H_
1877struct rename_args {
1878 char *from;
1879 char *to;
1880};
1881#endif
1882/* ARGSUSED */
1883int
1884rename(p, uap, retval)
1885 struct proc *p;
1886 register struct rename_args *uap;
1887 int *retval;
1888{
1889 register struct vnode *tvp, *fvp, *tdvp;
1890 struct nameidata fromnd, tond;
1891 int error;
1892
1893 NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE,
1894 uap->from, p);
1895 error = namei(&fromnd);
1896 if (error)
1897 return (error);
1898 fvp = fromnd.ni_vp;
1899 NDINIT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART,
1900 UIO_USERSPACE, uap->to, p);
1901 if (fromnd.ni_vp->v_type == VDIR)
1902 tond.ni_cnd.cn_flags |= WILLBEDIR;
1903 error = namei(&tond);
1904 if (error) {
1905 /* Translate error code for rename("dir1", "dir2/."). */
1906 if (error == EISDIR && fvp->v_type == VDIR)
1907 error = EINVAL;
1908
1909 VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
1910 vrele(fromnd.ni_dvp);
1911 vrele(fvp);
1912 goto out1;
1913 }
1914 tdvp = tond.ni_dvp;
1915 tvp = tond.ni_vp;
1916 if (tvp != NULL) {
1917 if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
1918 error = ENOTDIR;
1919 goto out;
1920 } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
1921 error = EISDIR;
1922 goto out;
1923 }
1924 }
1925 if (fvp == tdvp)
1926 error = EINVAL;
1927 /*
1928 * If source is the same as the destination (that is the
1929 * same inode number with the same name in the same directory),
1930 * then there is nothing to do.
1931 */
1932 if (fvp == tvp && fromnd.ni_dvp == tdvp &&
1933 fromnd.ni_cnd.cn_namelen == tond.ni_cnd.cn_namelen &&
1934 !bcmp(fromnd.ni_cnd.cn_nameptr, tond.ni_cnd.cn_nameptr,
1935 fromnd.ni_cnd.cn_namelen))
1936 error = -1;
1937out:
1938 if (!error) {
1939 LEASE_CHECK(tdvp, p, p->p_ucred, LEASE_WRITE);
1940 if (fromnd.ni_dvp != tdvp) {
1941 LEASE_CHECK(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
1942 }
1943 if (tvp) {
1944 LEASE_CHECK(tvp, p, p->p_ucred, LEASE_WRITE);
1945 (void) vnode_pager_uncache(tvp);
1946 }
1947 error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
1948 tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
1949 } else {
1950 VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
1951 if (tdvp == tvp)
1952 vrele(tdvp);
1953 else
1954 vput(tdvp);
1955 if (tvp)
1956 vput(tvp);
1957 VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
1958 vrele(fromnd.ni_dvp);
1959 vrele(fvp);
1960 }
1961 vrele(tond.ni_startdir);
1962 FREE(tond.ni_cnd.cn_pnbuf, M_NAMEI);
1963out1:
1964 if (fromnd.ni_startdir)
1965 vrele(fromnd.ni_startdir);
1966 FREE(fromnd.ni_cnd.cn_pnbuf, M_NAMEI);
1967 if (error == -1)
1968 return (0);
1969 return (error);
1970}
1971
1972/*
1973 * Make a directory file.
1974 */
1975#ifndef _SYS_SYSPROTO_H_
1976struct mkdir_args {
1977 char *path;
1978 int mode;
1979};
1980#endif
1981/* ARGSUSED */
1982int
1983mkdir(p, uap, retval)
1984 struct proc *p;
1985 register struct mkdir_args *uap;
1986 int *retval;
1987{
1988 register struct vnode *vp;
1989 struct vattr vattr;
1990 int error;
1991 struct nameidata nd;
1992
1993 NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
1994 nd.ni_cnd.cn_flags |= WILLBEDIR;
1995 error = namei(&nd);
1996 if (error)
1997 return (error);
1998 vp = nd.ni_vp;
1999 if (vp != NULL) {
2000 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2001 if (nd.ni_dvp == vp)
2002 vrele(nd.ni_dvp);
2003 else
2004 vput(nd.ni_dvp);
2005 vrele(vp);
2006 return (EEXIST);
2007 }
2008 VATTR_NULL(&vattr);
2009 vattr.va_type = VDIR;
2010 vattr.va_mode = (uap->mode & ACCESSPERMS) &~ p->p_fd->fd_cmask;
2011 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
2012 error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
2013 if (!error)
2014 vput(nd.ni_vp);
2015 return (error);
2016}
2017
2018/*
2019 * Remove a directory file.
2020 */
2021#ifndef _SYS_SYSPROTO_H_
2022struct rmdir_args {
2023 char *path;
2024};
2025#endif
2026/* ARGSUSED */
2027int
2028rmdir(p, uap, retval)
2029 struct proc *p;
2030 struct rmdir_args *uap;
2031 int *retval;
2032{
2033 register struct vnode *vp;
2034 int error;
2035 struct nameidata nd;
2036
2037 NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, uap->path, p);
2038 error = namei(&nd);
2039 if (error)
2040 return (error);
2041 vp = nd.ni_vp;
2042 if (vp->v_type != VDIR) {
2043 error = ENOTDIR;
2044 goto out;
2045 }
2046 /*
2047 * No rmdir "." please.
2048 */
2049 if (nd.ni_dvp == vp) {
2050 error = EINVAL;
2051 goto out;
2052 }
2053 /*
2054 * The root of a mounted filesystem cannot be deleted.
2055 */
2056 if (vp->v_flag & VROOT)
2057 error = EBUSY;
2058out:
2059 if (!error) {
2060 LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
2061 LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
2062 error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
2063 } else {
2064 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2065 if (nd.ni_dvp == vp)
2066 vrele(nd.ni_dvp);
2067 else
2068 vput(nd.ni_dvp);
2069 vput(vp);
2070 }
2071 return (error);
2072}
2073
2074#ifdef COMPAT_43
2075/*
2076 * Read a block of directory entries in a file system independent format.
2077 */
2078#ifndef _SYS_SYSPROTO_H_
2079struct ogetdirentries_args {
2080 int fd;
2081 char *buf;
2082 u_int count;
2083 long *basep;
2084};
2085#endif
2086int
2087ogetdirentries(p, uap, retval)
2088 struct proc *p;
2089 register struct ogetdirentries_args *uap;
2090 int *retval;
2091{
2092 register struct vnode *vp;
2093 struct file *fp;
2094 struct uio auio, kuio;
2095 struct iovec aiov, kiov;
2096 struct dirent *dp, *edp;
2097 caddr_t dirbuf;
2098 int error, readcnt;
2099 long loff;
2100
2101 error = getvnode(p->p_fd, uap->fd, &fp);
2102 if (error)
2103 return (error);
2104 if ((fp->f_flag & FREAD) == 0)
2105 return (EBADF);
2106 vp = (struct vnode *)fp->f_data;
2107 if (vp->v_type != VDIR)
2108 return (EINVAL);
2109 aiov.iov_base = uap->buf;
2110 aiov.iov_len = uap->count;
2111 auio.uio_iov = &aiov;
2112 auio.uio_iovcnt = 1;
2113 auio.uio_rw = UIO_READ;
2114 auio.uio_segflg = UIO_USERSPACE;
2115 auio.uio_procp = p;
2116 auio.uio_resid = uap->count;
2117 VOP_LOCK(vp);
2118 loff = auio.uio_offset = fp->f_offset;
2119# if (BYTE_ORDER != LITTLE_ENDIAN)
2120 if (vp->v_mount->mnt_maxsymlinklen <= 0) {
2121 error = VOP_READDIR(vp, &auio, fp->f_cred, NULL, NULL, NULL);
2122 fp->f_offset = auio.uio_offset;
2123 } else
2124# endif
2125 {
2126 kuio = auio;
2127 kuio.uio_iov = &kiov;
2128 kuio.uio_segflg = UIO_SYSSPACE;
2129 kiov.iov_len = uap->count;
2130 MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK);
2131 kiov.iov_base = dirbuf;
2132 error = VOP_READDIR(vp, &kuio, fp->f_cred, NULL, NULL, NULL);
2133 fp->f_offset = kuio.uio_offset;
2134 if (error == 0) {
2135 readcnt = uap->count - kuio.uio_resid;
2136 edp = (struct dirent *)&dirbuf[readcnt];
2137 for (dp = (struct dirent *)dirbuf; dp < edp; ) {
2138# if (BYTE_ORDER == LITTLE_ENDIAN)
2139 /*
2140 * The expected low byte of
2141 * dp->d_namlen is our dp->d_type.
2142 * The high MBZ byte of dp->d_namlen
2143 * is our dp->d_namlen.
2144 */
2145 dp->d_type = dp->d_namlen;
2146 dp->d_namlen = 0;
2147# else
2148 /*
2149 * The dp->d_type is the high byte
2150 * of the expected dp->d_namlen,
2151 * so must be zero'ed.
2152 */
2153 dp->d_type = 0;
2154# endif
2155 if (dp->d_reclen > 0) {
2156 dp = (struct dirent *)
2157 ((char *)dp + dp->d_reclen);
2158 } else {
2159 error = EIO;
2160 break;
2161 }
2162 }
2163 if (dp >= edp)
2164 error = uiomove(dirbuf, readcnt, &auio);
2165 }
2166 FREE(dirbuf, M_TEMP);
2167 }
2168 VOP_UNLOCK(vp);
2169 if (error)
2170 return (error);
2171 error = copyout((caddr_t)&loff, (caddr_t)uap->basep, sizeof(long));
2172 *retval = uap->count - auio.uio_resid;
2173 return (error);
2174}
2175#endif
2176
2177/*
2178 * Read a block of directory entries in a file system independent format.
2179 */
2180#ifndef _SYS_SYSPROTO_H_
2181struct getdirentries_args {
2182 int fd;
2183 char *buf;
2184 u_int count;
2185 long *basep;
2186};
2187#endif
2188int
2189getdirentries(p, uap, retval)
2190 struct proc *p;
2191 register struct getdirentries_args *uap;
2192 int *retval;
2193{
2194 register struct vnode *vp;
2195 struct file *fp;
2196 struct uio auio;
2197 struct iovec aiov;
2198 long loff;
2199 int error;
2200
2201 error = getvnode(p->p_fd, uap->fd, &fp);
2202 if (error)
2203 return (error);
2204 if ((fp->f_flag & FREAD) == 0)
2205 return (EBADF);
2206 vp = (struct vnode *)fp->f_data;
2207unionread:
2208 if (vp->v_type != VDIR)
2209 return (EINVAL);
2210 aiov.iov_base = uap->buf;
2211 aiov.iov_len = uap->count;
2212 auio.uio_iov = &aiov;
2213 auio.uio_iovcnt = 1;
2214 auio.uio_rw = UIO_READ;
2215 auio.uio_segflg = UIO_USERSPACE;
2216 auio.uio_procp = p;
2217 auio.uio_resid = uap->count;
2218 VOP_LOCK(vp);
2219 loff = auio.uio_offset = fp->f_offset;
2220 error = VOP_READDIR(vp, &auio, fp->f_cred, NULL, NULL, NULL);
2221 fp->f_offset = auio.uio_offset;
2222 VOP_UNLOCK(vp);
2223 if (error)
2224 return (error);
2225
2226#ifdef UNION
2227{
2228 if ((uap->count == auio.uio_resid) &&
2229 (vp->v_op == union_vnodeop_p)) {
2230 struct vnode *tvp = vp;
2231
2232 vp = union_lowervp(vp);
2233 if (vp != NULLVP) {
2234 VOP_LOCK(vp);
2235 error = VOP_OPEN(vp, FREAD, fp->f_cred, p);
2236 VOP_UNLOCK(vp);
2237
2238 if (error) {
2239 vrele(vp);
2240 return (error);
2241 }
2242 fp->f_data = (caddr_t) vp;
2243 fp->f_offset = 0;
2244 error = vn_close(tvp, FREAD, fp->f_cred, p);
2245 if (error)
2246 return (error);
2247 goto unionread;
2248 }
2249 }
2250}
2251#endif
2252
2253 if ((uap->count == auio.uio_resid) &&
2254 vp &&
2255 (vp->v_flag & VROOT) &&
2256 (vp->v_mount->mnt_flag & MNT_UNION)) {
2257 struct vnode *tvp = vp;
2258 vp = vp->v_mount->mnt_vnodecovered;
2259 VREF(vp);
2260 fp->f_data = (caddr_t) vp;
2261 fp->f_offset = 0;
2262 vrele(tvp);
2263 goto unionread;
2264 }
2265 error = copyout((caddr_t)&loff, (caddr_t)uap->basep, sizeof(long));
2266 *retval = uap->count - auio.uio_resid;
2267 return (error);
2268}
2269
2270/*
2271 * Set the mode mask for creation of filesystem nodes.
2272 */
2273#ifndef _SYS_SYSPROTO_H_
2274struct umask_args {
2275 int newmask;
2276};
2277#endif
2278mode_t /* XXX */
2279umask(p, uap, retval)
2280 struct proc *p;
2281 struct umask_args *uap;
2282 int *retval;
2283{
2284 register struct filedesc *fdp;
2285
2286 fdp = p->p_fd;
2287 *retval = fdp->fd_cmask;
2288 fdp->fd_cmask = uap->newmask & ALLPERMS;
2289 return (0);
2290}
2291
2292/*
2293 * Void all references to file by ripping underlying filesystem
2294 * away from vnode.
2295 */
2296#ifndef _SYS_SYSPROTO_H_
2297struct revoke_args {
2298 char *path;
2299};
2300#endif
2301/* ARGSUSED */
2302int
2303revoke(p, uap, retval)
2304 struct proc *p;
2305 register struct revoke_args *uap;
2306 int *retval;
2307{
2308 register struct vnode *vp;
2309 struct vattr vattr;
2310 int error;
2311 struct nameidata nd;
2312
2313 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
2314 error = namei(&nd);
2315 if (error)
2316 return (error);
2317 vp = nd.ni_vp;
2318 if (vp->v_type != VCHR && vp->v_type != VBLK) {
2319 error = EINVAL;
2320 goto out;
2321 }
2322 error = VOP_GETATTR(vp, &vattr, p->p_ucred, p);
2323 if (error)
2324 goto out;
2325 if (p->p_ucred->cr_uid != vattr.va_uid &&
2326 (error = suser(p->p_ucred, &p->p_acflag)))
2327 goto out;
2328 if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
2329 vgoneall(vp);
2330out:
2331 vrele(vp);
2332 return (error);
2333}
2334
2335/*
2336 * Convert a user file descriptor to a kernel file entry.
2337 */
2338int
2339getvnode(fdp, fd, fpp)
2340 struct filedesc *fdp;
2341 int fd;
2342 struct file **fpp;
2343{
2344 struct file *fp;
2345
2346 if ((u_int)fd >= fdp->fd_nfiles ||
2347 (fp = fdp->fd_ofiles[fd]) == NULL)
2348 return (EBADF);
2349 if (fp->f_type != DTYPE_VNODE)
2350 return (EINVAL);
2351 *fpp = fp;
2352 return (0);
2353}
|