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