36c9a1d24c5fcd26667d4102c46b9634bbcd735b
[dragonfly.git] / sys / kern / vfs_syscalls.c
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: src/sys/kern/vfs_syscalls.c,v 1.151.2.18 2003/04/04 20:35:58 tegge Exp $
40  * $DragonFly: src/sys/kern/vfs_syscalls.c,v 1.134 2008/09/17 21:44:18 dillon Exp $
41  */
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/buf.h>
46 #include <sys/conf.h>
47 #include <sys/sysent.h>
48 #include <sys/malloc.h>
49 #include <sys/mount.h>
50 #include <sys/mountctl.h>
51 #include <sys/sysproto.h>
52 #include <sys/filedesc.h>
53 #include <sys/kernel.h>
54 #include <sys/fcntl.h>
55 #include <sys/file.h>
56 #include <sys/linker.h>
57 #include <sys/stat.h>
58 #include <sys/unistd.h>
59 #include <sys/vnode.h>
60 #include <sys/proc.h>
61 #include <sys/namei.h>
62 #include <sys/nlookup.h>
63 #include <sys/dirent.h>
64 #include <sys/extattr.h>
65 #include <sys/spinlock.h>
66 #include <sys/kern_syscall.h>
67 #include <sys/objcache.h>
68 #include <sys/sysctl.h>
69
70 #include <sys/buf2.h>
71 #include <sys/file2.h>
72 #include <sys/spinlock2.h>
73
74 #include <vm/vm.h>
75 #include <vm/vm_object.h>
76 #include <vm/vm_page.h>
77
78 #include <machine/limits.h>
79 #include <machine/stdarg.h>
80
81 #include <vfs/union/union.h>
82
83 static void mount_warning(struct mount *mp, const char *ctl, ...);
84 static int mount_path(struct proc *p, struct mount *mp, char **rb, char **fb);
85 static int checkvp_chdir (struct vnode *vn, struct thread *td);
86 static void checkdirs (struct nchandle *old_nch, struct nchandle *new_nch);
87 static int chroot_refuse_vdir_fds (struct filedesc *fdp);
88 static int chroot_visible_mnt(struct mount *mp, struct proc *p);
89 static int getutimes (const struct timeval *, struct timespec *);
90 static int setfown (struct vnode *, uid_t, gid_t);
91 static int setfmode (struct vnode *, int);
92 static int setfflags (struct vnode *, int);
93 static int setutimes (struct vnode *, const struct timespec *, int);
94 static int      usermount = 0;  /* if 1, non-root can mount fs. */
95
96 int (*union_dircheckp) (struct thread *, struct vnode **, struct file *);
97
98 SYSCTL_INT(_vfs, OID_AUTO, usermount, CTLFLAG_RW, &usermount, 0, "");
99
100 /*
101  * Virtual File System System Calls
102  */
103
104 /*
105  * Mount a file system.
106  */
107 /*
108  * mount_args(char *type, char *path, int flags, caddr_t data)
109  */
110 /* ARGSUSED */
111 int
112 sys_mount(struct mount_args *uap)
113 {
114         struct thread *td = curthread;
115         struct proc *p = td->td_proc;
116         struct vnode *vp;
117         struct nchandle nch;
118         struct mount *mp;
119         struct vfsconf *vfsp;
120         int error, flag = 0, flag2 = 0;
121         int hasmount;
122         struct vattr va;
123         struct nlookupdata nd;
124         char fstypename[MFSNAMELEN];
125         struct ucred *cred = p->p_ucred;
126
127         KKASSERT(p);
128         if (cred->cr_prison != NULL)
129                 return (EPERM);
130         if (usermount == 0 && (error = suser(td)))
131                 return (error);
132         /*
133          * Do not allow NFS export by non-root users.
134          */
135         if (uap->flags & MNT_EXPORTED) {
136                 error = suser(td);
137                 if (error)
138                         return (error);
139         }
140         /*
141          * Silently enforce MNT_NOSUID and MNT_NODEV for non-root users
142          */
143         if (suser(td)) 
144                 uap->flags |= MNT_NOSUID | MNT_NODEV;
145
146         /*
147          * Lookup the requested path and extract the nch and vnode.
148          */
149         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
150         if (error == 0) {
151                 if ((error = nlookup(&nd)) == 0) {
152                         if (nd.nl_nch.ncp->nc_vp == NULL)
153                                 error = ENOENT;
154                 }
155         }
156         if (error) {
157                 nlookup_done(&nd);
158                 return (error);
159         }
160
161         /*
162          * Extract the locked+refd ncp and cleanup the nd structure
163          */
164         nch = nd.nl_nch;
165         cache_zero(&nd.nl_nch);
166         nlookup_done(&nd);
167
168         if ((nch.ncp->nc_flag & NCF_ISMOUNTPT) && cache_findmount(&nch))
169                 hasmount = 1;
170         else
171                 hasmount = 0;
172
173
174         /*
175          * now we have the locked ref'd nch and unreferenced vnode.
176          */
177         vp = nch.ncp->nc_vp;
178         if ((error = vget(vp, LK_EXCLUSIVE)) != 0) {
179                 cache_put(&nch);
180                 return (error);
181         }
182         cache_unlock(&nch);
183
184         /*
185          * Now we have an unlocked ref'd nch and a locked ref'd vp
186          */
187         if (uap->flags & MNT_UPDATE) {
188                 if ((vp->v_flag & (VROOT|VPFSROOT)) == 0) {
189                         cache_drop(&nch);
190                         vput(vp);
191                         return (EINVAL);
192                 }
193                 mp = vp->v_mount;
194                 flag = mp->mnt_flag;
195                 flag2 = mp->mnt_kern_flag;
196                 /*
197                  * We only allow the filesystem to be reloaded if it
198                  * is currently mounted read-only.
199                  */
200                 if ((uap->flags & MNT_RELOAD) &&
201                     ((mp->mnt_flag & MNT_RDONLY) == 0)) {
202                         cache_drop(&nch);
203                         vput(vp);
204                         return (EOPNOTSUPP);    /* Needs translation */
205                 }
206                 /*
207                  * Only root, or the user that did the original mount is
208                  * permitted to update it.
209                  */
210                 if (mp->mnt_stat.f_owner != cred->cr_uid &&
211                     (error = suser(td))) {
212                         cache_drop(&nch);
213                         vput(vp);
214                         return (error);
215                 }
216                 if (vfs_busy(mp, LK_NOWAIT)) {
217                         cache_drop(&nch);
218                         vput(vp);
219                         return (EBUSY);
220                 }
221                 if ((vp->v_flag & VMOUNT) != 0 || hasmount) {
222                         cache_drop(&nch);
223                         vfs_unbusy(mp);
224                         vput(vp);
225                         return (EBUSY);
226                 }
227                 vp->v_flag |= VMOUNT;
228                 mp->mnt_flag |=
229                     uap->flags & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE);
230                 vn_unlock(vp);
231                 goto update;
232         }
233         /*
234          * If the user is not root, ensure that they own the directory
235          * onto which we are attempting to mount.
236          */
237         if ((error = VOP_GETATTR(vp, &va)) ||
238             (va.va_uid != cred->cr_uid && (error = suser(td)))) {
239                 cache_drop(&nch);
240                 vput(vp);
241                 return (error);
242         }
243         if ((error = vinvalbuf(vp, V_SAVE, 0, 0)) != 0) {
244                 cache_drop(&nch);
245                 vput(vp);
246                 return (error);
247         }
248         if (vp->v_type != VDIR) {
249                 cache_drop(&nch);
250                 vput(vp);
251                 return (ENOTDIR);
252         }
253         if (vp->v_mount->mnt_kern_flag & MNTK_NOSTKMNT) {
254                 cache_drop(&nch);
255                 vput(vp);
256                 return (EPERM);
257         }
258         if ((error = copyinstr(uap->type, fstypename, MFSNAMELEN, NULL)) != 0) {
259                 cache_drop(&nch);
260                 vput(vp);
261                 return (error);
262         }
263         for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
264                 if (!strcmp(vfsp->vfc_name, fstypename))
265                         break;
266         }
267         if (vfsp == NULL) {
268                 linker_file_t lf;
269
270                 /* Only load modules for root (very important!) */
271                 if ((error = suser(td)) != 0) {
272                         cache_drop(&nch);
273                         vput(vp);
274                         return error;
275                 }
276                 error = linker_load_file(fstypename, &lf);
277                 if (error || lf == NULL) {
278                         cache_drop(&nch);
279                         vput(vp);
280                         if (lf == NULL)
281                                 error = ENODEV;
282                         return error;
283                 }
284                 lf->userrefs++;
285                 /* lookup again, see if the VFS was loaded */
286                 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
287                         if (!strcmp(vfsp->vfc_name, fstypename))
288                                 break;
289                 }
290                 if (vfsp == NULL) {
291                         lf->userrefs--;
292                         linker_file_unload(lf);
293                         cache_drop(&nch);
294                         vput(vp);
295                         return (ENODEV);
296                 }
297         }
298         if ((vp->v_flag & VMOUNT) != 0 || hasmount) {
299                 cache_drop(&nch);
300                 vput(vp);
301                 return (EBUSY);
302         }
303         vp->v_flag |= VMOUNT;
304
305         /*
306          * Allocate and initialize the filesystem.
307          */
308         mp = kmalloc(sizeof(struct mount), M_MOUNT, M_ZERO|M_WAITOK);
309         TAILQ_INIT(&mp->mnt_nvnodelist);
310         TAILQ_INIT(&mp->mnt_reservedvnlist);
311         TAILQ_INIT(&mp->mnt_jlist);
312         mp->mnt_nvnodelistsize = 0;
313         lockinit(&mp->mnt_lock, "vfslock", 0, 0);
314         vfs_busy(mp, LK_NOWAIT);
315         mp->mnt_op = vfsp->vfc_vfsops;
316         mp->mnt_vfc = vfsp;
317         vfsp->vfc_refcount++;
318         mp->mnt_stat.f_type = vfsp->vfc_typenum;
319         mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
320         strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
321         mp->mnt_stat.f_owner = cred->cr_uid;
322         mp->mnt_iosize_max = DFLTPHYS;
323         vn_unlock(vp);
324 update:
325         /*
326          * Set the mount level flags.
327          */
328         if (uap->flags & MNT_RDONLY)
329                 mp->mnt_flag |= MNT_RDONLY;
330         else if (mp->mnt_flag & MNT_RDONLY)
331                 mp->mnt_kern_flag |= MNTK_WANTRDWR;
332         mp->mnt_flag &=~ (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV |
333             MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC | MNT_NOATIME |
334             MNT_NOSYMFOLLOW | MNT_IGNORE |
335             MNT_NOCLUSTERR | MNT_NOCLUSTERW | MNT_SUIDDIR);
336         mp->mnt_flag |= uap->flags & (MNT_NOSUID | MNT_NOEXEC |
337             MNT_NODEV | MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC | MNT_FORCE |
338             MNT_NOSYMFOLLOW | MNT_IGNORE |
339             MNT_NOATIME | MNT_NOCLUSTERR | MNT_NOCLUSTERW | MNT_SUIDDIR);
340         /*
341          * Mount the filesystem.
342          * XXX The final recipients of VFS_MOUNT just overwrite the ndp they
343          * get. 
344          */
345         error = VFS_MOUNT(mp, uap->path, uap->data, cred);
346         if (mp->mnt_flag & MNT_UPDATE) {
347                 if (mp->mnt_kern_flag & MNTK_WANTRDWR)
348                         mp->mnt_flag &= ~MNT_RDONLY;
349                 mp->mnt_flag &=~ (MNT_UPDATE | MNT_RELOAD | MNT_FORCE);
350                 mp->mnt_kern_flag &=~ MNTK_WANTRDWR;
351                 if (error) {
352                         mp->mnt_flag = flag;
353                         mp->mnt_kern_flag = flag2;
354                 }
355                 vfs_unbusy(mp);
356                 vp->v_flag &= ~VMOUNT;
357                 vrele(vp);
358                 cache_drop(&nch);
359                 return (error);
360         }
361         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
362         /*
363          * Put the new filesystem on the mount list after root.  The mount
364          * point gets its own mnt_ncmountpt (unless the VFS already set one
365          * up) which represents the root of the mount.  The lookup code
366          * detects the mount point going forward and checks the root of
367          * the mount going backwards.
368          *
369          * It is not necessary to invalidate or purge the vnode underneath
370          * because elements under the mount will be given their own glue
371          * namecache record.
372          */
373         if (!error) {
374                 if (mp->mnt_ncmountpt.ncp == NULL) {
375                         /* 
376                          * allocate, then unlock, but leave the ref intact 
377                          */
378                         cache_allocroot(&mp->mnt_ncmountpt, mp, NULL);
379                         cache_unlock(&mp->mnt_ncmountpt);
380                 }
381                 mp->mnt_ncmounton = nch;                /* inherits ref */
382                 nch.ncp->nc_flag |= NCF_ISMOUNTPT;
383
384                 /* XXX get the root of the fs and cache_setvp(mnt_ncmountpt...) */
385                 vp->v_flag &= ~VMOUNT;
386                 mountlist_insert(mp, MNTINS_LAST);
387                 checkdirs(&mp->mnt_ncmounton, &mp->mnt_ncmountpt);
388                 vn_unlock(vp);
389                 error = vfs_allocate_syncvnode(mp);
390                 vfs_unbusy(mp);
391                 error = VFS_START(mp, 0);
392                 vrele(vp);
393         } else {
394                 vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_coherency_ops);
395                 vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_journal_ops);
396                 vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_norm_ops);
397                 vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_spec_ops);
398                 vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_fifo_ops);
399                 vp->v_flag &= ~VMOUNT;
400                 mp->mnt_vfc->vfc_refcount--;
401                 vfs_unbusy(mp);
402                 kfree(mp, M_MOUNT);
403                 cache_drop(&nch);
404                 vput(vp);
405         }
406         return (error);
407 }
408
409 /*
410  * Scan all active processes to see if any of them have a current
411  * or root directory onto which the new filesystem has just been
412  * mounted. If so, replace them with the new mount point.
413  *
414  * The passed ncp is ref'd and locked (from the mount code) and
415  * must be associated with the vnode representing the root of the
416  * mount point.
417  */
418 struct checkdirs_info {
419         struct nchandle old_nch;
420         struct nchandle new_nch;
421         struct vnode *old_vp;
422         struct vnode *new_vp;
423 };
424
425 static int checkdirs_callback(struct proc *p, void *data);
426
427 static void
428 checkdirs(struct nchandle *old_nch, struct nchandle *new_nch)
429 {
430         struct checkdirs_info info;
431         struct vnode *olddp;
432         struct vnode *newdp;
433         struct mount *mp;
434
435         /*
436          * If the old mount point's vnode has a usecount of 1, it is not
437          * being held as a descriptor anywhere.
438          */
439         olddp = old_nch->ncp->nc_vp;
440         if (olddp == NULL || olddp->v_sysref.refcnt == 1)
441                 return;
442
443         /*
444          * Force the root vnode of the new mount point to be resolved
445          * so we can update any matching processes.
446          */
447         mp = new_nch->mount;
448         if (VFS_ROOT(mp, &newdp))
449                 panic("mount: lost mount");
450         cache_setunresolved(new_nch);
451         cache_setvp(new_nch, newdp);
452
453         /*
454          * Special handling of the root node
455          */
456         if (rootvnode == olddp) {
457                 vref(newdp);
458                 vfs_cache_setroot(newdp, cache_hold(new_nch));
459         }
460
461         /*
462          * Pass newdp separately so the callback does not have to access
463          * it via new_nch->ncp->nc_vp.
464          */
465         info.old_nch = *old_nch;
466         info.new_nch = *new_nch;
467         info.new_vp = newdp;
468         allproc_scan(checkdirs_callback, &info);
469         vput(newdp);
470 }
471
472 /*
473  * NOTE: callback is not MP safe because the scanned process's filedesc
474  * structure can be ripped out from under us, amoung other things.
475  */
476 static int
477 checkdirs_callback(struct proc *p, void *data)
478 {
479         struct checkdirs_info *info = data;
480         struct filedesc *fdp;
481         struct nchandle ncdrop1;
482         struct nchandle ncdrop2;
483         struct vnode *vprele1;
484         struct vnode *vprele2;
485
486         if ((fdp = p->p_fd) != NULL) {
487                 cache_zero(&ncdrop1);
488                 cache_zero(&ncdrop2);
489                 vprele1 = NULL;
490                 vprele2 = NULL;
491
492                 /*
493                  * MPUNSAFE - XXX fdp can be pulled out from under a
494                  * foreign process.
495                  *
496                  * A shared filedesc is ok, we don't have to copy it
497                  * because we are making this change globally.
498                  */
499                 spin_lock_wr(&fdp->fd_spin);
500                 if (fdp->fd_ncdir.mount == info->old_nch.mount &&
501                     fdp->fd_ncdir.ncp == info->old_nch.ncp) {
502                         vprele1 = fdp->fd_cdir;
503                         vref(info->new_vp);
504                         fdp->fd_cdir = info->new_vp;
505                         ncdrop1 = fdp->fd_ncdir;
506                         cache_copy(&info->new_nch, &fdp->fd_ncdir);
507                 }
508                 if (fdp->fd_nrdir.mount == info->old_nch.mount &&
509                     fdp->fd_nrdir.ncp == info->old_nch.ncp) {
510                         vprele2 = fdp->fd_rdir;
511                         vref(info->new_vp);
512                         fdp->fd_rdir = info->new_vp;
513                         ncdrop2 = fdp->fd_nrdir;
514                         cache_copy(&info->new_nch, &fdp->fd_nrdir);
515                 }
516                 spin_unlock_wr(&fdp->fd_spin);
517                 if (ncdrop1.ncp)
518                         cache_drop(&ncdrop1);
519                 if (ncdrop2.ncp)
520                         cache_drop(&ncdrop2);
521                 if (vprele1)
522                         vrele(vprele1);
523                 if (vprele2)
524                         vrele(vprele2);
525         }
526         return(0);
527 }
528
529 /*
530  * Unmount a file system.
531  *
532  * Note: unmount takes a path to the vnode mounted on as argument,
533  * not special file (as before).
534  */
535 /*
536  * umount_args(char *path, int flags)
537  */
538 /* ARGSUSED */
539 int
540 sys_unmount(struct unmount_args *uap)
541 {
542         struct thread *td = curthread;
543         struct proc *p = td->td_proc;
544         struct mount *mp = NULL;
545         int error;
546         struct nlookupdata nd;
547
548         KKASSERT(p);
549         if (p->p_ucred->cr_prison != NULL)
550                 return (EPERM);
551         if (usermount == 0 && (error = suser(td)))
552                 return (error);
553
554         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
555         if (error == 0)
556                 error = nlookup(&nd);
557         if (error)
558                 goto out;
559
560         mp = nd.nl_nch.mount;
561
562         /*
563          * Only root, or the user that did the original mount is
564          * permitted to unmount this filesystem.
565          */
566         if ((mp->mnt_stat.f_owner != p->p_ucred->cr_uid) &&
567             (error = suser(td)))
568                 goto out;
569
570         /*
571          * Don't allow unmounting the root file system.
572          */
573         if (mp->mnt_flag & MNT_ROOTFS) {
574                 error = EINVAL;
575                 goto out;
576         }
577
578         /*
579          * Must be the root of the filesystem
580          */
581         if (nd.nl_nch.ncp != mp->mnt_ncmountpt.ncp) {
582                 error = EINVAL;
583                 goto out;
584         }
585
586 out:
587         nlookup_done(&nd);
588         if (error)
589                 return (error);
590         return (dounmount(mp, uap->flags));
591 }
592
593 /*
594  * Do the actual file system unmount.
595  */
596 static int
597 dounmount_interlock(struct mount *mp)
598 {
599         if (mp->mnt_kern_flag & MNTK_UNMOUNT)
600                 return (EBUSY);
601         mp->mnt_kern_flag |= MNTK_UNMOUNT;
602         return(0);
603 }
604
605 int
606 dounmount(struct mount *mp, int flags)
607 {
608         struct namecache *ncp;
609         struct nchandle nch;
610         struct vnode *vp;
611         int error;
612         int async_flag;
613         int lflags;
614         int freeok = 1;
615
616         /*
617          * Exclusive access for unmounting purposes
618          */
619         if ((error = mountlist_interlock(dounmount_interlock, mp)) != 0)
620                 return (error);
621
622         /*
623          * Allow filesystems to detect that a forced unmount is in progress.
624          */
625         if (flags & MNT_FORCE)
626                 mp->mnt_kern_flag |= MNTK_UNMOUNTF;
627         lflags = LK_EXCLUSIVE | ((flags & MNT_FORCE) ? 0 : LK_NOWAIT);
628         error = lockmgr(&mp->mnt_lock, lflags);
629         if (error) {
630                 mp->mnt_kern_flag &= ~(MNTK_UNMOUNT | MNTK_UNMOUNTF);
631                 if (mp->mnt_kern_flag & MNTK_MWAIT)
632                         wakeup(mp);
633                 return (error);
634         }
635
636         if (mp->mnt_flag & MNT_EXPUBLIC)
637                 vfs_setpublicfs(NULL, NULL, NULL);
638
639         vfs_msync(mp, MNT_WAIT);
640         async_flag = mp->mnt_flag & MNT_ASYNC;
641         mp->mnt_flag &=~ MNT_ASYNC;
642
643         /*
644          * If this filesystem isn't aliasing other filesystems,
645          * try to invalidate any remaining namecache entries and
646          * check the count afterwords.
647          */
648         if ((mp->mnt_kern_flag & MNTK_NCALIASED) == 0) {
649                 cache_lock(&mp->mnt_ncmountpt);
650                 cache_inval(&mp->mnt_ncmountpt, CINV_DESTROY|CINV_CHILDREN);
651                 cache_unlock(&mp->mnt_ncmountpt);
652
653                 if ((ncp = mp->mnt_ncmountpt.ncp) != NULL &&
654                     (ncp->nc_refs != 1 || TAILQ_FIRST(&ncp->nc_list))) {
655
656                         if ((flags & MNT_FORCE) == 0) {
657                                 error = EBUSY;
658                                 mount_warning(mp, "Cannot unmount: "
659                                                   "%d namecache "
660                                                   "references still "
661                                                   "present",
662                                                   ncp->nc_refs - 1);
663                         } else {
664                                 mount_warning(mp, "Forced unmount: "
665                                                   "%d namecache "
666                                                   "references still "
667                                                   "present",
668                                                   ncp->nc_refs - 1);
669                                 freeok = 0;
670                         }
671                 }
672         }
673
674         /*
675          * nchandle records ref the mount structure.  Expect a count of 1
676          * (our mount->mnt_ncmountpt).
677          */
678         if (mp->mnt_refs != 1) {
679                 if ((flags & MNT_FORCE) == 0) {
680                         mount_warning(mp, "Cannot unmount: "
681                                           "%d process references still "
682                                           "present", mp->mnt_refs);
683                         error = EBUSY;
684                 } else {
685                         mount_warning(mp, "Forced unmount: "
686                                           "%d process references still "
687                                           "present", mp->mnt_refs);
688                         freeok = 0;
689                 }
690         }
691
692         /*
693          * Decomission our special mnt_syncer vnode.  This also stops
694          * the vnlru code.  If we are unable to unmount we recommission
695          * the vnode.
696          */
697         if (error == 0) {
698                 if ((vp = mp->mnt_syncer) != NULL) {
699                         mp->mnt_syncer = NULL;
700                         vrele(vp);
701                 }
702                 if (((mp->mnt_flag & MNT_RDONLY) ||
703                      (error = VFS_SYNC(mp, MNT_WAIT)) == 0) ||
704                     (flags & MNT_FORCE)) {
705                         error = VFS_UNMOUNT(mp, flags);
706                 }
707         }
708         if (error) {
709                 if (mp->mnt_syncer == NULL)
710                         vfs_allocate_syncvnode(mp);
711                 mp->mnt_kern_flag &= ~(MNTK_UNMOUNT | MNTK_UNMOUNTF);
712                 mp->mnt_flag |= async_flag;
713                 lockmgr(&mp->mnt_lock, LK_RELEASE);
714                 if (mp->mnt_kern_flag & MNTK_MWAIT)
715                         wakeup(mp);
716                 return (error);
717         }
718         /*
719          * Clean up any journals still associated with the mount after
720          * filesystem activity has ceased.
721          */
722         journal_remove_all_journals(mp, 
723             ((flags & MNT_FORCE) ? MC_JOURNAL_STOP_IMM : 0));
724
725         mountlist_remove(mp);
726
727         /*
728          * Remove any installed vnode ops here so the individual VFSs don't
729          * have to.
730          */
731         vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_coherency_ops);
732         vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_journal_ops);
733         vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_norm_ops);
734         vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_spec_ops);
735         vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_fifo_ops);
736
737         if (mp->mnt_ncmountpt.ncp != NULL) {
738                 nch = mp->mnt_ncmountpt;
739                 cache_zero(&mp->mnt_ncmountpt);
740                 cache_clrmountpt(&nch);
741                 cache_drop(&nch);
742         }
743         if (mp->mnt_ncmounton.ncp != NULL) {
744                 nch = mp->mnt_ncmounton;
745                 cache_zero(&mp->mnt_ncmounton);
746                 cache_clrmountpt(&nch);
747                 cache_drop(&nch);
748         }
749
750         mp->mnt_vfc->vfc_refcount--;
751         if (!TAILQ_EMPTY(&mp->mnt_nvnodelist))
752                 panic("unmount: dangling vnode");
753         lockmgr(&mp->mnt_lock, LK_RELEASE);
754         if (mp->mnt_kern_flag & MNTK_MWAIT)
755                 wakeup(mp);
756         if (freeok)
757                 kfree(mp, M_MOUNT);
758         return (0);
759 }
760
761 static
762 void
763 mount_warning(struct mount *mp, const char *ctl, ...)
764 {
765         char *ptr;
766         char *buf;
767         __va_list va;
768
769         __va_start(va, ctl);
770         if (cache_fullpath(NULL, &mp->mnt_ncmounton, &ptr, &buf) == 0) {
771                 kprintf("unmount(%s): ", ptr);
772                 kvprintf(ctl, va);
773                 kprintf("\n");
774                 kfree(buf, M_TEMP);
775         } else {
776                 kprintf("unmount(%p", mp);
777                 if (mp->mnt_ncmounton.ncp && mp->mnt_ncmounton.ncp->nc_name)
778                         kprintf(",%s", mp->mnt_ncmounton.ncp->nc_name);
779                 kprintf("): ");
780                 kvprintf(ctl, va);
781                 kprintf("\n");
782         }
783         __va_end(va);
784 }
785
786 /*
787  * Shim cache_fullpath() to handle the case where a process is chrooted into
788  * a subdirectory of a mount.  In this case if the root mount matches the
789  * process root directory's mount we have to specify the process's root
790  * directory instead of the mount point, because the mount point might
791  * be above the root directory.
792  */
793 static
794 int
795 mount_path(struct proc *p, struct mount *mp, char **rb, char **fb)
796 {
797         struct nchandle *nch;
798
799         if (p && p->p_fd->fd_nrdir.mount == mp)
800                 nch = &p->p_fd->fd_nrdir;
801         else
802                 nch = &mp->mnt_ncmountpt;
803         return(cache_fullpath(p, nch, rb, fb));
804 }
805
806 /*
807  * Sync each mounted filesystem.
808  */
809
810 #ifdef DEBUG
811 static int syncprt = 0;
812 SYSCTL_INT(_debug, OID_AUTO, syncprt, CTLFLAG_RW, &syncprt, 0, "");
813 #endif /* DEBUG */
814
815 static int sync_callback(struct mount *mp, void *data);
816
817 /* ARGSUSED */
818 int
819 sys_sync(struct sync_args *uap)
820 {
821         mountlist_scan(sync_callback, NULL, MNTSCAN_FORWARD);
822 #ifdef DEBUG
823         /*
824          * print out buffer pool stat information on each sync() call.
825          */
826         if (syncprt)
827                 vfs_bufstats();
828 #endif /* DEBUG */
829         return (0);
830 }
831
832 static
833 int
834 sync_callback(struct mount *mp, void *data __unused)
835 {
836         int asyncflag;
837
838         if ((mp->mnt_flag & MNT_RDONLY) == 0) {
839                 asyncflag = mp->mnt_flag & MNT_ASYNC;
840                 mp->mnt_flag &= ~MNT_ASYNC;
841                 vfs_msync(mp, MNT_NOWAIT);
842                 VFS_SYNC(mp, MNT_NOWAIT);
843                 mp->mnt_flag |= asyncflag;
844         }
845         return(0);
846 }
847
848 /* XXX PRISON: could be per prison flag */
849 static int prison_quotas;
850 #if 0
851 SYSCTL_INT(_kern_prison, OID_AUTO, quotas, CTLFLAG_RW, &prison_quotas, 0, "");
852 #endif
853
854 /*
855  *  quotactl_args(char *path, int fcmd, int uid, caddr_t arg)
856  *
857  * Change filesystem quotas.
858  */
859 /* ARGSUSED */
860 int
861 sys_quotactl(struct quotactl_args *uap)
862 {
863         struct nlookupdata nd;
864         struct thread *td;
865         struct proc *p;
866         struct mount *mp;
867         int error;
868
869         td = curthread;
870         p = td->td_proc;
871         if (p->p_ucred->cr_prison && !prison_quotas)
872                 return (EPERM);
873
874         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
875         if (error == 0)
876                 error = nlookup(&nd);
877         if (error == 0) {
878                 mp = nd.nl_nch.mount;
879                 error = VFS_QUOTACTL(mp, uap->cmd, uap->uid,
880                                     uap->arg, nd.nl_cred);
881         }
882         nlookup_done(&nd);
883         return (error);
884 }
885
886 /*
887  * mountctl(char *path, int op, int fd, const void *ctl, int ctllen,
888  *              void *buf, int buflen)
889  *
890  * This function operates on a mount point and executes the specified
891  * operation using the specified control data, and possibly returns data.
892  *
893  * The actual number of bytes stored in the result buffer is returned, 0
894  * if none, otherwise an error is returned.
895  */
896 /* ARGSUSED */
897 int
898 sys_mountctl(struct mountctl_args *uap)
899 {
900         struct thread *td = curthread;
901         struct proc *p = td->td_proc;
902         struct file *fp;
903         void *ctl = NULL;
904         void *buf = NULL;
905         char *path = NULL;
906         int error;
907
908         /*
909          * Sanity and permissions checks.  We must be root.
910          */
911         KKASSERT(p);
912         if (p->p_ucred->cr_prison != NULL)
913                 return (EPERM);
914         if ((error = suser(td)) != 0)
915                 return (error);
916
917         /*
918          * Argument length checks
919          */
920         if (uap->ctllen < 0 || uap->ctllen > 1024)
921                 return (EINVAL);
922         if (uap->buflen < 0 || uap->buflen > 16 * 1024)
923                 return (EINVAL);
924         if (uap->path == NULL)
925                 return (EINVAL);
926
927         /*
928          * Allocate the necessary buffers and copyin data
929          */
930         path = objcache_get(namei_oc, M_WAITOK);
931         error = copyinstr(uap->path, path, MAXPATHLEN, NULL);
932         if (error)
933                 goto done;
934
935         if (uap->ctllen) {
936                 ctl = kmalloc(uap->ctllen + 1, M_TEMP, M_WAITOK|M_ZERO);
937                 error = copyin(uap->ctl, ctl, uap->ctllen);
938                 if (error)
939                         goto done;
940         }
941         if (uap->buflen)
942                 buf = kmalloc(uap->buflen + 1, M_TEMP, M_WAITOK|M_ZERO);
943
944         /*
945          * Validate the descriptor
946          */
947         if (uap->fd >= 0) {
948                 fp = holdfp(p->p_fd, uap->fd, -1);
949                 if (fp == NULL) {
950                         error = EBADF;
951                         goto done;
952                 }
953         } else {
954                 fp = NULL;
955         }
956
957         /*
958          * Execute the internal kernel function and clean up.
959          */
960         error = kern_mountctl(path, uap->op, fp, ctl, uap->ctllen, buf, uap->buflen, &uap->sysmsg_result);
961         if (fp)
962                 fdrop(fp);
963         if (error == 0 && uap->sysmsg_result > 0)
964                 error = copyout(buf, uap->buf, uap->sysmsg_result);
965 done:
966         if (path)
967                 objcache_put(namei_oc, path);
968         if (ctl)
969                 kfree(ctl, M_TEMP);
970         if (buf)
971                 kfree(buf, M_TEMP);
972         return (error);
973 }
974
975 /*
976  * Execute a mount control operation by resolving the path to a mount point
977  * and calling vop_mountctl().  
978  *
979  * Use the mount point from the nch instead of the vnode so nullfs mounts
980  * can properly spike the VOP.
981  */
982 int
983 kern_mountctl(const char *path, int op, struct file *fp, 
984                 const void *ctl, int ctllen, 
985                 void *buf, int buflen, int *res)
986 {
987         struct vnode *vp;
988         struct mount *mp;
989         struct nlookupdata nd;
990         int error;
991
992         *res = 0;
993         vp = NULL;
994         error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
995         if (error == 0)
996                 error = nlookup(&nd);
997         if (error == 0)
998                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
999         mp = nd.nl_nch.mount;
1000         nlookup_done(&nd);
1001         if (error)
1002                 return (error);
1003
1004         /*
1005          * Must be the root of the filesystem
1006          */
1007         if ((vp->v_flag & (VROOT|VPFSROOT)) == 0) {
1008                 vput(vp);
1009                 return (EINVAL);
1010         }
1011         error = vop_mountctl(mp->mnt_vn_use_ops, op, fp, ctl, ctllen, 
1012                                 buf, buflen, res);
1013         vput(vp);
1014         return (error);
1015 }
1016
1017 int
1018 kern_statfs(struct nlookupdata *nd, struct statfs *buf)
1019 {
1020         struct thread *td = curthread;
1021         struct proc *p = td->td_proc;
1022         struct mount *mp;
1023         struct statfs *sp;
1024         char *fullpath, *freepath;
1025         int error;
1026
1027         if ((error = nlookup(nd)) != 0)
1028                 return (error);
1029         mp = nd->nl_nch.mount;
1030         sp = &mp->mnt_stat;
1031         if ((error = VFS_STATFS(mp, sp, nd->nl_cred)) != 0)
1032                 return (error);
1033
1034         error = mount_path(p, mp, &fullpath, &freepath);
1035         if (error)
1036                 return(error);
1037         bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
1038         strlcpy(sp->f_mntonname, fullpath, sizeof(sp->f_mntonname));
1039         kfree(freepath, M_TEMP);
1040
1041         sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
1042         bcopy(sp, buf, sizeof(*buf));
1043         /* Only root should have access to the fsid's. */
1044         if (suser(td))
1045                 buf->f_fsid.val[0] = buf->f_fsid.val[1] = 0;
1046         return (0);
1047 }
1048
1049 /*
1050  * statfs_args(char *path, struct statfs *buf)
1051  *
1052  * Get filesystem statistics.
1053  */
1054 int
1055 sys_statfs(struct statfs_args *uap)
1056 {
1057         struct nlookupdata nd;
1058         struct statfs buf;
1059         int error;
1060
1061         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
1062         if (error == 0)
1063                 error = kern_statfs(&nd, &buf);
1064         nlookup_done(&nd);
1065         if (error == 0)
1066                 error = copyout(&buf, uap->buf, sizeof(*uap->buf));
1067         return (error);
1068 }
1069
1070 int
1071 kern_fstatfs(int fd, struct statfs *buf)
1072 {
1073         struct thread *td = curthread;
1074         struct proc *p = td->td_proc;
1075         struct file *fp;
1076         struct mount *mp;
1077         struct statfs *sp;
1078         char *fullpath, *freepath;
1079         int error;
1080
1081         KKASSERT(p);
1082         if ((error = holdvnode(p->p_fd, fd, &fp)) != 0)
1083                 return (error);
1084         mp = ((struct vnode *)fp->f_data)->v_mount;
1085         if (mp == NULL) {
1086                 error = EBADF;
1087                 goto done;
1088         }
1089         if (fp->f_cred == NULL) {
1090                 error = EINVAL;
1091                 goto done;
1092         }
1093         sp = &mp->mnt_stat;
1094         if ((error = VFS_STATFS(mp, sp, fp->f_cred)) != 0)
1095                 goto done;
1096
1097         if ((error = mount_path(p, mp, &fullpath, &freepath)) != 0)
1098                 goto done;
1099         bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
1100         strlcpy(sp->f_mntonname, fullpath, sizeof(sp->f_mntonname));
1101         kfree(freepath, M_TEMP);
1102
1103         sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
1104         bcopy(sp, buf, sizeof(*buf));
1105
1106         /* Only root should have access to the fsid's. */
1107         if (suser(td))
1108                 buf->f_fsid.val[0] = buf->f_fsid.val[1] = 0;
1109         error = 0;
1110 done:
1111         fdrop(fp);
1112         return (error);
1113 }
1114
1115 /*
1116  * fstatfs_args(int fd, struct statfs *buf)
1117  *
1118  * Get filesystem statistics.
1119  */
1120 int
1121 sys_fstatfs(struct fstatfs_args *uap)
1122 {
1123         struct statfs buf;
1124         int error;
1125
1126         error = kern_fstatfs(uap->fd, &buf);
1127
1128         if (error == 0)
1129                 error = copyout(&buf, uap->buf, sizeof(*uap->buf));
1130         return (error);
1131 }
1132
1133 int
1134 kern_statvfs(struct nlookupdata *nd, struct statvfs *buf)
1135 {
1136         struct mount *mp;
1137         struct statvfs *sp;
1138         int error;
1139
1140         if ((error = nlookup(nd)) != 0)
1141                 return (error);
1142         mp = nd->nl_nch.mount;
1143         sp = &mp->mnt_vstat;
1144         if ((error = VFS_STATVFS(mp, sp, nd->nl_cred)) != 0)
1145                 return (error);
1146
1147         sp->f_flag = 0;
1148         if (mp->mnt_flag & MNT_RDONLY)
1149                 sp->f_flag |= ST_RDONLY;
1150         if (mp->mnt_flag & MNT_NOSUID)
1151                 sp->f_flag |= ST_NOSUID;
1152         bcopy(sp, buf, sizeof(*buf));
1153         return (0);
1154 }
1155
1156 /*
1157  * statfs_args(char *path, struct statfs *buf)
1158  *
1159  * Get filesystem statistics.
1160  */
1161 int
1162 sys_statvfs(struct statvfs_args *uap)
1163 {
1164         struct nlookupdata nd;
1165         struct statvfs buf;
1166         int error;
1167
1168         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
1169         if (error == 0)
1170                 error = kern_statvfs(&nd, &buf);
1171         nlookup_done(&nd);
1172         if (error == 0)
1173                 error = copyout(&buf, uap->buf, sizeof(*uap->buf));
1174         return (error);
1175 }
1176
1177 int
1178 kern_fstatvfs(int fd, struct statvfs *buf)
1179 {
1180         struct thread *td = curthread;
1181         struct proc *p = td->td_proc;
1182         struct file *fp;
1183         struct mount *mp;
1184         struct statvfs *sp;
1185         int error;
1186
1187         KKASSERT(p);
1188         if ((error = holdvnode(p->p_fd, fd, &fp)) != 0)
1189                 return (error);
1190         mp = ((struct vnode *)fp->f_data)->v_mount;
1191         if (mp == NULL) {
1192                 error = EBADF;
1193                 goto done;
1194         }
1195         if (fp->f_cred == NULL) {
1196                 error = EINVAL;
1197                 goto done;
1198         }
1199         sp = &mp->mnt_vstat;
1200         if ((error = VFS_STATVFS(mp, sp, fp->f_cred)) != 0)
1201                 goto done;
1202
1203         sp->f_flag = 0;
1204         if (mp->mnt_flag & MNT_RDONLY)
1205                 sp->f_flag |= ST_RDONLY;
1206         if (mp->mnt_flag & MNT_NOSUID)
1207                 sp->f_flag |= ST_NOSUID;
1208
1209         bcopy(sp, buf, sizeof(*buf));
1210         error = 0;
1211 done:
1212         fdrop(fp);
1213         return (error);
1214 }
1215
1216 /*
1217  * fstatfs_args(int fd, struct statfs *buf)
1218  *
1219  * Get filesystem statistics.
1220  */
1221 int
1222 sys_fstatvfs(struct fstatvfs_args *uap)
1223 {
1224         struct statvfs buf;
1225         int error;
1226
1227         error = kern_fstatvfs(uap->fd, &buf);
1228
1229         if (error == 0)
1230                 error = copyout(&buf, uap->buf, sizeof(*uap->buf));
1231         return (error);
1232 }
1233
1234 /*
1235  * getfsstat_args(struct statfs *buf, long bufsize, int flags)
1236  *
1237  * Get statistics on all filesystems.
1238  */
1239
1240 struct getfsstat_info {
1241         struct statfs *sfsp;
1242         long count;
1243         long maxcount;
1244         int error;
1245         int flags;
1246         struct proc *p;
1247 };
1248
1249 static int getfsstat_callback(struct mount *, void *);
1250
1251 /* ARGSUSED */
1252 int
1253 sys_getfsstat(struct getfsstat_args *uap)
1254 {
1255         struct thread *td = curthread;
1256         struct proc *p = td->td_proc;
1257         struct getfsstat_info info;
1258
1259         bzero(&info, sizeof(info));
1260
1261         info.maxcount = uap->bufsize / sizeof(struct statfs);
1262         info.sfsp = uap->buf;
1263         info.count = 0;
1264         info.flags = uap->flags;
1265         info.p = p;
1266
1267         mountlist_scan(getfsstat_callback, &info, MNTSCAN_FORWARD);
1268         if (info.sfsp && info.count > info.maxcount)
1269                 uap->sysmsg_result = info.maxcount;
1270         else
1271                 uap->sysmsg_result = info.count;
1272         return (info.error);
1273 }
1274
1275 static int
1276 getfsstat_callback(struct mount *mp, void *data)
1277 {
1278         struct getfsstat_info *info = data;
1279         struct statfs *sp;
1280         char *freepath;
1281         char *fullpath;
1282         int error;
1283
1284         if (info->sfsp && info->count < info->maxcount) {
1285                 if (info->p && !chroot_visible_mnt(mp, info->p))
1286                         return(0);
1287                 sp = &mp->mnt_stat;
1288
1289                 /*
1290                  * If MNT_NOWAIT or MNT_LAZY is specified, do not
1291                  * refresh the fsstat cache. MNT_NOWAIT or MNT_LAZY
1292                  * overrides MNT_WAIT.
1293                  */
1294                 if (((info->flags & (MNT_LAZY|MNT_NOWAIT)) == 0 ||
1295                     (info->flags & MNT_WAIT)) &&
1296                     (error = VFS_STATFS(mp, sp, info->p->p_ucred))) {
1297                         return(0);
1298                 }
1299                 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
1300
1301                 error = mount_path(info->p, mp, &fullpath, &freepath);
1302                 if (error) {
1303                         info->error = error;
1304                         return(-1);
1305                 }
1306                 bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
1307                 strlcpy(sp->f_mntonname, fullpath, sizeof(sp->f_mntonname));
1308                 kfree(freepath, M_TEMP);
1309
1310                 error = copyout(sp, info->sfsp, sizeof(*sp));
1311                 if (error) {
1312                         info->error = error;
1313                         return (-1);
1314                 }
1315                 ++info->sfsp;
1316         }
1317         info->count++;
1318         return(0);
1319 }
1320
1321 /*
1322  * getvfsstat_args(struct statfs *buf, struct statvfs *vbuf,
1323                    long bufsize, int flags)
1324  *
1325  * Get statistics on all filesystems.
1326  */
1327
1328 struct getvfsstat_info {
1329         struct statfs *sfsp;
1330         struct statvfs *vsfsp;
1331         long count;
1332         long maxcount;
1333         int error;
1334         int flags;
1335         struct proc *p;
1336 };
1337
1338 static int getvfsstat_callback(struct mount *, void *);
1339
1340 /* ARGSUSED */
1341 int
1342 sys_getvfsstat(struct getvfsstat_args *uap)
1343 {
1344         struct thread *td = curthread;
1345         struct proc *p = td->td_proc;
1346         struct getvfsstat_info info;
1347
1348         bzero(&info, sizeof(info));
1349
1350         info.maxcount = uap->vbufsize / sizeof(struct statvfs);
1351         info.sfsp = uap->buf;
1352         info.vsfsp = uap->vbuf;
1353         info.count = 0;
1354         info.flags = uap->flags;
1355         info.p = p;
1356
1357         mountlist_scan(getvfsstat_callback, &info, MNTSCAN_FORWARD);
1358         if (info.vsfsp && info.count > info.maxcount)
1359                 uap->sysmsg_result = info.maxcount;
1360         else
1361                 uap->sysmsg_result = info.count;
1362         return (info.error);
1363 }
1364
1365 static int
1366 getvfsstat_callback(struct mount *mp, void *data)
1367 {
1368         struct getvfsstat_info *info = data;
1369         struct statfs *sp;
1370         struct statvfs *vsp;
1371         char *freepath;
1372         char *fullpath;
1373         int error;
1374
1375         if (info->vsfsp && info->count < info->maxcount) {
1376                 if (info->p && !chroot_visible_mnt(mp, info->p))
1377                         return(0);
1378                 sp = &mp->mnt_stat;
1379                 vsp = &mp->mnt_vstat;
1380
1381                 /*
1382                  * If MNT_NOWAIT or MNT_LAZY is specified, do not
1383                  * refresh the fsstat cache. MNT_NOWAIT or MNT_LAZY
1384                  * overrides MNT_WAIT.
1385                  */
1386                 if (((info->flags & (MNT_LAZY|MNT_NOWAIT)) == 0 ||
1387                     (info->flags & MNT_WAIT)) &&
1388                     (error = VFS_STATFS(mp, sp, info->p->p_ucred))) {
1389                         return(0);
1390                 }
1391                 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
1392
1393                 if (((info->flags & (MNT_LAZY|MNT_NOWAIT)) == 0 ||
1394                     (info->flags & MNT_WAIT)) &&
1395                     (error = VFS_STATVFS(mp, vsp, info->p->p_ucred))) {
1396                         return(0);
1397                 }
1398                 vsp->f_flag = 0;
1399                 if (mp->mnt_flag & MNT_RDONLY)
1400                         vsp->f_flag |= ST_RDONLY;
1401                 if (mp->mnt_flag & MNT_NOSUID)
1402                         vsp->f_flag |= ST_NOSUID;
1403
1404                 error = mount_path(info->p, mp, &fullpath, &freepath);
1405                 if (error) {
1406                         info->error = error;
1407                         return(-1);
1408                 }
1409                 bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
1410                 strlcpy(sp->f_mntonname, fullpath, sizeof(sp->f_mntonname));
1411                 kfree(freepath, M_TEMP);
1412
1413                 error = copyout(sp, info->sfsp, sizeof(*sp));
1414                 if (error == 0)
1415                         error = copyout(vsp, info->vsfsp, sizeof(*vsp));
1416                 if (error) {
1417                         info->error = error;
1418                         return (-1);
1419                 }
1420                 ++info->sfsp;
1421                 ++info->vsfsp;
1422         }
1423         info->count++;
1424         return(0);
1425 }
1426
1427
1428 /*
1429  * fchdir_args(int fd)
1430  *
1431  * Change current working directory to a given file descriptor.
1432  */
1433 /* ARGSUSED */
1434 int
1435 sys_fchdir(struct fchdir_args *uap)
1436 {
1437         struct thread *td = curthread;
1438         struct proc *p = td->td_proc;
1439         struct filedesc *fdp = p->p_fd;
1440         struct vnode *vp, *ovp;
1441         struct mount *mp;
1442         struct file *fp;
1443         struct nchandle nch, onch, tnch;
1444         int error;
1445
1446         if ((error = holdvnode(fdp, uap->fd, &fp)) != 0)
1447                 return (error);
1448         vp = (struct vnode *)fp->f_data;
1449         vref(vp);
1450         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1451         if (vp->v_type != VDIR || fp->f_nchandle.ncp == NULL)
1452                 error = ENOTDIR;
1453         else
1454                 error = VOP_ACCESS(vp, VEXEC, p->p_ucred);
1455         if (error) {
1456                 vput(vp);
1457                 fdrop(fp);
1458                 return (error);
1459         }
1460         cache_copy(&fp->f_nchandle, &nch);
1461
1462         /*
1463          * If the ncp has become a mount point, traverse through
1464          * the mount point.
1465          */
1466
1467         while (!error && (nch.ncp->nc_flag & NCF_ISMOUNTPT) &&
1468                (mp = cache_findmount(&nch)) != NULL
1469         ) {
1470                 error = nlookup_mp(mp, &tnch);
1471                 if (error == 0) {
1472                         cache_unlock(&tnch);    /* leave ref intact */
1473                         vput(vp);
1474                         vp = tnch.ncp->nc_vp;
1475                         error = vget(vp, LK_SHARED);
1476                         KKASSERT(error == 0);
1477                         cache_drop(&nch);
1478                         nch = tnch;
1479                 }
1480         }
1481         if (error == 0) {
1482                 ovp = fdp->fd_cdir;
1483                 onch = fdp->fd_ncdir;
1484                 vn_unlock(vp);          /* leave ref intact */
1485                 fdp->fd_cdir = vp;
1486                 fdp->fd_ncdir = nch;
1487                 cache_drop(&onch);
1488                 vrele(ovp);
1489         } else {
1490                 cache_drop(&nch);
1491                 vput(vp);
1492         }
1493         fdrop(fp);
1494         return (error);
1495 }
1496
1497 int
1498 kern_chdir(struct nlookupdata *nd)
1499 {
1500         struct thread *td = curthread;
1501         struct proc *p = td->td_proc;
1502         struct filedesc *fdp = p->p_fd;
1503         struct vnode *vp, *ovp;
1504         struct nchandle onch;
1505         int error;
1506
1507         if ((error = nlookup(nd)) != 0)
1508                 return (error);
1509         if ((vp = nd->nl_nch.ncp->nc_vp) == NULL)
1510                 return (ENOENT);
1511         if ((error = vget(vp, LK_SHARED)) != 0)
1512                 return (error);
1513
1514         error = checkvp_chdir(vp, td);
1515         vn_unlock(vp);
1516         if (error == 0) {
1517                 ovp = fdp->fd_cdir;
1518                 onch = fdp->fd_ncdir;
1519                 cache_unlock(&nd->nl_nch);      /* leave reference intact */
1520                 fdp->fd_ncdir = nd->nl_nch;
1521                 fdp->fd_cdir = vp;
1522                 cache_drop(&onch);
1523                 vrele(ovp);
1524                 cache_zero(&nd->nl_nch);
1525         } else {
1526                 vrele(vp);
1527         }
1528         return (error);
1529 }
1530
1531 /*
1532  * chdir_args(char *path)
1533  *
1534  * Change current working directory (``.'').
1535  */
1536 int
1537 sys_chdir(struct chdir_args *uap)
1538 {
1539         struct nlookupdata nd;
1540         int error;
1541
1542         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
1543         if (error == 0)
1544                 error = kern_chdir(&nd);
1545         nlookup_done(&nd);
1546         return (error);
1547 }
1548
1549 /*
1550  * Helper function for raised chroot(2) security function:  Refuse if
1551  * any filedescriptors are open directories.
1552  */
1553 static int
1554 chroot_refuse_vdir_fds(struct filedesc *fdp)
1555 {
1556         struct vnode *vp;
1557         struct file *fp;
1558         int error;
1559         int fd;
1560
1561         for (fd = 0; fd < fdp->fd_nfiles ; fd++) {
1562                 if ((error = holdvnode(fdp, fd, &fp)) != 0)
1563                         continue;
1564                 vp = (struct vnode *)fp->f_data;
1565                 if (vp->v_type != VDIR) {
1566                         fdrop(fp);
1567                         continue;
1568                 }
1569                 fdrop(fp);
1570                 return(EPERM);
1571         }
1572         return (0);
1573 }
1574
1575 /*
1576  * This sysctl determines if we will allow a process to chroot(2) if it
1577  * has a directory open:
1578  *      0: disallowed for all processes.
1579  *      1: allowed for processes that were not already chroot(2)'ed.
1580  *      2: allowed for all processes.
1581  */
1582
1583 static int chroot_allow_open_directories = 1;
1584
1585 SYSCTL_INT(_kern, OID_AUTO, chroot_allow_open_directories, CTLFLAG_RW,
1586      &chroot_allow_open_directories, 0, "");
1587
1588 /*
1589  * chroot to the specified namecache entry.  We obtain the vp from the
1590  * namecache data.  The passed ncp must be locked and referenced and will
1591  * remain locked and referenced on return.
1592  */
1593 int
1594 kern_chroot(struct nchandle *nch)
1595 {
1596         struct thread *td = curthread;
1597         struct proc *p = td->td_proc;
1598         struct filedesc *fdp = p->p_fd;
1599         struct vnode *vp;
1600         int error;
1601
1602         /*
1603          * Only root can chroot
1604          */
1605         if ((error = suser_cred(p->p_ucred, PRISON_ROOT)) != 0)
1606                 return (error);
1607
1608         /*
1609          * Disallow open directory descriptors (fchdir() breakouts).
1610          */
1611         if (chroot_allow_open_directories == 0 ||
1612            (chroot_allow_open_directories == 1 && fdp->fd_rdir != rootvnode)) {
1613                 if ((error = chroot_refuse_vdir_fds(fdp)) != 0)
1614                         return (error);
1615         }
1616         if ((vp = nch->ncp->nc_vp) == NULL)
1617                 return (ENOENT);
1618
1619         if ((error = vget(vp, LK_SHARED)) != 0)
1620                 return (error);
1621
1622         /*
1623          * Check the validity of vp as a directory to change to and 
1624          * associate it with rdir/jdir.
1625          */
1626         error = checkvp_chdir(vp, td);
1627         vn_unlock(vp);                  /* leave reference intact */
1628         if (error == 0) {
1629                 vrele(fdp->fd_rdir);
1630                 fdp->fd_rdir = vp;      /* reference inherited by fd_rdir */
1631                 cache_drop(&fdp->fd_nrdir);
1632                 cache_copy(nch, &fdp->fd_nrdir);
1633                 if (fdp->fd_jdir == NULL) {
1634                         fdp->fd_jdir = vp;
1635                         vref(fdp->fd_jdir);
1636                         cache_copy(nch, &fdp->fd_njdir);
1637                 }
1638         } else {
1639                 vrele(vp);
1640         }
1641         return (error);
1642 }
1643
1644 /*
1645  * chroot_args(char *path)
1646  *
1647  * Change notion of root (``/'') directory.
1648  */
1649 /* ARGSUSED */
1650 int
1651 sys_chroot(struct chroot_args *uap)
1652 {
1653         struct thread *td = curthread;
1654         struct nlookupdata nd;
1655         int error;
1656
1657         KKASSERT(td->td_proc);
1658         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
1659         if (error) {
1660                 nlookup_done(&nd);
1661                 return(error);
1662         }
1663         error = nlookup(&nd);
1664         if (error == 0)
1665                 error = kern_chroot(&nd.nl_nch);
1666         nlookup_done(&nd);
1667         return(error);
1668 }
1669
1670 /*
1671  * Common routine for chroot and chdir.  Given a locked, referenced vnode,
1672  * determine whether it is legal to chdir to the vnode.  The vnode's state
1673  * is not changed by this call.
1674  */
1675 int
1676 checkvp_chdir(struct vnode *vp, struct thread *td)
1677 {
1678         int error;
1679
1680         if (vp->v_type != VDIR)
1681                 error = ENOTDIR;
1682         else
1683                 error = VOP_ACCESS(vp, VEXEC, td->td_proc->p_ucred);
1684         return (error);
1685 }
1686
1687 int
1688 kern_open(struct nlookupdata *nd, int oflags, int mode, int *res)
1689 {
1690         struct thread *td = curthread;
1691         struct proc *p = td->td_proc;
1692         struct lwp *lp = td->td_lwp;
1693         struct filedesc *fdp = p->p_fd;
1694         int cmode, flags;
1695         struct file *nfp;
1696         struct file *fp;
1697         struct vnode *vp;
1698         int type, indx, error;
1699         struct flock lf;
1700
1701         if ((oflags & O_ACCMODE) == O_ACCMODE)
1702                 return (EINVAL);
1703         flags = FFLAGS(oflags);
1704         error = falloc(p, &nfp, NULL);
1705         if (error)
1706                 return (error);
1707         fp = nfp;
1708         cmode = ((mode &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT;
1709
1710         /*
1711          * XXX p_dupfd is a real mess.  It allows a device to return a
1712          * file descriptor to be duplicated rather then doing the open
1713          * itself.
1714          */
1715         lp->lwp_dupfd = -1;
1716
1717         /*
1718          * Call vn_open() to do the lookup and assign the vnode to the 
1719          * file pointer.  vn_open() does not change the ref count on fp
1720          * and the vnode, on success, will be inherited by the file pointer
1721          * and unlocked.
1722          */
1723         nd->nl_flags |= NLC_LOCKVP;
1724         error = vn_open(nd, fp, flags, cmode);
1725         nlookup_done(nd);
1726         if (error) {
1727                 /*
1728                  * handle special fdopen() case.  bleh.  dupfdopen() is
1729                  * responsible for dropping the old contents of ofiles[indx]
1730                  * if it succeeds.
1731                  *
1732                  * Note that fsetfd() will add a ref to fp which represents
1733                  * the fd_files[] assignment.  We must still drop our
1734                  * reference.
1735                  */
1736                 if ((error == ENODEV || error == ENXIO) && lp->lwp_dupfd >= 0) {
1737                         if (fdalloc(p, 0, &indx) == 0) {
1738                                 error = dupfdopen(p, indx, lp->lwp_dupfd, flags, error);
1739                                 if (error == 0) {
1740                                         *res = indx;
1741                                         fdrop(fp);      /* our ref */
1742                                         return (0);
1743                                 }
1744                                 fsetfd(p, NULL, indx);
1745                         }
1746                 }
1747                 fdrop(fp);      /* our ref */
1748                 if (error == ERESTART)
1749                         error = EINTR;
1750                 return (error);
1751         }
1752
1753         /*
1754          * ref the vnode for ourselves so it can't be ripped out from under
1755          * is.  XXX need an ND flag to request that the vnode be returned
1756          * anyway.
1757          *
1758          * Reserve a file descriptor but do not assign it until the open
1759          * succeeds.
1760          */
1761         vp = (struct vnode *)fp->f_data;
1762         vref(vp);
1763         if ((error = fdalloc(p, 0, &indx)) != 0) {
1764                 fdrop(fp);
1765                 vrele(vp);
1766                 return (error);
1767         }
1768
1769         /*
1770          * If no error occurs the vp will have been assigned to the file
1771          * pointer.
1772          */
1773         lp->lwp_dupfd = 0;
1774
1775         if (flags & (O_EXLOCK | O_SHLOCK)) {
1776                 lf.l_whence = SEEK_SET;
1777                 lf.l_start = 0;
1778                 lf.l_len = 0;
1779                 if (flags & O_EXLOCK)
1780                         lf.l_type = F_WRLCK;
1781                 else
1782                         lf.l_type = F_RDLCK;
1783                 if (flags & FNONBLOCK)
1784                         type = 0;
1785                 else
1786                         type = F_WAIT;
1787
1788                 if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) != 0) {
1789                         /*
1790                          * lock request failed.  Clean up the reserved
1791                          * descriptor.
1792                          */
1793                         vrele(vp);
1794                         fsetfd(p, NULL, indx);
1795                         fdrop(fp);
1796                         return (error);
1797                 }
1798                 fp->f_flag |= FHASLOCK;
1799         }
1800 #if 0
1801         /*
1802          * Assert that all regular file vnodes were created with a object.
1803          */
1804         KASSERT(vp->v_type != VREG || vp->v_object != NULL,
1805                 ("open: regular file has no backing object after vn_open"));
1806 #endif
1807
1808         vrele(vp);
1809
1810         /*
1811          * release our private reference, leaving the one associated with the
1812          * descriptor table intact.
1813          */
1814         fsetfd(p, fp, indx);
1815         fdrop(fp);
1816         *res = indx;
1817         return (0);
1818 }
1819
1820 /*
1821  * open_args(char *path, int flags, int mode)
1822  *
1823  * Check permissions, allocate an open file structure,
1824  * and call the device open routine if any.
1825  */
1826 int
1827 sys_open(struct open_args *uap)
1828 {
1829         struct nlookupdata nd;
1830         int error;
1831
1832         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
1833         if (error == 0) {
1834                 error = kern_open(&nd, uap->flags,
1835                                     uap->mode, &uap->sysmsg_result);
1836         }
1837         nlookup_done(&nd);
1838         return (error);
1839 }
1840
1841 int
1842 kern_mknod(struct nlookupdata *nd, int mode, int rmajor, int rminor)
1843 {
1844         struct thread *td = curthread;
1845         struct proc *p = td->td_proc;
1846         struct vnode *vp;
1847         struct vattr vattr;
1848         int error;
1849         int whiteout = 0;
1850
1851         KKASSERT(p);
1852
1853         switch (mode & S_IFMT) {
1854         case S_IFCHR:
1855         case S_IFBLK:
1856                 error = suser(td);
1857                 break;
1858         default:
1859                 error = suser_cred(p->p_ucred, PRISON_ROOT);
1860                 break;
1861         }
1862         if (error)
1863                 return (error);
1864
1865         bwillinode(1);
1866         nd->nl_flags |= NLC_CREATE | NLC_REFDVP;
1867         if ((error = nlookup(nd)) != 0)
1868                 return (error);
1869         if (nd->nl_nch.ncp->nc_vp)
1870                 return (EEXIST);
1871         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
1872                 return (error);
1873
1874         VATTR_NULL(&vattr);
1875         vattr.va_mode = (mode & ALLPERMS) &~ p->p_fd->fd_cmask;
1876         vattr.va_rmajor = rmajor;
1877         vattr.va_rminor = rminor;
1878         whiteout = 0;
1879
1880         switch (mode & S_IFMT) {
1881         case S_IFMT:    /* used by badsect to flag bad sectors */
1882                 vattr.va_type = VBAD;
1883                 break;
1884         case S_IFCHR:
1885                 vattr.va_type = VCHR;
1886                 break;
1887         case S_IFBLK:
1888                 vattr.va_type = VBLK;
1889                 break;
1890         case S_IFWHT:
1891                 whiteout = 1;
1892                 break;
1893         case S_IFDIR:
1894                 /* special directories support for HAMMER */
1895                 vattr.va_type = VDIR;
1896                 break;
1897         default:
1898                 error = EINVAL;
1899                 break;
1900         }
1901         if (error == 0) {
1902                 if (whiteout) {
1903                         error = VOP_NWHITEOUT(&nd->nl_nch, nd->nl_dvp,
1904                                               nd->nl_cred, NAMEI_CREATE);
1905                 } else {
1906                         vp = NULL;
1907                         error = VOP_NMKNOD(&nd->nl_nch, nd->nl_dvp,
1908                                            &vp, nd->nl_cred, &vattr);
1909                         if (error == 0)
1910                                 vput(vp);
1911                 }
1912         }
1913         return (error);
1914 }
1915
1916 /*
1917  * mknod_args(char *path, int mode, int dev)
1918  *
1919  * Create a special file.
1920  */
1921 int
1922 sys_mknod(struct mknod_args *uap)
1923 {
1924         struct nlookupdata nd;
1925         int error;
1926
1927         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
1928         if (error == 0) {
1929                 error = kern_mknod(&nd, uap->mode,
1930                                    umajor(uap->dev), uminor(uap->dev));
1931         }
1932         nlookup_done(&nd);
1933         return (error);
1934 }
1935
1936 int
1937 kern_mkfifo(struct nlookupdata *nd, int mode)
1938 {
1939         struct thread *td = curthread;
1940         struct proc *p = td->td_proc;
1941         struct vattr vattr;
1942         struct vnode *vp;
1943         int error;
1944
1945         bwillinode(1);
1946
1947         nd->nl_flags |= NLC_CREATE | NLC_REFDVP;
1948         if ((error = nlookup(nd)) != 0)
1949                 return (error);
1950         if (nd->nl_nch.ncp->nc_vp)
1951                 return (EEXIST);
1952         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
1953                 return (error);
1954
1955         VATTR_NULL(&vattr);
1956         vattr.va_type = VFIFO;
1957         vattr.va_mode = (mode & ALLPERMS) &~ p->p_fd->fd_cmask;
1958         vp = NULL;
1959         error = VOP_NMKNOD(&nd->nl_nch, nd->nl_dvp, &vp, nd->nl_cred, &vattr);
1960         if (error == 0)
1961                 vput(vp);
1962         return (error);
1963 }
1964
1965 /*
1966  * mkfifo_args(char *path, int mode)
1967  *
1968  * Create a named pipe.
1969  */
1970 int
1971 sys_mkfifo(struct mkfifo_args *uap)
1972 {
1973         struct nlookupdata nd;
1974         int error;
1975
1976         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
1977         if (error == 0)
1978                 error = kern_mkfifo(&nd, uap->mode);
1979         nlookup_done(&nd);
1980         return (error);
1981 }
1982
1983 static int hardlink_check_uid = 0;
1984 SYSCTL_INT(_security, OID_AUTO, hardlink_check_uid, CTLFLAG_RW,
1985     &hardlink_check_uid, 0, 
1986     "Unprivileged processes cannot create hard links to files owned by other "
1987     "users");
1988 static int hardlink_check_gid = 0;
1989 SYSCTL_INT(_security, OID_AUTO, hardlink_check_gid, CTLFLAG_RW,
1990     &hardlink_check_gid, 0,
1991     "Unprivileged processes cannot create hard links to files owned by other "
1992     "groups");
1993
1994 static int
1995 can_hardlink(struct vnode *vp, struct thread *td, struct ucred *cred)
1996 {
1997         struct vattr va;
1998         int error;
1999
2000         /*
2001          * Shortcut if disabled
2002          */
2003         if (hardlink_check_uid == 0 && hardlink_check_gid == 0)
2004                 return (0);
2005
2006         /*
2007          * root cred can always hardlink
2008          */
2009         if (suser_cred(cred, PRISON_ROOT) == 0)
2010                 return (0);
2011
2012         /*
2013          * Otherwise only if the originating file is owned by the
2014          * same user or group.  Note that any group is allowed if
2015          * the file is owned by the caller.
2016          */
2017         error = VOP_GETATTR(vp, &va);
2018         if (error != 0)
2019                 return (error);
2020         
2021         if (hardlink_check_uid) {
2022                 if (cred->cr_uid != va.va_uid)
2023                         return (EPERM);
2024         }
2025         
2026         if (hardlink_check_gid) {
2027                 if (cred->cr_uid != va.va_uid && !groupmember(va.va_gid, cred))
2028                         return (EPERM);
2029         }
2030
2031         return (0);
2032 }
2033
2034 int
2035 kern_link(struct nlookupdata *nd, struct nlookupdata *linknd)
2036 {
2037         struct thread *td = curthread;
2038         struct vnode *vp;
2039         int error;
2040
2041         /*
2042          * Lookup the source and obtained a locked vnode.
2043          *
2044          * XXX relookup on vget failure / race ?
2045          */
2046         bwillinode(1);
2047         if ((error = nlookup(nd)) != 0)
2048                 return (error);
2049         vp = nd->nl_nch.ncp->nc_vp;
2050         KKASSERT(vp != NULL);
2051         if (vp->v_type == VDIR)
2052                 return (EPERM);         /* POSIX */
2053         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
2054                 return (error);
2055         if ((error = vget(vp, LK_EXCLUSIVE)) != 0)
2056                 return (error);
2057
2058         /*
2059          * Unlock the source so we can lookup the target without deadlocking
2060          * (XXX vp is locked already, possible other deadlock?).  The target
2061          * must not exist.
2062          */
2063         KKASSERT(nd->nl_flags & NLC_NCPISLOCKED);
2064         nd->nl_flags &= ~NLC_NCPISLOCKED;
2065         cache_unlock(&nd->nl_nch);
2066
2067         linknd->nl_flags |= NLC_CREATE | NLC_REFDVP;
2068         if ((error = nlookup(linknd)) != 0) {
2069                 vput(vp);
2070                 return (error);
2071         }
2072         if (linknd->nl_nch.ncp->nc_vp) {
2073                 vput(vp);
2074                 return (EEXIST);
2075         }
2076
2077         /*
2078          * Finally run the new API VOP.
2079          */
2080         error = can_hardlink(vp, td, td->td_proc->p_ucred);
2081         if (error == 0) {
2082                 error = VOP_NLINK(&linknd->nl_nch, linknd->nl_dvp,
2083                                   vp, linknd->nl_cred);
2084         }
2085         vput(vp);
2086         return (error);
2087 }
2088
2089 /*
2090  * link_args(char *path, char *link)
2091  *
2092  * Make a hard file link.
2093  */
2094 int
2095 sys_link(struct link_args *uap)
2096 {
2097         struct nlookupdata nd, linknd;
2098         int error;
2099
2100         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
2101         if (error == 0) {
2102                 error = nlookup_init(&linknd, uap->link, UIO_USERSPACE, 0);
2103                 if (error == 0)
2104                         error = kern_link(&nd, &linknd);
2105                 nlookup_done(&linknd);
2106         }
2107         nlookup_done(&nd);
2108         return (error);
2109 }
2110
2111 int
2112 kern_symlink(struct nlookupdata *nd, char *path, int mode)
2113 {
2114         struct vattr vattr;
2115         struct vnode *vp;
2116         struct vnode *dvp;
2117         int error;
2118
2119         bwillinode(1);
2120         nd->nl_flags |= NLC_CREATE | NLC_REFDVP;
2121         if ((error = nlookup(nd)) != 0)
2122                 return (error);
2123         if (nd->nl_nch.ncp->nc_vp)
2124                 return (EEXIST);
2125         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
2126                 return (error);
2127         dvp = nd->nl_dvp;
2128         VATTR_NULL(&vattr);
2129         vattr.va_mode = mode;
2130         error = VOP_NSYMLINK(&nd->nl_nch, dvp, &vp, nd->nl_cred, &vattr, path);
2131         if (error == 0)
2132                 vput(vp);
2133         return (error);
2134 }
2135
2136 /*
2137  * symlink(char *path, char *link)
2138  *
2139  * Make a symbolic link.
2140  */
2141 int
2142 sys_symlink(struct symlink_args *uap)
2143 {
2144         struct thread *td = curthread;
2145         struct nlookupdata nd;
2146         char *path;
2147         int error;
2148         int mode;
2149
2150         path = objcache_get(namei_oc, M_WAITOK);
2151         error = copyinstr(uap->path, path, MAXPATHLEN, NULL);
2152         if (error == 0) {
2153                 error = nlookup_init(&nd, uap->link, UIO_USERSPACE, 0);
2154                 if (error == 0) {
2155                         mode = ACCESSPERMS & ~td->td_proc->p_fd->fd_cmask;
2156                         error = kern_symlink(&nd, path, mode);
2157                 }
2158                 nlookup_done(&nd);
2159         }
2160         objcache_put(namei_oc, path);
2161         return (error);
2162 }
2163
2164 /*
2165  * undelete_args(char *path)
2166  *
2167  * Delete a whiteout from the filesystem.
2168  */
2169 /* ARGSUSED */
2170 int
2171 sys_undelete(struct undelete_args *uap)
2172 {
2173         struct nlookupdata nd;
2174         int error;
2175
2176         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
2177         bwillinode(1);
2178         nd.nl_flags |= NLC_DELETE | NLC_REFDVP;
2179         if (error == 0)
2180                 error = nlookup(&nd);
2181         if (error == 0)
2182                 error = ncp_writechk(&nd.nl_nch);
2183         if (error == 0) {
2184                 error = VOP_NWHITEOUT(&nd.nl_nch, nd.nl_dvp, nd.nl_cred,
2185                                       NAMEI_DELETE);
2186         }
2187         nlookup_done(&nd);
2188         return (error);
2189 }
2190
2191 int
2192 kern_unlink(struct nlookupdata *nd)
2193 {
2194         int error;
2195
2196         bwillinode(1);
2197         nd->nl_flags |= NLC_DELETE | NLC_REFDVP;
2198         if ((error = nlookup(nd)) != 0)
2199                 return (error);
2200         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
2201                 return (error);
2202         error = VOP_NREMOVE(&nd->nl_nch, nd->nl_dvp, nd->nl_cred);
2203         return (error);
2204 }
2205
2206 /*
2207  * unlink_args(char *path)
2208  *
2209  * Delete a name from the filesystem.
2210  */
2211 int
2212 sys_unlink(struct unlink_args *uap)
2213 {
2214         struct nlookupdata nd;
2215         int error;
2216
2217         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
2218         if (error == 0)
2219                 error = kern_unlink(&nd);
2220         nlookup_done(&nd);
2221         return (error);
2222 }
2223
2224 int
2225 kern_lseek(int fd, off_t offset, int whence, off_t *res)
2226 {
2227         struct thread *td = curthread;
2228         struct proc *p = td->td_proc;
2229         struct file *fp;
2230         struct vnode *vp;
2231         struct vattr vattr;
2232         off_t new_offset;
2233         int error;
2234
2235         fp = holdfp(p->p_fd, fd, -1);
2236         if (fp == NULL)
2237                 return (EBADF);
2238         if (fp->f_type != DTYPE_VNODE) {
2239                 error = ESPIPE;
2240                 goto done;
2241         }
2242         vp = (struct vnode *)fp->f_data;
2243
2244         switch (whence) {
2245         case L_INCR:
2246                 new_offset = fp->f_offset + offset;
2247                 error = 0;
2248                 break;
2249         case L_XTND:
2250                 error = VOP_GETATTR(vp, &vattr);
2251                 new_offset = offset + vattr.va_size;
2252                 break;
2253         case L_SET:
2254                 new_offset = offset;
2255                 error = 0;
2256                 break;
2257         default:
2258                 new_offset = 0;
2259                 error = EINVAL;
2260                 break;
2261         }
2262
2263         /*
2264          * Validate the seek position.  Negative offsets are not allowed
2265          * for regular files, block specials, or directories.
2266          */
2267         if (error == 0) {
2268                 if (new_offset < 0 &&
2269                     (vp->v_type == VREG || vp->v_type == VDIR ||
2270                      vp->v_type == VCHR || vp->v_type == VBLK)) {
2271                         error = EINVAL;
2272                 } else {
2273                         fp->f_offset = new_offset;
2274                 }
2275         }
2276         *res = fp->f_offset;
2277 done:
2278         fdrop(fp);
2279         return (error);
2280 }
2281
2282 /*
2283  * lseek_args(int fd, int pad, off_t offset, int whence)
2284  *
2285  * Reposition read/write file offset.
2286  */
2287 int
2288 sys_lseek(struct lseek_args *uap)
2289 {
2290         int error;
2291
2292         error = kern_lseek(uap->fd, uap->offset, uap->whence,
2293                            &uap->sysmsg_offset);
2294
2295         return (error);
2296 }
2297
2298 int
2299 kern_access(struct nlookupdata *nd, int aflags)
2300 {
2301         struct vnode *vp;
2302         int error, flags;
2303
2304         if ((error = nlookup(nd)) != 0)
2305                 return (error);
2306 retry:
2307         error = cache_vget(&nd->nl_nch, nd->nl_cred, LK_EXCLUSIVE, &vp);
2308         if (error)
2309                 return (error);
2310
2311         /* Flags == 0 means only check for existence. */
2312         if (aflags) {
2313                 flags = 0;
2314                 if (aflags & R_OK)
2315                         flags |= VREAD;
2316                 if (aflags & W_OK)
2317                         flags |= VWRITE;
2318                 if (aflags & X_OK)
2319                         flags |= VEXEC;
2320                 if ((flags & VWRITE) == 0 || 
2321                     (error = vn_writechk(vp, &nd->nl_nch)) == 0)
2322                         error = VOP_ACCESS(vp, flags, nd->nl_cred);
2323
2324                 /*
2325                  * If the file handle is stale we have to re-resolve the
2326                  * entry.  This is a hack at the moment.
2327                  */
2328                 if (error == ESTALE) {
2329                         vput(vp);
2330                         cache_setunresolved(&nd->nl_nch);
2331                         error = cache_resolve(&nd->nl_nch, nd->nl_cred);
2332                         if (error == 0) {
2333                                 vp = NULL;
2334                                 goto retry;
2335                         }
2336                         return(error);
2337                 }
2338         }
2339         vput(vp);
2340         return (error);
2341 }
2342
2343 /*
2344  * access_args(char *path, int flags)
2345  *
2346  * Check access permissions.
2347  */
2348 int
2349 sys_access(struct access_args *uap)
2350 {
2351         struct nlookupdata nd;
2352         int error;
2353
2354         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
2355         if (error == 0)
2356                 error = kern_access(&nd, uap->flags);
2357         nlookup_done(&nd);
2358         return (error);
2359 }
2360
2361 int
2362 kern_stat(struct nlookupdata *nd, struct stat *st)
2363 {
2364         int error;
2365         struct vnode *vp;
2366         thread_t td;
2367
2368         if ((error = nlookup(nd)) != 0)
2369                 return (error);
2370 again:
2371         if ((vp = nd->nl_nch.ncp->nc_vp) == NULL)
2372                 return (ENOENT);
2373
2374         td = curthread;
2375         if ((error = vget(vp, LK_SHARED)) != 0)
2376                 return (error);
2377         error = vn_stat(vp, st, nd->nl_cred);
2378
2379         /*
2380          * If the file handle is stale we have to re-resolve the entry.  This
2381          * is a hack at the moment.
2382          */
2383         if (error == ESTALE) {
2384                 vput(vp);
2385                 cache_setunresolved(&nd->nl_nch);
2386                 error = cache_resolve(&nd->nl_nch, nd->nl_cred);
2387                 if (error == 0)
2388                         goto again;
2389         } else {
2390                 vput(vp);
2391         }
2392         return (error);
2393 }
2394
2395 /*
2396  * stat_args(char *path, struct stat *ub)
2397  *
2398  * Get file status; this version follows links.
2399  */
2400 int
2401 sys_stat(struct stat_args *uap)
2402 {
2403         struct nlookupdata nd;
2404         struct stat st;
2405         int error;
2406
2407         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
2408         if (error == 0) {
2409                 error = kern_stat(&nd, &st);
2410                 if (error == 0)
2411                         error = copyout(&st, uap->ub, sizeof(*uap->ub));
2412         }
2413         nlookup_done(&nd);
2414         return (error);
2415 }
2416
2417 /*
2418  * lstat_args(char *path, struct stat *ub)
2419  *
2420  * Get file status; this version does not follow links.
2421  */
2422 int
2423 sys_lstat(struct lstat_args *uap)
2424 {
2425         struct nlookupdata nd;
2426         struct stat st;
2427         int error;
2428
2429         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
2430         if (error == 0) {
2431                 error = kern_stat(&nd, &st);
2432                 if (error == 0)
2433                         error = copyout(&st, uap->ub, sizeof(*uap->ub));
2434         }
2435         nlookup_done(&nd);
2436         return (error);
2437 }
2438
2439 /*
2440  * pathconf_Args(char *path, int name)
2441  *
2442  * Get configurable pathname variables.
2443  */
2444 /* ARGSUSED */
2445 int
2446 sys_pathconf(struct pathconf_args *uap)
2447 {
2448         struct nlookupdata nd;
2449         struct vnode *vp;
2450         int error;
2451
2452         vp = NULL;
2453         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
2454         if (error == 0)
2455                 error = nlookup(&nd);
2456         if (error == 0)
2457                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
2458         nlookup_done(&nd);
2459         if (error == 0) {
2460                 error = VOP_PATHCONF(vp, uap->name, uap->sysmsg_fds);
2461                 vput(vp);
2462         }
2463         return (error);
2464 }
2465
2466 /*
2467  * XXX: daver
2468  * kern_readlink isn't properly split yet.  There is a copyin burried
2469  * in VOP_READLINK().
2470  */
2471 int
2472 kern_readlink(struct nlookupdata *nd, char *buf, int count, int *res)
2473 {
2474         struct thread *td = curthread;
2475         struct proc *p = td->td_proc;
2476         struct vnode *vp;
2477         struct iovec aiov;
2478         struct uio auio;
2479         int error;
2480
2481         if ((error = nlookup(nd)) != 0)
2482                 return (error);
2483         error = cache_vget(&nd->nl_nch, nd->nl_cred, LK_EXCLUSIVE, &vp);
2484         if (error)
2485                 return (error);
2486         if (vp->v_type != VLNK) {
2487                 error = EINVAL;
2488         } else {
2489                 aiov.iov_base = buf;
2490                 aiov.iov_len = count;
2491                 auio.uio_iov = &aiov;
2492                 auio.uio_iovcnt = 1;
2493                 auio.uio_offset = 0;
2494                 auio.uio_rw = UIO_READ;
2495                 auio.uio_segflg = UIO_USERSPACE;
2496                 auio.uio_td = td;
2497                 auio.uio_resid = count;
2498                 error = VOP_READLINK(vp, &auio, p->p_ucred);
2499         }
2500         vput(vp);
2501         *res = count - auio.uio_resid;
2502         return (error);
2503 }
2504
2505 /*
2506  * readlink_args(char *path, char *buf, int count)
2507  *
2508  * Return target name of a symbolic link.
2509  */
2510 int
2511 sys_readlink(struct readlink_args *uap)
2512 {
2513         struct nlookupdata nd;
2514         int error;
2515
2516         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
2517         if (error == 0) {
2518                 error = kern_readlink(&nd, uap->buf, uap->count,
2519                                         &uap->sysmsg_result);
2520         }
2521         nlookup_done(&nd);
2522         return (error);
2523 }
2524
2525 static int
2526 setfflags(struct vnode *vp, int flags)
2527 {
2528         struct thread *td = curthread;
2529         struct proc *p = td->td_proc;
2530         int error;
2531         struct vattr vattr;
2532
2533         /*
2534          * Prevent non-root users from setting flags on devices.  When
2535          * a device is reused, users can retain ownership of the device
2536          * if they are allowed to set flags and programs assume that
2537          * chown can't fail when done as root.
2538          */
2539         if ((vp->v_type == VCHR || vp->v_type == VBLK) && 
2540             ((error = suser_cred(p->p_ucred, PRISON_ROOT)) != 0))
2541                 return (error);
2542
2543         /*
2544          * note: vget is required for any operation that might mod the vnode
2545          * so VINACTIVE is properly cleared.
2546          */
2547         if ((error = vget(vp, LK_EXCLUSIVE)) == 0) {
2548                 VATTR_NULL(&vattr);
2549                 vattr.va_flags = flags;
2550                 error = VOP_SETATTR(vp, &vattr, p->p_ucred);
2551                 vput(vp);
2552         }
2553         return (error);
2554 }
2555
2556 /*
2557  * chflags(char *path, int flags)
2558  *
2559  * Change flags of a file given a path name.
2560  */
2561 /* ARGSUSED */
2562 int
2563 sys_chflags(struct chflags_args *uap)
2564 {
2565         struct nlookupdata nd;
2566         struct vnode *vp;
2567         int error;
2568
2569         vp = NULL;
2570         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
2571         /* XXX Add NLC flag indicating modifying operation? */
2572         if (error == 0)
2573                 error = nlookup(&nd);
2574         if (error == 0)
2575                 error = ncp_writechk(&nd.nl_nch);
2576         if (error == 0)
2577                 error = cache_vref(&nd.nl_nch, nd.nl_cred, &vp);
2578         nlookup_done(&nd);
2579         if (error == 0) {
2580                 error = setfflags(vp, uap->flags);
2581                 vrele(vp);
2582         }
2583         return (error);
2584 }
2585
2586 /*
2587  * fchflags_args(int fd, int flags)
2588  *
2589  * Change flags of a file given a file descriptor.
2590  */
2591 /* ARGSUSED */
2592 int
2593 sys_fchflags(struct fchflags_args *uap)
2594 {
2595         struct thread *td = curthread;
2596         struct proc *p = td->td_proc;
2597         struct file *fp;
2598         int error;
2599
2600         if ((error = holdvnode(p->p_fd, uap->fd, &fp)) != 0)
2601                 return (error);
2602         if (fp->f_nchandle.ncp)
2603                 error = ncp_writechk(&fp->f_nchandle);
2604         if (error == 0)
2605                 error = setfflags((struct vnode *) fp->f_data, uap->flags);
2606         fdrop(fp);
2607         return (error);
2608 }
2609
2610 static int
2611 setfmode(struct vnode *vp, int mode)
2612 {
2613         struct thread *td = curthread;
2614         struct proc *p = td->td_proc;
2615         int error;
2616         struct vattr vattr;
2617
2618         /*
2619          * note: vget is required for any operation that might mod the vnode
2620          * so VINACTIVE is properly cleared.
2621          */
2622         if ((error = vget(vp, LK_EXCLUSIVE)) == 0) {
2623                 VATTR_NULL(&vattr);
2624                 vattr.va_mode = mode & ALLPERMS;
2625                 error = VOP_SETATTR(vp, &vattr, p->p_ucred);
2626                 vput(vp);
2627         }
2628         return error;
2629 }
2630
2631 int
2632 kern_chmod(struct nlookupdata *nd, int mode)
2633 {
2634         struct vnode *vp;
2635         int error;
2636
2637         /* XXX Add NLC flag indicating modifying operation? */
2638         if ((error = nlookup(nd)) != 0)
2639                 return (error);
2640         if ((error = cache_vref(&nd->nl_nch, nd->nl_cred, &vp)) != 0)
2641                 return (error);
2642         if ((error = ncp_writechk(&nd->nl_nch)) == 0)
2643                 error = setfmode(vp, mode);
2644         vrele(vp);
2645         return (error);
2646 }
2647
2648 /*
2649  * chmod_args(char *path, int mode)
2650  *
2651  * Change mode of a file given path name.
2652  */
2653 /* ARGSUSED */
2654 int
2655 sys_chmod(struct chmod_args *uap)
2656 {
2657         struct nlookupdata nd;
2658         int error;
2659
2660         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
2661         if (error == 0)
2662                 error = kern_chmod(&nd, uap->mode);
2663         nlookup_done(&nd);
2664         return (error);
2665 }
2666
2667 /*
2668  * lchmod_args(char *path, int mode)
2669  *
2670  * Change mode of a file given path name (don't follow links.)
2671  */
2672 /* ARGSUSED */
2673 int
2674 sys_lchmod(struct lchmod_args *uap)
2675 {
2676         struct nlookupdata nd;
2677         int error;
2678
2679         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
2680         if (error == 0)
2681                 error = kern_chmod(&nd, uap->mode);
2682         nlookup_done(&nd);
2683         return (error);
2684 }
2685
2686 /*
2687  * fchmod_args(int fd, int mode)
2688  *
2689  * Change mode of a file given a file descriptor.
2690  */
2691 /* ARGSUSED */
2692 int
2693 sys_fchmod(struct fchmod_args *uap)
2694 {
2695         struct thread *td = curthread;
2696         struct proc *p = td->td_proc;
2697         struct file *fp;
2698         int error;
2699
2700         if ((error = holdvnode(p->p_fd, uap->fd, &fp)) != 0)
2701                 return (error);
2702         if (fp->f_nchandle.ncp)
2703                 error = ncp_writechk(&fp->f_nchandle);
2704         if (error == 0)
2705                 error = setfmode((struct vnode *)fp->f_data, uap->mode);
2706         fdrop(fp);
2707         return (error);
2708 }
2709
2710 static int
2711 setfown(struct vnode *vp, uid_t uid, gid_t gid)
2712 {
2713         struct thread *td = curthread;
2714         struct proc *p = td->td_proc;
2715         int error;
2716         struct vattr vattr;
2717
2718         /*
2719          * note: vget is required for any operation that might mod the vnode
2720          * so VINACTIVE is properly cleared.
2721          */
2722         if ((error = vget(vp, LK_EXCLUSIVE)) == 0) {
2723                 VATTR_NULL(&vattr);
2724                 vattr.va_uid = uid;
2725                 vattr.va_gid = gid;
2726                 error = VOP_SETATTR(vp, &vattr, p->p_ucred);
2727                 vput(vp);
2728         }
2729         return error;
2730 }
2731
2732 int
2733 kern_chown(struct nlookupdata *nd, int uid, int gid)
2734 {
2735         struct vnode *vp;
2736         int error;
2737
2738         /* XXX Add NLC flag indicating modifying operation? */
2739         if ((error = nlookup(nd)) != 0)
2740                 return (error);
2741         if ((error = cache_vref(&nd->nl_nch, nd->nl_cred, &vp)) != 0)
2742                 return (error);
2743         if ((error = ncp_writechk(&nd->nl_nch)) == 0)
2744                 error = setfown(vp, uid, gid);
2745         vrele(vp);
2746         return (error);
2747 }
2748
2749 /*
2750  * chown(char *path, int uid, int gid)
2751  *
2752  * Set ownership given a path name.
2753  */
2754 int
2755 sys_chown(struct chown_args *uap)
2756 {
2757         struct nlookupdata nd;
2758         int error;
2759
2760         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
2761         if (error == 0)
2762                 error = kern_chown(&nd, uap->uid, uap->gid);
2763         nlookup_done(&nd);
2764         return (error);
2765 }
2766
2767 /*
2768  * lchown_args(char *path, int uid, int gid)
2769  *
2770  * Set ownership given a path name, do not cross symlinks.
2771  */
2772 int
2773 sys_lchown(struct lchown_args *uap)
2774 {
2775         struct nlookupdata nd;
2776         int error;
2777
2778         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
2779         if (error == 0)
2780                 error = kern_chown(&nd, uap->uid, uap->gid);
2781         nlookup_done(&nd);
2782         return (error);
2783 }
2784
2785 /*
2786  * fchown_args(int fd, int uid, int gid)
2787  *
2788  * Set ownership given a file descriptor.
2789  */
2790 /* ARGSUSED */
2791 int
2792 sys_fchown(struct fchown_args *uap)
2793 {
2794         struct thread *td = curthread;
2795         struct proc *p = td->td_proc;
2796         struct file *fp;
2797         int error;
2798
2799         if ((error = holdvnode(p->p_fd, uap->fd, &fp)) != 0)
2800                 return (error);
2801         if (fp->f_nchandle.ncp)
2802                 error = ncp_writechk(&fp->f_nchandle);
2803         if (error == 0)
2804                 error = setfown((struct vnode *)fp->f_data, uap->uid, uap->gid);
2805         fdrop(fp);
2806         return (error);
2807 }
2808
2809 static int
2810 getutimes(const struct timeval *tvp, struct timespec *tsp)
2811 {
2812         struct timeval tv[2];
2813
2814         if (tvp == NULL) {
2815                 microtime(&tv[0]);
2816                 TIMEVAL_TO_TIMESPEC(&tv[0], &tsp[0]);
2817                 tsp[1] = tsp[0];
2818         } else {
2819                 TIMEVAL_TO_TIMESPEC(&tvp[0], &tsp[0]);
2820                 TIMEVAL_TO_TIMESPEC(&tvp[1], &tsp[1]);
2821         }
2822         return 0;
2823 }
2824
2825 static int
2826 setutimes(struct vnode *vp, const struct timespec *ts, int nullflag)
2827 {
2828         struct thread *td = curthread;
2829         struct proc *p = td->td_proc;
2830         int error;
2831         struct vattr vattr;
2832
2833         /*
2834          * note: vget is required for any operation that might mod the vnode
2835          * so VINACTIVE is properly cleared.
2836          */
2837         if ((error = vget(vp, LK_EXCLUSIVE)) == 0) {
2838                 VATTR_NULL(&vattr);
2839                 vattr.va_atime = ts[0];
2840                 vattr.va_mtime = ts[1];
2841                 if (nullflag)
2842                         vattr.va_vaflags |= VA_UTIMES_NULL;
2843                 error = VOP_SETATTR(vp, &vattr, p->p_ucred);
2844                 vput(vp);
2845         }
2846         return error;
2847 }
2848
2849 int
2850 kern_utimes(struct nlookupdata *nd, struct timeval *tptr)
2851 {
2852         struct timespec ts[2];
2853         struct vnode *vp;
2854         int error;
2855
2856         if ((error = getutimes(tptr, ts)) != 0)
2857                 return (error);
2858         /* XXX Add NLC flag indicating modifying operation? */
2859         if ((error = nlookup(nd)) != 0)
2860                 return (error);
2861         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
2862                 return (error);
2863         if ((error = cache_vref(&nd->nl_nch, nd->nl_cred, &vp)) != 0)
2864                 return (error);
2865         error = setutimes(vp, ts, tptr == NULL);
2866         vrele(vp);
2867         return (error);
2868 }
2869
2870 /*
2871  * utimes_args(char *path, struct timeval *tptr)
2872  *
2873  * Set the access and modification times of a file.
2874  */
2875 int
2876 sys_utimes(struct utimes_args *uap)
2877 {
2878         struct timeval tv[2];
2879         struct nlookupdata nd;
2880         int error;
2881
2882         if (uap->tptr) {
2883                 error = copyin(uap->tptr, tv, sizeof(tv));
2884                 if (error)
2885                         return (error);
2886         }
2887         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
2888         if (error == 0)
2889                 error = kern_utimes(&nd, uap->tptr ? tv : NULL);
2890         nlookup_done(&nd);
2891         return (error);
2892 }
2893
2894 /*
2895  * lutimes_args(char *path, struct timeval *tptr)
2896  *
2897  * Set the access and modification times of a file.
2898  */
2899 int
2900 sys_lutimes(struct lutimes_args *uap)
2901 {
2902         struct timeval tv[2];
2903         struct nlookupdata nd;
2904         int error;
2905
2906         if (uap->tptr) {
2907                 error = copyin(uap->tptr, tv, sizeof(tv));
2908                 if (error)
2909                         return (error);
2910         }
2911         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
2912         if (error == 0)
2913                 error = kern_utimes(&nd, uap->tptr ? tv : NULL);
2914         nlookup_done(&nd);
2915         return (error);
2916 }
2917
2918 int
2919 kern_futimes(int fd, struct timeval *tptr)
2920 {
2921         struct thread *td = curthread;
2922         struct proc *p = td->td_proc;
2923         struct timespec ts[2];
2924         struct file *fp;
2925         int error;
2926
2927         error = getutimes(tptr, ts);
2928         if (error)
2929                 return (error);
2930         if ((error = holdvnode(p->p_fd, fd, &fp)) != 0)
2931                 return (error);
2932         if (fp->f_nchandle.ncp)
2933                 error = ncp_writechk(&fp->f_nchandle);
2934         if (error == 0)
2935                 error =  setutimes((struct vnode *)fp->f_data, ts, tptr == NULL);
2936         fdrop(fp);
2937         return (error);
2938 }
2939
2940 /*
2941  * futimes_args(int fd, struct timeval *tptr)
2942  *
2943  * Set the access and modification times of a file.
2944  */
2945 int
2946 sys_futimes(struct futimes_args *uap)
2947 {
2948         struct timeval tv[2];
2949         int error;
2950
2951         if (uap->tptr) {
2952                 error = copyin(uap->tptr, tv, sizeof(tv));
2953                 if (error)
2954                         return (error);
2955         }
2956
2957         error = kern_futimes(uap->fd, uap->tptr ? tv : NULL);
2958
2959         return (error);
2960 }
2961
2962 int
2963 kern_truncate(struct nlookupdata *nd, off_t length)
2964 {
2965         struct vnode *vp;
2966         struct vattr vattr;
2967         int error;
2968
2969         if (length < 0)
2970                 return(EINVAL);
2971         /* XXX Add NLC flag indicating modifying operation? */
2972         if ((error = nlookup(nd)) != 0)
2973                 return (error);
2974         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
2975                 return (error);
2976         if ((error = cache_vref(&nd->nl_nch, nd->nl_cred, &vp)) != 0)
2977                 return (error);
2978         if ((error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY)) != 0) {
2979                 vrele(vp);
2980                 return (error);
2981         }
2982         if (vp->v_type == VDIR) {
2983                 error = EISDIR;
2984         } else if ((error = vn_writechk(vp, &nd->nl_nch)) == 0 &&
2985             (error = VOP_ACCESS(vp, VWRITE, nd->nl_cred)) == 0) {
2986                 VATTR_NULL(&vattr);
2987                 vattr.va_size = length;
2988                 error = VOP_SETATTR(vp, &vattr, nd->nl_cred);
2989         }
2990         vput(vp);
2991         return (error);
2992 }
2993
2994 /*
2995  * truncate(char *path, int pad, off_t length)
2996  *
2997  * Truncate a file given its path name.
2998  */
2999 int
3000 sys_truncate(struct truncate_args *uap)
3001 {
3002         struct nlookupdata nd;
3003         int error;
3004
3005         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
3006         if (error == 0)
3007                 error = kern_truncate(&nd, uap->length);
3008         nlookup_done(&nd);
3009         return error;
3010 }
3011
3012 int
3013 kern_ftruncate(int fd, off_t length)
3014 {
3015         struct thread *td = curthread;
3016         struct proc *p = td->td_proc;
3017         struct vattr vattr;
3018         struct vnode *vp;
3019         struct file *fp;
3020         int error;
3021
3022         if (length < 0)
3023                 return(EINVAL);
3024         if ((error = holdvnode(p->p_fd, fd, &fp)) != 0)
3025                 return (error);
3026         if (fp->f_nchandle.ncp) {
3027                 error = ncp_writechk(&fp->f_nchandle);
3028                 if (error)
3029                         goto done;
3030         }
3031         if ((fp->f_flag & FWRITE) == 0) {
3032                 error = EINVAL;
3033                 goto done;
3034         }
3035         vp = (struct vnode *)fp->f_data;
3036         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3037         if (vp->v_type == VDIR) {
3038                 error = EISDIR;
3039         } else if ((error = vn_writechk(vp, NULL)) == 0) {
3040                 VATTR_NULL(&vattr);
3041                 vattr.va_size = length;
3042                 error = VOP_SETATTR(vp, &vattr, fp->f_cred);
3043         }
3044         vn_unlock(vp);
3045 done:
3046         fdrop(fp);
3047         return (error);
3048 }
3049
3050 /*
3051  * ftruncate_args(int fd, int pad, off_t length)
3052  *
3053  * Truncate a file given a file descriptor.
3054  */
3055 int
3056 sys_ftruncate(struct ftruncate_args *uap)
3057 {
3058         int error;
3059
3060         error = kern_ftruncate(uap->fd, uap->length);
3061
3062         return (error);
3063 }
3064
3065 /*
3066  * fsync(int fd)
3067  *
3068  * Sync an open file.
3069  */
3070 /* ARGSUSED */
3071 int
3072 sys_fsync(struct fsync_args *uap)
3073 {
3074         struct thread *td = curthread;
3075         struct proc *p = td->td_proc;
3076         struct vnode *vp;
3077         struct file *fp;
3078         vm_object_t obj;
3079         int error;
3080
3081         if ((error = holdvnode(p->p_fd, uap->fd, &fp)) != 0)
3082                 return (error);
3083         vp = (struct vnode *)fp->f_data;
3084         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3085         if ((obj = vp->v_object) != NULL)
3086                 vm_object_page_clean(obj, 0, 0, 0);
3087         if ((error = VOP_FSYNC(vp, MNT_WAIT)) == 0 && vp->v_mount)
3088                 error = buf_fsync(vp);
3089         vn_unlock(vp);
3090         fdrop(fp);
3091         return (error);
3092 }
3093
3094 int
3095 kern_rename(struct nlookupdata *fromnd, struct nlookupdata *tond)
3096 {
3097         struct nchandle fnchd;
3098         struct nchandle tnchd;
3099         struct namecache *ncp;
3100         struct vnode *fdvp;
3101         struct vnode *tdvp;
3102         struct mount *mp;
3103         int error;
3104
3105         bwillinode(1);
3106         fromnd->nl_flags |= NLC_REFDVP;
3107         if ((error = nlookup(fromnd)) != 0)
3108                 return (error);
3109         if ((fnchd.ncp = fromnd->nl_nch.ncp->nc_parent) == NULL)
3110                 return (ENOENT);
3111         fnchd.mount = fromnd->nl_nch.mount;
3112         cache_hold(&fnchd);
3113
3114         /*
3115          * unlock the source nch so we can lookup the target nch without
3116          * deadlocking.  The target may or may not exist so we do not check
3117          * for a target vp like kern_mkdir() and other creation functions do.
3118          *
3119          * The source and target directories are ref'd and rechecked after
3120          * everything is relocked to determine if the source or target file
3121          * has been renamed.
3122          */
3123         KKASSERT(fromnd->nl_flags & NLC_NCPISLOCKED);
3124         fromnd->nl_flags &= ~NLC_NCPISLOCKED;
3125         cache_unlock(&fromnd->nl_nch);
3126
3127         tond->nl_flags |= NLC_CREATE | NLC_REFDVP;
3128         if ((error = nlookup(tond)) != 0) {
3129                 cache_drop(&fnchd);
3130                 return (error);
3131         }
3132         if ((tnchd.ncp = tond->nl_nch.ncp->nc_parent) == NULL) {
3133                 cache_drop(&fnchd);
3134                 return (ENOENT);
3135         }
3136         tnchd.mount = tond->nl_nch.mount;
3137         cache_hold(&tnchd);
3138
3139         /*
3140          * If the source and target are the same there is nothing to do
3141          */
3142         if (fromnd->nl_nch.ncp == tond->nl_nch.ncp) {
3143                 cache_drop(&fnchd);
3144                 cache_drop(&tnchd);
3145                 return (0);
3146         }
3147
3148         /*
3149          * Mount points cannot be renamed or overwritten
3150          */
3151         if ((fromnd->nl_nch.ncp->nc_flag | tond->nl_nch.ncp->nc_flag) &
3152             NCF_ISMOUNTPT
3153         ) {
3154                 cache_drop(&fnchd);
3155                 cache_drop(&tnchd);
3156                 return (EINVAL);
3157         }
3158
3159         /*
3160          * relock the source ncp.  NOTE AFTER RELOCKING: the source ncp
3161          * may have become invalid while it was unlocked, nc_vp and nc_mount
3162          * could be NULL.
3163          */
3164         if (cache_lock_nonblock(&fromnd->nl_nch) == 0) {
3165                 cache_resolve(&fromnd->nl_nch, fromnd->nl_cred);
3166         } else if (fromnd->nl_nch.ncp > tond->nl_nch.ncp) {
3167                 cache_lock(&fromnd->nl_nch);
3168                 cache_resolve(&fromnd->nl_nch, fromnd->nl_cred);
3169         } else {
3170                 cache_unlock(&tond->nl_nch);
3171                 cache_lock(&fromnd->nl_nch);
3172                 cache_resolve(&fromnd->nl_nch, fromnd->nl_cred);
3173                 cache_lock(&tond->nl_nch);
3174                 cache_resolve(&tond->nl_nch, tond->nl_cred);
3175         }
3176         fromnd->nl_flags |= NLC_NCPISLOCKED;
3177
3178         /*
3179          * make sure the parent directories linkages are the same
3180          */
3181         if (fnchd.ncp != fromnd->nl_nch.ncp->nc_parent ||
3182             tnchd.ncp != tond->nl_nch.ncp->nc_parent) {
3183                 cache_drop(&fnchd);
3184                 cache_drop(&tnchd);
3185                 return (ENOENT);
3186         }
3187
3188         /*
3189          * Both the source and target must be within the same filesystem and
3190          * in the same filesystem as their parent directories within the
3191          * namecache topology.
3192          *
3193          * NOTE: fromnd's nc_mount or nc_vp could be NULL.
3194          */
3195         mp = fnchd.mount;
3196         if (mp != tnchd.mount || mp != fromnd->nl_nch.mount ||
3197             mp != tond->nl_nch.mount) {
3198                 cache_drop(&fnchd);
3199                 cache_drop(&tnchd);
3200                 return (EXDEV);
3201         }
3202
3203         /*
3204          * Make sure the mount point is writable
3205          */
3206         if ((error = ncp_writechk(&tond->nl_nch)) != 0) {
3207                 cache_drop(&fnchd);
3208                 cache_drop(&tnchd);
3209                 return (error);
3210         }
3211
3212         /*
3213          * If the target exists and either the source or target is a directory,
3214          * then both must be directories.
3215          *
3216          * Due to relocking of the source, fromnd->nl_nch.ncp->nc_vp might h
3217          * have become NULL.
3218          */
3219         if (tond->nl_nch.ncp->nc_vp) {
3220                 if (fromnd->nl_nch.ncp->nc_vp == NULL) {
3221                         error = ENOENT;
3222                 } else if (fromnd->nl_nch.ncp->nc_vp->v_type == VDIR) {
3223                         if (tond->nl_nch.ncp->nc_vp->v_type != VDIR)
3224                                 error = ENOTDIR;
3225                 } else if (tond->nl_nch.ncp->nc_vp->v_type == VDIR) {
3226                         error = EISDIR;
3227                 }
3228         }
3229
3230         /*
3231          * You cannot rename a source into itself or a subdirectory of itself.
3232          * We check this by travsersing the target directory upwards looking
3233          * for a match against the source.
3234          */
3235         if (error == 0) {
3236                 for (ncp = tnchd.ncp; ncp; ncp = ncp->nc_parent) {
3237                         if (fromnd->nl_nch.ncp == ncp) {
3238                                 error = EINVAL;
3239                                 break;
3240                         }
3241                 }
3242         }
3243
3244         cache_drop(&fnchd);
3245         cache_drop(&tnchd);
3246
3247         /*
3248          * Even though the namespaces are different, they may still represent
3249          * hardlinks to the same file.  The filesystem might have a hard time
3250          * with this so we issue a NREMOVE of the source instead of a NRENAME
3251          * when we detect the situation.
3252          */
3253         if (error == 0) {
3254                 fdvp = fromnd->nl_dvp;
3255                 tdvp = tond->nl_dvp;
3256                 if (fdvp == NULL || tdvp == NULL) {
3257                         error = EPERM;
3258                 } else if (fromnd->nl_nch.ncp->nc_vp == tond->nl_nch.ncp->nc_vp) {
3259                         error = VOP_NREMOVE(&fromnd->nl_nch, fdvp,
3260                                             fromnd->nl_cred);
3261                 } else {
3262                         error = VOP_NRENAME(&fromnd->nl_nch, &tond->nl_nch, 
3263                                             fdvp, tdvp, tond->nl_cred);
3264                 }
3265         }
3266         return (error);
3267 }
3268
3269 /*
3270  * rename_args(char *from, char *to)
3271  *
3272  * Rename files.  Source and destination must either both be directories,
3273  * or both not be directories.  If target is a directory, it must be empty.
3274  */
3275 int
3276 sys_rename(struct rename_args *uap)
3277 {
3278         struct nlookupdata fromnd, tond;
3279         int error;
3280
3281         error = nlookup_init(&fromnd, uap->from, UIO_USERSPACE, 0);
3282         if (error == 0) {
3283                 error = nlookup_init(&tond, uap->to, UIO_USERSPACE, 0);
3284                 if (error == 0)
3285                         error = kern_rename(&fromnd, &tond);
3286                 nlookup_done(&tond);
3287         }
3288         nlookup_done(&fromnd);
3289         return (error);
3290 }
3291
3292 int
3293 kern_mkdir(struct nlookupdata *nd, int mode)
3294 {
3295         struct thread *td = curthread;
3296         struct proc *p = td->td_proc;
3297         struct vnode *vp;
3298         struct vattr vattr;
3299         int error;
3300
3301         bwillinode(1);
3302         nd->nl_flags |= NLC_WILLBEDIR | NLC_CREATE | NLC_REFDVP;
3303         if ((error = nlookup(nd)) != 0)
3304                 return (error);
3305
3306         if (nd->nl_nch.ncp->nc_vp)
3307                 return (EEXIST);
3308         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
3309                 return (error);
3310         VATTR_NULL(&vattr);
3311         vattr.va_type = VDIR;
3312         vattr.va_mode = (mode & ACCESSPERMS) &~ p->p_fd->fd_cmask;
3313
3314         vp = NULL;
3315         error = VOP_NMKDIR(&nd->nl_nch, nd->nl_dvp, &vp, p->p_ucred, &vattr);
3316         if (error == 0)
3317                 vput(vp);
3318         return (error);
3319 }
3320
3321 /*
3322  * mkdir_args(char *path, int mode)
3323  *
3324  * Make a directory file.
3325  */
3326 /* ARGSUSED */
3327 int
3328 sys_mkdir(struct mkdir_args *uap)
3329 {
3330         struct nlookupdata nd;
3331         int error;
3332
3333         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
3334         if (error == 0)
3335                 error = kern_mkdir(&nd, uap->mode);
3336         nlookup_done(&nd);
3337         return (error);
3338 }
3339
3340 int
3341 kern_rmdir(struct nlookupdata *nd)
3342 {
3343         int error;
3344
3345         bwillinode(1);
3346         nd->nl_flags |= NLC_DELETE | NLC_REFDVP;
3347         if ((error = nlookup(nd)) != 0)
3348                 return (error);
3349
3350         /*
3351          * Do not allow directories representing mount points to be
3352          * deleted, even if empty.  Check write perms on mount point
3353          * in case the vnode is aliased (aka nullfs).
3354          */
3355         if (nd->nl_nch.ncp->nc_flag & (NCF_ISMOUNTPT))
3356                 return (EINVAL);
3357         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
3358                 return (error);
3359         error = VOP_NRMDIR(&nd->nl_nch, nd->nl_dvp, nd->nl_cred);
3360         return (error);
3361 }
3362
3363 /*
3364  * rmdir_args(char *path)
3365  *
3366  * Remove a directory file.
3367  */
3368 /* ARGSUSED */
3369 int
3370 sys_rmdir(struct rmdir_args *uap)
3371 {
3372         struct nlookupdata nd;
3373         int error;
3374
3375         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, 0);
3376         if (error == 0)
3377                 error = kern_rmdir(&nd);
3378         nlookup_done(&nd);
3379         return (error);
3380 }
3381
3382 int
3383 kern_getdirentries(int fd, char *buf, u_int count, long *basep, int *res,
3384     enum uio_seg direction)
3385 {
3386         struct thread *td = curthread;
3387         struct proc *p = td->td_proc;
3388         struct vnode *vp;
3389         struct file *fp;
3390         struct uio auio;
3391         struct iovec aiov;
3392         off_t loff;
3393         int error, eofflag;
3394
3395         if ((error = holdvnode(p->p_fd, fd, &fp)) != 0)
3396                 return (error);
3397         if ((fp->f_flag & FREAD) == 0) {
3398                 error = EBADF;
3399                 goto done;
3400         }
3401         vp = (struct vnode *)fp->f_data;
3402 unionread:
3403         if (vp->v_type != VDIR) {
3404                 error = EINVAL;
3405                 goto done;
3406         }
3407         aiov.iov_base = buf;
3408         aiov.iov_len = count;
3409         auio.uio_iov = &aiov;
3410         auio.uio_iovcnt = 1;
3411         auio.uio_rw = UIO_READ;
3412         auio.uio_segflg = direction;
3413         auio.uio_td = td;
3414         auio.uio_resid = count;
3415         loff = auio.uio_offset = fp->f_offset;
3416         error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, NULL, NULL);
3417         fp->f_offset = auio.uio_offset;
3418         if (error)
3419                 goto done;
3420         if (count == auio.uio_resid) {
3421                 if (union_dircheckp) {
3422                         error = union_dircheckp(td, &vp, fp);
3423                         if (error == -1)
3424                                 goto unionread;
3425                         if (error)
3426                                 goto done;
3427                 }
3428 #if 0
3429                 if ((vp->v_flag & VROOT) &&
3430                     (vp->v_mount->mnt_flag & MNT_UNION)) {
3431                         struct vnode *tvp = vp;
3432                         vp = vp->v_mount->mnt_vnodecovered;
3433                         vref(vp);
3434                         fp->f_data = vp;
3435                         fp->f_offset = 0;
3436                         vrele(tvp);
3437                         goto unionread;
3438                 }
3439 #endif
3440         }
3441
3442         /*
3443          * WARNING!  *basep may not be wide enough to accomodate the
3444          * seek offset.   XXX should we hack this to return the upper 32 bits
3445          * for offsets greater then 4G?
3446          */
3447         if (basep) {
3448                 *basep = (long)loff;
3449         }
3450         *res = count - auio.uio_resid;
3451 done:
3452         fdrop(fp);
3453         return (error);
3454 }
3455
3456 /*
3457  * getdirentries_args(int fd, char *buf, u_int conut, long *basep)
3458  *
3459  * Read a block of directory entries in a file system independent format.
3460  */
3461 int
3462 sys_getdirentries(struct getdirentries_args *uap)
3463 {
3464         long base;
3465         int error;
3466
3467         error = kern_getdirentries(uap->fd, uap->buf, uap->count, &base,
3468                                    &uap->sysmsg_result, UIO_USERSPACE);
3469
3470         if (error == 0 && uap->basep)
3471                 error = copyout(&base, uap->basep, sizeof(*uap->basep));
3472         return (error);
3473 }
3474
3475 /*
3476  * getdents_args(int fd, char *buf, size_t count)
3477  */
3478 int
3479 sys_getdents(struct getdents_args *uap)
3480 {
3481         int error;
3482
3483         error = kern_getdirentries(uap->fd, uap->buf, uap->count, NULL,
3484             &uap->sysmsg_result, UIO_USERSPACE);
3485
3486         return (error);
3487 }
3488
3489 /*
3490  * umask(int newmask)
3491  *
3492  * Set the mode mask for creation of filesystem nodes.
3493  *
3494  * MP SAFE
3495  */
3496 int
3497 sys_umask(struct umask_args *uap)
3498 {
3499         struct thread *td = curthread;
3500         struct proc *p = td->td_proc;
3501         struct filedesc *fdp;
3502
3503         fdp = p->p_fd;
3504         uap->sysmsg_result = fdp->fd_cmask;
3505         fdp->fd_cmask = uap->newmask & ALLPERMS;
3506         return (0);
3507 }
3508
3509 /*
3510  * revoke(char *path)
3511  *
3512  * Void all references to file by ripping underlying filesystem
3513  * away from vnode.
3514  */
3515 /* ARGSUSED */
3516 int
3517 sys_revoke(struct revoke_args *uap)
3518 {
3519         struct nlookupdata nd;
3520         struct vattr vattr;
3521         struct vnode *vp;
3522         struct ucred *cred;
3523         int error;
3524
3525         vp = NULL;
3526         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
3527         if (error == 0)
3528                 error = nlookup(&nd);
3529         if (error == 0)
3530                 error = cache_vref(&nd.nl_nch, nd.nl_cred, &vp);
3531         cred = crhold(nd.nl_cred);
3532         nlookup_done(&nd);
3533         if (error == 0) {
3534                 if (vp->v_type != VCHR && vp->v_type != VBLK)
3535                         error = EINVAL;
3536                 if (error == 0)
3537                         error = VOP_GETATTR(vp, &vattr);
3538                 if (error == 0 && cred->cr_uid != vattr.va_uid)
3539                         error = suser_cred(cred, PRISON_ROOT);
3540                 if (error == 0 && count_udev(vp->v_umajor, vp->v_uminor) > 0) {
3541                         error = 0;
3542                         vx_lock(vp);
3543                         VOP_REVOKE(vp, REVOKEALL);
3544                         vx_unlock(vp);
3545                 }
3546                 vrele(vp);
3547         }
3548         if (cred)
3549                 crfree(cred);
3550         return (error);
3551 }
3552
3553 /*
3554  * getfh_args(char *fname, fhandle_t *fhp)
3555  *
3556  * Get (NFS) file handle
3557  *
3558  * NOTE: We use the fsid of the covering mount, even if it is a nullfs
3559  * mount.  This allows nullfs mounts to be explicitly exported. 
3560  *
3561  * WARNING: nullfs mounts of HAMMER PFS ROOTs are safe.
3562  *
3563  *          nullfs mounts of subdirectories are not safe.  That is, it will
3564  *          work, but you do not really have protection against access to
3565  *          the related parent directories.
3566  */
3567 int
3568 sys_getfh(struct getfh_args *uap)
3569 {
3570         struct thread *td = curthread;
3571         struct nlookupdata nd;
3572         fhandle_t fh;
3573         struct vnode *vp;
3574         struct mount *mp;
3575         int error;
3576
3577         /*
3578          * Must be super user
3579          */
3580         if ((error = suser(td)) != 0)
3581                 return (error);
3582
3583         vp = NULL;
3584         error = nlookup_init(&nd, uap->fname, UIO_USERSPACE, NLC_FOLLOW);
3585         if (error == 0)
3586                 error = nlookup(&nd);
3587         if (error == 0)
3588                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
3589         mp = nd.nl_nch.mount;
3590         nlookup_done(&nd);
3591         if (error == 0) {
3592                 bzero(&fh, sizeof(fh));
3593                 fh.fh_fsid = mp->mnt_stat.f_fsid;
3594                 error = VFS_VPTOFH(vp, &fh.fh_fid);
3595                 vput(vp);
3596                 if (error == 0)
3597                         error = copyout(&fh, uap->fhp, sizeof(fh));
3598         }
3599         return (error);
3600 }
3601
3602 /*
3603  * fhopen_args(const struct fhandle *u_fhp, int flags)
3604  *
3605  * syscall for the rpc.lockd to use to translate a NFS file handle into
3606  * an open descriptor.
3607  *
3608  * warning: do not remove the suser() call or this becomes one giant
3609  * security hole.
3610  */
3611 int
3612 sys_fhopen(struct fhopen_args *uap)
3613 {
3614         struct thread *td = curthread;
3615         struct proc *p = td->td_proc;
3616         struct mount *mp;
3617         struct vnode *vp;
3618         struct fhandle fhp;
3619         struct vattr vat;
3620         struct vattr *vap = &vat;
3621         struct flock lf;
3622         int fmode, mode, error, type;
3623         struct file *nfp; 
3624         struct file *fp;
3625         int indx;
3626
3627         /*
3628          * Must be super user
3629          */
3630         error = suser(td);
3631         if (error)
3632                 return (error);
3633
3634         fmode = FFLAGS(uap->flags);
3635         /* why not allow a non-read/write open for our lockd? */
3636         if (((fmode & (FREAD | FWRITE)) == 0) || (fmode & O_CREAT))
3637                 return (EINVAL);
3638         error = copyin(uap->u_fhp, &fhp, sizeof(fhp));
3639         if (error)
3640                 return(error);
3641         /* find the mount point */
3642         mp = vfs_getvfs(&fhp.fh_fsid);
3643         if (mp == NULL)
3644                 return (ESTALE);
3645         /* now give me my vnode, it gets returned to me locked */
3646         error = VFS_FHTOVP(mp, NULL, &fhp.fh_fid, &vp);
3647         if (error)
3648                 return (error);
3649         /*
3650          * from now on we have to make sure not
3651          * to forget about the vnode
3652          * any error that causes an abort must vput(vp) 
3653          * just set error = err and 'goto bad;'.
3654          */
3655
3656         /* 
3657          * from vn_open 
3658          */
3659         if (vp->v_type == VLNK) {
3660                 error = EMLINK;
3661                 goto bad;
3662         }
3663         if (vp->v_type == VSOCK) {
3664                 error = EOPNOTSUPP;
3665                 goto bad;
3666         }
3667         mode = 0;
3668         if (fmode & (FWRITE | O_TRUNC)) {
3669                 if (vp->v_type == VDIR) {
3670                         error = EISDIR;
3671                         goto bad;
3672                 }
3673                 error = vn_writechk(vp, NULL);
3674                 if (error)
3675                         goto bad;
3676                 mode |= VWRITE;
3677         }
3678         if (fmode & FREAD)
3679                 mode |= VREAD;
3680         if (mode) {
3681                 error = VOP_ACCESS(vp, mode, p->p_ucred);
3682                 if (error)
3683                         goto bad;
3684         }
3685         if (fmode & O_TRUNC) {
3686                 vn_unlock(vp);                          /* XXX */
3687                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);   /* XXX */
3688                 VATTR_NULL(vap);
3689                 vap->va_size = 0;
3690                 error = VOP_SETATTR(vp, vap, p->p_ucred);
3691                 if (error)
3692                         goto bad;
3693         }
3694
3695         /*
3696          * VOP_OPEN needs the file pointer so it can potentially override
3697          * it.
3698          *
3699          * WARNING! no f_nchandle will be associated when fhopen()ing a
3700          * directory.  XXX
3701          */
3702         if ((error = falloc(p, &nfp, &indx)) != 0)
3703                 goto bad;
3704         fp = nfp;
3705
3706         error = VOP_OPEN(vp, fmode, p->p_ucred, fp);
3707         if (error) {
3708                 /*
3709                  * setting f_ops this way prevents VOP_CLOSE from being
3710                  * called or fdrop() releasing the vp from v_data.   Since
3711                  * the VOP_OPEN failed we don't want to VOP_CLOSE.
3712                  */
3713                 fp->f_ops = &badfileops;
3714                 fp->f_data = NULL;
3715                 goto bad_drop;
3716         }
3717
3718         /*
3719          * The fp is given its own reference, we still have our ref and lock.
3720          *
3721          * Assert that all regular files must be created with a VM object.
3722          */
3723         if (vp->v_type == VREG && vp->v_object == NULL) {
3724                 kprintf("fhopen: regular file did not have VM object: %p\n", vp);
3725                 goto bad_drop;
3726         }
3727
3728         /*
3729          * The open was successful.  Handle any locking requirements.
3730          */
3731         if (fmode & (O_EXLOCK | O_SHLOCK)) {
3732                 lf.l_whence = SEEK_SET;
3733                 lf.l_start = 0;
3734                 lf.l_len = 0;
3735                 if (fmode & O_EXLOCK)
3736                         lf.l_type = F_WRLCK;
3737                 else
3738                         lf.l_type = F_RDLCK;
3739                 if (fmode & FNONBLOCK)
3740                         type = 0;
3741                 else
3742                         type = F_WAIT;
3743                 vn_unlock(vp);
3744                 if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) != 0) {
3745                         /*
3746                          * release our private reference.
3747                          */
3748                         fsetfd(p, NULL, indx);
3749                         fdrop(fp);
3750                         vrele(vp);
3751                         return (error);
3752                 }
3753                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3754                 fp->f_flag |= FHASLOCK;
3755         }
3756
3757         /*
3758          * Clean up.  Associate the file pointer with the previously
3759          * reserved descriptor and return it.
3760          */
3761         vput(vp);
3762         fsetfd(p, fp, indx);
3763         fdrop(fp);
3764         uap->sysmsg_result = indx;
3765         return (0);
3766
3767 bad_drop:
3768         fsetfd(p, NULL, indx);
3769         fdrop(fp);
3770 bad:
3771         vput(vp);
3772         return (error);
3773 }
3774
3775 /*
3776  * fhstat_args(struct fhandle *u_fhp, struct stat *sb)
3777  */
3778 int
3779 sys_fhstat(struct fhstat_args *uap)
3780 {
3781         struct thread *td = curthread;
3782         struct stat sb;
3783         fhandle_t fh;
3784         struct mount *mp;
3785         struct vnode *vp;
3786         int error;
3787
3788         /*
3789          * Must be super user
3790          */
3791         error = suser(td);
3792         if (error)
3793                 return (error);
3794         
3795         error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
3796         if (error)
3797                 return (error);
3798
3799         if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
3800                 return (ESTALE);
3801         if ((error = VFS_FHTOVP(mp, NULL, &fh.fh_fid, &vp)))
3802                 return (error);
3803         error = vn_stat(vp, &sb, td->td_proc->p_ucred);
3804         vput(vp);
3805         if (error)
3806                 return (error);
3807         error = copyout(&sb, uap->sb, sizeof(sb));
3808         return (error);
3809 }
3810
3811 /*
3812  * fhstatfs_args(struct fhandle *u_fhp, struct statfs *buf)
3813  */
3814 int
3815 sys_fhstatfs(struct fhstatfs_args *uap)
3816 {
3817         struct thread *td = curthread;
3818         struct proc *p = td->td_proc;
3819         struct statfs *sp;
3820         struct mount *mp;
3821         struct vnode *vp;
3822         struct statfs sb;
3823         char *fullpath, *freepath;
3824         fhandle_t fh;
3825         int error;
3826
3827         /*
3828          * Must be super user
3829          */
3830         if ((error = suser(td)))
3831                 return (error);
3832
3833         if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
3834                 return (error);
3835
3836         if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
3837                 return (ESTALE);
3838
3839         if (p != NULL && !chroot_visible_mnt(mp, p))
3840                 return (ESTALE);
3841
3842         if ((error = VFS_FHTOVP(mp, NULL, &fh.fh_fid, &vp)))
3843                 return (error);
3844         mp = vp->v_mount;
3845         sp = &mp->mnt_stat;
3846         vput(vp);
3847         if ((error = VFS_STATFS(mp, sp, p->p_ucred)) != 0)
3848                 return (error);
3849
3850         error = mount_path(p, mp, &fullpath, &freepath);
3851         if (error)
3852                 return(error);
3853         bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
3854         strlcpy(sp->f_mntonname, fullpath, sizeof(sp->f_mntonname));
3855         kfree(freepath, M_TEMP);
3856
3857         sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
3858         if (suser(td)) {
3859                 bcopy(sp, &sb, sizeof(sb));
3860                 sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
3861                 sp = &sb;
3862         }
3863         return (copyout(sp, uap->buf, sizeof(*sp)));
3864 }
3865
3866 /*
3867  * fhstatvfs_args(struct fhandle *u_fhp, struct statvfs *buf)
3868  */
3869 int
3870 sys_fhstatvfs(struct fhstatvfs_args *uap)
3871 {
3872         struct thread *td = curthread;
3873         struct proc *p = td->td_proc;
3874         struct statvfs *sp;
3875         struct mount *mp;
3876         struct vnode *vp;
3877         fhandle_t fh;
3878         int error;
3879
3880         /*
3881          * Must be super user
3882          */
3883         if ((error = suser(td)))
3884                 return (error);
3885
3886         if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
3887                 return (error);
3888
3889         if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
3890                 return (ESTALE);
3891
3892         if (p != NULL && !chroot_visible_mnt(mp, p))
3893                 return (ESTALE);
3894
3895         if ((error = VFS_FHTOVP(mp, NULL, &fh.fh_fid, &vp)))
3896                 return (error);
3897         mp = vp->v_mount;
3898         sp = &mp->mnt_vstat;
3899         vput(vp);
3900         if ((error = VFS_STATVFS(mp, sp, p->p_ucred)) != 0)
3901                 return (error);
3902
3903         sp->f_flag = 0;
3904         if (mp->mnt_flag & MNT_RDONLY)
3905                 sp->f_flag |= ST_RDONLY;
3906         if (mp->mnt_flag & MNT_NOSUID)
3907                 sp->f_flag |= ST_NOSUID;
3908
3909         return (copyout(sp, uap->buf, sizeof(*sp)));
3910 }
3911
3912
3913 /*
3914  * Syscall to push extended attribute configuration information into the
3915  * VFS.  Accepts a path, which it converts to a mountpoint, as well as
3916  * a command (int cmd), and attribute name and misc data.  For now, the
3917  * attribute name is left in userspace for consumption by the VFS_op.
3918  * It will probably be changed to be copied into sysspace by the
3919  * syscall in the future, once issues with various consumers of the
3920  * attribute code have raised their hands.
3921  *
3922  * Currently this is used only by UFS Extended Attributes.
3923  */
3924 int
3925 sys_extattrctl(struct extattrctl_args *uap)
3926 {
3927         struct nlookupdata nd;
3928         struct mount *mp;
3929         struct vnode *vp;
3930         int error;
3931
3932         vp = NULL;
3933         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
3934         if (error == 0)
3935                 error = nlookup(&nd);
3936         if (error == 0) {
3937                 mp = nd.nl_nch.mount;
3938                 error = VFS_EXTATTRCTL(mp, uap->cmd, 
3939                                 uap->attrname, uap->arg, 
3940                                 nd.nl_cred);
3941         }
3942         nlookup_done(&nd);
3943         return (error);
3944 }
3945
3946 /*
3947  * Syscall to set a named extended attribute on a file or directory.
3948  * Accepts attribute name, and a uio structure pointing to the data to set.
3949  * The uio is consumed in the style of writev().  The real work happens
3950  * in VOP_SETEXTATTR().
3951  */
3952 int
3953 sys_extattr_set_file(struct extattr_set_file_args *uap)
3954 {
3955         char attrname[EXTATTR_MAXNAMELEN];
3956         struct iovec aiov[UIO_SMALLIOV];
3957         struct iovec *needfree;
3958         struct nlookupdata nd;
3959         struct iovec *iov;
3960         struct vnode *vp;
3961         struct uio auio;
3962         u_int iovlen;
3963         u_int cnt;
3964         int error;
3965         int i;
3966
3967         error = copyin(uap->attrname, attrname, EXTATTR_MAXNAMELEN);
3968         if (error)
3969                 return (error);
3970
3971         vp = NULL;
3972         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
3973         if (error == 0)
3974                 error = nlookup(&nd);
3975         if (error == 0)
3976                 error = ncp_writechk(&nd.nl_nch);
3977         if (error == 0)
3978                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
3979         if (error) {
3980                 nlookup_done(&nd);
3981                 return (error);
3982         }
3983
3984         needfree = NULL;
3985         iovlen = uap->iovcnt * sizeof(struct iovec);
3986         if (uap->iovcnt > UIO_SMALLIOV) {
3987                 if (uap->iovcnt > UIO_MAXIOV) {
3988                         error = EINVAL;
3989                         goto done;
3990                 }
3991                 MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK);
3992                 needfree = iov;
3993         } else {
3994                 iov = aiov;
3995         }
3996         auio.uio_iov = iov;
3997         auio.uio_iovcnt = uap->iovcnt;
3998         auio.uio_rw = UIO_WRITE;
3999         auio.uio_segflg = UIO_USERSPACE;
4000         auio.uio_td = nd.nl_td;
4001         auio.uio_offset = 0;
4002         if ((error = copyin(uap->iovp, iov, iovlen)))
4003                 goto done;
4004         auio.uio_resid = 0;
4005         for (i = 0; i < uap->iovcnt; i++) {
4006                 if (iov->iov_len > INT_MAX - auio.uio_resid) {
4007                         error = EINVAL;
4008                         goto done;
4009                 }
4010                 auio.uio_resid += iov->iov_len;
4011                 iov++;
4012         }
4013         cnt = auio.uio_resid;
4014         error = VOP_SETEXTATTR(vp, attrname, &auio, nd.nl_cred);
4015         cnt -= auio.uio_resid;
4016         uap->sysmsg_result = cnt;
4017 done:
4018         vput(vp);
4019         nlookup_done(&nd);
4020         if (needfree)
4021                 FREE(needfree, M_IOV);
4022         return (error);
4023 }
4024
4025 /*
4026  * Syscall to get a named extended attribute on a file or directory.
4027  * Accepts attribute name, and a uio structure pointing to a buffer for the
4028  * data.  The uio is consumed in the style of readv().  The real work
4029  * happens in VOP_GETEXTATTR();
4030  */
4031 int
4032 sys_extattr_get_file(struct extattr_get_file_args *uap)
4033 {
4034         char attrname[EXTATTR_MAXNAMELEN];
4035         struct iovec aiov[UIO_SMALLIOV];
4036         struct iovec *needfree;
4037         struct nlookupdata nd;
4038         struct iovec *iov;
4039         struct vnode *vp;
4040         struct uio auio;
4041         u_int iovlen;
4042         u_int cnt;
4043         int error;
4044         int i;
4045
4046         error = copyin(uap->attrname, attrname, EXTATTR_MAXNAMELEN);
4047         if (error)
4048                 return (error);
4049
4050         vp = NULL;
4051         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
4052         if (error == 0)
4053                 error = nlookup(&nd);
4054         if (error == 0)
4055                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
4056         if (error) {
4057                 nlookup_done(&nd);
4058                 return (error);
4059         }
4060
4061         iovlen = uap->iovcnt * sizeof (struct iovec);
4062         needfree = NULL;
4063         if (uap->iovcnt > UIO_SMALLIOV) {
4064                 if (uap->iovcnt > UIO_MAXIOV) {
4065                         error = EINVAL;
4066                         goto done;
4067                 }
4068                 MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK);
4069                 needfree = iov;
4070         } else {
4071                 iov = aiov;
4072         }
4073         auio.uio_iov = iov;
4074         auio.uio_iovcnt = uap->iovcnt;
4075         auio.uio_rw = UIO_READ;
4076         auio.uio_segflg = UIO_USERSPACE;
4077         auio.uio_td = nd.nl_td;
4078         auio.uio_offset = 0;
4079         if ((error = copyin(uap->iovp, iov, iovlen)))
4080                 goto done;
4081         auio.uio_resid = 0;
4082         for (i = 0; i < uap->iovcnt; i++) {
4083                 if (iov->iov_len > INT_MAX - auio.uio_resid) {
4084                         error = EINVAL;
4085                         goto done;
4086                 }
4087                 auio.uio_resid += iov->iov_len;
4088                 iov++;
4089         }
4090         cnt = auio.uio_resid;
4091         error = VOP_GETEXTATTR(vp, attrname, &auio, nd.nl_cred);
4092         cnt -= auio.uio_resid;
4093         uap->sysmsg_result = cnt;
4094 done:
4095         vput(vp);
4096         nlookup_done(&nd);
4097         if (needfree)
4098                 FREE(needfree, M_IOV);
4099         return(error);
4100 }
4101
4102 /*
4103  * Syscall to delete a named extended attribute from a file or directory.
4104  * Accepts attribute name.  The real work happens in VOP_SETEXTATTR().
4105  */
4106 int
4107 sys_extattr_delete_file(struct extattr_delete_file_args *uap)
4108 {
4109         char attrname[EXTATTR_MAXNAMELEN];
4110         struct nlookupdata nd;
4111         struct vnode *vp;
4112         int error;
4113
4114         error = copyin(uap->attrname, attrname, EXTATTR_MAXNAMELEN);
4115         if (error)
4116                 return(error);
4117
4118         vp = NULL;
4119         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
4120         if (error == 0)
4121                 error = nlookup(&nd);
4122         if (error == 0)
4123                 error = ncp_writechk(&nd.nl_nch);
4124         if (error == 0)
4125                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
4126         if (error) {
4127                 nlookup_done(&nd);
4128                 return (error);
4129         }
4130
4131         error = VOP_SETEXTATTR(vp, attrname, NULL, nd.nl_cred);
4132         vput(vp);
4133         nlookup_done(&nd);
4134         return(error);
4135 }
4136
4137 /*
4138  * Determine if the mount is visible to the process.
4139  */
4140 static int
4141 chroot_visible_mnt(struct mount *mp, struct proc *p)
4142 {
4143         struct nchandle nch;
4144
4145         /*
4146          * Traverse from the mount point upwards.  If we hit the process
4147          * root then the mount point is visible to the process.
4148          */
4149         nch = mp->mnt_ncmountpt;
4150         while (nch.ncp) {
4151                 if (nch.mount == p->p_fd->fd_nrdir.mount &&
4152                     nch.ncp == p->p_fd->fd_nrdir.ncp) {
4153                         return(1);
4154                 }
4155                 if (nch.ncp == nch.mount->mnt_ncmountpt.ncp) {
4156                         nch = nch.mount->mnt_ncmounton;
4157                 } else {
4158                         nch.ncp = nch.ncp->nc_parent;
4159                 }
4160         }
4161
4162         /*
4163          * If the mount point is not visible to the process, but the
4164          * process root is in a subdirectory of the mount, return
4165          * TRUE anyway.
4166          */
4167         if (p->p_fd->fd_nrdir.mount == mp)
4168                 return(1);
4169
4170         return(0);
4171 }
4172