xref: /freebsd/sys/kern/vfs_extattr.c (revision 77b7cdf1999ee965ad494fddd184b18f532ac91a)
1 /*
2  * Copyright (c) 1989, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  * (c) UNIX System Laboratories, Inc.
5  * All or some portions of this file are derived from material licensed
6  * to the University of California by American Telephone and Telegraph
7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8  * the permission of UNIX System Laboratories, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *	This product includes software developed by the University of
21  *	California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  *	@(#)vfs_syscalls.c	8.13 (Berkeley) 4/15/94
39  * $FreeBSD$
40  */
41 
42 /* For 4.3 integer FS ID compatibility */
43 #include "opt_compat.h"
44 #include "opt_mac.h"
45 
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/bio.h>
49 #include <sys/buf.h>
50 #include <sys/sysent.h>
51 #include <sys/mac.h>
52 #include <sys/malloc.h>
53 #include <sys/mount.h>
54 #include <sys/mutex.h>
55 #include <sys/sysproto.h>
56 #include <sys/namei.h>
57 #include <sys/filedesc.h>
58 #include <sys/kernel.h>
59 #include <sys/fcntl.h>
60 #include <sys/file.h>
61 #include <sys/limits.h>
62 #include <sys/linker.h>
63 #include <sys/stat.h>
64 #include <sys/sx.h>
65 #include <sys/unistd.h>
66 #include <sys/vnode.h>
67 #include <sys/proc.h>
68 #include <sys/dirent.h>
69 #include <sys/extattr.h>
70 #include <sys/jail.h>
71 #include <sys/syscallsubr.h>
72 #include <sys/sysctl.h>
73 
74 #include <machine/stdarg.h>
75 
76 #include <vm/vm.h>
77 #include <vm/vm_object.h>
78 #include <vm/vm_page.h>
79 #include <vm/uma.h>
80 
81 static int chroot_refuse_vdir_fds(struct filedesc *fdp);
82 static int getutimes(const struct timeval *, enum uio_seg, struct timespec *);
83 static int setfown(struct thread *td, struct vnode *, uid_t, gid_t);
84 static int setfmode(struct thread *td, struct vnode *, int);
85 static int setfflags(struct thread *td, struct vnode *, int);
86 static int setutimes(struct thread *td, struct vnode *,
87     const struct timespec *, int, int);
88 static int vn_access(struct vnode *vp, int user_flags, struct ucred *cred,
89     struct thread *td);
90 
91 int (*union_dircheckp)(struct thread *td, struct vnode **, struct file *);
92 int (*softdep_fsync_hook)(struct vnode *);
93 
94 /*
95  * The module initialization routine for POSIX asynchronous I/O will
96  * set this to the version of AIO that it implements.  (Zero means
97  * that it is not implemented.)  This value is used here by pathconf()
98  * and in kern_descrip.c by fpathconf().
99  */
100 int async_io_version;
101 
102 /*
103  * Sync each mounted filesystem.
104  */
105 #ifndef _SYS_SYSPROTO_H_
106 struct sync_args {
107         int     dummy;
108 };
109 #endif
110 
111 #ifdef DEBUG
112 static int syncprt = 0;
113 SYSCTL_INT(_debug, OID_AUTO, syncprt, CTLFLAG_RW, &syncprt, 0, "");
114 #endif
115 
116 /* ARGSUSED */
117 int
118 sync(td, uap)
119 	struct thread *td;
120 	struct sync_args *uap;
121 {
122 	struct mount *mp, *nmp;
123 	int asyncflag;
124 
125 	mtx_lock(&mountlist_mtx);
126 	for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
127 		if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
128 			nmp = TAILQ_NEXT(mp, mnt_list);
129 			continue;
130 		}
131 		if ((mp->mnt_flag & MNT_RDONLY) == 0 &&
132 		    vn_start_write(NULL, &mp, V_NOWAIT) == 0) {
133 			asyncflag = mp->mnt_flag & MNT_ASYNC;
134 			mp->mnt_flag &= ~MNT_ASYNC;
135 			vfs_msync(mp, MNT_NOWAIT);
136 			VFS_SYNC(mp, MNT_NOWAIT,
137 			    ((td != NULL) ? td->td_ucred : NOCRED), td);
138 			mp->mnt_flag |= asyncflag;
139 			vn_finished_write(mp);
140 		}
141 		mtx_lock(&mountlist_mtx);
142 		nmp = TAILQ_NEXT(mp, mnt_list);
143 		vfs_unbusy(mp, td);
144 	}
145 	mtx_unlock(&mountlist_mtx);
146 #if 0
147 /*
148  * XXX don't call vfs_bufstats() yet because that routine
149  * was not imported in the Lite2 merge.
150  */
151 #ifdef DIAGNOSTIC
152 	if (syncprt)
153 		vfs_bufstats();
154 #endif /* DIAGNOSTIC */
155 #endif
156 	return (0);
157 }
158 
159 /* XXX PRISON: could be per prison flag */
160 static int prison_quotas;
161 #if 0
162 SYSCTL_INT(_kern_prison, OID_AUTO, quotas, CTLFLAG_RW, &prison_quotas, 0, "");
163 #endif
164 
165 /*
166  * Change filesystem quotas.
167  */
168 #ifndef _SYS_SYSPROTO_H_
169 struct quotactl_args {
170 	char *path;
171 	int cmd;
172 	int uid;
173 	caddr_t arg;
174 };
175 #endif
176 /* ARGSUSED */
177 int
178 quotactl(td, uap)
179 	struct thread *td;
180 	register struct quotactl_args /* {
181 		char *path;
182 		int cmd;
183 		int uid;
184 		caddr_t arg;
185 	} */ *uap;
186 {
187 	struct mount *mp;
188 	int error;
189 	struct nameidata nd;
190 
191 	if (jailed(td->td_ucred) && !prison_quotas)
192 		return (EPERM);
193 	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
194 	if ((error = namei(&nd)) != 0)
195 		return (error);
196 	NDFREE(&nd, NDF_ONLY_PNBUF);
197 	error = vn_start_write(nd.ni_vp, &mp, V_WAIT | PCATCH);
198 	vrele(nd.ni_vp);
199 	if (error)
200 		return (error);
201 	error = VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg, td);
202 	vn_finished_write(mp);
203 	return (error);
204 }
205 
206 /*
207  * Get filesystem statistics.
208  */
209 #ifndef _SYS_SYSPROTO_H_
210 struct statfs_args {
211 	char *path;
212 	struct statfs *buf;
213 };
214 #endif
215 /* ARGSUSED */
216 int
217 statfs(td, uap)
218 	struct thread *td;
219 	register struct statfs_args /* {
220 		char *path;
221 		struct statfs *buf;
222 	} */ *uap;
223 {
224 	register struct mount *mp;
225 	register struct statfs *sp;
226 	int error;
227 	struct nameidata nd;
228 	struct statfs sb;
229 
230 	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
231 	if ((error = namei(&nd)) != 0)
232 		return (error);
233 	mp = nd.ni_vp->v_mount;
234 	sp = &mp->mnt_stat;
235 	NDFREE(&nd, NDF_ONLY_PNBUF);
236 	vrele(nd.ni_vp);
237 #ifdef MAC
238 	error = mac_check_mount_stat(td->td_ucred, mp);
239 	if (error)
240 		return (error);
241 #endif
242 	error = VFS_STATFS(mp, sp, td);
243 	if (error)
244 		return (error);
245 	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
246 	if (suser(td)) {
247 		bcopy(sp, &sb, sizeof(sb));
248 		sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
249 		sp = &sb;
250 	}
251 	return (copyout(sp, uap->buf, sizeof(*sp)));
252 }
253 
254 /*
255  * Get filesystem statistics.
256  */
257 #ifndef _SYS_SYSPROTO_H_
258 struct fstatfs_args {
259 	int fd;
260 	struct statfs *buf;
261 };
262 #endif
263 /* ARGSUSED */
264 int
265 fstatfs(td, uap)
266 	struct thread *td;
267 	register struct fstatfs_args /* {
268 		int fd;
269 		struct statfs *buf;
270 	} */ *uap;
271 {
272 	struct file *fp;
273 	struct mount *mp;
274 	register struct statfs *sp;
275 	int error;
276 	struct statfs sb;
277 
278 	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
279 		return (error);
280 	mp = ((struct vnode *)fp->f_data)->v_mount;
281 	fdrop(fp, td);
282 	if (mp == NULL)
283 		return (EBADF);
284 #ifdef MAC
285 	error = mac_check_mount_stat(td->td_ucred, mp);
286 	if (error)
287 		return (error);
288 #endif
289 	sp = &mp->mnt_stat;
290 	error = VFS_STATFS(mp, sp, td);
291 	if (error)
292 		return (error);
293 	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
294 	if (suser(td)) {
295 		bcopy(sp, &sb, sizeof(sb));
296 		sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
297 		sp = &sb;
298 	}
299 	return (copyout(sp, uap->buf, sizeof(*sp)));
300 }
301 
302 /*
303  * Get statistics on all filesystems.
304  */
305 #ifndef _SYS_SYSPROTO_H_
306 struct getfsstat_args {
307 	struct statfs *buf;
308 	long bufsize;
309 	int flags;
310 };
311 #endif
312 int
313 getfsstat(td, uap)
314 	struct thread *td;
315 	register struct getfsstat_args /* {
316 		struct statfs *buf;
317 		long bufsize;
318 		int flags;
319 	} */ *uap;
320 {
321 	register struct mount *mp, *nmp;
322 	register struct statfs *sp;
323 	caddr_t sfsp;
324 	long count, maxcount, error;
325 
326 	maxcount = uap->bufsize / sizeof(struct statfs);
327 	sfsp = (caddr_t)uap->buf;
328 	count = 0;
329 	mtx_lock(&mountlist_mtx);
330 	for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
331 #ifdef MAC
332 		if (mac_check_mount_stat(td->td_ucred, mp) != 0) {
333 			nmp = TAILQ_NEXT(mp, mnt_list);
334 			continue;
335 		}
336 #endif
337 		if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
338 			nmp = TAILQ_NEXT(mp, mnt_list);
339 			continue;
340 		}
341 		if (sfsp && count < maxcount) {
342 			sp = &mp->mnt_stat;
343 			/*
344 			 * If MNT_NOWAIT or MNT_LAZY is specified, do not
345 			 * refresh the fsstat cache. MNT_NOWAIT or MNT_LAZY
346 			 * overrides MNT_WAIT.
347 			 */
348 			if (((uap->flags & (MNT_LAZY|MNT_NOWAIT)) == 0 ||
349 			    (uap->flags & MNT_WAIT)) &&
350 			    (error = VFS_STATFS(mp, sp, td))) {
351 				mtx_lock(&mountlist_mtx);
352 				nmp = TAILQ_NEXT(mp, mnt_list);
353 				vfs_unbusy(mp, td);
354 				continue;
355 			}
356 			sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
357 			error = copyout(sp, sfsp, sizeof(*sp));
358 			if (error) {
359 				vfs_unbusy(mp, td);
360 				return (error);
361 			}
362 			sfsp += sizeof(*sp);
363 		}
364 		count++;
365 		mtx_lock(&mountlist_mtx);
366 		nmp = TAILQ_NEXT(mp, mnt_list);
367 		vfs_unbusy(mp, td);
368 	}
369 	mtx_unlock(&mountlist_mtx);
370 	if (sfsp && count > maxcount)
371 		td->td_retval[0] = maxcount;
372 	else
373 		td->td_retval[0] = count;
374 	return (0);
375 }
376 
377 /*
378  * Change current working directory to a given file descriptor.
379  */
380 #ifndef _SYS_SYSPROTO_H_
381 struct fchdir_args {
382 	int	fd;
383 };
384 #endif
385 /* ARGSUSED */
386 int
387 fchdir(td, uap)
388 	struct thread *td;
389 	struct fchdir_args /* {
390 		int fd;
391 	} */ *uap;
392 {
393 	register struct filedesc *fdp = td->td_proc->p_fd;
394 	struct vnode *vp, *tdp, *vpold;
395 	struct mount *mp;
396 	struct file *fp;
397 	int error;
398 
399 	if ((error = getvnode(fdp, uap->fd, &fp)) != 0)
400 		return (error);
401 	vp = fp->f_data;
402 	VREF(vp);
403 	fdrop(fp, td);
404 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
405 	if (vp->v_type != VDIR)
406 		error = ENOTDIR;
407 #ifdef MAC
408 	else if ((error = mac_check_vnode_chdir(td->td_ucred, vp)) != 0) {
409 	}
410 #endif
411 	else
412 		error = VOP_ACCESS(vp, VEXEC, td->td_ucred, td);
413 	while (!error && (mp = vp->v_mountedhere) != NULL) {
414 		if (vfs_busy(mp, 0, 0, td))
415 			continue;
416 		error = VFS_ROOT(mp, &tdp);
417 		vfs_unbusy(mp, td);
418 		if (error)
419 			break;
420 		vput(vp);
421 		vp = tdp;
422 	}
423 	if (error) {
424 		vput(vp);
425 		return (error);
426 	}
427 	VOP_UNLOCK(vp, 0, td);
428 	FILEDESC_LOCK(fdp);
429 	vpold = fdp->fd_cdir;
430 	fdp->fd_cdir = vp;
431 	FILEDESC_UNLOCK(fdp);
432 	vrele(vpold);
433 	return (0);
434 }
435 
436 /*
437  * Change current working directory (``.'').
438  */
439 #ifndef _SYS_SYSPROTO_H_
440 struct chdir_args {
441 	char	*path;
442 };
443 #endif
444 /* ARGSUSED */
445 int
446 chdir(td, uap)
447 	struct thread *td;
448 	struct chdir_args /* {
449 		char *path;
450 	} */ *uap;
451 {
452 
453 	return (kern_chdir(td, uap->path, UIO_USERSPACE));
454 }
455 
456 int
457 kern_chdir(struct thread *td, char *path, enum uio_seg pathseg)
458 {
459 	register struct filedesc *fdp = td->td_proc->p_fd;
460 	int error;
461 	struct nameidata nd;
462 	struct vnode *vp;
463 
464 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, pathseg, path, td);
465 	if ((error = namei(&nd)) != 0)
466 		return (error);
467 	if ((error = change_dir(nd.ni_vp, td)) != 0) {
468 		vput(nd.ni_vp);
469 		NDFREE(&nd, NDF_ONLY_PNBUF);
470 		return (error);
471 	}
472 	VOP_UNLOCK(nd.ni_vp, 0, td);
473 	NDFREE(&nd, NDF_ONLY_PNBUF);
474 	FILEDESC_LOCK(fdp);
475 	vp = fdp->fd_cdir;
476 	fdp->fd_cdir = nd.ni_vp;
477 	FILEDESC_UNLOCK(fdp);
478 	vrele(vp);
479 	return (0);
480 }
481 
482 /*
483  * Helper function for raised chroot(2) security function:  Refuse if
484  * any filedescriptors are open directories.
485  */
486 static int
487 chroot_refuse_vdir_fds(fdp)
488 	struct filedesc *fdp;
489 {
490 	struct vnode *vp;
491 	struct file *fp;
492 	int fd;
493 
494 	FILEDESC_LOCK_ASSERT(fdp, MA_OWNED);
495 	for (fd = 0; fd < fdp->fd_nfiles ; fd++) {
496 		fp = fget_locked(fdp, fd);
497 		if (fp == NULL)
498 			continue;
499 		if (fp->f_type == DTYPE_VNODE) {
500 			vp = fp->f_data;
501 			if (vp->v_type == VDIR)
502 				return (EPERM);
503 		}
504 	}
505 	return (0);
506 }
507 
508 /*
509  * This sysctl determines if we will allow a process to chroot(2) if it
510  * has a directory open:
511  *	0: disallowed for all processes.
512  *	1: allowed for processes that were not already chroot(2)'ed.
513  *	2: allowed for all processes.
514  */
515 
516 static int chroot_allow_open_directories = 1;
517 
518 SYSCTL_INT(_kern, OID_AUTO, chroot_allow_open_directories, CTLFLAG_RW,
519      &chroot_allow_open_directories, 0, "");
520 
521 /*
522  * Change notion of root (``/'') directory.
523  */
524 #ifndef _SYS_SYSPROTO_H_
525 struct chroot_args {
526 	char	*path;
527 };
528 #endif
529 /* ARGSUSED */
530 int
531 chroot(td, uap)
532 	struct thread *td;
533 	struct chroot_args /* {
534 		char *path;
535 	} */ *uap;
536 {
537 	int error;
538 	struct nameidata nd;
539 
540 	error = suser_cred(td->td_ucred, PRISON_ROOT);
541 	if (error)
542 		return (error);
543 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, td);
544 	mtx_lock(&Giant);
545 	error = namei(&nd);
546 	if (error)
547 		goto error;
548 	if ((error = change_dir(nd.ni_vp, td)) != 0)
549 		goto e_vunlock;
550 #ifdef MAC
551 	if ((error = mac_check_vnode_chroot(td->td_ucred, nd.ni_vp)))
552 		goto e_vunlock;
553 #endif
554 	VOP_UNLOCK(nd.ni_vp, 0, td);
555 	error = change_root(nd.ni_vp, td);
556 	vrele(nd.ni_vp);
557 	NDFREE(&nd, NDF_ONLY_PNBUF);
558 	mtx_unlock(&Giant);
559 	return (error);
560 e_vunlock:
561 	vput(nd.ni_vp);
562 error:
563 	mtx_unlock(&Giant);
564 	NDFREE(&nd, NDF_ONLY_PNBUF);
565 	return (error);
566 }
567 
568 /*
569  * Common routine for chroot and chdir.  Callers must provide a locked vnode
570  * instance.
571  */
572 int
573 change_dir(vp, td)
574 	struct vnode *vp;
575 	struct thread *td;
576 {
577 	int error;
578 
579 	ASSERT_VOP_LOCKED(vp, "change_dir(): vp not locked");
580 	if (vp->v_type != VDIR)
581 		return (ENOTDIR);
582 #ifdef MAC
583 	error = mac_check_vnode_chdir(td->td_ucred, vp);
584 	if (error)
585 		return (error);
586 #endif
587 	error = VOP_ACCESS(vp, VEXEC, td->td_ucred, td);
588 	return (error);
589 }
590 
591 /*
592  * Common routine for kern_chroot() and jail_attach().  The caller is
593  * responsible for invoking suser() and mac_check_chroot() to authorize this
594  * operation.
595  */
596 int
597 change_root(vp, td)
598 	struct vnode *vp;
599 	struct thread *td;
600 {
601 	struct filedesc *fdp;
602 	struct vnode *oldvp;
603 	int error;
604 
605 	mtx_assert(&Giant, MA_OWNED);
606 	fdp = td->td_proc->p_fd;
607 	FILEDESC_LOCK(fdp);
608 	if (chroot_allow_open_directories == 0 ||
609 	    (chroot_allow_open_directories == 1 && fdp->fd_rdir != rootvnode)) {
610 		error = chroot_refuse_vdir_fds(fdp);
611 		if (error) {
612 			FILEDESC_UNLOCK(fdp);
613 			return (error);
614 		}
615 	}
616 	oldvp = fdp->fd_rdir;
617 	fdp->fd_rdir = vp;
618 	VREF(fdp->fd_rdir);
619 	if (!fdp->fd_jdir) {
620 		fdp->fd_jdir = vp;
621 		VREF(fdp->fd_jdir);
622 	}
623 	FILEDESC_UNLOCK(fdp);
624 	vrele(oldvp);
625 	return (0);
626 }
627 
628 /*
629  * Check permissions, allocate an open file structure,
630  * and call the device open routine if any.
631  */
632 #ifndef _SYS_SYSPROTO_H_
633 struct open_args {
634 	char	*path;
635 	int	flags;
636 	int	mode;
637 };
638 #endif
639 int
640 open(td, uap)
641 	struct thread *td;
642 	register struct open_args /* {
643 		char *path;
644 		int flags;
645 		int mode;
646 	} */ *uap;
647 {
648 
649 	return (kern_open(td, uap->path, UIO_USERSPACE, uap->flags, uap->mode));
650 }
651 
652 int
653 kern_open(struct thread *td, char *path, enum uio_seg pathseg, int flags,
654     int mode)
655 {
656 	struct proc *p = td->td_proc;
657 	struct filedesc *fdp = p->p_fd;
658 	struct file *fp;
659 	struct vnode *vp;
660 	struct vattr vat;
661 	struct mount *mp;
662 	int cmode, oflags;
663 	struct file *nfp;
664 	int type, indx, error;
665 	struct flock lf;
666 	struct nameidata nd;
667 
668 	if ((flags & O_ACCMODE) == O_ACCMODE)
669 		return (EINVAL);
670 	oflags = flags;
671 	flags = FFLAGS(flags);
672 	error = falloc(td, &nfp, &indx);
673 	if (error)
674 		return (error);
675 	fp = nfp;
676 	cmode = ((mode &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT;
677 	NDINIT(&nd, LOOKUP, FOLLOW, pathseg, path, td);
678 	td->td_dupfd = -indx - 1;		/* XXX check for fdopen */
679 	/*
680 	 * Bump the ref count to prevent another process from closing
681 	 * the descriptor while we are blocked in vn_open()
682 	 */
683 	fhold(fp);
684 	error = vn_open(&nd, &flags, cmode);
685 	if (error) {
686 		/*
687 		 * release our own reference
688 		 */
689 		fdrop(fp, td);
690 
691 		/*
692 		 * handle special fdopen() case.  bleh.  dupfdopen() is
693 		 * responsible for dropping the old contents of ofiles[indx]
694 		 * if it succeeds.
695 		 */
696 		if ((error == ENODEV || error == ENXIO) &&
697 		    td->td_dupfd >= 0 &&		/* XXX from fdopen */
698 		    (error =
699 			dupfdopen(td, fdp, indx, td->td_dupfd, flags, error)) == 0) {
700 			td->td_retval[0] = indx;
701 			return (0);
702 		}
703 		/*
704 		 * Clean up the descriptor, but only if another thread hadn't
705 		 * replaced or closed it.
706 		 */
707 		FILEDESC_LOCK(fdp);
708 		if (fdp->fd_ofiles[indx] == fp) {
709 			fdp->fd_ofiles[indx] = NULL;
710 			FILEDESC_UNLOCK(fdp);
711 			fdrop(fp, td);
712 		} else
713 			FILEDESC_UNLOCK(fdp);
714 
715 		if (error == ERESTART)
716 			error = EINTR;
717 		return (error);
718 	}
719 	td->td_dupfd = 0;
720 	NDFREE(&nd, NDF_ONLY_PNBUF);
721 	vp = nd.ni_vp;
722 
723 	/*
724 	 * There should be 2 references on the file, one from the descriptor
725 	 * table, and one for us.
726 	 *
727 	 * Handle the case where someone closed the file (via its file
728 	 * descriptor) while we were blocked.  The end result should look
729 	 * like opening the file succeeded but it was immediately closed.
730 	 */
731 	FILEDESC_LOCK(fdp);
732 	FILE_LOCK(fp);
733 	if (fp->f_count == 1) {
734 		KASSERT(fdp->fd_ofiles[indx] != fp,
735 		    ("Open file descriptor lost all refs"));
736 		FILEDESC_UNLOCK(fdp);
737 		FILE_UNLOCK(fp);
738 		VOP_UNLOCK(vp, 0, td);
739 		vn_close(vp, flags & FMASK, fp->f_cred, td);
740 		fdrop(fp, td);
741 		td->td_retval[0] = indx;
742 		return 0;
743 	}
744 
745 	/* assert that vn_open created a backing object if one is needed */
746 	KASSERT(!vn_canvmio(vp) || VOP_GETVOBJECT(vp, NULL) == 0,
747 		("open: vmio vnode has no backing object after vn_open"));
748 
749 	fp->f_data = vp;
750 	fp->f_flag = flags & FMASK;
751 	fp->f_ops = &vnops;
752 	fp->f_type = (vp->v_type == VFIFO ? DTYPE_FIFO : DTYPE_VNODE);
753 	FILEDESC_UNLOCK(fdp);
754 	FILE_UNLOCK(fp);
755 	VOP_UNLOCK(vp, 0, td);
756 	if (flags & (O_EXLOCK | O_SHLOCK)) {
757 		lf.l_whence = SEEK_SET;
758 		lf.l_start = 0;
759 		lf.l_len = 0;
760 		if (flags & O_EXLOCK)
761 			lf.l_type = F_WRLCK;
762 		else
763 			lf.l_type = F_RDLCK;
764 		type = F_FLOCK;
765 		if ((flags & FNONBLOCK) == 0)
766 			type |= F_WAIT;
767 		if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf,
768 			    type)) != 0)
769 			goto bad;
770 		fp->f_flag |= FHASLOCK;
771 	}
772 	if (flags & O_TRUNC) {
773 		if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
774 			goto bad;
775 		VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
776 		VATTR_NULL(&vat);
777 		vat.va_size = 0;
778 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
779 #ifdef MAC
780 		error = mac_check_vnode_write(td->td_ucred, fp->f_cred, vp);
781 		if (error == 0)
782 #endif
783 			error = VOP_SETATTR(vp, &vat, td->td_ucred, td);
784 		VOP_UNLOCK(vp, 0, td);
785 		vn_finished_write(mp);
786 		if (error)
787 			goto bad;
788 	}
789 	/*
790 	 * Release our private reference, leaving the one associated with
791 	 * the descriptor table intact.
792 	 */
793 	fdrop(fp, td);
794 	td->td_retval[0] = indx;
795 	return (0);
796 bad:
797 	FILEDESC_LOCK(fdp);
798 	if (fdp->fd_ofiles[indx] == fp) {
799 		fdp->fd_ofiles[indx] = NULL;
800 		FILEDESC_UNLOCK(fdp);
801 		fdrop(fp, td);
802 	} else
803 		FILEDESC_UNLOCK(fdp);
804 	fdrop(fp, td);
805 	return (error);
806 }
807 
808 #ifdef COMPAT_43
809 /*
810  * Create a file.
811  */
812 #ifndef _SYS_SYSPROTO_H_
813 struct ocreat_args {
814 	char	*path;
815 	int	mode;
816 };
817 #endif
818 int
819 ocreat(td, uap)
820 	struct thread *td;
821 	register struct ocreat_args /* {
822 		char *path;
823 		int mode;
824 	} */ *uap;
825 {
826 	struct open_args /* {
827 		char *path;
828 		int flags;
829 		int mode;
830 	} */ nuap;
831 
832 	nuap.path = uap->path;
833 	nuap.mode = uap->mode;
834 	nuap.flags = O_WRONLY | O_CREAT | O_TRUNC;
835 	return (open(td, &nuap));
836 }
837 #endif /* COMPAT_43 */
838 
839 /*
840  * Create a special file.
841  */
842 #ifndef _SYS_SYSPROTO_H_
843 struct mknod_args {
844 	char	*path;
845 	int	mode;
846 	int	dev;
847 };
848 #endif
849 /* ARGSUSED */
850 int
851 mknod(td, uap)
852 	struct thread *td;
853 	register struct mknod_args /* {
854 		char *path;
855 		int mode;
856 		int dev;
857 	} */ *uap;
858 {
859 
860 	return (kern_mknod(td, uap->path, UIO_USERSPACE, uap->mode, uap->dev));
861 }
862 
863 int
864 kern_mknod(struct thread *td, char *path, enum uio_seg pathseg, int mode,
865     int dev)
866 {
867 	struct vnode *vp;
868 	struct mount *mp;
869 	struct vattr vattr;
870 	int error;
871 	int whiteout = 0;
872 	struct nameidata nd;
873 
874 	switch (mode & S_IFMT) {
875 	case S_IFCHR:
876 	case S_IFBLK:
877 		error = suser(td);
878 		break;
879 	default:
880 		error = suser_cred(td->td_ucred, PRISON_ROOT);
881 		break;
882 	}
883 	if (error)
884 		return (error);
885 restart:
886 	bwillwrite();
887 	NDINIT(&nd, CREATE, LOCKPARENT | SAVENAME, pathseg, path, td);
888 	if ((error = namei(&nd)) != 0)
889 		return (error);
890 	vp = nd.ni_vp;
891 	if (vp != NULL) {
892 		vrele(vp);
893 		error = EEXIST;
894 	} else {
895 		VATTR_NULL(&vattr);
896 		FILEDESC_LOCK(td->td_proc->p_fd);
897 		vattr.va_mode = (mode & ALLPERMS) &
898 		    ~td->td_proc->p_fd->fd_cmask;
899 		FILEDESC_UNLOCK(td->td_proc->p_fd);
900 		vattr.va_rdev = dev;
901 		whiteout = 0;
902 
903 		switch (mode & S_IFMT) {
904 		case S_IFMT:	/* used by badsect to flag bad sectors */
905 			vattr.va_type = VBAD;
906 			break;
907 		case S_IFCHR:
908 			vattr.va_type = VCHR;
909 			break;
910 		case S_IFBLK:
911 			vattr.va_type = VBLK;
912 			break;
913 		case S_IFWHT:
914 			whiteout = 1;
915 			break;
916 		default:
917 			error = EINVAL;
918 			break;
919 		}
920 	}
921 	if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
922 		NDFREE(&nd, NDF_ONLY_PNBUF);
923 		vput(nd.ni_dvp);
924 		if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
925 			return (error);
926 		goto restart;
927 	}
928 #ifdef MAC
929 	if (error == 0 && !whiteout)
930 		error = mac_check_vnode_create(td->td_ucred, nd.ni_dvp,
931 		    &nd.ni_cnd, &vattr);
932 #endif
933 	if (!error) {
934 		VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
935 		if (whiteout)
936 			error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, CREATE);
937 		else {
938 			error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp,
939 						&nd.ni_cnd, &vattr);
940 			if (error == 0)
941 				vput(nd.ni_vp);
942 		}
943 	}
944 	NDFREE(&nd, NDF_ONLY_PNBUF);
945 	vput(nd.ni_dvp);
946 	vn_finished_write(mp);
947 	ASSERT_VOP_UNLOCKED(nd.ni_dvp, "mknod");
948 	ASSERT_VOP_UNLOCKED(nd.ni_vp, "mknod");
949 	return (error);
950 }
951 
952 /*
953  * Create a named pipe.
954  */
955 #ifndef _SYS_SYSPROTO_H_
956 struct mkfifo_args {
957 	char	*path;
958 	int	mode;
959 };
960 #endif
961 /* ARGSUSED */
962 int
963 mkfifo(td, uap)
964 	struct thread *td;
965 	register struct mkfifo_args /* {
966 		char *path;
967 		int mode;
968 	} */ *uap;
969 {
970 
971 	return (kern_mkfifo(td, uap->path, UIO_USERSPACE, uap->mode));
972 }
973 
974 int
975 kern_mkfifo(struct thread *td, char *path, enum uio_seg pathseg, int mode)
976 {
977 	struct mount *mp;
978 	struct vattr vattr;
979 	int error;
980 	struct nameidata nd;
981 
982 restart:
983 	bwillwrite();
984 	NDINIT(&nd, CREATE, LOCKPARENT | SAVENAME, pathseg, path, td);
985 	if ((error = namei(&nd)) != 0)
986 		return (error);
987 	if (nd.ni_vp != NULL) {
988 		NDFREE(&nd, NDF_ONLY_PNBUF);
989 		vrele(nd.ni_vp);
990 		vput(nd.ni_dvp);
991 		return (EEXIST);
992 	}
993 	if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
994 		NDFREE(&nd, NDF_ONLY_PNBUF);
995 		vput(nd.ni_dvp);
996 		if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
997 			return (error);
998 		goto restart;
999 	}
1000 	VATTR_NULL(&vattr);
1001 	vattr.va_type = VFIFO;
1002 	FILEDESC_LOCK(td->td_proc->p_fd);
1003 	vattr.va_mode = (mode & ALLPERMS) & ~td->td_proc->p_fd->fd_cmask;
1004 	FILEDESC_UNLOCK(td->td_proc->p_fd);
1005 #ifdef MAC
1006 	error = mac_check_vnode_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
1007 	    &vattr);
1008 	if (error)
1009 		goto out;
1010 #endif
1011 	VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
1012 	error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
1013 	if (error == 0)
1014 		vput(nd.ni_vp);
1015 #ifdef MAC
1016 out:
1017 #endif
1018 	NDFREE(&nd, NDF_ONLY_PNBUF);
1019 	vput(nd.ni_dvp);
1020 	vn_finished_write(mp);
1021 	return (error);
1022 }
1023 
1024 /*
1025  * Make a hard file link.
1026  */
1027 #ifndef _SYS_SYSPROTO_H_
1028 struct link_args {
1029 	char	*path;
1030 	char	*link;
1031 };
1032 #endif
1033 /* ARGSUSED */
1034 int
1035 link(td, uap)
1036 	struct thread *td;
1037 	register struct link_args /* {
1038 		char *path;
1039 		char *link;
1040 	} */ *uap;
1041 {
1042 
1043 	return (kern_link(td, uap->path, uap->link, UIO_USERSPACE));
1044 }
1045 
1046 int
1047 kern_link(struct thread *td, char *path, char *link, enum uio_seg segflg)
1048 {
1049 	struct vnode *vp;
1050 	struct mount *mp;
1051 	struct nameidata nd;
1052 	int error;
1053 
1054 	bwillwrite();
1055 	NDINIT(&nd, LOOKUP, FOLLOW|NOOBJ, segflg, path, td);
1056 	if ((error = namei(&nd)) != 0)
1057 		return (error);
1058 	NDFREE(&nd, NDF_ONLY_PNBUF);
1059 	vp = nd.ni_vp;
1060 	if (vp->v_type == VDIR) {
1061 		vrele(vp);
1062 		return (EPERM);		/* POSIX */
1063 	}
1064 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) {
1065 		vrele(vp);
1066 		return (error);
1067 	}
1068 	NDINIT(&nd, CREATE, LOCKPARENT | NOOBJ | SAVENAME, segflg, link, td);
1069 	if ((error = namei(&nd)) == 0) {
1070 		if (nd.ni_vp != NULL) {
1071 			vrele(nd.ni_vp);
1072 			error = EEXIST;
1073 		} else if ((error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td))
1074 		    == 0) {
1075 			VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
1076 			VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
1077 #ifdef MAC
1078 			error = mac_check_vnode_link(td->td_ucred, nd.ni_dvp,
1079 			    vp, &nd.ni_cnd);
1080 			if (error == 0)
1081 #endif
1082 				error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);
1083 			VOP_UNLOCK(vp, 0, td);
1084 		}
1085 		NDFREE(&nd, NDF_ONLY_PNBUF);
1086 		vput(nd.ni_dvp);
1087 	}
1088 	vrele(vp);
1089 	vn_finished_write(mp);
1090 	ASSERT_VOP_UNLOCKED(nd.ni_dvp, "link");
1091 	ASSERT_VOP_UNLOCKED(nd.ni_vp, "link");
1092 	return (error);
1093 }
1094 
1095 /*
1096  * Make a symbolic link.
1097  */
1098 #ifndef _SYS_SYSPROTO_H_
1099 struct symlink_args {
1100 	char	*path;
1101 	char	*link;
1102 };
1103 #endif
1104 /* ARGSUSED */
1105 int
1106 symlink(td, uap)
1107 	struct thread *td;
1108 	register struct symlink_args /* {
1109 		char *path;
1110 		char *link;
1111 	} */ *uap;
1112 {
1113 
1114 	return (kern_symlink(td, uap->path, uap->link, UIO_USERSPACE));
1115 }
1116 
1117 int
1118 kern_symlink(struct thread *td, char *path, char *link, enum uio_seg segflg)
1119 {
1120 	struct mount *mp;
1121 	struct vattr vattr;
1122 	char *syspath;
1123 	int error;
1124 	struct nameidata nd;
1125 
1126 	if (segflg == UIO_SYSSPACE) {
1127 		syspath = path;
1128 	} else {
1129 		syspath = uma_zalloc(namei_zone, M_WAITOK);
1130 		if ((error = copyinstr(path, syspath, MAXPATHLEN, NULL)) != 0)
1131 			goto out;
1132 	}
1133 restart:
1134 	bwillwrite();
1135 	NDINIT(&nd, CREATE, LOCKPARENT | NOOBJ | SAVENAME, segflg, link, td);
1136 	if ((error = namei(&nd)) != 0)
1137 		goto out;
1138 	if (nd.ni_vp) {
1139 		NDFREE(&nd, NDF_ONLY_PNBUF);
1140 		vrele(nd.ni_vp);
1141 		vput(nd.ni_dvp);
1142 		error = EEXIST;
1143 		goto out;
1144 	}
1145 	if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
1146 		NDFREE(&nd, NDF_ONLY_PNBUF);
1147 		vput(nd.ni_dvp);
1148 		if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
1149 			return (error);
1150 		goto restart;
1151 	}
1152 	VATTR_NULL(&vattr);
1153 	FILEDESC_LOCK(td->td_proc->p_fd);
1154 	vattr.va_mode = ACCESSPERMS &~ td->td_proc->p_fd->fd_cmask;
1155 	FILEDESC_UNLOCK(td->td_proc->p_fd);
1156 #ifdef MAC
1157 	vattr.va_type = VLNK;
1158 	error = mac_check_vnode_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
1159 	    &vattr);
1160 	if (error)
1161 		goto out2;
1162 #endif
1163 	VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
1164 	error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, syspath);
1165 	if (error == 0)
1166 		vput(nd.ni_vp);
1167 #ifdef MAC
1168 out2:
1169 #endif
1170 	NDFREE(&nd, NDF_ONLY_PNBUF);
1171 	vput(nd.ni_dvp);
1172 	vn_finished_write(mp);
1173 	ASSERT_VOP_UNLOCKED(nd.ni_dvp, "symlink");
1174 	ASSERT_VOP_UNLOCKED(nd.ni_vp, "symlink");
1175 out:
1176 	if (segflg != UIO_SYSSPACE)
1177 		uma_zfree(namei_zone, syspath);
1178 	return (error);
1179 }
1180 
1181 /*
1182  * Delete a whiteout from the filesystem.
1183  */
1184 /* ARGSUSED */
1185 int
1186 undelete(td, uap)
1187 	struct thread *td;
1188 	register struct undelete_args /* {
1189 		char *path;
1190 	} */ *uap;
1191 {
1192 	int error;
1193 	struct mount *mp;
1194 	struct nameidata nd;
1195 
1196 restart:
1197 	bwillwrite();
1198 	NDINIT(&nd, DELETE, LOCKPARENT|DOWHITEOUT, UIO_USERSPACE,
1199 	    uap->path, td);
1200 	error = namei(&nd);
1201 	if (error)
1202 		return (error);
1203 
1204 	if (nd.ni_vp != NULLVP || !(nd.ni_cnd.cn_flags & ISWHITEOUT)) {
1205 		NDFREE(&nd, NDF_ONLY_PNBUF);
1206 		if (nd.ni_vp)
1207 			vrele(nd.ni_vp);
1208 		vput(nd.ni_dvp);
1209 		return (EEXIST);
1210 	}
1211 	if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
1212 		NDFREE(&nd, NDF_ONLY_PNBUF);
1213 		vput(nd.ni_dvp);
1214 		if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
1215 			return (error);
1216 		goto restart;
1217 	}
1218 	VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
1219 	error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, DELETE);
1220 	NDFREE(&nd, NDF_ONLY_PNBUF);
1221 	vput(nd.ni_dvp);
1222 	vn_finished_write(mp);
1223 	ASSERT_VOP_UNLOCKED(nd.ni_dvp, "undelete");
1224 	ASSERT_VOP_UNLOCKED(nd.ni_vp, "undelete");
1225 	return (error);
1226 }
1227 
1228 /*
1229  * Delete a name from the filesystem.
1230  */
1231 #ifndef _SYS_SYSPROTO_H_
1232 struct unlink_args {
1233 	char	*path;
1234 };
1235 #endif
1236 /* ARGSUSED */
1237 int
1238 unlink(td, uap)
1239 	struct thread *td;
1240 	struct unlink_args /* {
1241 		char *path;
1242 	} */ *uap;
1243 {
1244 
1245 	return (kern_unlink(td, uap->path, UIO_USERSPACE));
1246 }
1247 
1248 int
1249 kern_unlink(struct thread *td, char *path, enum uio_seg pathseg)
1250 {
1251 	struct mount *mp;
1252 	struct vnode *vp;
1253 	int error;
1254 	struct nameidata nd;
1255 
1256 restart:
1257 	bwillwrite();
1258 	NDINIT(&nd, DELETE, LOCKPARENT|LOCKLEAF, pathseg, path, td);
1259 	if ((error = namei(&nd)) != 0)
1260 		return (error);
1261 	vp = nd.ni_vp;
1262 	if (vp->v_type == VDIR)
1263 		error = EPERM;		/* POSIX */
1264 	else {
1265 		/*
1266 		 * The root of a mounted filesystem cannot be deleted.
1267 		 *
1268 		 * XXX: can this only be a VDIR case?
1269 		 */
1270 		if (vp->v_vflag & VV_ROOT)
1271 			error = EBUSY;
1272 	}
1273 	if (error == 0) {
1274 		if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
1275 			NDFREE(&nd, NDF_ONLY_PNBUF);
1276 			if (vp == nd.ni_dvp)
1277 				vrele(vp);
1278 			else
1279 				vput(vp);
1280 			vput(nd.ni_dvp);
1281 			if ((error = vn_start_write(NULL, &mp,
1282 			    V_XSLEEP | PCATCH)) != 0)
1283 				return (error);
1284 			goto restart;
1285 		}
1286 #ifdef MAC
1287 		error = mac_check_vnode_delete(td->td_ucred, nd.ni_dvp, vp,
1288 		    &nd.ni_cnd);
1289 		if (error)
1290 			goto out;
1291 #endif
1292 		VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
1293 		error = VOP_REMOVE(nd.ni_dvp, vp, &nd.ni_cnd);
1294 #ifdef MAC
1295 out:
1296 #endif
1297 		vn_finished_write(mp);
1298 	}
1299 	NDFREE(&nd, NDF_ONLY_PNBUF);
1300 	if (vp == nd.ni_dvp)
1301 		vrele(vp);
1302 	else
1303 		vput(vp);
1304 	vput(nd.ni_dvp);
1305 	ASSERT_VOP_UNLOCKED(nd.ni_dvp, "unlink");
1306 	ASSERT_VOP_UNLOCKED(nd.ni_vp, "unlink");
1307 	return (error);
1308 }
1309 
1310 /*
1311  * Reposition read/write file offset.
1312  */
1313 #ifndef _SYS_SYSPROTO_H_
1314 struct lseek_args {
1315 	int	fd;
1316 	int	pad;
1317 	off_t	offset;
1318 	int	whence;
1319 };
1320 #endif
1321 int
1322 lseek(td, uap)
1323 	struct thread *td;
1324 	register struct lseek_args /* {
1325 		int fd;
1326 		int pad;
1327 		off_t offset;
1328 		int whence;
1329 	} */ *uap;
1330 {
1331 	struct ucred *cred = td->td_ucred;
1332 	struct file *fp;
1333 	struct vnode *vp;
1334 	struct vattr vattr;
1335 	off_t offset;
1336 	int error, noneg;
1337 
1338 	if ((error = fget(td, uap->fd, &fp)) != 0)
1339 		return (error);
1340 	if (fp->f_type != DTYPE_VNODE) {
1341 		fdrop(fp, td);
1342 		return (ESPIPE);
1343 	}
1344 	vp = fp->f_data;
1345 	noneg = (vp->v_type != VCHR);
1346 	offset = uap->offset;
1347 	switch (uap->whence) {
1348 	case L_INCR:
1349 		if (noneg &&
1350 		    (fp->f_offset < 0 ||
1351 		    (offset > 0 && fp->f_offset > OFF_MAX - offset))) {
1352 			error = EOVERFLOW;
1353 			break;
1354 		}
1355 		offset += fp->f_offset;
1356 		break;
1357 	case L_XTND:
1358 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
1359 		error = VOP_GETATTR(vp, &vattr, cred, td);
1360 		VOP_UNLOCK(vp, 0, td);
1361 		if (error)
1362 			break;
1363 		if (noneg &&
1364 		    (vattr.va_size > OFF_MAX ||
1365 		    (offset > 0 && vattr.va_size > OFF_MAX - offset))) {
1366 			error = EOVERFLOW;
1367 			break;
1368 		}
1369 		offset += vattr.va_size;
1370 		break;
1371 	case L_SET:
1372 		break;
1373 	default:
1374 		error = EINVAL;
1375 	}
1376 	if (error == 0 && noneg && offset < 0)
1377 		error = EINVAL;
1378 	if (error != 0) {
1379 		fdrop(fp, td);
1380 		return (error);
1381 	}
1382 	fp->f_offset = offset;
1383 	*(off_t *)(td->td_retval) = fp->f_offset;
1384 	fdrop(fp, td);
1385 	return (0);
1386 }
1387 
1388 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1389 /*
1390  * Reposition read/write file offset.
1391  */
1392 #ifndef _SYS_SYSPROTO_H_
1393 struct olseek_args {
1394 	int	fd;
1395 	long	offset;
1396 	int	whence;
1397 };
1398 #endif
1399 int
1400 olseek(td, uap)
1401 	struct thread *td;
1402 	register struct olseek_args /* {
1403 		int fd;
1404 		long offset;
1405 		int whence;
1406 	} */ *uap;
1407 {
1408 	struct lseek_args /* {
1409 		int fd;
1410 		int pad;
1411 		off_t offset;
1412 		int whence;
1413 	} */ nuap;
1414 	int error;
1415 
1416 	nuap.fd = uap->fd;
1417 	nuap.offset = uap->offset;
1418 	nuap.whence = uap->whence;
1419 	error = lseek(td, &nuap);
1420 	return (error);
1421 }
1422 #endif /* COMPAT_43 */
1423 
1424 /*
1425  * Check access permissions using passed credentials.
1426  */
1427 static int
1428 vn_access(vp, user_flags, cred, td)
1429 	struct vnode	*vp;
1430 	int		user_flags;
1431 	struct ucred	*cred;
1432 	struct thread	*td;
1433 {
1434 	int error, flags;
1435 
1436 	/* Flags == 0 means only check for existence. */
1437 	error = 0;
1438 	if (user_flags) {
1439 		flags = 0;
1440 		if (user_flags & R_OK)
1441 			flags |= VREAD;
1442 		if (user_flags & W_OK)
1443 			flags |= VWRITE;
1444 		if (user_flags & X_OK)
1445 			flags |= VEXEC;
1446 #ifdef MAC
1447 		error = mac_check_vnode_access(cred, vp, flags);
1448 		if (error)
1449 			return (error);
1450 #endif
1451 		if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
1452 			error = VOP_ACCESS(vp, flags, cred, td);
1453 	}
1454 	return (error);
1455 }
1456 
1457 /*
1458  * Check access permissions using "real" credentials.
1459  */
1460 #ifndef _SYS_SYSPROTO_H_
1461 struct access_args {
1462 	char	*path;
1463 	int	flags;
1464 };
1465 #endif
1466 int
1467 access(td, uap)
1468 	struct thread *td;
1469 	register struct access_args /* {
1470 		char *path;
1471 		int flags;
1472 	} */ *uap;
1473 {
1474 
1475 	return (kern_access(td, uap->path, UIO_USERSPACE, uap->flags));
1476 }
1477 
1478 int
1479 kern_access(struct thread *td, char *path, enum uio_seg pathseg, int flags)
1480 {
1481 	struct ucred *cred, *tmpcred;
1482 	register struct vnode *vp;
1483 	int error;
1484 	struct nameidata nd;
1485 
1486 	/*
1487 	 * Create and modify a temporary credential instead of one that
1488 	 * is potentially shared.  This could also mess up socket
1489 	 * buffer accounting which can run in an interrupt context.
1490 	 *
1491 	 * XXX - Depending on how "threads" are finally implemented, it
1492 	 * may be better to explicitly pass the credential to namei()
1493 	 * rather than to modify the potentially shared process structure.
1494 	 */
1495 	cred = td->td_ucred;
1496 	tmpcred = crdup(cred);
1497 	tmpcred->cr_uid = cred->cr_ruid;
1498 	tmpcred->cr_groups[0] = cred->cr_rgid;
1499 	td->td_ucred = tmpcred;
1500 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, pathseg, path, td);
1501 	if ((error = namei(&nd)) != 0)
1502 		goto out1;
1503 	vp = nd.ni_vp;
1504 
1505 	error = vn_access(vp, flags, tmpcred, td);
1506 	NDFREE(&nd, NDF_ONLY_PNBUF);
1507 	vput(vp);
1508 out1:
1509 	td->td_ucred = cred;
1510 	crfree(tmpcred);
1511 	return (error);
1512 }
1513 
1514 /*
1515  * Check access permissions using "effective" credentials.
1516  */
1517 #ifndef _SYS_SYSPROTO_H_
1518 struct eaccess_args {
1519 	char	*path;
1520 	int	flags;
1521 };
1522 #endif
1523 int
1524 eaccess(td, uap)
1525 	struct thread *td;
1526 	register struct eaccess_args /* {
1527 		char *path;
1528 		int flags;
1529 	} */ *uap;
1530 {
1531 	struct nameidata nd;
1532 	struct vnode *vp;
1533 	int error;
1534 
1535 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
1536 	    uap->path, td);
1537 	if ((error = namei(&nd)) != 0)
1538 		return (error);
1539 	vp = nd.ni_vp;
1540 
1541 	error = vn_access(vp, uap->flags, td->td_ucred, td);
1542 	NDFREE(&nd, NDF_ONLY_PNBUF);
1543 	vput(vp);
1544 	return (error);
1545 }
1546 
1547 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1548 /*
1549  * Get file status; this version follows links.
1550  */
1551 #ifndef _SYS_SYSPROTO_H_
1552 struct ostat_args {
1553 	char	*path;
1554 	struct ostat *ub;
1555 };
1556 #endif
1557 /* ARGSUSED */
1558 int
1559 ostat(td, uap)
1560 	struct thread *td;
1561 	register struct ostat_args /* {
1562 		char *path;
1563 		struct ostat *ub;
1564 	} */ *uap;
1565 {
1566 	struct stat sb;
1567 	struct ostat osb;
1568 	int error;
1569 	struct nameidata nd;
1570 
1571 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
1572 	    uap->path, td);
1573 	if ((error = namei(&nd)) != 0)
1574 		return (error);
1575 	NDFREE(&nd, NDF_ONLY_PNBUF);
1576 	error = vn_stat(nd.ni_vp, &sb, td->td_ucred, NOCRED, td);
1577 	vput(nd.ni_vp);
1578 	if (error)
1579 		return (error);
1580 	cvtstat(&sb, &osb);
1581 	error = copyout(&osb, uap->ub, sizeof (osb));
1582 	return (error);
1583 }
1584 
1585 /*
1586  * Get file status; this version does not follow links.
1587  */
1588 #ifndef _SYS_SYSPROTO_H_
1589 struct olstat_args {
1590 	char	*path;
1591 	struct ostat *ub;
1592 };
1593 #endif
1594 /* ARGSUSED */
1595 int
1596 olstat(td, uap)
1597 	struct thread *td;
1598 	register struct olstat_args /* {
1599 		char *path;
1600 		struct ostat *ub;
1601 	} */ *uap;
1602 {
1603 	struct vnode *vp;
1604 	struct stat sb;
1605 	struct ostat osb;
1606 	int error;
1607 	struct nameidata nd;
1608 
1609 	NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
1610 	    uap->path, td);
1611 	if ((error = namei(&nd)) != 0)
1612 		return (error);
1613 	vp = nd.ni_vp;
1614 	error = vn_stat(vp, &sb, td->td_ucred, NOCRED, td);
1615 	NDFREE(&nd, NDF_ONLY_PNBUF);
1616 	vput(vp);
1617 	if (error)
1618 		return (error);
1619 	cvtstat(&sb, &osb);
1620 	error = copyout(&osb, uap->ub, sizeof (osb));
1621 	return (error);
1622 }
1623 
1624 /*
1625  * Convert from an old to a new stat structure.
1626  */
1627 void
1628 cvtstat(st, ost)
1629 	struct stat *st;
1630 	struct ostat *ost;
1631 {
1632 
1633 	ost->st_dev = st->st_dev;
1634 	ost->st_ino = st->st_ino;
1635 	ost->st_mode = st->st_mode;
1636 	ost->st_nlink = st->st_nlink;
1637 	ost->st_uid = st->st_uid;
1638 	ost->st_gid = st->st_gid;
1639 	ost->st_rdev = st->st_rdev;
1640 	if (st->st_size < (quad_t)1 << 32)
1641 		ost->st_size = st->st_size;
1642 	else
1643 		ost->st_size = -2;
1644 	ost->st_atime = st->st_atime;
1645 	ost->st_mtime = st->st_mtime;
1646 	ost->st_ctime = st->st_ctime;
1647 	ost->st_blksize = st->st_blksize;
1648 	ost->st_blocks = st->st_blocks;
1649 	ost->st_flags = st->st_flags;
1650 	ost->st_gen = st->st_gen;
1651 }
1652 #endif /* COMPAT_43 || COMPAT_SUNOS */
1653 
1654 /*
1655  * Get file status; this version follows links.
1656  */
1657 #ifndef _SYS_SYSPROTO_H_
1658 struct stat_args {
1659 	char	*path;
1660 	struct stat *ub;
1661 };
1662 #endif
1663 /* ARGSUSED */
1664 int
1665 stat(td, uap)
1666 	struct thread *td;
1667 	register struct stat_args /* {
1668 		char *path;
1669 		struct stat *ub;
1670 	} */ *uap;
1671 {
1672 	struct stat sb;
1673 	int error;
1674 	struct nameidata nd;
1675 
1676 #ifdef LOOKUP_SHARED
1677 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF | NOOBJ,
1678 	    UIO_USERSPACE, uap->path, td);
1679 #else
1680 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
1681 	    uap->path, td);
1682 #endif
1683 	if ((error = namei(&nd)) != 0)
1684 		return (error);
1685 	error = vn_stat(nd.ni_vp, &sb, td->td_ucred, NOCRED, td);
1686 	NDFREE(&nd, NDF_ONLY_PNBUF);
1687 	vput(nd.ni_vp);
1688 	if (error)
1689 		return (error);
1690 	error = copyout(&sb, uap->ub, sizeof (sb));
1691 	return (error);
1692 }
1693 
1694 /*
1695  * Get file status; this version does not follow links.
1696  */
1697 #ifndef _SYS_SYSPROTO_H_
1698 struct lstat_args {
1699 	char	*path;
1700 	struct stat *ub;
1701 };
1702 #endif
1703 /* ARGSUSED */
1704 int
1705 lstat(td, uap)
1706 	struct thread *td;
1707 	register struct lstat_args /* {
1708 		char *path;
1709 		struct stat *ub;
1710 	} */ *uap;
1711 {
1712 	int error;
1713 	struct vnode *vp;
1714 	struct stat sb;
1715 	struct nameidata nd;
1716 
1717 	NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
1718 	    uap->path, td);
1719 	if ((error = namei(&nd)) != 0)
1720 		return (error);
1721 	vp = nd.ni_vp;
1722 	error = vn_stat(vp, &sb, td->td_ucred, NOCRED, td);
1723 	NDFREE(&nd, NDF_ONLY_PNBUF);
1724 	vput(vp);
1725 	if (error)
1726 		return (error);
1727 	error = copyout(&sb, uap->ub, sizeof (sb));
1728 	return (error);
1729 }
1730 
1731 /*
1732  * Implementation of the NetBSD stat() function.
1733  * XXX This should probably be collapsed with the FreeBSD version,
1734  * as the differences are only due to vn_stat() clearing spares at
1735  * the end of the structures.  vn_stat could be split to avoid this,
1736  * and thus collapse the following to close to zero code.
1737  */
1738 void
1739 cvtnstat(sb, nsb)
1740 	struct stat *sb;
1741 	struct nstat *nsb;
1742 {
1743 	bzero(nsb, sizeof *nsb);
1744 	nsb->st_dev = sb->st_dev;
1745 	nsb->st_ino = sb->st_ino;
1746 	nsb->st_mode = sb->st_mode;
1747 	nsb->st_nlink = sb->st_nlink;
1748 	nsb->st_uid = sb->st_uid;
1749 	nsb->st_gid = sb->st_gid;
1750 	nsb->st_rdev = sb->st_rdev;
1751 	nsb->st_atimespec = sb->st_atimespec;
1752 	nsb->st_mtimespec = sb->st_mtimespec;
1753 	nsb->st_ctimespec = sb->st_ctimespec;
1754 	nsb->st_size = sb->st_size;
1755 	nsb->st_blocks = sb->st_blocks;
1756 	nsb->st_blksize = sb->st_blksize;
1757 	nsb->st_flags = sb->st_flags;
1758 	nsb->st_gen = sb->st_gen;
1759 	nsb->st_birthtimespec = sb->st_birthtimespec;
1760 }
1761 
1762 #ifndef _SYS_SYSPROTO_H_
1763 struct nstat_args {
1764 	char	*path;
1765 	struct nstat *ub;
1766 };
1767 #endif
1768 /* ARGSUSED */
1769 int
1770 nstat(td, uap)
1771 	struct thread *td;
1772 	register struct nstat_args /* {
1773 		char *path;
1774 		struct nstat *ub;
1775 	} */ *uap;
1776 {
1777 	struct stat sb;
1778 	struct nstat nsb;
1779 	int error;
1780 	struct nameidata nd;
1781 
1782 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
1783 	    uap->path, td);
1784 	if ((error = namei(&nd)) != 0)
1785 		return (error);
1786 	NDFREE(&nd, NDF_ONLY_PNBUF);
1787 	error = vn_stat(nd.ni_vp, &sb, td->td_ucred, NOCRED, td);
1788 	vput(nd.ni_vp);
1789 	if (error)
1790 		return (error);
1791 	cvtnstat(&sb, &nsb);
1792 	error = copyout(&nsb, uap->ub, sizeof (nsb));
1793 	return (error);
1794 }
1795 
1796 /*
1797  * NetBSD lstat.  Get file status; this version does not follow links.
1798  */
1799 #ifndef _SYS_SYSPROTO_H_
1800 struct lstat_args {
1801 	char	*path;
1802 	struct stat *ub;
1803 };
1804 #endif
1805 /* ARGSUSED */
1806 int
1807 nlstat(td, uap)
1808 	struct thread *td;
1809 	register struct nlstat_args /* {
1810 		char *path;
1811 		struct nstat *ub;
1812 	} */ *uap;
1813 {
1814 	int error;
1815 	struct vnode *vp;
1816 	struct stat sb;
1817 	struct nstat nsb;
1818 	struct nameidata nd;
1819 
1820 	NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
1821 	    uap->path, td);
1822 	if ((error = namei(&nd)) != 0)
1823 		return (error);
1824 	vp = nd.ni_vp;
1825 	NDFREE(&nd, NDF_ONLY_PNBUF);
1826 	error = vn_stat(vp, &sb, td->td_ucred, NOCRED, td);
1827 	vput(vp);
1828 	if (error)
1829 		return (error);
1830 	cvtnstat(&sb, &nsb);
1831 	error = copyout(&nsb, uap->ub, sizeof (nsb));
1832 	return (error);
1833 }
1834 
1835 /*
1836  * Get configurable pathname variables.
1837  */
1838 #ifndef _SYS_SYSPROTO_H_
1839 struct pathconf_args {
1840 	char	*path;
1841 	int	name;
1842 };
1843 #endif
1844 /* ARGSUSED */
1845 int
1846 pathconf(td, uap)
1847 	struct thread *td;
1848 	register struct pathconf_args /* {
1849 		char *path;
1850 		int name;
1851 	} */ *uap;
1852 {
1853 	int error;
1854 	struct nameidata nd;
1855 
1856 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
1857 	    uap->path, td);
1858 	if ((error = namei(&nd)) != 0)
1859 		return (error);
1860 	NDFREE(&nd, NDF_ONLY_PNBUF);
1861 
1862 	/* If asynchronous I/O is available, it works for all files. */
1863 	if (uap->name == _PC_ASYNC_IO)
1864 		td->td_retval[0] = async_io_version;
1865 	else
1866 		error = VOP_PATHCONF(nd.ni_vp, uap->name, td->td_retval);
1867 	vput(nd.ni_vp);
1868 	return (error);
1869 }
1870 
1871 /*
1872  * Return target name of a symbolic link.
1873  */
1874 #ifndef _SYS_SYSPROTO_H_
1875 struct readlink_args {
1876 	char	*path;
1877 	char	*buf;
1878 	int	count;
1879 };
1880 #endif
1881 /* ARGSUSED */
1882 int
1883 readlink(td, uap)
1884 	struct thread *td;
1885 	register struct readlink_args /* {
1886 		char *path;
1887 		char *buf;
1888 		int count;
1889 	} */ *uap;
1890 {
1891 
1892 	return (kern_readlink(td, uap->path, UIO_USERSPACE, uap->buf,
1893 	    UIO_USERSPACE, uap->count));
1894 }
1895 
1896 int
1897 kern_readlink(struct thread *td, char *path, enum uio_seg pathseg, char *buf,
1898     enum uio_seg bufseg, int count)
1899 {
1900 	register struct vnode *vp;
1901 	struct iovec aiov;
1902 	struct uio auio;
1903 	int error;
1904 	struct nameidata nd;
1905 
1906 	NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, pathseg, path, td);
1907 	if ((error = namei(&nd)) != 0)
1908 		return (error);
1909 	NDFREE(&nd, NDF_ONLY_PNBUF);
1910 	vp = nd.ni_vp;
1911 #ifdef MAC
1912 	error = mac_check_vnode_readlink(td->td_ucred, vp);
1913 	if (error) {
1914 		vput(vp);
1915 		return (error);
1916 	}
1917 #endif
1918 	if (vp->v_type != VLNK)
1919 		error = EINVAL;
1920 	else {
1921 		aiov.iov_base = buf;
1922 		aiov.iov_len = count;
1923 		auio.uio_iov = &aiov;
1924 		auio.uio_iovcnt = 1;
1925 		auio.uio_offset = 0;
1926 		auio.uio_rw = UIO_READ;
1927 		auio.uio_segflg = bufseg;
1928 		auio.uio_td = td;
1929 		auio.uio_resid = count;
1930 		error = VOP_READLINK(vp, &auio, td->td_ucred);
1931 	}
1932 	vput(vp);
1933 	td->td_retval[0] = count - auio.uio_resid;
1934 	return (error);
1935 }
1936 
1937 /*
1938  * Common implementation code for chflags() and fchflags().
1939  */
1940 static int
1941 setfflags(td, vp, flags)
1942 	struct thread *td;
1943 	struct vnode *vp;
1944 	int flags;
1945 {
1946 	int error;
1947 	struct mount *mp;
1948 	struct vattr vattr;
1949 
1950 	/*
1951 	 * Prevent non-root users from setting flags on devices.  When
1952 	 * a device is reused, users can retain ownership of the device
1953 	 * if they are allowed to set flags and programs assume that
1954 	 * chown can't fail when done as root.
1955 	 */
1956 	if (vp->v_type == VCHR || vp->v_type == VBLK) {
1957 		error = suser_cred(td->td_ucred, PRISON_ROOT);
1958 		if (error)
1959 			return (error);
1960 	}
1961 
1962 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
1963 		return (error);
1964 	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
1965 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
1966 	VATTR_NULL(&vattr);
1967 	vattr.va_flags = flags;
1968 #ifdef MAC
1969 	error = mac_check_vnode_setflags(td->td_ucred, vp, vattr.va_flags);
1970 	if (error == 0)
1971 #endif
1972 		error = VOP_SETATTR(vp, &vattr, td->td_ucred, td);
1973 	VOP_UNLOCK(vp, 0, td);
1974 	vn_finished_write(mp);
1975 	return (error);
1976 }
1977 
1978 /*
1979  * Change flags of a file given a path name.
1980  */
1981 #ifndef _SYS_SYSPROTO_H_
1982 struct chflags_args {
1983 	char	*path;
1984 	int	flags;
1985 };
1986 #endif
1987 /* ARGSUSED */
1988 int
1989 chflags(td, uap)
1990 	struct thread *td;
1991 	register struct chflags_args /* {
1992 		char *path;
1993 		int flags;
1994 	} */ *uap;
1995 {
1996 	int error;
1997 	struct nameidata nd;
1998 
1999 	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
2000 	if ((error = namei(&nd)) != 0)
2001 		return (error);
2002 	NDFREE(&nd, NDF_ONLY_PNBUF);
2003 	error = setfflags(td, nd.ni_vp, uap->flags);
2004 	vrele(nd.ni_vp);
2005 	return error;
2006 }
2007 
2008 /*
2009  * Same as chflags() but doesn't follow symlinks.
2010  */
2011 int
2012 lchflags(td, uap)
2013 	struct thread *td;
2014 	register struct lchflags_args /* {
2015 		char *path;
2016 		int flags;
2017 	} */ *uap;
2018 {
2019 	int error;
2020 	struct nameidata nd;
2021 
2022 	NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->path, td);
2023 	if ((error = namei(&nd)) != 0)
2024 		return (error);
2025 	NDFREE(&nd, NDF_ONLY_PNBUF);
2026 	error = setfflags(td, nd.ni_vp, uap->flags);
2027 	vrele(nd.ni_vp);
2028 	return error;
2029 }
2030 
2031 /*
2032  * Change flags of a file given a file descriptor.
2033  */
2034 #ifndef _SYS_SYSPROTO_H_
2035 struct fchflags_args {
2036 	int	fd;
2037 	int	flags;
2038 };
2039 #endif
2040 /* ARGSUSED */
2041 int
2042 fchflags(td, uap)
2043 	struct thread *td;
2044 	register struct fchflags_args /* {
2045 		int fd;
2046 		int flags;
2047 	} */ *uap;
2048 {
2049 	struct file *fp;
2050 	int error;
2051 
2052 	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
2053 		return (error);
2054 	error = setfflags(td, fp->f_data, uap->flags);
2055 	fdrop(fp, td);
2056 	return (error);
2057 }
2058 
2059 /*
2060  * Common implementation code for chmod(), lchmod() and fchmod().
2061  */
2062 static int
2063 setfmode(td, vp, mode)
2064 	struct thread *td;
2065 	struct vnode *vp;
2066 	int mode;
2067 {
2068 	int error;
2069 	struct mount *mp;
2070 	struct vattr vattr;
2071 
2072 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
2073 		return (error);
2074 	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
2075 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
2076 	VATTR_NULL(&vattr);
2077 	vattr.va_mode = mode & ALLPERMS;
2078 #ifdef MAC
2079 	error = mac_check_vnode_setmode(td->td_ucred, vp, vattr.va_mode);
2080 	if (error == 0)
2081 #endif
2082 		error = VOP_SETATTR(vp, &vattr, td->td_ucred, td);
2083 	VOP_UNLOCK(vp, 0, td);
2084 	vn_finished_write(mp);
2085 	return error;
2086 }
2087 
2088 /*
2089  * Change mode of a file given path name.
2090  */
2091 #ifndef _SYS_SYSPROTO_H_
2092 struct chmod_args {
2093 	char	*path;
2094 	int	mode;
2095 };
2096 #endif
2097 /* ARGSUSED */
2098 int
2099 chmod(td, uap)
2100 	struct thread *td;
2101 	register struct chmod_args /* {
2102 		char *path;
2103 		int mode;
2104 	} */ *uap;
2105 {
2106 
2107 	return (kern_chmod(td, uap->path, UIO_USERSPACE, uap->mode));
2108 }
2109 
2110 int
2111 kern_chmod(struct thread *td, char *path, enum uio_seg pathseg, int mode)
2112 {
2113 	int error;
2114 	struct nameidata nd;
2115 
2116 	NDINIT(&nd, LOOKUP, FOLLOW, pathseg, path, td);
2117 	if ((error = namei(&nd)) != 0)
2118 		return (error);
2119 	NDFREE(&nd, NDF_ONLY_PNBUF);
2120 	error = setfmode(td, nd.ni_vp, mode);
2121 	vrele(nd.ni_vp);
2122 	return error;
2123 }
2124 
2125 /*
2126  * Change mode of a file given path name (don't follow links.)
2127  */
2128 #ifndef _SYS_SYSPROTO_H_
2129 struct lchmod_args {
2130 	char	*path;
2131 	int	mode;
2132 };
2133 #endif
2134 /* ARGSUSED */
2135 int
2136 lchmod(td, uap)
2137 	struct thread *td;
2138 	register struct lchmod_args /* {
2139 		char *path;
2140 		int mode;
2141 	} */ *uap;
2142 {
2143 	int error;
2144 	struct nameidata nd;
2145 
2146 	NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->path, td);
2147 	if ((error = namei(&nd)) != 0)
2148 		return (error);
2149 	NDFREE(&nd, NDF_ONLY_PNBUF);
2150 	error = setfmode(td, nd.ni_vp, uap->mode);
2151 	vrele(nd.ni_vp);
2152 	return error;
2153 }
2154 
2155 /*
2156  * Change mode of a file given a file descriptor.
2157  */
2158 #ifndef _SYS_SYSPROTO_H_
2159 struct fchmod_args {
2160 	int	fd;
2161 	int	mode;
2162 };
2163 #endif
2164 /* ARGSUSED */
2165 int
2166 fchmod(td, uap)
2167 	struct thread *td;
2168 	register struct fchmod_args /* {
2169 		int fd;
2170 		int mode;
2171 	} */ *uap;
2172 {
2173 	struct file *fp;
2174 	struct vnode *vp;
2175 	int error;
2176 
2177 	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
2178 		return (error);
2179 	vp = fp->f_data;
2180 	error = setfmode(td, fp->f_data, uap->mode);
2181 	fdrop(fp, td);
2182 	return (error);
2183 }
2184 
2185 /*
2186  * Common implementation for chown(), lchown(), and fchown()
2187  */
2188 static int
2189 setfown(td, vp, uid, gid)
2190 	struct thread *td;
2191 	struct vnode *vp;
2192 	uid_t uid;
2193 	gid_t gid;
2194 {
2195 	int error;
2196 	struct mount *mp;
2197 	struct vattr vattr;
2198 
2199 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
2200 		return (error);
2201 	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
2202 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
2203 	VATTR_NULL(&vattr);
2204 	vattr.va_uid = uid;
2205 	vattr.va_gid = gid;
2206 #ifdef MAC
2207 	error = mac_check_vnode_setowner(td->td_ucred, vp, vattr.va_uid,
2208 	    vattr.va_gid);
2209 	if (error == 0)
2210 #endif
2211 		error = VOP_SETATTR(vp, &vattr, td->td_ucred, td);
2212 	VOP_UNLOCK(vp, 0, td);
2213 	vn_finished_write(mp);
2214 	return error;
2215 }
2216 
2217 /*
2218  * Set ownership given a path name.
2219  */
2220 #ifndef _SYS_SYSPROTO_H_
2221 struct chown_args {
2222 	char	*path;
2223 	int	uid;
2224 	int	gid;
2225 };
2226 #endif
2227 /* ARGSUSED */
2228 int
2229 chown(td, uap)
2230 	struct thread *td;
2231 	register struct chown_args /* {
2232 		char *path;
2233 		int uid;
2234 		int gid;
2235 	} */ *uap;
2236 {
2237 
2238 	return (kern_chown(td, uap->path, UIO_USERSPACE, uap->uid, uap->gid));
2239 }
2240 
2241 int
2242 kern_chown(struct thread *td, char *path, enum uio_seg pathseg, int uid,
2243     int gid)
2244 {
2245 	int error;
2246 	struct nameidata nd;
2247 
2248 	NDINIT(&nd, LOOKUP, FOLLOW, pathseg, path, td);
2249 	if ((error = namei(&nd)) != 0)
2250 		return (error);
2251 	NDFREE(&nd, NDF_ONLY_PNBUF);
2252 	error = setfown(td, nd.ni_vp, uid, gid);
2253 	vrele(nd.ni_vp);
2254 	return (error);
2255 }
2256 
2257 /*
2258  * Set ownership given a path name, do not cross symlinks.
2259  */
2260 #ifndef _SYS_SYSPROTO_H_
2261 struct lchown_args {
2262 	char	*path;
2263 	int	uid;
2264 	int	gid;
2265 };
2266 #endif
2267 /* ARGSUSED */
2268 int
2269 lchown(td, uap)
2270 	struct thread *td;
2271 	register struct lchown_args /* {
2272 		char *path;
2273 		int uid;
2274 		int gid;
2275 	} */ *uap;
2276 {
2277 
2278 	return (kern_lchown(td, uap->path, UIO_USERSPACE, uap->uid, uap->gid));
2279 }
2280 
2281 int
2282 kern_lchown(struct thread *td, char *path, enum uio_seg pathseg, int uid,
2283     int gid)
2284 {
2285 	int error;
2286 	struct nameidata nd;
2287 
2288 	NDINIT(&nd, LOOKUP, NOFOLLOW, pathseg, path, td);
2289 	if ((error = namei(&nd)) != 0)
2290 		return (error);
2291 	NDFREE(&nd, NDF_ONLY_PNBUF);
2292 	error = setfown(td, nd.ni_vp, uid, gid);
2293 	vrele(nd.ni_vp);
2294 	return (error);
2295 }
2296 
2297 /*
2298  * Set ownership given a file descriptor.
2299  */
2300 #ifndef _SYS_SYSPROTO_H_
2301 struct fchown_args {
2302 	int	fd;
2303 	int	uid;
2304 	int	gid;
2305 };
2306 #endif
2307 /* ARGSUSED */
2308 int
2309 fchown(td, uap)
2310 	struct thread *td;
2311 	register struct fchown_args /* {
2312 		int fd;
2313 		int uid;
2314 		int gid;
2315 	} */ *uap;
2316 {
2317 	struct file *fp;
2318 	struct vnode *vp;
2319 	int error;
2320 
2321 	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
2322 		return (error);
2323 	vp = fp->f_data;
2324 	error = setfown(td, fp->f_data, uap->uid, uap->gid);
2325 	fdrop(fp, td);
2326 	return (error);
2327 }
2328 
2329 /*
2330  * Common implementation code for utimes(), lutimes(), and futimes().
2331  */
2332 static int
2333 getutimes(usrtvp, tvpseg, tsp)
2334 	const struct timeval *usrtvp;
2335 	enum uio_seg tvpseg;
2336 	struct timespec *tsp;
2337 {
2338 	struct timeval tv[2];
2339 	const struct timeval *tvp;
2340 	int error;
2341 
2342 	if (usrtvp == NULL) {
2343 		microtime(&tv[0]);
2344 		TIMEVAL_TO_TIMESPEC(&tv[0], &tsp[0]);
2345 		tsp[1] = tsp[0];
2346 	} else {
2347 		if (tvpseg == UIO_SYSSPACE) {
2348 			tvp = usrtvp;
2349 		} else {
2350 			if ((error = copyin(usrtvp, tv, sizeof(tv))) != 0)
2351 				return (error);
2352 			tvp = tv;
2353 		}
2354 
2355 		TIMEVAL_TO_TIMESPEC(&tvp[0], &tsp[0]);
2356 		TIMEVAL_TO_TIMESPEC(&tvp[1], &tsp[1]);
2357 	}
2358 	return 0;
2359 }
2360 
2361 /*
2362  * Common implementation code for utimes(), lutimes(), and futimes().
2363  */
2364 static int
2365 setutimes(td, vp, ts, numtimes, nullflag)
2366 	struct thread *td;
2367 	struct vnode *vp;
2368 	const struct timespec *ts;
2369 	int numtimes;
2370 	int nullflag;
2371 {
2372 	int error, setbirthtime;
2373 	struct mount *mp;
2374 	struct vattr vattr;
2375 
2376 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
2377 		return (error);
2378 	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
2379 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
2380 	setbirthtime = 0;
2381 	if (numtimes < 3 && VOP_GETATTR(vp, &vattr, td->td_ucred, td) == 0 &&
2382 	    timespeccmp(&ts[1], &vattr.va_birthtime, < ))
2383 		setbirthtime = 1;
2384 	VATTR_NULL(&vattr);
2385 	vattr.va_atime = ts[0];
2386 	vattr.va_mtime = ts[1];
2387 	if (setbirthtime)
2388 		vattr.va_birthtime = ts[1];
2389 	if (numtimes > 2)
2390 		vattr.va_birthtime = ts[2];
2391 	if (nullflag)
2392 		vattr.va_vaflags |= VA_UTIMES_NULL;
2393 #ifdef MAC
2394 	error = mac_check_vnode_setutimes(td->td_ucred, vp, vattr.va_atime,
2395 	    vattr.va_mtime);
2396 #endif
2397 	if (error == 0)
2398 		error = VOP_SETATTR(vp, &vattr, td->td_ucred, td);
2399 	VOP_UNLOCK(vp, 0, td);
2400 	vn_finished_write(mp);
2401 	return error;
2402 }
2403 
2404 /*
2405  * Set the access and modification times of a file.
2406  */
2407 #ifndef _SYS_SYSPROTO_H_
2408 struct utimes_args {
2409 	char	*path;
2410 	struct	timeval *tptr;
2411 };
2412 #endif
2413 /* ARGSUSED */
2414 int
2415 utimes(td, uap)
2416 	struct thread *td;
2417 	register struct utimes_args /* {
2418 		char *path;
2419 		struct timeval *tptr;
2420 	} */ *uap;
2421 {
2422 
2423 	return (kern_utimes(td, uap->path, UIO_USERSPACE, uap->tptr,
2424 	    UIO_USERSPACE));
2425 }
2426 
2427 int
2428 kern_utimes(struct thread *td, char *path, enum uio_seg pathseg,
2429     struct timeval *tptr, enum uio_seg tptrseg)
2430 {
2431 	struct timespec ts[2];
2432 	int error;
2433 	struct nameidata nd;
2434 
2435 	if ((error = getutimes(tptr, tptrseg, ts)) != 0)
2436 		return (error);
2437 	NDINIT(&nd, LOOKUP, FOLLOW, pathseg, path, td);
2438 	if ((error = namei(&nd)) != 0)
2439 		return (error);
2440 	NDFREE(&nd, NDF_ONLY_PNBUF);
2441 	error = setutimes(td, nd.ni_vp, ts, 2, tptr == NULL);
2442 	vrele(nd.ni_vp);
2443 	return (error);
2444 }
2445 
2446 /*
2447  * Set the access and modification times of a file.
2448  */
2449 #ifndef _SYS_SYSPROTO_H_
2450 struct lutimes_args {
2451 	char	*path;
2452 	struct	timeval *tptr;
2453 };
2454 #endif
2455 /* ARGSUSED */
2456 int
2457 lutimes(td, uap)
2458 	struct thread *td;
2459 	register struct lutimes_args /* {
2460 		char *path;
2461 		struct timeval *tptr;
2462 	} */ *uap;
2463 {
2464 
2465 	return (kern_lutimes(td, uap->path, UIO_USERSPACE, uap->tptr,
2466 	    UIO_USERSPACE));
2467 }
2468 
2469 int
2470 kern_lutimes(struct thread *td, char *path, enum uio_seg pathseg,
2471     struct timeval *tptr, enum uio_seg tptrseg)
2472 {
2473 	struct timespec ts[2];
2474 	int error;
2475 	struct nameidata nd;
2476 
2477 	if ((error = getutimes(tptr, tptrseg, ts)) != 0)
2478 		return (error);
2479 	NDINIT(&nd, LOOKUP, NOFOLLOW, pathseg, path, td);
2480 	if ((error = namei(&nd)) != 0)
2481 		return (error);
2482 	NDFREE(&nd, NDF_ONLY_PNBUF);
2483 	error = setutimes(td, nd.ni_vp, ts, 2, tptr == NULL);
2484 	vrele(nd.ni_vp);
2485 	return (error);
2486 }
2487 
2488 /*
2489  * Set the access and modification times of a file.
2490  */
2491 #ifndef _SYS_SYSPROTO_H_
2492 struct futimes_args {
2493 	int	fd;
2494 	struct	timeval *tptr;
2495 };
2496 #endif
2497 /* ARGSUSED */
2498 int
2499 futimes(td, uap)
2500 	struct thread *td;
2501 	register struct futimes_args /* {
2502 		int  fd;
2503 		struct timeval *tptr;
2504 	} */ *uap;
2505 {
2506 
2507 	return (kern_futimes(td, uap->fd, uap->tptr, UIO_USERSPACE));
2508 }
2509 
2510 int
2511 kern_futimes(struct thread *td, int fd, struct timeval *tptr,
2512     enum uio_seg tptrseg)
2513 {
2514 	struct timespec ts[2];
2515 	struct file *fp;
2516 	int error;
2517 
2518 	if ((error = getutimes(tptr, tptrseg, ts)) != 0)
2519 		return (error);
2520 	if ((error = getvnode(td->td_proc->p_fd, fd, &fp)) != 0)
2521 		return (error);
2522 	error = setutimes(td, fp->f_data, ts, 2, tptr == NULL);
2523 	fdrop(fp, td);
2524 	return (error);
2525 }
2526 
2527 /*
2528  * Truncate a file given its path name.
2529  */
2530 #ifndef _SYS_SYSPROTO_H_
2531 struct truncate_args {
2532 	char	*path;
2533 	int	pad;
2534 	off_t	length;
2535 };
2536 #endif
2537 /* ARGSUSED */
2538 int
2539 truncate(td, uap)
2540 	struct thread *td;
2541 	register struct truncate_args /* {
2542 		char *path;
2543 		int pad;
2544 		off_t length;
2545 	} */ *uap;
2546 {
2547 
2548 	return (kern_truncate(td, uap->path, UIO_USERSPACE, uap->length));
2549 }
2550 
2551 int
2552 kern_truncate(struct thread *td, char *path, enum uio_seg pathseg, off_t length)
2553 {
2554 	struct mount *mp;
2555 	struct vnode *vp;
2556 	struct vattr vattr;
2557 	int error;
2558 	struct nameidata nd;
2559 
2560 	if (length < 0)
2561 		return(EINVAL);
2562 	NDINIT(&nd, LOOKUP, FOLLOW, pathseg, path, td);
2563 	if ((error = namei(&nd)) != 0)
2564 		return (error);
2565 	vp = nd.ni_vp;
2566 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) {
2567 		vrele(vp);
2568 		return (error);
2569 	}
2570 	NDFREE(&nd, NDF_ONLY_PNBUF);
2571 	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
2572 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
2573 	if (vp->v_type == VDIR)
2574 		error = EISDIR;
2575 #ifdef MAC
2576 	else if ((error = mac_check_vnode_write(td->td_ucred, NOCRED, vp))) {
2577 	}
2578 #endif
2579 	else if ((error = vn_writechk(vp)) == 0 &&
2580 	    (error = VOP_ACCESS(vp, VWRITE, td->td_ucred, td)) == 0) {
2581 		VATTR_NULL(&vattr);
2582 		vattr.va_size = length;
2583 		error = VOP_SETATTR(vp, &vattr, td->td_ucred, td);
2584 	}
2585 	vput(vp);
2586 	vn_finished_write(mp);
2587 	return (error);
2588 }
2589 
2590 /*
2591  * Truncate a file given a file descriptor.
2592  */
2593 #ifndef _SYS_SYSPROTO_H_
2594 struct ftruncate_args {
2595 	int	fd;
2596 	int	pad;
2597 	off_t	length;
2598 };
2599 #endif
2600 /* ARGSUSED */
2601 int
2602 ftruncate(td, uap)
2603 	struct thread *td;
2604 	register struct ftruncate_args /* {
2605 		int fd;
2606 		int pad;
2607 		off_t length;
2608 	} */ *uap;
2609 {
2610 	struct mount *mp;
2611 	struct vattr vattr;
2612 	struct vnode *vp;
2613 	struct file *fp;
2614 	int error;
2615 
2616 	if (uap->length < 0)
2617 		return(EINVAL);
2618 	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
2619 		return (error);
2620 	if ((fp->f_flag & FWRITE) == 0) {
2621 		fdrop(fp, td);
2622 		return (EINVAL);
2623 	}
2624 	vp = fp->f_data;
2625 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) {
2626 		fdrop(fp, td);
2627 		return (error);
2628 	}
2629 	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
2630 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
2631 	if (vp->v_type == VDIR)
2632 		error = EISDIR;
2633 #ifdef MAC
2634 	else if ((error = mac_check_vnode_write(td->td_ucred, fp->f_cred,
2635 	    vp))) {
2636 	}
2637 #endif
2638 	else if ((error = vn_writechk(vp)) == 0) {
2639 		VATTR_NULL(&vattr);
2640 		vattr.va_size = uap->length;
2641 		error = VOP_SETATTR(vp, &vattr, fp->f_cred, td);
2642 	}
2643 	VOP_UNLOCK(vp, 0, td);
2644 	vn_finished_write(mp);
2645 	fdrop(fp, td);
2646 	return (error);
2647 }
2648 
2649 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
2650 /*
2651  * Truncate a file given its path name.
2652  */
2653 #ifndef _SYS_SYSPROTO_H_
2654 struct otruncate_args {
2655 	char	*path;
2656 	long	length;
2657 };
2658 #endif
2659 /* ARGSUSED */
2660 int
2661 otruncate(td, uap)
2662 	struct thread *td;
2663 	register struct otruncate_args /* {
2664 		char *path;
2665 		long length;
2666 	} */ *uap;
2667 {
2668 	struct truncate_args /* {
2669 		char *path;
2670 		int pad;
2671 		off_t length;
2672 	} */ nuap;
2673 
2674 	nuap.path = uap->path;
2675 	nuap.length = uap->length;
2676 	return (truncate(td, &nuap));
2677 }
2678 
2679 /*
2680  * Truncate a file given a file descriptor.
2681  */
2682 #ifndef _SYS_SYSPROTO_H_
2683 struct oftruncate_args {
2684 	int	fd;
2685 	long	length;
2686 };
2687 #endif
2688 /* ARGSUSED */
2689 int
2690 oftruncate(td, uap)
2691 	struct thread *td;
2692 	register struct oftruncate_args /* {
2693 		int fd;
2694 		long length;
2695 	} */ *uap;
2696 {
2697 	struct ftruncate_args /* {
2698 		int fd;
2699 		int pad;
2700 		off_t length;
2701 	} */ nuap;
2702 
2703 	nuap.fd = uap->fd;
2704 	nuap.length = uap->length;
2705 	return (ftruncate(td, &nuap));
2706 }
2707 #endif /* COMPAT_43 || COMPAT_SUNOS */
2708 
2709 /*
2710  * Sync an open file.
2711  */
2712 #ifndef _SYS_SYSPROTO_H_
2713 struct fsync_args {
2714 	int	fd;
2715 };
2716 #endif
2717 /* ARGSUSED */
2718 int
2719 fsync(td, uap)
2720 	struct thread *td;
2721 	struct fsync_args /* {
2722 		int fd;
2723 	} */ *uap;
2724 {
2725 	struct vnode *vp;
2726 	struct mount *mp;
2727 	struct file *fp;
2728 	vm_object_t obj;
2729 	int error;
2730 
2731 	GIANT_REQUIRED;
2732 
2733 	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
2734 		return (error);
2735 	vp = fp->f_data;
2736 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) {
2737 		fdrop(fp, td);
2738 		return (error);
2739 	}
2740 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
2741 	if (VOP_GETVOBJECT(vp, &obj) == 0) {
2742 		VM_OBJECT_LOCK(obj);
2743 		vm_object_page_clean(obj, 0, 0, 0);
2744 		VM_OBJECT_UNLOCK(obj);
2745 	}
2746 	error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, td);
2747 	if (error == 0 && vp->v_mount && (vp->v_mount->mnt_flag & MNT_SOFTDEP)
2748 	    && softdep_fsync_hook != NULL)
2749 		error = (*softdep_fsync_hook)(vp);
2750 
2751 	VOP_UNLOCK(vp, 0, td);
2752 	vn_finished_write(mp);
2753 	fdrop(fp, td);
2754 	return (error);
2755 }
2756 
2757 /*
2758  * Rename files.  Source and destination must either both be directories,
2759  * or both not be directories.  If target is a directory, it must be empty.
2760  */
2761 #ifndef _SYS_SYSPROTO_H_
2762 struct rename_args {
2763 	char	*from;
2764 	char	*to;
2765 };
2766 #endif
2767 /* ARGSUSED */
2768 int
2769 rename(td, uap)
2770 	struct thread *td;
2771 	register struct rename_args /* {
2772 		char *from;
2773 		char *to;
2774 	} */ *uap;
2775 {
2776 
2777 	return (kern_rename(td, uap->from, uap->to, UIO_USERSPACE));
2778 }
2779 
2780 int
2781 kern_rename(struct thread *td, char *from, char *to, enum uio_seg pathseg)
2782 {
2783 	struct mount *mp = NULL;
2784 	struct vnode *tvp, *fvp, *tdvp;
2785 	struct nameidata fromnd, tond;
2786 	int error;
2787 
2788 	bwillwrite();
2789 #ifdef MAC
2790 	NDINIT(&fromnd, DELETE, LOCKPARENT | LOCKLEAF | SAVESTART, pathseg,
2791 	    from, td);
2792 #else
2793 	NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, pathseg, from, td);
2794 #endif
2795 	if ((error = namei(&fromnd)) != 0)
2796 		return (error);
2797 #ifdef MAC
2798 	error = mac_check_vnode_rename_from(td->td_ucred, fromnd.ni_dvp,
2799 	    fromnd.ni_vp, &fromnd.ni_cnd);
2800 	VOP_UNLOCK(fromnd.ni_dvp, 0, td);
2801 	VOP_UNLOCK(fromnd.ni_vp, 0, td);
2802 #endif
2803 	fvp = fromnd.ni_vp;
2804 	if (error == 0)
2805 		error = vn_start_write(fvp, &mp, V_WAIT | PCATCH);
2806 	if (error != 0) {
2807 		NDFREE(&fromnd, NDF_ONLY_PNBUF);
2808 		vrele(fromnd.ni_dvp);
2809 		vrele(fvp);
2810 		goto out1;
2811 	}
2812 	NDINIT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART |
2813 	    NOOBJ, pathseg, to, td);
2814 	if (fromnd.ni_vp->v_type == VDIR)
2815 		tond.ni_cnd.cn_flags |= WILLBEDIR;
2816 	if ((error = namei(&tond)) != 0) {
2817 		/* Translate error code for rename("dir1", "dir2/."). */
2818 		if (error == EISDIR && fvp->v_type == VDIR)
2819 			error = EINVAL;
2820 		NDFREE(&fromnd, NDF_ONLY_PNBUF);
2821 		vrele(fromnd.ni_dvp);
2822 		vrele(fvp);
2823 		goto out1;
2824 	}
2825 	tdvp = tond.ni_dvp;
2826 	tvp = tond.ni_vp;
2827 	if (tvp != NULL) {
2828 		if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
2829 			error = ENOTDIR;
2830 			goto out;
2831 		} else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
2832 			error = EISDIR;
2833 			goto out;
2834 		}
2835 	}
2836 	if (fvp == tdvp)
2837 		error = EINVAL;
2838 	/*
2839 	 * If the source is the same as the destination (that is, if they
2840 	 * are links to the same vnode), then there is nothing to do.
2841 	 */
2842 	if (fvp == tvp)
2843 		error = -1;
2844 #ifdef MAC
2845 	else
2846 		error = mac_check_vnode_rename_to(td->td_ucred, tdvp,
2847 		    tond.ni_vp, fromnd.ni_dvp == tdvp, &tond.ni_cnd);
2848 #endif
2849 out:
2850 	if (!error) {
2851 		VOP_LEASE(tdvp, td, td->td_ucred, LEASE_WRITE);
2852 		if (fromnd.ni_dvp != tdvp) {
2853 			VOP_LEASE(fromnd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
2854 		}
2855 		if (tvp) {
2856 			VOP_LEASE(tvp, td, td->td_ucred, LEASE_WRITE);
2857 		}
2858 		error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
2859 				   tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
2860 		NDFREE(&fromnd, NDF_ONLY_PNBUF);
2861 		NDFREE(&tond, NDF_ONLY_PNBUF);
2862 	} else {
2863 		NDFREE(&fromnd, NDF_ONLY_PNBUF);
2864 		NDFREE(&tond, NDF_ONLY_PNBUF);
2865 		if (tdvp == tvp)
2866 			vrele(tdvp);
2867 		else
2868 			vput(tdvp);
2869 		if (tvp)
2870 			vput(tvp);
2871 		vrele(fromnd.ni_dvp);
2872 		vrele(fvp);
2873 	}
2874 	vrele(tond.ni_startdir);
2875 	ASSERT_VOP_UNLOCKED(fromnd.ni_dvp, "rename");
2876 	ASSERT_VOP_UNLOCKED(fromnd.ni_vp, "rename");
2877 	ASSERT_VOP_UNLOCKED(tond.ni_dvp, "rename");
2878 	ASSERT_VOP_UNLOCKED(tond.ni_vp, "rename");
2879 out1:
2880 	vn_finished_write(mp);
2881 	if (fromnd.ni_startdir)
2882 		vrele(fromnd.ni_startdir);
2883 	if (error == -1)
2884 		return (0);
2885 	return (error);
2886 }
2887 
2888 /*
2889  * Make a directory file.
2890  */
2891 #ifndef _SYS_SYSPROTO_H_
2892 struct mkdir_args {
2893 	char	*path;
2894 	int	mode;
2895 };
2896 #endif
2897 /* ARGSUSED */
2898 int
2899 mkdir(td, uap)
2900 	struct thread *td;
2901 	register struct mkdir_args /* {
2902 		char *path;
2903 		int mode;
2904 	} */ *uap;
2905 {
2906 
2907 	return (kern_mkdir(td, uap->path, UIO_USERSPACE, uap->mode));
2908 }
2909 
2910 int
2911 kern_mkdir(struct thread *td, char *path, enum uio_seg segflg, int mode)
2912 {
2913 	struct mount *mp;
2914 	struct vnode *vp;
2915 	struct vattr vattr;
2916 	int error;
2917 	struct nameidata nd;
2918 
2919 restart:
2920 	bwillwrite();
2921 	NDINIT(&nd, CREATE, LOCKPARENT | SAVENAME, segflg, path, td);
2922 	nd.ni_cnd.cn_flags |= WILLBEDIR;
2923 	if ((error = namei(&nd)) != 0)
2924 		return (error);
2925 	vp = nd.ni_vp;
2926 	if (vp != NULL) {
2927 		NDFREE(&nd, NDF_ONLY_PNBUF);
2928 		vrele(vp);
2929 		/*
2930 		 * XXX namei called with LOCKPARENT but not LOCKLEAF has
2931 		 * the strange behaviour of leaving the vnode unlocked
2932 		 * if the target is the same vnode as the parent.
2933 		 */
2934 		if (vp == nd.ni_dvp)
2935 			vrele(nd.ni_dvp);
2936 		else
2937 			vput(nd.ni_dvp);
2938 		return (EEXIST);
2939 	}
2940 	if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
2941 		NDFREE(&nd, NDF_ONLY_PNBUF);
2942 		vput(nd.ni_dvp);
2943 		if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
2944 			return (error);
2945 		goto restart;
2946 	}
2947 	VATTR_NULL(&vattr);
2948 	vattr.va_type = VDIR;
2949 	FILEDESC_LOCK(td->td_proc->p_fd);
2950 	vattr.va_mode = (mode & ACCESSPERMS) &~ td->td_proc->p_fd->fd_cmask;
2951 	FILEDESC_UNLOCK(td->td_proc->p_fd);
2952 #ifdef MAC
2953 	error = mac_check_vnode_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
2954 	    &vattr);
2955 	if (error)
2956 		goto out;
2957 #endif
2958 	VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
2959 	error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
2960 #ifdef MAC
2961 out:
2962 #endif
2963 	NDFREE(&nd, NDF_ONLY_PNBUF);
2964 	vput(nd.ni_dvp);
2965 	if (!error)
2966 		vput(nd.ni_vp);
2967 	vn_finished_write(mp);
2968 	ASSERT_VOP_UNLOCKED(nd.ni_dvp, "mkdir");
2969 	ASSERT_VOP_UNLOCKED(nd.ni_vp, "mkdir");
2970 	return (error);
2971 }
2972 
2973 /*
2974  * Remove a directory file.
2975  */
2976 #ifndef _SYS_SYSPROTO_H_
2977 struct rmdir_args {
2978 	char	*path;
2979 };
2980 #endif
2981 /* ARGSUSED */
2982 int
2983 rmdir(td, uap)
2984 	struct thread *td;
2985 	struct rmdir_args /* {
2986 		char *path;
2987 	} */ *uap;
2988 {
2989 
2990 	return (kern_rmdir(td, uap->path, UIO_USERSPACE));
2991 }
2992 
2993 int
2994 kern_rmdir(struct thread *td, char *path, enum uio_seg pathseg)
2995 {
2996 	struct mount *mp;
2997 	struct vnode *vp;
2998 	int error;
2999 	struct nameidata nd;
3000 
3001 restart:
3002 	bwillwrite();
3003 	NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, pathseg, path, td);
3004 	if ((error = namei(&nd)) != 0)
3005 		return (error);
3006 	vp = nd.ni_vp;
3007 	if (vp->v_type != VDIR) {
3008 		error = ENOTDIR;
3009 		goto out;
3010 	}
3011 	/*
3012 	 * No rmdir "." please.
3013 	 */
3014 	if (nd.ni_dvp == vp) {
3015 		error = EINVAL;
3016 		goto out;
3017 	}
3018 	/*
3019 	 * The root of a mounted filesystem cannot be deleted.
3020 	 */
3021 	if (vp->v_vflag & VV_ROOT) {
3022 		error = EBUSY;
3023 		goto out;
3024 	}
3025 #ifdef MAC
3026 	error = mac_check_vnode_delete(td->td_ucred, nd.ni_dvp, vp,
3027 	    &nd.ni_cnd);
3028 	if (error)
3029 		goto out;
3030 #endif
3031 	if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
3032 		NDFREE(&nd, NDF_ONLY_PNBUF);
3033 		if (nd.ni_dvp == vp)
3034 			vrele(nd.ni_dvp);
3035 		else
3036 			vput(nd.ni_dvp);
3037 		vput(vp);
3038 		if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
3039 			return (error);
3040 		goto restart;
3041 	}
3042 	VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
3043 	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
3044 	error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
3045 	vn_finished_write(mp);
3046 out:
3047 	NDFREE(&nd, NDF_ONLY_PNBUF);
3048 	if (nd.ni_dvp == vp)
3049 		vrele(nd.ni_dvp);
3050 	else
3051 		vput(nd.ni_dvp);
3052 	vput(vp);
3053 	ASSERT_VOP_UNLOCKED(nd.ni_dvp, "rmdir");
3054 	ASSERT_VOP_UNLOCKED(nd.ni_vp, "rmdir");
3055 	return (error);
3056 }
3057 
3058 #ifdef COMPAT_43
3059 /*
3060  * Read a block of directory entries in a filesystem independent format.
3061  */
3062 #ifndef _SYS_SYSPROTO_H_
3063 struct ogetdirentries_args {
3064 	int	fd;
3065 	char	*buf;
3066 	u_int	count;
3067 	long	*basep;
3068 };
3069 #endif
3070 int
3071 ogetdirentries(td, uap)
3072 	struct thread *td;
3073 	register struct ogetdirentries_args /* {
3074 		int fd;
3075 		char *buf;
3076 		u_int count;
3077 		long *basep;
3078 	} */ *uap;
3079 {
3080 	struct vnode *vp;
3081 	struct file *fp;
3082 	struct uio auio, kuio;
3083 	struct iovec aiov, kiov;
3084 	struct dirent *dp, *edp;
3085 	caddr_t dirbuf;
3086 	int error, eofflag, readcnt;
3087 	long loff;
3088 
3089 	/* XXX arbitrary sanity limit on `count'. */
3090 	if (uap->count > 64 * 1024)
3091 		return (EINVAL);
3092 	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
3093 		return (error);
3094 	if ((fp->f_flag & FREAD) == 0) {
3095 		fdrop(fp, td);
3096 		return (EBADF);
3097 	}
3098 	vp = fp->f_data;
3099 unionread:
3100 	if (vp->v_type != VDIR) {
3101 		fdrop(fp, td);
3102 		return (EINVAL);
3103 	}
3104 	aiov.iov_base = uap->buf;
3105 	aiov.iov_len = uap->count;
3106 	auio.uio_iov = &aiov;
3107 	auio.uio_iovcnt = 1;
3108 	auio.uio_rw = UIO_READ;
3109 	auio.uio_segflg = UIO_USERSPACE;
3110 	auio.uio_td = td;
3111 	auio.uio_resid = uap->count;
3112 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
3113 	loff = auio.uio_offset = fp->f_offset;
3114 #ifdef MAC
3115 	error = mac_check_vnode_readdir(td->td_ucred, vp);
3116 	if (error) {
3117 		VOP_UNLOCK(vp, 0, td);
3118 		fdrop(fp, td);
3119 		return (error);
3120 	}
3121 #endif
3122 #	if (BYTE_ORDER != LITTLE_ENDIAN)
3123 		if (vp->v_mount->mnt_maxsymlinklen <= 0) {
3124 			error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag,
3125 			    NULL, NULL);
3126 			fp->f_offset = auio.uio_offset;
3127 		} else
3128 #	endif
3129 	{
3130 		kuio = auio;
3131 		kuio.uio_iov = &kiov;
3132 		kuio.uio_segflg = UIO_SYSSPACE;
3133 		kiov.iov_len = uap->count;
3134 		MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK);
3135 		kiov.iov_base = dirbuf;
3136 		error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag,
3137 			    NULL, NULL);
3138 		fp->f_offset = kuio.uio_offset;
3139 		if (error == 0) {
3140 			readcnt = uap->count - kuio.uio_resid;
3141 			edp = (struct dirent *)&dirbuf[readcnt];
3142 			for (dp = (struct dirent *)dirbuf; dp < edp; ) {
3143 #				if (BYTE_ORDER == LITTLE_ENDIAN)
3144 					/*
3145 					 * The expected low byte of
3146 					 * dp->d_namlen is our dp->d_type.
3147 					 * The high MBZ byte of dp->d_namlen
3148 					 * is our dp->d_namlen.
3149 					 */
3150 					dp->d_type = dp->d_namlen;
3151 					dp->d_namlen = 0;
3152 #				else
3153 					/*
3154 					 * The dp->d_type is the high byte
3155 					 * of the expected dp->d_namlen,
3156 					 * so must be zero'ed.
3157 					 */
3158 					dp->d_type = 0;
3159 #				endif
3160 				if (dp->d_reclen > 0) {
3161 					dp = (struct dirent *)
3162 					    ((char *)dp + dp->d_reclen);
3163 				} else {
3164 					error = EIO;
3165 					break;
3166 				}
3167 			}
3168 			if (dp >= edp)
3169 				error = uiomove(dirbuf, readcnt, &auio);
3170 		}
3171 		FREE(dirbuf, M_TEMP);
3172 	}
3173 	VOP_UNLOCK(vp, 0, td);
3174 	if (error) {
3175 		fdrop(fp, td);
3176 		return (error);
3177 	}
3178 	if (uap->count == auio.uio_resid) {
3179 		if (union_dircheckp) {
3180 			error = union_dircheckp(td, &vp, fp);
3181 			if (error == -1)
3182 				goto unionread;
3183 			if (error) {
3184 				fdrop(fp, td);
3185 				return (error);
3186 			}
3187 		}
3188 		/*
3189 		 * XXX We could delay dropping the lock above but
3190 		 * union_dircheckp complicates things.
3191 		 */
3192 		vn_lock(vp, LK_EXCLUSIVE|LK_RETRY, td);
3193 		if ((vp->v_vflag & VV_ROOT) &&
3194 		    (vp->v_mount->mnt_flag & MNT_UNION)) {
3195 			struct vnode *tvp = vp;
3196 			vp = vp->v_mount->mnt_vnodecovered;
3197 			VREF(vp);
3198 			fp->f_data = vp;
3199 			fp->f_offset = 0;
3200 			vput(tvp);
3201 			goto unionread;
3202 		}
3203 		VOP_UNLOCK(vp, 0, td);
3204 	}
3205 	error = copyout(&loff, uap->basep, sizeof(long));
3206 	fdrop(fp, td);
3207 	td->td_retval[0] = uap->count - auio.uio_resid;
3208 	return (error);
3209 }
3210 #endif /* COMPAT_43 */
3211 
3212 /*
3213  * Read a block of directory entries in a filesystem independent format.
3214  */
3215 #ifndef _SYS_SYSPROTO_H_
3216 struct getdirentries_args {
3217 	int	fd;
3218 	char	*buf;
3219 	u_int	count;
3220 	long	*basep;
3221 };
3222 #endif
3223 int
3224 getdirentries(td, uap)
3225 	struct thread *td;
3226 	register struct getdirentries_args /* {
3227 		int fd;
3228 		char *buf;
3229 		u_int count;
3230 		long *basep;
3231 	} */ *uap;
3232 {
3233 	struct vnode *vp;
3234 	struct file *fp;
3235 	struct uio auio;
3236 	struct iovec aiov;
3237 	long loff;
3238 	int error, eofflag;
3239 
3240 	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
3241 		return (error);
3242 	if ((fp->f_flag & FREAD) == 0) {
3243 		fdrop(fp, td);
3244 		return (EBADF);
3245 	}
3246 	vp = fp->f_data;
3247 unionread:
3248 	if (vp->v_type != VDIR) {
3249 		fdrop(fp, td);
3250 		return (EINVAL);
3251 	}
3252 	aiov.iov_base = uap->buf;
3253 	aiov.iov_len = uap->count;
3254 	auio.uio_iov = &aiov;
3255 	auio.uio_iovcnt = 1;
3256 	auio.uio_rw = UIO_READ;
3257 	auio.uio_segflg = UIO_USERSPACE;
3258 	auio.uio_td = td;
3259 	auio.uio_resid = uap->count;
3260 	/* vn_lock(vp, LK_SHARED | LK_RETRY, td); */
3261 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
3262 	loff = auio.uio_offset = fp->f_offset;
3263 #ifdef MAC
3264 	error = mac_check_vnode_readdir(td->td_ucred, vp);
3265 	if (error == 0)
3266 #endif
3267 		error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, NULL,
3268 		    NULL);
3269 	fp->f_offset = auio.uio_offset;
3270 	VOP_UNLOCK(vp, 0, td);
3271 	if (error) {
3272 		fdrop(fp, td);
3273 		return (error);
3274 	}
3275 	if (uap->count == auio.uio_resid) {
3276 		if (union_dircheckp) {
3277 			error = union_dircheckp(td, &vp, fp);
3278 			if (error == -1)
3279 				goto unionread;
3280 			if (error) {
3281 				fdrop(fp, td);
3282 				return (error);
3283 			}
3284 		}
3285 		/*
3286 		 * XXX We could delay dropping the lock above but
3287 		 * union_dircheckp complicates things.
3288 		 */
3289 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
3290 		if ((vp->v_vflag & VV_ROOT) &&
3291 		    (vp->v_mount->mnt_flag & MNT_UNION)) {
3292 			struct vnode *tvp = vp;
3293 			vp = vp->v_mount->mnt_vnodecovered;
3294 			VREF(vp);
3295 			fp->f_data = vp;
3296 			fp->f_offset = 0;
3297 			vput(tvp);
3298 			goto unionread;
3299 		}
3300 		VOP_UNLOCK(vp, 0, td);
3301 	}
3302 	if (uap->basep != NULL) {
3303 		error = copyout(&loff, uap->basep, sizeof(long));
3304 	}
3305 	td->td_retval[0] = uap->count - auio.uio_resid;
3306 	fdrop(fp, td);
3307 	return (error);
3308 }
3309 #ifndef _SYS_SYSPROTO_H_
3310 struct getdents_args {
3311 	int fd;
3312 	char *buf;
3313 	size_t count;
3314 };
3315 #endif
3316 int
3317 getdents(td, uap)
3318 	struct thread *td;
3319 	register struct getdents_args /* {
3320 		int fd;
3321 		char *buf;
3322 		u_int count;
3323 	} */ *uap;
3324 {
3325 	struct getdirentries_args ap;
3326 	ap.fd = uap->fd;
3327 	ap.buf = uap->buf;
3328 	ap.count = uap->count;
3329 	ap.basep = NULL;
3330 	return getdirentries(td, &ap);
3331 }
3332 
3333 /*
3334  * Set the mode mask for creation of filesystem nodes.
3335  *
3336  * MP SAFE
3337  */
3338 #ifndef _SYS_SYSPROTO_H_
3339 struct umask_args {
3340 	int	newmask;
3341 };
3342 #endif
3343 int
3344 umask(td, uap)
3345 	struct thread *td;
3346 	struct umask_args /* {
3347 		int newmask;
3348 	} */ *uap;
3349 {
3350 	register struct filedesc *fdp;
3351 
3352 	FILEDESC_LOCK(td->td_proc->p_fd);
3353 	fdp = td->td_proc->p_fd;
3354 	td->td_retval[0] = fdp->fd_cmask;
3355 	fdp->fd_cmask = uap->newmask & ALLPERMS;
3356 	FILEDESC_UNLOCK(td->td_proc->p_fd);
3357 	return (0);
3358 }
3359 
3360 /*
3361  * Void all references to file by ripping underlying filesystem
3362  * away from vnode.
3363  */
3364 #ifndef _SYS_SYSPROTO_H_
3365 struct revoke_args {
3366 	char	*path;
3367 };
3368 #endif
3369 /* ARGSUSED */
3370 int
3371 revoke(td, uap)
3372 	struct thread *td;
3373 	register struct revoke_args /* {
3374 		char *path;
3375 	} */ *uap;
3376 {
3377 	struct mount *mp;
3378 	struct vnode *vp;
3379 	struct vattr vattr;
3380 	int error;
3381 	struct nameidata nd;
3382 
3383 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, td);
3384 	if ((error = namei(&nd)) != 0)
3385 		return (error);
3386 	vp = nd.ni_vp;
3387 	NDFREE(&nd, NDF_ONLY_PNBUF);
3388 	if (vp->v_type != VCHR) {
3389 		vput(vp);
3390 		return (EINVAL);
3391 	}
3392 #ifdef MAC
3393 	error = mac_check_vnode_revoke(td->td_ucred, vp);
3394 	if (error) {
3395 		vput(vp);
3396 		return (error);
3397 	}
3398 #endif
3399 	error = VOP_GETATTR(vp, &vattr, td->td_ucred, td);
3400 	if (error) {
3401 		vput(vp);
3402 		return (error);
3403 	}
3404 	VOP_UNLOCK(vp, 0, td);
3405 	if (td->td_ucred->cr_uid != vattr.va_uid) {
3406 		error = suser_cred(td->td_ucred, PRISON_ROOT);
3407 		if (error)
3408 			goto out;
3409 	}
3410 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
3411 		goto out;
3412 	if (vcount(vp) > 1)
3413 		VOP_REVOKE(vp, REVOKEALL);
3414 	vn_finished_write(mp);
3415 out:
3416 	vrele(vp);
3417 	return (error);
3418 }
3419 
3420 /*
3421  * Convert a user file descriptor to a kernel file entry.
3422  * The file entry is locked upon returning.
3423  */
3424 int
3425 getvnode(fdp, fd, fpp)
3426 	struct filedesc *fdp;
3427 	int fd;
3428 	struct file **fpp;
3429 {
3430 	int error;
3431 	struct file *fp;
3432 
3433 	fp = NULL;
3434 	if (fdp == NULL)
3435 		error = EBADF;
3436 	else {
3437 		FILEDESC_LOCK(fdp);
3438 		if ((u_int)fd >= fdp->fd_nfiles ||
3439 		    (fp = fdp->fd_ofiles[fd]) == NULL)
3440 			error = EBADF;
3441 		else if (fp->f_type != DTYPE_VNODE && fp->f_type != DTYPE_FIFO) {
3442 			fp = NULL;
3443 			error = EINVAL;
3444 		} else {
3445 			fhold(fp);
3446 			error = 0;
3447 		}
3448 		FILEDESC_UNLOCK(fdp);
3449 	}
3450 	*fpp = fp;
3451 	return (error);
3452 }
3453 /*
3454  * Get (NFS) file handle
3455  */
3456 #ifndef _SYS_SYSPROTO_H_
3457 struct getfh_args {
3458 	char	*fname;
3459 	fhandle_t *fhp;
3460 };
3461 #endif
3462 int
3463 getfh(td, uap)
3464 	struct thread *td;
3465 	register struct getfh_args *uap;
3466 {
3467 	struct nameidata nd;
3468 	fhandle_t fh;
3469 	register struct vnode *vp;
3470 	int error;
3471 
3472 	/*
3473 	 * Must be super user
3474 	 */
3475 	error = suser(td);
3476 	if (error)
3477 		return (error);
3478 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, td);
3479 	error = namei(&nd);
3480 	if (error)
3481 		return (error);
3482 	NDFREE(&nd, NDF_ONLY_PNBUF);
3483 	vp = nd.ni_vp;
3484 	bzero(&fh, sizeof(fh));
3485 	fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid;
3486 	error = VFS_VPTOFH(vp, &fh.fh_fid);
3487 	vput(vp);
3488 	if (error)
3489 		return (error);
3490 	error = copyout(&fh, uap->fhp, sizeof (fh));
3491 	return (error);
3492 }
3493 
3494 /*
3495  * syscall for the rpc.lockd to use to translate a NFS file handle into
3496  * an open descriptor.
3497  *
3498  * warning: do not remove the suser() call or this becomes one giant
3499  * security hole.
3500  */
3501 #ifndef _SYS_SYSPROTO_H_
3502 struct fhopen_args {
3503 	const struct fhandle *u_fhp;
3504 	int flags;
3505 };
3506 #endif
3507 int
3508 fhopen(td, uap)
3509 	struct thread *td;
3510 	struct fhopen_args /* {
3511 		const struct fhandle *u_fhp;
3512 		int flags;
3513 	} */ *uap;
3514 {
3515 	struct proc *p = td->td_proc;
3516 	struct mount *mp;
3517 	struct vnode *vp;
3518 	struct fhandle fhp;
3519 	struct vattr vat;
3520 	struct vattr *vap = &vat;
3521 	struct flock lf;
3522 	struct file *fp;
3523 	register struct filedesc *fdp = p->p_fd;
3524 	int fmode, mode, error, type;
3525 	struct file *nfp;
3526 	int indx;
3527 
3528 	/*
3529 	 * Must be super user
3530 	 */
3531 	error = suser(td);
3532 	if (error)
3533 		return (error);
3534 
3535 	fmode = FFLAGS(uap->flags);
3536 	/* why not allow a non-read/write open for our lockd? */
3537 	if (((fmode & (FREAD | FWRITE)) == 0) || (fmode & O_CREAT))
3538 		return (EINVAL);
3539 	error = copyin(uap->u_fhp, &fhp, sizeof(fhp));
3540 	if (error)
3541 		return(error);
3542 	/* find the mount point */
3543 	mp = vfs_getvfs(&fhp.fh_fsid);
3544 	if (mp == NULL)
3545 		return (ESTALE);
3546 	/* now give me my vnode, it gets returned to me locked */
3547 	error = VFS_FHTOVP(mp, &fhp.fh_fid, &vp);
3548 	if (error)
3549 		return (error);
3550  	/*
3551 	 * from now on we have to make sure not
3552 	 * to forget about the vnode
3553 	 * any error that causes an abort must vput(vp)
3554 	 * just set error = err and 'goto bad;'.
3555 	 */
3556 
3557 	/*
3558 	 * from vn_open
3559 	 */
3560 	if (vp->v_type == VLNK) {
3561 		error = EMLINK;
3562 		goto bad;
3563 	}
3564 	if (vp->v_type == VSOCK) {
3565 		error = EOPNOTSUPP;
3566 		goto bad;
3567 	}
3568 	mode = 0;
3569 	if (fmode & (FWRITE | O_TRUNC)) {
3570 		if (vp->v_type == VDIR) {
3571 			error = EISDIR;
3572 			goto bad;
3573 		}
3574 		error = vn_writechk(vp);
3575 		if (error)
3576 			goto bad;
3577 		mode |= VWRITE;
3578 	}
3579 	if (fmode & FREAD)
3580 		mode |= VREAD;
3581 	if (fmode & O_APPEND)
3582 		mode |= VAPPEND;
3583 #ifdef MAC
3584 	error = mac_check_vnode_open(td->td_ucred, vp, mode);
3585 	if (error)
3586 		goto bad;
3587 #endif
3588 	if (mode) {
3589 		error = VOP_ACCESS(vp, mode, td->td_ucred, td);
3590 		if (error)
3591 			goto bad;
3592 	}
3593 	if (fmode & O_TRUNC) {
3594 		VOP_UNLOCK(vp, 0, td);				/* XXX */
3595 		if ((error = vn_start_write(NULL, &mp, V_WAIT | PCATCH)) != 0) {
3596 			vrele(vp);
3597 			return (error);
3598 		}
3599 		VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
3600 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);	/* XXX */
3601 #ifdef MAC
3602 		/*
3603 		 * We don't yet have fp->f_cred, so use td->td_ucred, which
3604 		 * should be right.
3605 		 */
3606 		error = mac_check_vnode_write(td->td_ucred, td->td_ucred, vp);
3607 		if (error == 0) {
3608 #endif
3609 			VATTR_NULL(vap);
3610 			vap->va_size = 0;
3611 			error = VOP_SETATTR(vp, vap, td->td_ucred, td);
3612 #ifdef MAC
3613 		}
3614 #endif
3615 		vn_finished_write(mp);
3616 		if (error)
3617 			goto bad;
3618 	}
3619 	error = VOP_OPEN(vp, fmode, td->td_ucred, td);
3620 	if (error)
3621 		goto bad;
3622 	/*
3623 	 * Make sure that a VM object is created for VMIO support.
3624 	 */
3625 	if (vn_canvmio(vp) == TRUE) {
3626 		if ((error = vfs_object_create(vp, td, td->td_ucred)) != 0)
3627 			goto bad;
3628 	}
3629 	if (fmode & FWRITE)
3630 		vp->v_writecount++;
3631 
3632 	/*
3633 	 * end of vn_open code
3634 	 */
3635 
3636 	if ((error = falloc(td, &nfp, &indx)) != 0) {
3637 		if (fmode & FWRITE)
3638 			vp->v_writecount--;
3639 		goto bad;
3640 	}
3641 	fp = nfp;
3642 
3643 	/*
3644 	 * Hold an extra reference to avoid having fp ripped out
3645 	 * from under us while we block in the lock op
3646 	 */
3647 	fhold(fp);
3648 	nfp->f_data = vp;
3649 	nfp->f_flag = fmode & FMASK;
3650 	nfp->f_ops = &vnops;
3651 	nfp->f_type = DTYPE_VNODE;
3652 	if (fmode & (O_EXLOCK | O_SHLOCK)) {
3653 		lf.l_whence = SEEK_SET;
3654 		lf.l_start = 0;
3655 		lf.l_len = 0;
3656 		if (fmode & O_EXLOCK)
3657 			lf.l_type = F_WRLCK;
3658 		else
3659 			lf.l_type = F_RDLCK;
3660 		type = F_FLOCK;
3661 		if ((fmode & FNONBLOCK) == 0)
3662 			type |= F_WAIT;
3663 		VOP_UNLOCK(vp, 0, td);
3664 		if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf,
3665 			    type)) != 0) {
3666 			/*
3667 			 * The lock request failed.  Normally close the
3668 			 * descriptor but handle the case where someone might
3669 			 * have dup()d or close()d it when we weren't looking.
3670 			 */
3671 			FILEDESC_LOCK(fdp);
3672 			if (fdp->fd_ofiles[indx] == fp) {
3673 				fdp->fd_ofiles[indx] = NULL;
3674 				FILEDESC_UNLOCK(fdp);
3675 				fdrop(fp, td);
3676 			} else
3677 				FILEDESC_UNLOCK(fdp);
3678 			/*
3679 			 * release our private reference
3680 			 */
3681 			fdrop(fp, td);
3682 			return(error);
3683 		}
3684 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
3685 		fp->f_flag |= FHASLOCK;
3686 	}
3687 	if ((vp->v_type == VREG) && (VOP_GETVOBJECT(vp, NULL) != 0))
3688 		vfs_object_create(vp, td, td->td_ucred);
3689 
3690 	VOP_UNLOCK(vp, 0, td);
3691 	fdrop(fp, td);
3692 	td->td_retval[0] = indx;
3693 	return (0);
3694 
3695 bad:
3696 	vput(vp);
3697 	return (error);
3698 }
3699 
3700 /*
3701  * Stat an (NFS) file handle.
3702  */
3703 #ifndef _SYS_SYSPROTO_H_
3704 struct fhstat_args {
3705 	struct fhandle *u_fhp;
3706 	struct stat *sb;
3707 };
3708 #endif
3709 int
3710 fhstat(td, uap)
3711 	struct thread *td;
3712 	register struct fhstat_args /* {
3713 		struct fhandle *u_fhp;
3714 		struct stat *sb;
3715 	} */ *uap;
3716 {
3717 	struct stat sb;
3718 	fhandle_t fh;
3719 	struct mount *mp;
3720 	struct vnode *vp;
3721 	int error;
3722 
3723 	/*
3724 	 * Must be super user
3725 	 */
3726 	error = suser(td);
3727 	if (error)
3728 		return (error);
3729 
3730 	error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
3731 	if (error)
3732 		return (error);
3733 
3734 	if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
3735 		return (ESTALE);
3736 	if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp)))
3737 		return (error);
3738 	error = vn_stat(vp, &sb, td->td_ucred, NOCRED, td);
3739 	vput(vp);
3740 	if (error)
3741 		return (error);
3742 	error = copyout(&sb, uap->sb, sizeof(sb));
3743 	return (error);
3744 }
3745 
3746 /*
3747  * Implement fstatfs() for (NFS) file handles.
3748  */
3749 #ifndef _SYS_SYSPROTO_H_
3750 struct fhstatfs_args {
3751 	struct fhandle *u_fhp;
3752 	struct statfs *buf;
3753 };
3754 #endif
3755 int
3756 fhstatfs(td, uap)
3757 	struct thread *td;
3758 	struct fhstatfs_args /* {
3759 		struct fhandle *u_fhp;
3760 		struct statfs *buf;
3761 	} */ *uap;
3762 {
3763 	struct statfs *sp;
3764 	struct mount *mp;
3765 	struct vnode *vp;
3766 	struct statfs sb;
3767 	fhandle_t fh;
3768 	int error;
3769 
3770 	/*
3771 	 * Must be super user
3772 	 */
3773 	error = suser(td);
3774 	if (error)
3775 		return (error);
3776 
3777 	if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
3778 		return (error);
3779 
3780 	if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
3781 		return (ESTALE);
3782 	if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp)))
3783 		return (error);
3784 	mp = vp->v_mount;
3785 	sp = &mp->mnt_stat;
3786 	vput(vp);
3787 #ifdef MAC
3788 	error = mac_check_mount_stat(td->td_ucred, mp);
3789 	if (error)
3790 		return (error);
3791 #endif
3792 	if ((error = VFS_STATFS(mp, sp, td)) != 0)
3793 		return (error);
3794 	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
3795 	if (suser(td)) {
3796 		bcopy(sp, &sb, sizeof(sb));
3797 		sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
3798 		sp = &sb;
3799 	}
3800 	return (copyout(sp, uap->buf, sizeof(*sp)));
3801 }
3802 
3803 /*
3804  * Syscall to push extended attribute configuration information into the
3805  * VFS.  Accepts a path, which it converts to a mountpoint, as well as
3806  * a command (int cmd), and attribute name and misc data.  For now, the
3807  * attribute name is left in userspace for consumption by the VFS_op.
3808  * It will probably be changed to be copied into sysspace by the
3809  * syscall in the future, once issues with various consumers of the
3810  * attribute code have raised their hands.
3811  *
3812  * Currently this is used only by UFS Extended Attributes.
3813  */
3814 int
3815 extattrctl(td, uap)
3816 	struct thread *td;
3817 	struct extattrctl_args /* {
3818 		const char *path;
3819 		int cmd;
3820 		const char *filename;
3821 		int attrnamespace;
3822 		const char *attrname;
3823 	} */ *uap;
3824 {
3825 	struct vnode *filename_vp;
3826 	struct nameidata nd;
3827 	struct mount *mp, *mp_writable;
3828 	char attrname[EXTATTR_MAXNAMELEN];
3829 	int error;
3830 
3831 	/*
3832 	 * uap->attrname is not always defined.  We check again later when we
3833 	 * invoke the VFS call so as to pass in NULL there if needed.
3834 	 */
3835 	if (uap->attrname != NULL) {
3836 		error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN,
3837 		    NULL);
3838 		if (error)
3839 			return (error);
3840 	}
3841 
3842 	/*
3843 	 * uap->filename is not always defined.  If it is, grab a vnode lock,
3844 	 * which VFS_EXTATTRCTL() will later release.
3845 	 */
3846 	filename_vp = NULL;
3847 	if (uap->filename != NULL) {
3848 		NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
3849 		    uap->filename, td);
3850 		error = namei(&nd);
3851 		if (error)
3852 			return (error);
3853 		filename_vp = nd.ni_vp;
3854 		NDFREE(&nd, NDF_NO_VP_RELE | NDF_NO_VP_UNLOCK);
3855 	}
3856 
3857 	/* uap->path is always defined. */
3858 	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
3859 	error = namei(&nd);
3860 	if (error) {
3861 		if (filename_vp != NULL)
3862 			vput(filename_vp);
3863 		return (error);
3864 	}
3865 	mp = nd.ni_vp->v_mount;
3866 	error = vn_start_write(nd.ni_vp, &mp_writable, V_WAIT | PCATCH);
3867 	NDFREE(&nd, 0);
3868 	if (error) {
3869 		if (filename_vp != NULL)
3870 			vput(filename_vp);
3871 		return (error);
3872 	}
3873 
3874 	error = VFS_EXTATTRCTL(mp, uap->cmd, filename_vp, uap->attrnamespace,
3875 	    uap->attrname != NULL ? attrname : NULL, td);
3876 
3877 	vn_finished_write(mp_writable);
3878 	/*
3879 	 * VFS_EXTATTRCTL will have unlocked, but not de-ref'd,
3880 	 * filename_vp, so vrele it if it is defined.
3881 	 */
3882 	if (filename_vp != NULL)
3883 		vrele(filename_vp);
3884 	return (error);
3885 }
3886 
3887 /*-
3888  * Set a named extended attribute on a file or directory
3889  *
3890  * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace",
3891  *            kernelspace string pointer "attrname", userspace buffer
3892  *            pointer "data", buffer length "nbytes", thread "td".
3893  * Returns: 0 on success, an error number otherwise
3894  * Locks: none
3895  * References: vp must be a valid reference for the duration of the call
3896  */
3897 static int
3898 extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname,
3899     void *data, size_t nbytes, struct thread *td)
3900 {
3901 	struct mount *mp;
3902 	struct uio auio;
3903 	struct iovec aiov;
3904 	ssize_t cnt;
3905 	int error;
3906 
3907 	error = vn_start_write(vp, &mp, V_WAIT | PCATCH);
3908 	if (error)
3909 		return (error);
3910 	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
3911 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
3912 
3913 	aiov.iov_base = data;
3914 	aiov.iov_len = nbytes;
3915 	auio.uio_iov = &aiov;
3916 	auio.uio_iovcnt = 1;
3917 	auio.uio_offset = 0;
3918 	if (nbytes > INT_MAX) {
3919 		error = EINVAL;
3920 		goto done;
3921 	}
3922 	auio.uio_resid = nbytes;
3923 	auio.uio_rw = UIO_WRITE;
3924 	auio.uio_segflg = UIO_USERSPACE;
3925 	auio.uio_td = td;
3926 	cnt = nbytes;
3927 
3928 #ifdef MAC
3929 	error = mac_check_vnode_setextattr(td->td_ucred, vp, attrnamespace,
3930 	    attrname, &auio);
3931 	if (error)
3932 		goto done;
3933 #endif
3934 
3935 	error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio,
3936 	    td->td_ucred, td);
3937 	cnt -= auio.uio_resid;
3938 	td->td_retval[0] = cnt;
3939 
3940 done:
3941 	VOP_UNLOCK(vp, 0, td);
3942 	vn_finished_write(mp);
3943 	return (error);
3944 }
3945 
3946 int
3947 extattr_set_fd(td, uap)
3948 	struct thread *td;
3949 	struct extattr_set_fd_args /* {
3950 		int fd;
3951 		int attrnamespace;
3952 		const char *attrname;
3953 		void *data;
3954 		size_t nbytes;
3955 	} */ *uap;
3956 {
3957 	struct file *fp;
3958 	char attrname[EXTATTR_MAXNAMELEN];
3959 	int error;
3960 
3961 	error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN, NULL);
3962 	if (error)
3963 		return (error);
3964 
3965 	error = getvnode(td->td_proc->p_fd, uap->fd, &fp);
3966 	if (error)
3967 		return (error);
3968 
3969 	error = extattr_set_vp(fp->f_data, uap->attrnamespace,
3970 	    attrname, uap->data, uap->nbytes, td);
3971 	fdrop(fp, td);
3972 
3973 	return (error);
3974 }
3975 
3976 int
3977 extattr_set_file(td, uap)
3978 	struct thread *td;
3979 	struct extattr_set_file_args /* {
3980 		const char *path;
3981 		int attrnamespace;
3982 		const char *attrname;
3983 		void *data;
3984 		size_t nbytes;
3985 	} */ *uap;
3986 {
3987 	struct nameidata nd;
3988 	char attrname[EXTATTR_MAXNAMELEN];
3989 	int error;
3990 
3991 	error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN, NULL);
3992 	if (error)
3993 		return (error);
3994 
3995 	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
3996 	error = namei(&nd);
3997 	if (error)
3998 		return (error);
3999 	NDFREE(&nd, NDF_ONLY_PNBUF);
4000 
4001 	error = extattr_set_vp(nd.ni_vp, uap->attrnamespace, attrname,
4002 	    uap->data, uap->nbytes, td);
4003 
4004 	vrele(nd.ni_vp);
4005 	return (error);
4006 }
4007 
4008 int
4009 extattr_set_link(td, uap)
4010 	struct thread *td;
4011 	struct extattr_set_link_args /* {
4012 		const char *path;
4013 		int attrnamespace;
4014 		const char *attrname;
4015 		void *data;
4016 		size_t nbytes;
4017 	} */ *uap;
4018 {
4019 	struct nameidata nd;
4020 	char attrname[EXTATTR_MAXNAMELEN];
4021 	int error;
4022 
4023 	error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN, NULL);
4024 	if (error)
4025 		return (error);
4026 
4027 	NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->path, td);
4028 	error = namei(&nd);
4029 	if (error)
4030 		return (error);
4031 	NDFREE(&nd, NDF_ONLY_PNBUF);
4032 
4033 	error = extattr_set_vp(nd.ni_vp, uap->attrnamespace, attrname,
4034 	    uap->data, uap->nbytes, td);
4035 
4036 	vrele(nd.ni_vp);
4037 	return (error);
4038 }
4039 
4040 /*-
4041  * Get a named extended attribute on a file or directory
4042  *
4043  * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace",
4044  *            kernelspace string pointer "attrname", userspace buffer
4045  *            pointer "data", buffer length "nbytes", thread "td".
4046  * Returns: 0 on success, an error number otherwise
4047  * Locks: none
4048  * References: vp must be a valid reference for the duration of the call
4049  */
4050 static int
4051 extattr_get_vp(struct vnode *vp, int attrnamespace, const char *attrname,
4052     void *data, size_t nbytes, struct thread *td)
4053 {
4054 	struct uio auio, *auiop;
4055 	struct iovec aiov;
4056 	ssize_t cnt;
4057 	size_t size, *sizep;
4058 	int error;
4059 
4060 	VOP_LEASE(vp, td, td->td_ucred, LEASE_READ);
4061 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
4062 
4063 	/*
4064 	 * Slightly unusual semantics: if the user provides a NULL data
4065 	 * pointer, they don't want to receive the data, just the
4066 	 * maximum read length.
4067 	 */
4068 	auiop = NULL;
4069 	sizep = NULL;
4070 	cnt = 0;
4071 	if (data != NULL) {
4072 		aiov.iov_base = data;
4073 		aiov.iov_len = nbytes;
4074 		auio.uio_iov = &aiov;
4075 		auio.uio_offset = 0;
4076 		if (nbytes > INT_MAX) {
4077 			error = EINVAL;
4078 			goto done;
4079 		}
4080 		auio.uio_resid = nbytes;
4081 		auio.uio_rw = UIO_READ;
4082 		auio.uio_segflg = UIO_USERSPACE;
4083 		auio.uio_td = td;
4084 		auiop = &auio;
4085 		cnt = nbytes;
4086 	} else
4087 		sizep = &size;
4088 
4089 #ifdef MAC
4090 	error = mac_check_vnode_getextattr(td->td_ucred, vp, attrnamespace,
4091 	    attrname, &auio);
4092 	if (error)
4093 		goto done;
4094 #endif
4095 
4096 	error = VOP_GETEXTATTR(vp, attrnamespace, attrname, auiop, sizep,
4097 	    td->td_ucred, td);
4098 
4099 	if (auiop != NULL) {
4100 		cnt -= auio.uio_resid;
4101 		td->td_retval[0] = cnt;
4102 	} else
4103 		td->td_retval[0] = size;
4104 
4105 done:
4106 	VOP_UNLOCK(vp, 0, td);
4107 	return (error);
4108 }
4109 
4110 int
4111 extattr_get_fd(td, uap)
4112 	struct thread *td;
4113 	struct extattr_get_fd_args /* {
4114 		int fd;
4115 		int attrnamespace;
4116 		const char *attrname;
4117 		void *data;
4118 		size_t nbytes;
4119 	} */ *uap;
4120 {
4121 	struct file *fp;
4122 	char attrname[EXTATTR_MAXNAMELEN];
4123 	int error;
4124 
4125 	error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN, NULL);
4126 	if (error)
4127 		return (error);
4128 
4129 	error = getvnode(td->td_proc->p_fd, uap->fd, &fp);
4130 	if (error)
4131 		return (error);
4132 
4133 	error = extattr_get_vp(fp->f_data, uap->attrnamespace,
4134 	    attrname, uap->data, uap->nbytes, td);
4135 
4136 	fdrop(fp, td);
4137 	return (error);
4138 }
4139 
4140 int
4141 extattr_get_file(td, uap)
4142 	struct thread *td;
4143 	struct extattr_get_file_args /* {
4144 		const char *path;
4145 		int attrnamespace;
4146 		const char *attrname;
4147 		void *data;
4148 		size_t nbytes;
4149 	} */ *uap;
4150 {
4151 	struct nameidata nd;
4152 	char attrname[EXTATTR_MAXNAMELEN];
4153 	int error;
4154 
4155 	error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN, NULL);
4156 	if (error)
4157 		return (error);
4158 
4159 	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
4160 	error = namei(&nd);
4161 	if (error)
4162 		return (error);
4163 	NDFREE(&nd, NDF_ONLY_PNBUF);
4164 
4165 	error = extattr_get_vp(nd.ni_vp, uap->attrnamespace, attrname,
4166 	    uap->data, uap->nbytes, td);
4167 
4168 	vrele(nd.ni_vp);
4169 	return (error);
4170 }
4171 
4172 int
4173 extattr_get_link(td, uap)
4174 	struct thread *td;
4175 	struct extattr_get_link_args /* {
4176 		const char *path;
4177 		int attrnamespace;
4178 		const char *attrname;
4179 		void *data;
4180 		size_t nbytes;
4181 	} */ *uap;
4182 {
4183 	struct nameidata nd;
4184 	char attrname[EXTATTR_MAXNAMELEN];
4185 	int error;
4186 
4187 	error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN, NULL);
4188 	if (error)
4189 		return (error);
4190 
4191 	NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->path, td);
4192 	error = namei(&nd);
4193 	if (error)
4194 		return (error);
4195 	NDFREE(&nd, NDF_ONLY_PNBUF);
4196 
4197 	error = extattr_get_vp(nd.ni_vp, uap->attrnamespace, attrname,
4198 	    uap->data, uap->nbytes, td);
4199 
4200 	vrele(nd.ni_vp);
4201 	return (error);
4202 }
4203 
4204 /*
4205  * extattr_delete_vp(): Delete a named extended attribute on a file or
4206  *                      directory
4207  *
4208  * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace",
4209  *            kernelspace string pointer "attrname", proc "p"
4210  * Returns: 0 on success, an error number otherwise
4211  * Locks: none
4212  * References: vp must be a valid reference for the duration of the call
4213  */
4214 static int
4215 extattr_delete_vp(struct vnode *vp, int attrnamespace, const char *attrname,
4216     struct thread *td)
4217 {
4218 	struct mount *mp;
4219 	int error;
4220 
4221 	error = vn_start_write(vp, &mp, V_WAIT | PCATCH);
4222 	if (error)
4223 		return (error);
4224 	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
4225 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
4226 
4227 #ifdef MAC
4228 	error = mac_check_vnode_setextattr(td->td_ucred, vp, attrnamespace,
4229 	    attrname, NULL);
4230 	if (error)
4231 		goto done;
4232 #endif
4233 
4234 	error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL, td->td_ucred,
4235 	    td);
4236 #ifdef MAC
4237 done:
4238 #endif
4239 	VOP_UNLOCK(vp, 0, td);
4240 	vn_finished_write(mp);
4241 	return (error);
4242 }
4243 
4244 int
4245 extattr_delete_fd(td, uap)
4246 	struct thread *td;
4247 	struct extattr_delete_fd_args /* {
4248 		int fd;
4249 		int attrnamespace;
4250 		const char *attrname;
4251 	} */ *uap;
4252 {
4253 	struct file *fp;
4254 	struct vnode *vp;
4255 	char attrname[EXTATTR_MAXNAMELEN];
4256 	int error;
4257 
4258 	error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN, NULL);
4259 	if (error)
4260 		return (error);
4261 
4262 	error = getvnode(td->td_proc->p_fd, uap->fd, &fp);
4263 	if (error)
4264 		return (error);
4265 	vp = fp->f_data;
4266 
4267 	error = extattr_delete_vp(vp, uap->attrnamespace, attrname, td);
4268 	fdrop(fp, td);
4269 	return (error);
4270 }
4271 
4272 int
4273 extattr_delete_file(td, uap)
4274 	struct thread *td;
4275 	struct extattr_delete_file_args /* {
4276 		const char *path;
4277 		int attrnamespace;
4278 		const char *attrname;
4279 	} */ *uap;
4280 {
4281 	struct nameidata nd;
4282 	char attrname[EXTATTR_MAXNAMELEN];
4283 	int error;
4284 
4285 	error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN, NULL);
4286 	if (error)
4287 		return(error);
4288 
4289 	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
4290 	error = namei(&nd);
4291 	if (error)
4292 		return(error);
4293 	NDFREE(&nd, NDF_ONLY_PNBUF);
4294 
4295 	error = extattr_delete_vp(nd.ni_vp, uap->attrnamespace, attrname, td);
4296 	vrele(nd.ni_vp);
4297 	return(error);
4298 }
4299 
4300 int
4301 extattr_delete_link(td, uap)
4302 	struct thread *td;
4303 	struct extattr_delete_link_args /* {
4304 		const char *path;
4305 		int attrnamespace;
4306 		const char *attrname;
4307 	} */ *uap;
4308 {
4309 	struct nameidata nd;
4310 	char attrname[EXTATTR_MAXNAMELEN];
4311 	int error;
4312 
4313 	error = copyinstr(uap->attrname, attrname, EXTATTR_MAXNAMELEN, NULL);
4314 	if (error)
4315 		return(error);
4316 
4317 	NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->path, td);
4318 	error = namei(&nd);
4319 	if (error)
4320 		return(error);
4321 	NDFREE(&nd, NDF_ONLY_PNBUF);
4322 
4323 	error = extattr_delete_vp(nd.ni_vp, uap->attrnamespace, attrname, td);
4324 	vrele(nd.ni_vp);
4325 	return(error);
4326 }
4327