![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vfs_syscalls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / vfs|
Return to vfs_syscalls.c CVS log | Up to [Apple XNU] / XNU / bsd / vfs |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1995-1999 Apple Computer, Inc. All Rights Reserved */
23: /*
24: * Copyright (c) 1989, 1993
25: * The Regents of the University of California. All rights reserved.
26: * (c) UNIX System Laboratories, Inc.
27: * All or some portions of this file are derived from material licensed
28: * to the University of California by American Telephone and Telegraph
29: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
30: * the permission of UNIX System Laboratories, Inc.
31: *
32: * Redistribution and use in source and binary forms, with or without
33: * modification, are permitted provided that the following conditions
34: * are met:
35: * 1. Redistributions of source code must retain the above copyright
36: * notice, this list of conditions and the following disclaimer.
37: * 2. Redistributions in binary form must reproduce the above copyright
38: * notice, this list of conditions and the following disclaimer in the
39: * documentation and/or other materials provided with the distribution.
40: * 3. All advertising materials mentioning features or use of this software
41: * must display the following acknowledgement:
42: * This product includes software developed by the University of
43: * California, Berkeley and its contributors.
44: * 4. Neither the name of the University nor the names of its contributors
45: * may be used to endorse or promote products derived from this software
46: * without specific prior written permission.
47: *
48: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58: * SUCH DAMAGE.
59: *
60: * @(#)vfs_syscalls.c 8.41 (Berkeley) 6/15/95
61: */
62:
63: #include <mach_nbc.h>
64: #include <sys/param.h>
65: #include <sys/systm.h>
66: #include <sys/namei.h>
67: #include <sys/filedesc.h>
68: #include <sys/kernel.h>
69: #include <sys/file.h>
70: #include <sys/stat.h>
71: #include <sys/vnode.h>
72: #include <sys/mount.h>
73: #include <sys/proc.h>
74: #include <sys/uio.h>
75: #include <sys/malloc.h>
76: #include <sys/dirent.h>
77: #include <sys/attr.h>
78: #include <sys/sysctl.h>
79: #include <kern/mapfs.h>
80:
81: struct lock__bsd__ exchangelock;
82:
83: static int change_dir __P((struct nameidata *ndp, struct proc *p));
84: static void checkdirs __P((struct vnode *olddp));
85:
86: #ifdef NeXT
87: unsigned int vfs_nummntops=0; /* counts number of mount and unmount operations */
88: #endif
89:
90: /*
91: * Virtual File System System Calls
92: */
93:
94: /*
95: * Mount a file system.
96: */
97: struct mount_args {
98: char *type;
99: char *path;
100: int flags;
101: caddr_t data;
102: };
103: /* ARGSUSED */
104: int
105: mount(p, uap, retval)
106: struct proc *p;
107: register struct mount_args *uap;
108: register_t *retval;
109: {
110: struct vnode *vp;
111: struct mount *mp;
112: struct vfsconf *vfsp;
113: int error, flag;
114: struct vattr va;
115: u_long fstypenum;
116: struct nameidata nd;
117: char fstypename[MFSNAMELEN];
118: size_t dummy=0;
119: /*
120: * Get vnode to be covered
121: */
122: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
123: uap->path, p);
124: if (error = namei(&nd))
125: return (error);
126: vp = nd.ni_vp;
127:
128: if ((vp->v_flag & VROOT) &&
129: (vp->v_mount->mnt_flag & MNT_ROOTFS)) uap->flags |= MNT_UPDATE;
130:
131: if (uap->flags & MNT_UPDATE) {
132: if ((vp->v_flag & VROOT) == 0) {
133: vput(vp);
134: return (EINVAL);
135: }
136: mp = vp->v_mount;
137: flag = mp->mnt_flag;
138: /*
139: * We only allow the filesystem to be reloaded if it
140: * is currently mounted read-only.
141: */
142: if ((uap->flags & MNT_RELOAD) &&
143: ((mp->mnt_flag & MNT_RDONLY) == 0)) {
144: vput(vp);
145: return (EOPNOTSUPP); /* Needs translation */
146: }
147: mp->mnt_flag |=
148: uap->flags & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE);
149: /*
150: * Only root, or the user that did the original mount is
151: * permitted to update it.
152: */
153: if (mp->mnt_stat.f_owner != p->p_ucred->cr_uid &&
154: (error = suser(p->p_ucred, &p->p_acflag))) {
155: vput(vp);
156: return (error);
157: }
158: /*
159: * Do not allow NFS export by non-root users. FOr non-root
160: * users, silently enforce MNT_NOSUID and MNT_NODEV, and
161: * MNT_NOEXEC if mount point is already MNT_NOEXEC.
162: */
163: if (p->p_ucred->cr_uid != 0) {
164: if (uap->flags & MNT_EXPORTED) {
165: vput(vp);
166: return (EPERM);
167: }
168: uap->flags |= MNT_NOSUID | MNT_NODEV;
169: if (flag & MNT_NOEXEC)
170: uap->flags |= MNT_NOEXEC;
171: }
172: if (vfs_busy(mp, LK_NOWAIT, 0, p)) {
173: vput(vp);
174: return (EBUSY);
175: }
176: VOP_UNLOCK(vp, 0, p);
177: goto update;
178: }
179: /*
180: * If the user is not root, ensure that they own the directory
181: * onto which we are attempting to mount.
182: */
183: if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) ||
184: (va.va_uid != p->p_ucred->cr_uid &&
185: (error = suser(p->p_ucred, &p->p_acflag)))) {
186: vput(vp);
187: return (error);
188: }
189: /*
190: * Do not allow NFS export by non-root users. FOr non-root
191: * users, silently enforce MNT_NOSUID and MNT_NODEV, and
192: * MNT_NOEXEC if mount point is already MNT_NOEXEC.
193: */
194: if (p->p_ucred->cr_uid != 0) {
195: if (uap->flags & MNT_EXPORTED) {
196: vput(vp);
197: return (EPERM);
198: }
199: uap->flags |= MNT_NOSUID | MNT_NODEV;
200: if (vp->v_mount->mnt_flag & MNT_NOEXEC)
201: uap->flags |= MNT_NOEXEC;
202: }
203: if (error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0)) {
204: vput(vp);
205: return (error);
206: }
207: if (vp->v_type != VDIR) {
208: vput(vp);
209: return (ENOTDIR);
210: }
211: #if COMPAT_43
212: /*
213: * Historically filesystem types were identified by number. If we
214: * get an integer for the filesystem type instead of a string, we
215: * check to see if it matches one of the historic filesystem types.
216: */
217: fstypenum = (u_long)uap->type;
218: if (fstypenum < maxvfsconf) {
219: for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
220: if (vfsp->vfc_typenum == fstypenum)
221: break;
222: if (vfsp == NULL) {
223: vput(vp);
224: return (ENODEV);
225: }
226: strncpy(fstypename, vfsp->vfc_name, MFSNAMELEN);
227: } else
228: #endif /* COMPAT_43 */
229: if (error = copyinstr(uap->type, fstypename, MFSNAMELEN, &dummy)) {
230: vput(vp);
231: return (error);
232: }
233: for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
234: if (!strcmp(vfsp->vfc_name, fstypename))
235: break;
236: if (vfsp == NULL) {
237: vput(vp);
238: return (ENODEV);
239: }
240: if (vp->v_mountedhere != NULL) {
241: vput(vp);
242: return (EBUSY);
243: }
244:
245: /*
246: * Allocate and initialize the filesystem.
247: */
248: mp = (struct mount *)_MALLOC_ZONE((u_long)sizeof(struct mount),
249: M_MOUNT, M_WAITOK);
250: bzero((char *)mp, (u_long)sizeof(struct mount));
251: lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, 0);
252: (void)vfs_busy(mp, LK_NOWAIT, 0, p);
253: mp->mnt_op = vfsp->vfc_vfsops;
254: mp->mnt_vfc = vfsp;
255: vfsp->vfc_refcount++;
256: mp->mnt_stat.f_type = vfsp->vfc_typenum;
257: mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
258: strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
259: vp->v_mountedhere = mp;
260: mp->mnt_vnodecovered = vp;
261: mp->mnt_stat.f_owner = p->p_ucred->cr_uid;
262: update:
263: /*
264: * Set the mount level flags.
265: */
266: if (uap->flags & MNT_RDONLY)
267: mp->mnt_flag |= MNT_RDONLY;
268: else if (mp->mnt_flag & MNT_RDONLY)
269: mp->mnt_flag |= MNT_WANTRDWR;
270: mp->mnt_flag &=~ (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV |
271: MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC);
272: mp->mnt_flag |= uap->flags & (MNT_NOSUID | MNT_NOEXEC |
273: MNT_NODEV | MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC);
274: /*
275: * Mount the filesystem.
276: */
277: error = VFS_MOUNT(mp, uap->path, uap->data, &nd, p);
278: if (mp->mnt_flag & MNT_UPDATE) {
279: vrele(vp);
280: if (mp->mnt_flag & MNT_WANTRDWR)
281: mp->mnt_flag &= ~MNT_RDONLY;
282: mp->mnt_flag &=~
283: (MNT_UPDATE | MNT_RELOAD | MNT_FORCE | MNT_WANTRDWR);
284: if (error)
285: mp->mnt_flag = flag;
286: vfs_unbusy(mp, p);
287: return (error);
288: }
289: /*
290: * Put the new filesystem on the mount list after root.
291: */
292: cache_purge(vp);
293: if (!error) {
294: simple_lock(&mountlist_slock);
295: CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
296: simple_unlock(&mountlist_slock);
297: checkdirs(vp);
298: VOP_UNLOCK(vp, 0, p);
299: vfs_unbusy(mp, p);
300: if (error = VFS_START(mp, 0, p))
301: vrele(vp);
302: #ifdef NeXT
303: /* increment the operations count */
304: if (!error) vfs_nummntops++;
305: #endif
306: } else {
307: mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
308: mp->mnt_vfc->vfc_refcount--;
309: vfs_unbusy(mp, p);
310: _FREE_ZONE((caddr_t)mp, sizeof (struct mount), M_MOUNT);
311: vput(vp);
312: }
313: return (error);
314: }
315:
316: /*
317: * Scan all active processes to see if any of them have a current
318: * or root directory onto which the new filesystem has just been
319: * mounted. If so, replace them with the new mount point.
320: */
321: static void
322: checkdirs(olddp)
323: struct vnode *olddp;
324: {
325: struct filedesc *fdp;
326: struct vnode *newdp;
327: struct proc *p;
328:
329: if (olddp->v_usecount == 1)
330: return;
331: if (VFS_ROOT(olddp->v_mountedhere, &newdp))
332: panic("mount: lost mount");
333: for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
334: fdp = p->p_fd;
335: if (fdp->fd_cdir == olddp) {
336: vrele(fdp->fd_cdir);
337: VREF(newdp);
338: fdp->fd_cdir = newdp;
339: }
340: if (fdp->fd_rdir == olddp) {
341: vrele(fdp->fd_rdir);
342: VREF(newdp);
343: fdp->fd_rdir = newdp;
344: }
345: }
346: if (rootvnode == olddp) {
347: vrele(rootvnode);
348: VREF(newdp);
349: rootvnode = newdp;
350: }
351: vput(newdp);
352: }
353:
354: /*
355: * Unmount a file system.
356: *
357: * Note: unmount takes a path to the vnode mounted on as argument,
358: * not special file (as before).
359: */
360: struct unmount_args {
361: char *path;
362: int flags;
363: };
364: /* ARGSUSED */
365: int
366: unmount(p, uap, retval)
367: struct proc *p;
368: register struct unmount_args *uap;
369: register_t *retval;
370: {
371: register struct vnode *vp;
372: struct mount *mp;
373: int error;
374: struct nameidata nd;
375:
376: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
377: uap->path, p);
378: if (error = namei(&nd))
379: return (error);
380: vp = nd.ni_vp;
381: mp = vp->v_mount;
382:
383: /*
384: * Only root, or the user that did the original mount is
385: * permitted to unmount this filesystem.
386: */
387: if ((mp->mnt_stat.f_owner != p->p_ucred->cr_uid) &&
388: (error = suser(p->p_ucred, &p->p_acflag))) {
389: vput(vp);
390: return (error);
391: }
392:
393: /*
394: * Don't allow unmounting the root file system.
395: */
396: if (mp->mnt_flag & MNT_ROOTFS) {
397: vput(vp);
398: return (EINVAL);
399: }
400:
401: /*
402: * Must be the root of the filesystem
403: */
404: if ((vp->v_flag & VROOT) == 0) {
405: vput(vp);
406: return (EINVAL);
407: }
408: vput(vp);
409: return (dounmount(mp, uap->flags, p));
410: }
411:
412: /*
413: * Do the actual file system unmount.
414: */
415: int
416: dounmount(mp, flags, p)
417: register struct mount *mp;
418: int flags;
419: struct proc *p;
420: {
421: struct vnode *coveredvp;
422: int error;
423:
424: simple_lock(&mountlist_slock);
425: mp->mnt_flag |= MNT_UNMOUNT;
426: lockmgr(&mp->mnt_lock, LK_DRAIN | LK_INTERLOCK, &mountlist_slock, p);
427: mp->mnt_flag &=~ MNT_ASYNC;
428: #if MACH_NBC
429: mapfs_cache_clear();
430: #endif
431: vnode_pager_umount(mp); /* release cached vnodes */
432: #if MACH_NBC
433: vm_object_cache_clear(); /* clear the object cache */
434: #endif /* MACH_NBC */
435: cache_purgevfs(mp); /* remove cache entries for this file sys */
436: if (((mp->mnt_flag & MNT_RDONLY) ||
437: (error = VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p)) == 0) ||
438: (flags & MNT_FORCE))
439: error = VFS_UNMOUNT(mp, flags, p);
440: simple_lock(&mountlist_slock);
441: if (error) {
442: mp->mnt_flag &= ~MNT_UNMOUNT;
443: lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK | LK_REENABLE,
444: &mountlist_slock, p);
445: goto out;
446: }
447: #ifdef NeXT
448: /* increment the operations count */
449: if (!error) vfs_nummntops++;
450: #endif
451: CIRCLEQ_REMOVE(&mountlist, mp, mnt_list);
452: if ((coveredvp = mp->mnt_vnodecovered) != NULLVP) {
453: coveredvp->v_mountedhere = (struct mount *)0;
454: simple_unlock(&mountlist_slock);
455: vrele(coveredvp);
456: simple_lock(&mountlist_slock);
457: }
458: mp->mnt_vfc->vfc_refcount--;
459: if (mp->mnt_vnodelist.lh_first != NULL)
460: panic("unmount: dangling vnode");
461: lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK, &mountlist_slock, p);
462: out:
463: if (mp->mnt_flag & MNT_MWAIT)
464: wakeup((caddr_t)mp);
465: if (!error)
466: _FREE_ZONE((caddr_t)mp, sizeof (struct mount), M_MOUNT);
467: return (error);
468: }
469:
470: /*
471: * Sync each mounted filesystem.
472: */
473: #if DIAGNOSTIC
474: int syncprt = 0;
475: struct ctldebug debug0 = { "syncprt", &syncprt };
476: #endif
477:
478: struct sync_args {
479: int dummy;
480: };
481: /* ARGSUSED */
482: int
483: sync(p, uap, retval)
484: struct proc *p;
485: struct sync_args *uap;
486: register_t *retval;
487: {
488: register struct mount *mp, *nmp;
489: int asyncflag;
490:
491: #if MACH_NBC
492: #if DIAGNOSTIC
493: {
494: int error = 0;
495: error = mapfs_sync();
496: if (error)
497: panic("sync: mapfs_sync %d", error);
498: }
499: #else
500: (void)mapfs_sync(); /* Ignore errors! */
501: #endif /* DIAGNOSTIC */
502: #endif /* MACH_NBC */
503:
504: simple_lock(&mountlist_slock);
505: for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
506: if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
507: nmp = mp->mnt_list.cqe_next;
508: continue;
509: }
510: if ((mp->mnt_flag & MNT_RDONLY) == 0) {
511: asyncflag = mp->mnt_flag & MNT_ASYNC;
512: mp->mnt_flag &= ~MNT_ASYNC;
513: VFS_SYNC(mp, MNT_NOWAIT, p->p_ucred, p);
514: if (asyncflag)
515: mp->mnt_flag |= MNT_ASYNC;
516: }
517: simple_lock(&mountlist_slock);
518: nmp = mp->mnt_list.cqe_next;
519: vfs_unbusy(mp, p);
520: }
521: simple_unlock(&mountlist_slock);
522: #if DIAGNOSTIC
523: if (syncprt)
524: vfs_bufstats();
525: #endif /* DIAGNOSTIC */
526: return (0);
527: }
528:
529: /*
530: * Change filesystem quotas.
531: */
532: struct quotactl_args {
533: char *path;
534: int cmd;
535: int uid;
536: caddr_t arg;
537: };
538: /* ARGSUSED */
539: int
540: quotactl(p, uap, retval)
541: struct proc *p;
542: register struct quotactl_args *uap;
543: register_t *retval;
544: {
545: register struct mount *mp;
546: int error;
547: struct nameidata nd;
548:
549: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
550: if (error = namei(&nd))
551: return (error);
552: mp = nd.ni_vp->v_mount;
553: vrele(nd.ni_vp);
554: return (VFS_QUOTACTL(mp, uap->cmd, uap->uid,
555: uap->arg, p));
556: }
557:
558: /*
559: * Get filesystem statistics.
560: */
561: struct statfs_args {
562: char *path;
563: struct statfs *buf;
564: };
565: /* ARGSUSED */
566: int
567: statfs(p, uap, retval)
568: struct proc *p;
569: register struct statfs_args *uap;
570: register_t *retval;
571: {
572: register struct mount *mp;
573: register struct statfs *sp;
574: int error;
575: struct nameidata nd;
576:
577: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
578: if (error = namei(&nd))
579: return (error);
580: mp = nd.ni_vp->v_mount;
581: sp = &mp->mnt_stat;
582: vrele(nd.ni_vp);
583: if (error = VFS_STATFS(mp, sp, p))
584: return (error);
585: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
586: return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
587: }
588:
589: /*
590: * Get filesystem statistics.
591: */
592: struct fstatfs_args {
593: int fd;
594: struct statfs *buf;
595: };
596: /* ARGSUSED */
597: int
598: fstatfs(p, uap, retval)
599: struct proc *p;
600: register struct fstatfs_args *uap;
601: register_t *retval;
602: {
603: struct file *fp;
604: struct mount *mp;
605: register struct statfs *sp;
606: int error;
607:
608: if (error = getvnode(p, uap->fd, &fp))
609: return (error);
610: mp = ((struct vnode *)fp->f_data)->v_mount;
611: if (!mp)
612: return (EBADF);
613: sp = &mp->mnt_stat;
614: if (error = VFS_STATFS(mp, sp, p))
615: return (error);
616: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
617: return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
618: }
619:
620: /*
621: * Get statistics on all filesystems.
622: */
623: struct getfsstat_args {
624: struct statfs *buf;
625: long bufsize;
626: int flags;
627: };
628: int
629: getfsstat(p, uap, retval)
630: struct proc *p;
631: register struct getfsstat_args *uap;
632: register_t *retval;
633: {
634: register struct mount *mp, *nmp;
635: register struct statfs *sp;
636: caddr_t sfsp;
637: long count, maxcount, error;
638:
639: maxcount = uap->bufsize / sizeof(struct statfs);
640: sfsp = (caddr_t)uap->buf;
641: count = 0;
642: simple_lock(&mountlist_slock);
643: for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
644: if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
645: nmp = mp->mnt_list.cqe_next;
646: continue;
647: }
648: if (sfsp && count < maxcount) {
649: sp = &mp->mnt_stat;
650: /*
651: * If MNT_NOWAIT is specified, do not refresh the
652: * fsstat cache. MNT_WAIT overrides MNT_NOWAIT.
653: */
654: if (((uap->flags & MNT_NOWAIT) == 0 ||
655: (uap->flags & MNT_WAIT)) &&
656: (error = VFS_STATFS(mp, sp, p))) {
657: simple_lock(&mountlist_slock);
658: nmp = mp->mnt_list.cqe_next;
659: vfs_unbusy(mp, p);
660: continue;
661: }
662: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
663: if (error = copyout((caddr_t)sp, sfsp, sizeof(*sp)))
664: return (error);
665: sfsp += sizeof(*sp);
666: }
667: count++;
668: simple_lock(&mountlist_slock);
669: nmp = mp->mnt_list.cqe_next;
670: vfs_unbusy(mp, p);
671: }
672: simple_unlock(&mountlist_slock);
673: if (sfsp && count > maxcount)
674: *retval = maxcount;
675: else
676: *retval = count;
677: return (0);
678: }
679:
680: /*
681: * Change current working directory to a given file descriptor.
682: */
683: struct fchdir_args {
684: int fd;
685: };
686: /* ARGSUSED */
687: int
688: fchdir(p, uap, retval)
689: struct proc *p;
690: struct fchdir_args *uap;
691: register_t *retval;
692: {
693: register struct filedesc *fdp = p->p_fd;
694: struct vnode *vp, *tdp;
695: struct mount *mp;
696: struct file *fp;
697: int error;
698:
699: if (error = getvnode(p, uap->fd, &fp))
700: return (error);
701: vp = (struct vnode *)fp->f_data;
702: VREF(vp);
703: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
704: if (vp->v_type != VDIR)
705: error = ENOTDIR;
706: else
707: error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
708: while (!error && (mp = vp->v_mountedhere) != NULL) {
709: if (vfs_busy(mp, 0, 0, p))
710: continue;
711: error = VFS_ROOT(mp, &tdp);
712: vfs_unbusy(mp, p);
713: if (error)
714: break;
715: vput(vp);
716: vp = tdp;
717: }
718: if (error) {
719: vput(vp);
720: return (error);
721: }
722: VOP_UNLOCK(vp, 0, p);
723: vrele(fdp->fd_cdir);
724: fdp->fd_cdir = vp;
725: return (0);
726: }
727:
728: /*
729: * Change current working directory (``.'').
730: */
731: struct chdir_args {
732: char *path;
733: };
734: /* ARGSUSED */
735: int
736: chdir(p, uap, retval)
737: struct proc *p;
738: struct chdir_args *uap;
739: register_t *retval;
740: {
741: register struct filedesc *fdp = p->p_fd;
742: int error;
743: struct nameidata nd;
744:
745: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
746: uap->path, p);
747: if (error = change_dir(&nd, p))
748: return (error);
749: vrele(fdp->fd_cdir);
750: fdp->fd_cdir = nd.ni_vp;
751: return (0);
752: }
753:
754: /*
755: * Change notion of root (``/'') directory.
756: */
757: struct chroot_args {
758: char *path;
759: };
760: /* ARGSUSED */
761: int
762: chroot(p, uap, retval)
763: struct proc *p;
764: struct chroot_args *uap;
765: register_t *retval;
766: {
767: register struct filedesc *fdp = p->p_fd;
768: int error;
769: struct nameidata nd;
770:
771: if (error = suser(p->p_ucred, &p->p_acflag))
772: return (error);
773: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
774: uap->path, p);
775: if (error = change_dir(&nd, p))
776: return (error);
777: if (fdp->fd_rdir != NULL)
778: vrele(fdp->fd_rdir);
779: fdp->fd_rdir = nd.ni_vp;
780: return (0);
781: }
782:
783: /*
784: * Common routine for chroot and chdir.
785: */
786: static int
787: change_dir(ndp, p)
788: register struct nameidata *ndp;
789: struct proc *p;
790: {
791: struct vnode *vp;
792: int error;
793:
794: if (error = namei(ndp))
795: return (error);
796: vp = ndp->ni_vp;
797: if (vp->v_type != VDIR)
798: error = ENOTDIR;
799: else
800: error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
801: if (error)
802: vput(vp);
803: else
804: VOP_UNLOCK(vp, 0, p);
805: return (error);
806: }
807:
808: /*
809: * Check permissions, allocate an open file structure,
810: * and call the device open routine if any.
811: */
812: struct open_args {
813: char *path;
814: int flags;
815: int mode;
816: };
817: int
818: open(p, uap, retval)
819: struct proc *p;
820: register struct open_args *uap;
821: register_t *retval;
822: {
823: register struct filedesc *fdp = p->p_fd;
824: register struct file *fp;
825: register struct vnode *vp;
826: int flags, cmode;
827: struct file *nfp;
828: int type, indx, error;
829: struct flock lf;
830: struct nameidata nd;
831: extern struct fileops vnops;
832:
833: /* CERT advisory patch applied from FreeBSD */
834: /* Refer to Radar#2262895 A. Ramesh */
835: flags = FFLAGS(uap->flags);
836: if ((flags & (FREAD | FWRITE))==0)
837: return(EINVAL);
838: if (error = falloc(p, &nfp, &indx))
839: return (error);
840: fp = nfp;
841: cmode = ((uap->mode &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT;
842: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
843: p->p_dupfd = -indx - 1; /* XXX check for fdopen */
844: if (error = vn_open(&nd, flags, cmode)) {
845: ffree(fp);
846: if ((error == ENODEV || error == ENXIO) &&
847: p->p_dupfd >= 0 && /* XXX from fdopen */
848: (error =
849: dupfdopen(fdp, indx, p->p_dupfd, flags, error)) == 0) {
850: *retval = indx;
851: return (0);
852: }
853: if (error == ERESTART)
854: error = EINTR;
855: fdrelse(p, indx);
856: return (error);
857: }
858: p->p_dupfd = 0;
859: vp = nd.ni_vp;
860: fp->f_flag = flags & FMASK;
861: fp->f_type = DTYPE_VNODE;
862: fp->f_ops = &vnops;
863: fp->f_data = (caddr_t)vp;
864: if (flags & (O_EXLOCK | O_SHLOCK)) {
865: lf.l_whence = SEEK_SET;
866: lf.l_start = 0;
867: lf.l_len = 0;
868: if (flags & O_EXLOCK)
869: lf.l_type = F_WRLCK;
870: else
871: lf.l_type = F_RDLCK;
872: type = F_FLOCK;
873: if ((flags & FNONBLOCK) == 0)
874: type |= F_WAIT;
875: VOP_UNLOCK(vp, 0, p);
876: if (error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) {
877: (void) vn_close(vp, fp->f_flag, fp->f_cred, p);
878: ffree(fp);
879: fdrelse(p, indx);
880: return (error);
881: }
882: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
883: fp->f_flag |= FHASLOCK;
884: }
885: VOP_UNLOCK(vp, 0, p);
886: *fdflags(p, indx) &= ~UF_RESERVED;
887: *retval = indx;
888: return (0);
889: }
890:
891: #if COMPAT_43
892: /*
893: * Create a file.
894: */
895: struct ocreat_args {
896: char *path;
897: int mode;
898: };
899: int
900: ocreat(p, uap, retval)
901: struct proc *p;
902: register struct ocreat_args *uap;
903: register_t *retval;
904: {
905: struct open_args nuap;
906:
907: nuap.path = uap->path;
908: nuap.mode = uap->mode;
909: nuap.flags = O_WRONLY | O_CREAT | O_TRUNC;
910: return (open(p, &nuap, retval));
911: }
912: #endif /* COMPAT_43 */
913:
914: /*
915: * Create a special file.
916: */
917: struct mknod_args {
918: char *path;
919: int mode;
920: int dev;
921: };
922: /* ARGSUSED */
923: int
924: mknod(p, uap, retval)
925: struct proc *p;
926: register struct mknod_args *uap;
927: register_t *retval;
928: {
929: register struct vnode *vp;
930: struct vattr vattr;
931: int error;
932: int whiteout;
933: struct nameidata nd;
934:
935: if (error = suser(p->p_ucred, &p->p_acflag))
936: return (error);
937: NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
938: if (error = namei(&nd))
939: return (error);
940: vp = nd.ni_vp;
941: if (vp != NULL)
942: error = EEXIST;
943: else {
944: VATTR_NULL(&vattr);
945: vattr.va_mode = (uap->mode & ALLPERMS) &~ p->p_fd->fd_cmask;
946: vattr.va_rdev = uap->dev;
947: whiteout = 0;
948:
949: switch (uap->mode & S_IFMT) {
950: case S_IFMT: /* used by badsect to flag bad sectors */
951: vattr.va_type = VBAD;
952: break;
953: case S_IFCHR:
954: vattr.va_type = VCHR;
955: break;
956: case S_IFBLK:
957: vattr.va_type = VBLK;
958: break;
959: case S_IFWHT:
960: whiteout = 1;
961: break;
962: default:
963: error = EINVAL;
964: break;
965: }
966: }
967: if (!error) {
968: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
969: if (whiteout) {
970: error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, CREATE);
971: if (error)
972: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
973: vput(nd.ni_dvp);
974: } else {
975: error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp,
976: &nd.ni_cnd, &vattr);
977: }
978: } else {
979: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
980: if (nd.ni_dvp == vp)
981: vrele(nd.ni_dvp);
982: else
983: vput(nd.ni_dvp);
984: if (vp)
985: vrele(vp);
986: }
987: return (error);
988: }
989:
990: /*
991: * Create a named pipe.
992: */
993: struct mkfifo_args {
994: char *path;
995: int mode;
996: };
997: /* ARGSUSED */
998: int
999: mkfifo(p, uap, retval)
1000: struct proc *p;
1001: register struct mkfifo_args *uap;
1002: register_t *retval;
1003: {
1004: struct vattr vattr;
1005: int error;
1006: struct nameidata nd;
1007:
1008: #if !FIFO
1009: return (EOPNOTSUPP);
1010: #else
1011: NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
1012: if (error = namei(&nd))
1013: return (error);
1014: if (nd.ni_vp != NULL) {
1015: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1016: if (nd.ni_dvp == nd.ni_vp)
1017: vrele(nd.ni_dvp);
1018: else
1019: vput(nd.ni_dvp);
1020: vrele(nd.ni_vp);
1021: return (EEXIST);
1022: }
1023: VATTR_NULL(&vattr);
1024: vattr.va_type = VFIFO;
1025: vattr.va_mode = (uap->mode & ALLPERMS) &~ p->p_fd->fd_cmask;
1026: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
1027: return (VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr));
1028: #endif /* FIFO */
1029: }
1030:
1031: /*
1032: * Make a hard file link.
1033: */
1034: struct link_args {
1035: char *path;
1036: char *link;
1037: };
1038: /* ARGSUSED */
1039: int
1040: link(p, uap, retval)
1041: struct proc *p;
1042: register struct link_args *uap;
1043: register_t *retval;
1044: {
1045: register struct vnode *vp;
1046: struct nameidata nd;
1047: int error;
1048:
1049: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1050: if (error = namei(&nd))
1051: return (error);
1052: vp = nd.ni_vp;
1053: if (vp->v_type == VDIR)
1054: error = EPERM; /* POSIX */
1055: else {
1056: nd.ni_cnd.cn_nameiop = CREATE;
1057: nd.ni_cnd.cn_flags = LOCKPARENT;
1058: nd.ni_dirp = uap->link;
1059: if ((error = namei(&nd)) == 0) {
1060: if (nd.ni_vp != NULL)
1061: error = EEXIST;
1062: if (!error) {
1063: VOP_LEASE(nd.ni_dvp, p, p->p_ucred,
1064: LEASE_WRITE);
1065: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1066: error = VOP_LINK(vp, nd.ni_dvp, &nd.ni_cnd);
1067: } else {
1068: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1069: if (nd.ni_dvp == nd.ni_vp)
1070: vrele(nd.ni_dvp);
1071: else
1072: vput(nd.ni_dvp);
1073: if (nd.ni_vp)
1074: vrele(nd.ni_vp);
1075: }
1076: }
1077: }
1078: vrele(vp);
1079: return (error);
1080: }
1081:
1082: /*
1083: * Make a symbolic link.
1084: */
1085: struct symlink_args {
1086: char *path;
1087: char *link;
1088: };
1089: /* ARGSUSED */
1090: int
1091: symlink(p, uap, retval)
1092: struct proc *p;
1093: register struct symlink_args *uap;
1094: register_t *retval;
1095: {
1096: struct vattr vattr;
1097: char *path;
1098: int error;
1099: struct nameidata nd;
1100: size_t dummy=0;
1101: MALLOC_ZONE(path, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
1102: if (error = copyinstr(uap->path, path, MAXPATHLEN, &dummy))
1103: goto out;
1104: NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->link, p);
1105: if (error = namei(&nd))
1106: goto out;
1107: if (nd.ni_vp) {
1108: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1109: if (nd.ni_dvp == nd.ni_vp)
1110: vrele(nd.ni_dvp);
1111: else
1112: vput(nd.ni_dvp);
1113: vrele(nd.ni_vp);
1114: error = EEXIST;
1115: goto out;
1116: }
1117: VATTR_NULL(&vattr);
1118: vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask;
1119: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
1120: error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path);
1121: out:
1122: FREE_ZONE(path, MAXPATHLEN, M_NAMEI);
1123: return (error);
1124: }
1125:
1126: /*
1127: * Delete a whiteout from the filesystem.
1128: */
1129: struct undelete_args {
1130: char *path;
1131: };
1132: /* ARGSUSED */
1133: int
1134: undelete(p, uap, retval)
1135: struct proc *p;
1136: register struct undelete_args *uap;
1137: register_t *retval;
1138: {
1139: int error;
1140: struct nameidata nd;
1141:
1142: NDINIT(&nd, DELETE, LOCKPARENT|DOWHITEOUT, UIO_USERSPACE,
1143: uap->path, p);
1144: error = namei(&nd);
1145: if (error)
1146: return (error);
1147:
1148: if (nd.ni_vp != NULLVP || !(nd.ni_cnd.cn_flags & ISWHITEOUT)) {
1149: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1150: if (nd.ni_dvp == nd.ni_vp)
1151: vrele(nd.ni_dvp);
1152: else
1153: vput(nd.ni_dvp);
1154: if (nd.ni_vp)
1155: vrele(nd.ni_vp);
1156: return (EEXIST);
1157: }
1158:
1159: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
1160: if (error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, DELETE))
1161: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1162: vput(nd.ni_dvp);
1163: return (error);
1164: }
1165:
1166: /*
1167: * Delete a name from the filesystem.
1168: */
1169: struct unlink_args {
1170: char *path;
1171: };
1172: /* ARGSUSED */
1173: static int
1174: _unlink(p, uap, retval, nodelbusy)
1175: struct proc *p;
1176: struct unlink_args *uap;
1177: register_t *retval;
1178: int nodelbusy;
1179: {
1180: register struct vnode *vp;
1181: int error;
1182: struct nameidata nd;
1183:
1184: NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
1185: /* with hfs semantics, busy files cannot be deleted */
1186: if (nodelbusy)
1187: nd.ni_cnd.cn_flags |= NODELETEBUSY;
1188: if (error = namei(&nd))
1189: return (error);
1190: vp = nd.ni_vp;
1191: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1192: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1193:
1194: if (vp->v_type == VDIR)
1195: error = EPERM; /* POSIX */
1196: else {
1197: /*
1198: * The root of a mounted filesystem cannot be deleted.
1199: *
1200: * XXX: can this only be a VDIR case?
1201: */
1202: if (vp->v_flag & VROOT)
1203: error = EBUSY;
1204: else {
1205: (void) vnode_uncache(vp);
1206: if (ISMAPPEDFILE(vp)) {
1207: ubc_unlink(vp);
1208: }
1209: }
1210: }
1211:
1212: if (!error) {
1213: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
1214: error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
1215: } else {
1216: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1217: if (nd.ni_dvp == vp)
1218: vrele(nd.ni_dvp);
1219: else
1220: vput(nd.ni_dvp);
1221: if (vp != NULLVP)
1222: vput(vp);
1223: }
1224: return (error);
1225: }
1226:
1227: /*
1228: * Delete a name from the filesystem using POSIX semantics.
1229: */
1230: int
1231: unlink(p, uap, retval)
1232: struct proc *p;
1233: struct unlink_args *uap;
1234: register_t *retval;
1235: {
1236: return _unlink(p, uap, retval, 0);
1237: }
1238:
1239: /*
1240: * Delete a name from the filesystem using HFS semantics.
1241: */
1242: int
1243: delete(p, uap, retval)
1244: struct proc *p;
1245: struct unlink_args *uap;
1246: register_t *retval;
1247: {
1248: return _unlink(p, uap, retval, 1);
1249: }
1250:
1251: /*
1252: * Reposition read/write file offset.
1253: */
1254: struct lseek_args {
1255: int fd;
1256: #ifdef DOUBLE_ALIGN_PARAMS
1257: int pad;
1258: #endif
1259: off_t offset;
1260: int whence;
1261: };
1262: int
1263: lseek(p, uap, retval)
1264: struct proc *p;
1265: register struct lseek_args *uap;
1266: register_t *retval;
1267: {
1268: struct ucred *cred = p->p_ucred;
1269: struct file *fp;
1270: struct vattr vattr;
1271: int error;
1272:
1273: if (error = fdgetf(p, uap->fd, &fp))
1274: return (error);
1275: if (fp->f_type != DTYPE_VNODE)
1276: return (ESPIPE);
1277: switch (uap->whence) {
1278: case L_INCR:
1279: fp->f_offset += uap->offset;
1280: break;
1281: case L_XTND:
1282: if (error =
1283: VOP_GETATTR((struct vnode *)fp->f_data, &vattr, cred, p))
1284: return (error);
1285: fp->f_offset = uap->offset + vattr.va_size;
1286: break;
1287: case L_SET:
1288: fp->f_offset = uap->offset;
1289: break;
1290: default:
1291: return (EINVAL);
1292: }
1293: *(off_t *)retval = fp->f_offset;
1294: return (0);
1295: }
1296:
1297: #if COMPAT_43
1298: /*
1299: * Reposition read/write file offset.
1300: */
1301: struct olseek_args {
1302: int fd;
1303: long offset;
1304: int whence;
1305: };
1306: int
1307: olseek(p, uap, retval)
1308: struct proc *p;
1309: register struct olseek_args *uap;
1310: register_t *retval;
1311: {
1312: struct lseek_args /* {
1313: syscallarg(int) fd;
1314: #ifdef DOUBLE_ALIGN_PARAMS
1315: syscallarg(int) pad;
1316: #endif
1317: syscallarg(off_t) offset;
1318: syscallarg(int) whence;
1319: } */ nuap;
1320: off_t qret;
1321: int error;
1322:
1323: nuap.fd = uap->fd;
1324: nuap.offset = uap->offset;
1325: nuap.whence = uap->whence;
1326: error = lseek(p, &nuap, &qret);
1327: *(long *)retval = qret;
1328: return (error);
1329: }
1330: #endif /* COMPAT_43 */
1331:
1332: /*
1333: * Check access permissions.
1334: */
1335: struct access_args {
1336: char *path;
1337: int flags;
1338: };
1339: int
1340: access(p, uap, retval)
1341: struct proc *p;
1342: register struct access_args *uap;
1343: register_t *retval;
1344: {
1345: register struct ucred *cred = p->p_ucred;
1346: register struct vnode *vp;
1347: int error, flags, t_gid, t_uid;
1348: struct nameidata nd;
1349:
1350: t_uid = cred->cr_uid;
1351: t_gid = cred->cr_groups[0];
1352: cred->cr_uid = p->p_cred->p_ruid;
1353: cred->cr_groups[0] = p->p_cred->p_rgid;
1354: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
1355: uap->path, p);
1356: if (error = namei(&nd))
1357: goto out1;
1358: vp = nd.ni_vp;
1359:
1360: /* Flags == 0 means only check for existence. */
1361: if (uap->flags) {
1362: flags = 0;
1363: if (uap->flags & R_OK)
1364: flags |= VREAD;
1365: if (uap->flags & W_OK)
1366: flags |= VWRITE;
1367: if (uap->flags & X_OK)
1368: flags |= VEXEC;
1369: if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
1370: error = VOP_ACCESS(vp, flags, cred, p);
1371: }
1372: vput(vp);
1373: out1:
1374: cred->cr_uid = t_uid;
1375: cred->cr_groups[0] = t_gid;
1376: return (error);
1377: }
1378:
1379: #if COMPAT_43
1380: /*
1381: * Get file status; this version follows links.
1382: */
1383: struct ostat_args {
1384: char *path;
1385: struct ostat *ub;
1386: };
1387: /* ARGSUSED */
1388: int
1389: ostat(p, uap, retval)
1390: struct proc *p;
1391: register struct ostat_args *uap;
1392: register_t *retval;
1393: {
1394: struct stat sb;
1395: struct ostat osb;
1396: int error;
1397: struct nameidata nd;
1398:
1399: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
1400: uap->path, p);
1401: if (error = namei(&nd))
1402: return (error);
1403: error = vn_stat(nd.ni_vp, &sb, p);
1404: vput(nd.ni_vp);
1405: if (error)
1406: return (error);
1407: cvtstat(&sb, &osb);
1408: error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
1409: return (error);
1410: }
1411:
1412: /*
1413: * Get file status; this version does not follow links.
1414: */
1415: struct olstat_args {
1416: char *path;
1417: struct ostat *ub;
1418: };
1419: /* ARGSUSED */
1420: int
1421: olstat(p, uap, retval)
1422: struct proc *p;
1423: register struct olstat_args *uap;
1424: register_t *retval;
1425: {
1426: struct vnode *vp, *dvp;
1427: struct stat sb, sb1;
1428: struct ostat osb;
1429: int error;
1430: struct nameidata nd;
1431:
1432: NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | LOCKPARENT, UIO_USERSPACE,
1433: uap->path, p);
1434: if (error = namei(&nd))
1435: return (error);
1436: /*
1437: * For symbolic links, always return the attributes of its
1438: * containing directory, except for mode, size, and links.
1439: */
1440: vp = nd.ni_vp;
1441: dvp = nd.ni_dvp;
1442: if (vp->v_type != VLNK) {
1443: if (dvp == vp)
1444: vrele(dvp);
1445: else
1446: vput(dvp);
1447: error = vn_stat(vp, &sb, p);
1448: vput(vp);
1449: if (error)
1450: return (error);
1451: } else {
1452: error = vn_stat(dvp, &sb, p);
1453: vput(dvp);
1454: if (error) {
1455: vput(vp);
1456: return (error);
1457: }
1458: error = vn_stat(vp, &sb1, p);
1459: vput(vp);
1460: if (error)
1461: return (error);
1462: sb.st_mode &= ~S_IFDIR;
1463: sb.st_mode |= S_IFLNK;
1464: sb.st_nlink = sb1.st_nlink;
1465: sb.st_size = sb1.st_size;
1466: sb.st_blocks = sb1.st_blocks;
1467: }
1468: cvtstat(&sb, &osb);
1469: error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
1470: return (error);
1471: }
1472:
1473: /*
1474: * Convert from an old to a new stat structure.
1475: */
1476: void
1477: cvtstat(st, ost)
1478: struct stat *st;
1479: struct ostat *ost;
1480: {
1481:
1482: ost->st_dev = st->st_dev;
1483: ost->st_ino = st->st_ino;
1484: ost->st_mode = st->st_mode;
1485: ost->st_nlink = st->st_nlink;
1486: ost->st_uid = st->st_uid;
1487: ost->st_gid = st->st_gid;
1488: ost->st_rdev = st->st_rdev;
1489: if (st->st_size < (quad_t)1 << 32)
1490: ost->st_size = st->st_size;
1491: else
1492: ost->st_size = -2;
1493: ost->st_atime = st->st_atime;
1494: ost->st_mtime = st->st_mtime;
1495: ost->st_ctime = st->st_ctime;
1496: ost->st_blksize = st->st_blksize;
1497: ost->st_blocks = st->st_blocks;
1498: ost->st_flags = st->st_flags;
1499: ost->st_gen = st->st_gen;
1500: }
1501: #endif /* COMPAT_43 */
1502:
1503: /*
1504: * Get file status; this version follows links.
1505: */
1506: struct stat_args {
1507: char *path;
1508: struct stat *ub;
1509: };
1510: /* ARGSUSED */
1511: int
1512: stat(p, uap, retval)
1513: struct proc *p;
1514: register struct stat_args *uap;
1515: register_t *retval;
1516: {
1517: struct stat sb;
1518: int error;
1519: struct nameidata nd;
1520:
1521: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
1522: uap->path, p);
1523: if (error = namei(&nd))
1524: return (error);
1525: error = vn_stat(nd.ni_vp, &sb, p);
1526: vput(nd.ni_vp);
1527: if (error)
1528: return (error);
1529: error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
1530: return (error);
1531: }
1532:
1533: /*
1534: * Get file status; this version does not follow links.
1535: */
1536: struct lstat_args {
1537: char *path;
1538: struct stat *ub;
1539: };
1540: /* ARGSUSED */
1541: int
1542: lstat(p, uap, retval)
1543: struct proc *p;
1544: register struct lstat_args *uap;
1545: register_t *retval;
1546: {
1547: int error;
1548: struct vnode *vp, *dvp;
1549: struct stat sb, sb1;
1550: struct nameidata nd;
1551:
1552: NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | LOCKPARENT, UIO_USERSPACE,
1553: uap->path, p);
1554: if (error = namei(&nd))
1555: return (error);
1556: /*
1557: * For symbolic links, always return the attributes of its containing
1558: * directory, except for mode, size, inode number, and links.
1559: */
1560: vp = nd.ni_vp;
1561: dvp = nd.ni_dvp;
1562: if ((vp->v_type != VLNK) || ((vp->v_type == VLNK) && (vp->v_tag == VT_NFS))) {
1563: if (dvp == vp)
1564: vrele(dvp);
1565: else
1566: vput(dvp);
1567: error = vn_stat(vp, &sb, p);
1568: vput(vp);
1569: if (error)
1570: return (error);
1571: if (vp->v_type == VLNK)
1572: sb.st_mode |= S_IFLNK;
1573: } else {
1574: error = vn_stat(dvp, &sb, p);
1575: vput(dvp);
1576: if (error) {
1577: vput(vp);
1578: return (error);
1579: }
1580: error = vn_stat(vp, &sb1, p);
1581: vput(vp);
1582: if (error)
1583: return (error);
1584: sb.st_mode &= ~S_IFDIR;
1585: sb.st_mode |= S_IFLNK;
1586: sb.st_nlink = sb1.st_nlink;
1587: sb.st_size = sb1.st_size;
1588: sb.st_blocks = sb1.st_blocks;
1589: sb.st_ino = sb1.st_ino;
1590: }
1591: error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
1592: return (error);
1593: }
1594:
1595: /*
1596: * Get configurable pathname variables.
1597: */
1598: struct pathconf_args {
1599: char *path;
1600: int name;
1601: };
1602: /* ARGSUSED */
1603: int
1604: pathconf(p, uap, retval)
1605: struct proc *p;
1606: register struct pathconf_args *uap;
1607: register_t *retval;
1608: {
1609: int error;
1610: struct nameidata nd;
1611:
1612: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
1613: uap->path, p);
1614: if (error = namei(&nd))
1615: return (error);
1616: error = VOP_PATHCONF(nd.ni_vp, uap->name, retval);
1617: vput(nd.ni_vp);
1618: return (error);
1619: }
1620:
1621: /*
1622: * Return target name of a symbolic link.
1623: */
1624: struct readlink_args {
1625: char *path;
1626: char *buf;
1627: int count;
1628: };
1629: /* ARGSUSED */
1630: int
1631: readlink(p, uap, retval)
1632: struct proc *p;
1633: register struct readlink_args *uap;
1634: register_t *retval;
1635: {
1636: register struct vnode *vp;
1637: struct iovec aiov;
1638: struct uio auio;
1639: int error;
1640: struct nameidata nd;
1641:
1642: NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE,
1643: uap->path, p);
1644: if (error = namei(&nd))
1645: return (error);
1646: vp = nd.ni_vp;
1647: if (vp->v_type != VLNK)
1648: error = EINVAL;
1649: else {
1650: aiov.iov_base = uap->buf;
1651: aiov.iov_len = uap->count;
1652: auio.uio_iov = &aiov;
1653: auio.uio_iovcnt = 1;
1654: auio.uio_offset = 0;
1655: auio.uio_rw = UIO_READ;
1656: auio.uio_segflg = UIO_USERSPACE;
1657: auio.uio_procp = p;
1658: auio.uio_resid = uap->count;
1659: error = VOP_READLINK(vp, &auio, p->p_ucred);
1660: }
1661: vput(vp);
1662: *retval = uap->count - auio.uio_resid;
1663: return (error);
1664: }
1665:
1666: /*
1667: * Change flags of a file given a path name.
1668: */
1669: struct chflags_args {
1670: char *path;
1671: int flags;
1672: };
1673: /* ARGSUSED */
1674: int
1675: chflags(p, uap, retval)
1676: struct proc *p;
1677: register struct chflags_args *uap;
1678: register_t *retval;
1679: {
1680: register struct vnode *vp;
1681: struct vattr vattr;
1682: int error;
1683: struct nameidata nd;
1684:
1685: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1686: if (error = namei(&nd))
1687: return (error);
1688: vp = nd.ni_vp;
1689: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1690: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1691: VATTR_NULL(&vattr);
1692: vattr.va_flags = uap->flags;
1693: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1694: vput(vp);
1695: return (error);
1696: }
1697:
1698: /*
1699: * Change flags of a file given a file descriptor.
1700: */
1701: struct fchflags_args {
1702: int fd;
1703: int flags;
1704: };
1705: /* ARGSUSED */
1706: int
1707: fchflags(p, uap, retval)
1708: struct proc *p;
1709: register struct fchflags_args *uap;
1710: register_t *retval;
1711: {
1712: struct vattr vattr;
1713: struct vnode *vp;
1714: struct file *fp;
1715: int error;
1716:
1717: if (error = getvnode(p, uap->fd, &fp))
1718: return (error);
1719: vp = (struct vnode *)fp->f_data;
1720: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1721: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1722: VATTR_NULL(&vattr);
1723: vattr.va_flags = uap->flags;
1724: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1725: VOP_UNLOCK(vp, 0, p);
1726: return (error);
1727: }
1728:
1729: /*
1730: * Change mode of a file given path name.
1731: */
1732: struct chmod_args {
1733: char *path;
1734: int mode;
1735: };
1736: /* ARGSUSED */
1737: int
1738: chmod(p, uap, retval)
1739: struct proc *p;
1740: register struct chmod_args *uap;
1741: register_t *retval;
1742: {
1743: register struct vnode *vp;
1744: struct vattr vattr;
1745: int error;
1746: struct nameidata nd;
1747:
1748: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1749: if (error = namei(&nd))
1750: return (error);
1751: vp = nd.ni_vp;
1752: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1753: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1754: VATTR_NULL(&vattr);
1755: vattr.va_mode = uap->mode & ALLPERMS;
1756: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1757: vput(vp);
1758: return (error);
1759: }
1760:
1761: /*
1762: * Change mode of a file given a file descriptor.
1763: */
1764: struct fchmod_args {
1765: int fd;
1766: int mode;
1767: };
1768: /* ARGSUSED */
1769: int
1770: fchmod(p, uap, retval)
1771: struct proc *p;
1772: register struct fchmod_args *uap;
1773: register_t *retval;
1774: {
1775: struct vattr vattr;
1776: struct vnode *vp;
1777: struct file *fp;
1778: int error;
1779:
1780: if (error = getvnode(p, uap->fd, &fp))
1781: return (error);
1782: vp = (struct vnode *)fp->f_data;
1783: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1784: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1785: VATTR_NULL(&vattr);
1786: vattr.va_mode = uap->mode & ALLPERMS;
1787: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1788: VOP_UNLOCK(vp, 0, p);
1789: return (error);
1790: }
1791:
1792: /*
1793: * Set ownership given a path name.
1794: */
1795: struct chown_args {
1796: char *path;
1797: int uid;
1798: int gid;
1799: };
1800: /* ARGSUSED */
1801: int
1802: chown(p, uap, retval)
1803: struct proc *p;
1804: register struct chown_args *uap;
1805: register_t *retval;
1806: {
1807: register struct vnode *vp;
1808: struct vattr vattr;
1809: int error;
1810: struct nameidata nd;
1811:
1812: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1813: if (error = namei(&nd))
1814: return (error);
1815: vp = nd.ni_vp;
1816: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1817: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1818: VATTR_NULL(&vattr);
1819: vattr.va_uid = uap->uid;
1820: vattr.va_gid = uap->gid;
1821: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1822: vput(vp);
1823: return (error);
1824: }
1825:
1826: /*
1827: * Set ownership given a file descriptor.
1828: */
1829: struct fchown_args {
1830: int fd;
1831: int uid;
1832: int gid;
1833: };
1834: /* ARGSUSED */
1835: int
1836: fchown(p, uap, retval)
1837: struct proc *p;
1838: register struct fchown_args *uap;
1839: register_t *retval;
1840: {
1841: struct vattr vattr;
1842: struct vnode *vp;
1843: struct file *fp;
1844: int error;
1845:
1846: if (error = getvnode(p, uap->fd, &fp))
1847: return (error);
1848: vp = (struct vnode *)fp->f_data;
1849: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1850: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1851: VATTR_NULL(&vattr);
1852: vattr.va_uid = uap->uid;
1853: vattr.va_gid = uap->gid;
1854: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1855: VOP_UNLOCK(vp, 0, p);
1856: return (error);
1857: }
1858:
1859: /*
1860: * Set the access and modification times of a file.
1861: */
1862: struct utimes_args {
1863: char *path;
1864: struct timeval *tptr;
1865: };
1866: /* ARGSUSED */
1867: int
1868: utimes(p, uap, retval)
1869: struct proc *p;
1870: register struct utimes_args *uap;
1871: register_t *retval;
1872: {
1873: register struct vnode *vp;
1874: struct timeval tv[2];
1875: struct vattr vattr;
1876: int error;
1877: struct nameidata nd;
1878:
1879: VATTR_NULL(&vattr);
1880: if (uap->tptr == NULL) {
1881: microtime(&tv[0]);
1882: tv[1] = tv[0];
1883: vattr.va_vaflags |= VA_UTIMES_NULL;
1884: } else if (error = copyin((caddr_t)uap->tptr, (caddr_t)tv,
1885: sizeof (tv)))
1886: return (error);
1887: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1888: if (error = namei(&nd))
1889: return (error);
1890: vp = nd.ni_vp;
1891: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1892: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1893: vattr.va_atime.tv_sec = tv[0].tv_sec;
1894: vattr.va_atime.tv_nsec = tv[0].tv_usec * 1000;
1895: vattr.va_mtime.tv_sec = tv[1].tv_sec;
1896: vattr.va_mtime.tv_nsec = tv[1].tv_usec * 1000;
1897: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1898: vput(vp);
1899: return (error);
1900: }
1901:
1902: /*
1903: * Truncate a file given its path name.
1904: */
1905: struct truncate_args {
1906: char *path;
1907: #ifdef DOUBLE_ALIGN_PARAMS
1908: int pad;
1909: #endif
1910: off_t length;
1911: };
1912: /* ARGSUSED */
1913: int
1914: truncate(p, uap, retval)
1915: struct proc *p;
1916: register struct truncate_args *uap;
1917: register_t *retval;
1918: {
1919: register struct vnode *vp;
1920: struct vattr vattr;
1921: int error;
1922: struct nameidata nd;
1923:
1924: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
1925: if (error = namei(&nd))
1926: return (error);
1927: vp = nd.ni_vp;
1928: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1929: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1930: if (vp->v_type == VDIR)
1931: error = EISDIR;
1932: else if ((error = vn_writechk(vp)) == 0 &&
1933: (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) == 0) {
1934: VATTR_NULL(&vattr);
1935: vattr.va_size = uap->length;
1936: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1937: }
1938: vput(vp);
1939: return (error);
1940: }
1941:
1942: /*
1943: * Truncate a file given a file descriptor.
1944: */
1945: struct ftruncate_args {
1946: int fd;
1947: #ifdef DOUBLE_ALIGN_PARAMS
1948: int pad;
1949: #endif
1950: off_t length;
1951: };
1952: /* ARGSUSED */
1953: int
1954: ftruncate(p, uap, retval)
1955: struct proc *p;
1956: register struct ftruncate_args *uap;
1957: register_t *retval;
1958: {
1959: struct vattr vattr;
1960: struct vnode *vp;
1961: struct file *fp;
1962: int error;
1963:
1964: if (error = fdgetf(p, uap->fd, &fp))
1965: return (error);
1966:
1967: if (fp->f_type == DTYPE_PSXSHM) {
1968: return(pshm_truncate(p, fp, uap->fd, uap->length, retval));
1969: }
1970: if (fp->f_type != DTYPE_VNODE)
1971: return (EINVAL);
1972:
1973:
1974: if ((fp->f_flag & FWRITE) == 0)
1975: return (EINVAL);
1976: vp = (struct vnode *)fp->f_data;
1977: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
1978: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1979: if (vp->v_type == VDIR)
1980: error = EISDIR;
1981: else if ((error = vn_writechk(vp)) == 0) {
1982: VATTR_NULL(&vattr);
1983: vattr.va_size = uap->length;
1984: error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
1985: }
1986: VOP_UNLOCK(vp, 0, p);
1987: return (error);
1988: }
1989:
1990: #if COMPAT_43
1991: /*
1992: * Truncate a file given its path name.
1993: */
1994: struct otruncate_args {
1995: char *path;
1996: long length;
1997: };
1998: /* ARGSUSED */
1999: int
2000: otruncate(p, uap, retval)
2001: struct proc *p;
2002: register struct otruncate_args *uap;
2003: register_t *retval;
2004: {
2005: struct truncate_args /* {
2006: syscallarg(char *) path;
2007: #ifdef DOUBLE_ALIGN_PARAMS
2008: syscallarg(int) pad;
2009: #endif
2010: syscallarg(off_t) length;
2011: } */ nuap;
2012:
2013: nuap.path = uap->path;
2014: nuap.length = uap->length;
2015: return (truncate(p, &nuap, retval));
2016: }
2017:
2018: /*
2019: * Truncate a file given a file descriptor.
2020: */
2021: struct oftruncate_args {
2022: int fd;
2023: long length;
2024: };
2025: /* ARGSUSED */
2026: int
2027: oftruncate(p, uap, retval)
2028: struct proc *p;
2029: register struct oftruncate_args *uap;
2030: register_t *retval;
2031: {
2032: struct ftruncate_args /* {
2033: syscallarg(int) fd;
2034: #ifdef DOUBLE_ALIGN_PARAMS
2035: syscallarg(int) pad;
2036: #endif
2037: syscallarg(off_t) length;
2038: } */ nuap;
2039:
2040: nuap.fd = uap->fd;
2041: nuap.length = uap->length;
2042: return (ftruncate(p, &nuap, retval));
2043: }
2044: #endif /* COMPAT_43 */
2045:
2046: /*
2047: * Sync an open file.
2048: */
2049: struct fsync_args {
2050: int fd;
2051: };
2052: /* ARGSUSED */
2053: int
2054: fsync(p, uap, retval)
2055: struct proc *p;
2056: struct fsync_args *uap;
2057: register_t *retval;
2058: {
2059: register struct vnode *vp;
2060: struct file *fp;
2061: int error;
2062:
2063: if (error = getvnode(p, uap->fd, &fp))
2064: return (error);
2065: vp = (struct vnode *)fp->f_data;
2066: #if MACH_NBC
2067: mapfs_fsync(vp);
2068: #endif
2069: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
2070: error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, p);
2071: VOP_UNLOCK(vp, 0, p);
2072: return (error);
2073: }
2074:
2075: /*
2076: * Duplicate files. Source must be a file, target must be a file or
2077: * must not exist.
2078: */
2079:
2080: struct copyfile_args {
2081: char *from;
2082: char *to;
2083: int mode;
2084: int flags;
2085: };
2086: /* ARGSUSED */
2087: int
2088: copyfile(p, uap, retval)
2089: struct proc *p;
2090: register struct copyfile_args *uap;
2091: register_t *retval;
2092: {
2093: register struct vnode *tvp, *fvp, *tdvp;
2094: register struct ucred *cred = p->p_ucred;
2095: struct nameidata fromnd, tond;
2096: int error;
2097:
2098: /* Check that the flags are valid.
2099: */
2100:
2101: if (uap->flags & ~CPF_MASK) {
2102: return(EINVAL);
2103: }
2104:
2105: NDINIT(&fromnd, LOOKUP, SAVESTART, UIO_USERSPACE,
2106: uap->from, p);
2107: if (error = namei(&fromnd))
2108: return (error);
2109: fvp = fromnd.ni_vp;
2110:
2111: NDINIT(&tond, CREATE, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART,
2112: UIO_USERSPACE, uap->to, p);
2113: if (error = namei(&tond)) {
2114: vrele(fvp);
2115: goto out1;
2116: }
2117: tdvp = tond.ni_dvp;
2118: tvp = tond.ni_vp;
2119: if (tvp != NULL) {
2120: if (!(uap->flags & CPF_OVERWRITE)) {
2121: error = EEXIST;
2122: goto out;
2123: }
2124: }
2125:
2126: if (fvp->v_type == VDIR || (tvp && tvp->v_type == VDIR)) {
2127: error = EISDIR;
2128: goto out;
2129: }
2130:
2131: if (error = VOP_ACCESS(tdvp, VWRITE, cred, p))
2132: goto out;
2133:
2134: if (fvp == tdvp)
2135: error = EINVAL;
2136: /*
2137: * If source is the same as the destination (that is the
2138: * same inode number) then there is nothing to do.
2139: * (fixed to have POSIX semantics - CSM 3/2/98)
2140: */
2141: if (fvp == tvp)
2142: error = -1;
2143: out:
2144: if (!error) {
2145: error = VOP_COPYFILE(fvp,tdvp,tvp,&tond.ni_cnd,uap->mode,uap->flags);
2146: } else {
2147: VOP_ABORTOP(tdvp, &tond.ni_cnd);
2148: if (tdvp == tvp)
2149: vrele(tdvp);
2150: else
2151: vput(tdvp);
2152: if (tvp)
2153: vput(tvp);
2154: vrele(fvp);
2155: }
2156: vrele(tond.ni_startdir);
2157: FREE_ZONE(tond.ni_cnd.cn_pnbuf, tond.ni_cnd.cn_pnlen, M_NAMEI);
2158: out1:
2159: if (fromnd.ni_startdir)
2160: vrele(fromnd.ni_startdir);
2161: FREE_ZONE(fromnd.ni_cnd.cn_pnbuf, fromnd.ni_cnd.cn_pnlen, M_NAMEI);
2162: if (error == -1)
2163: return (0);
2164: return (error);
2165: }
2166:
2167: /*
2168: /*
2169: * Rename files. Source and destination must either both be directories,
2170: * or both not be directories. If target is a directory, it must be empty.
2171: */
2172: struct rename_args {
2173: char *from;
2174: char *to;
2175: };
2176: /* ARGSUSED */
2177: int
2178: rename(p, uap, retval)
2179: struct proc *p;
2180: register struct rename_args *uap;
2181: register_t *retval;
2182: {
2183: register struct vnode *tvp, *fvp, *tdvp;
2184: struct nameidata fromnd, tond;
2185: int error;
2186:
2187: NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE,
2188: uap->from, p);
2189: if (error = namei(&fromnd))
2190: return (error);
2191: fvp = fromnd.ni_vp;
2192: NDINIT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART,
2193: UIO_USERSPACE, uap->to, p);
2194: if (error = namei(&tond)) {
2195: VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
2196: vrele(fromnd.ni_dvp);
2197: vrele(fvp);
2198: goto out1;
2199: }
2200: tdvp = tond.ni_dvp;
2201: tvp = tond.ni_vp;
2202: if (tvp != NULL) {
2203: if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
2204: error = ENOTDIR;
2205: goto out;
2206: } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
2207: error = EISDIR;
2208: goto out;
2209: }
2210: }
2211: if (fvp == tdvp)
2212: error = EINVAL;
2213: /*
2214: * If source is the same as the destination (that is the
2215: * same inode number) then there is nothing to do.
2216: * (fixed to have POSIX semantics - CSM 3/2/98)
2217: */
2218: if (fvp == tvp)
2219: error = -1;
2220: out:
2221: if (!error) {
2222: VOP_LEASE(tdvp, p, p->p_ucred, LEASE_WRITE);
2223: if (fromnd.ni_dvp != tdvp)
2224: VOP_LEASE(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
2225: if (tvp)
2226: VOP_LEASE(tvp, p, p->p_ucred, LEASE_WRITE);
2227: error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
2228: tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
2229: } else {
2230: VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
2231: if (tdvp == tvp)
2232: vrele(tdvp);
2233: else
2234: vput(tdvp);
2235: if (tvp)
2236: vput(tvp);
2237: VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
2238: vrele(fromnd.ni_dvp);
2239: vrele(fvp);
2240: }
2241: vrele(tond.ni_startdir);
2242: FREE_ZONE(tond.ni_cnd.cn_pnbuf, tond.ni_cnd.cn_pnlen, M_NAMEI);
2243: out1:
2244: if (fromnd.ni_startdir)
2245: vrele(fromnd.ni_startdir);
2246: FREE_ZONE(fromnd.ni_cnd.cn_pnbuf, fromnd.ni_cnd.cn_pnlen, M_NAMEI);
2247: if (error == -1)
2248: return (0);
2249: return (error);
2250: }
2251:
2252: /*
2253: * Make a directory file.
2254: */
2255: struct mkdir_args {
2256: char *path;
2257: int mode;
2258: };
2259: /* ARGSUSED */
2260: int
2261: mkdir(p, uap, retval)
2262: struct proc *p;
2263: register struct mkdir_args *uap;
2264: register_t *retval;
2265: {
2266: register struct vnode *vp;
2267: struct vattr vattr;
2268: int error;
2269: struct nameidata nd;
2270:
2271: NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p);
2272: if (error = namei(&nd))
2273: return (error);
2274: vp = nd.ni_vp;
2275: if (vp != NULL) {
2276: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2277: if (nd.ni_dvp == vp)
2278: vrele(nd.ni_dvp);
2279: else
2280: vput(nd.ni_dvp);
2281: vrele(vp);
2282: return (EEXIST);
2283: }
2284: VATTR_NULL(&vattr);
2285: vattr.va_type = VDIR;
2286: vattr.va_mode = (uap->mode & ACCESSPERMS) &~ p->p_fd->fd_cmask;
2287: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
2288: error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
2289: if (!error)
2290: vput(nd.ni_vp);
2291: return (error);
2292: }
2293:
2294: /*
2295: * Remove a directory file.
2296: */
2297: struct rmdir_args {
2298: char *path;
2299: };
2300: /* ARGSUSED */
2301: int
2302: rmdir(p, uap, retval)
2303: struct proc *p;
2304: struct rmdir_args *uap;
2305: register_t *retval;
2306: {
2307: register struct vnode *vp;
2308: int error;
2309: struct nameidata nd;
2310:
2311: NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE,
2312: uap->path, p);
2313: if (error = namei(&nd))
2314: return (error);
2315: vp = nd.ni_vp;
2316: if (vp->v_type != VDIR) {
2317: error = ENOTDIR;
2318: goto out;
2319: }
2320: /*
2321: * No rmdir "." please.
2322: */
2323: if (nd.ni_dvp == vp) {
2324: error = EINVAL;
2325: goto out;
2326: }
2327: /*
2328: * The root of a mounted filesystem cannot be deleted.
2329: */
2330: if (vp->v_flag & VROOT)
2331: error = EBUSY;
2332: out:
2333: if (!error) {
2334: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
2335: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
2336: error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
2337: } else {
2338: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2339: if (nd.ni_dvp == vp)
2340: vrele(nd.ni_dvp);
2341: else
2342: vput(nd.ni_dvp);
2343: vput(vp);
2344: }
2345: return (error);
2346: }
2347:
2348: #if COMPAT_43
2349: /*
2350: * Read a block of directory entries in a file system independent format.
2351: */
2352: struct ogetdirentries_args {
2353: int fd;
2354: char *buf;
2355: u_int count;
2356: long *basep;
2357: };
2358: int
2359: ogetdirentries(p, uap, retval)
2360: struct proc *p;
2361: register struct ogetdirentries_args *uap;
2362: register_t *retval;
2363: {
2364: register struct vnode *vp;
2365: struct file *fp;
2366: struct uio auio, kuio;
2367: struct iovec aiov, kiov;
2368: struct dirent *dp, *edp;
2369: caddr_t dirbuf;
2370: int error, eofflag, readcnt;
2371: long loff;
2372:
2373: if (error = getvnode(p, uap->fd, &fp))
2374: return (error);
2375: if ((fp->f_flag & FREAD) == 0)
2376: return (EBADF);
2377: vp = (struct vnode *)fp->f_data;
2378: unionread:
2379: if (vp->v_type != VDIR)
2380: return (EINVAL);
2381: aiov.iov_base = uap->buf;
2382: aiov.iov_len = uap->count;
2383: auio.uio_iov = &aiov;
2384: auio.uio_iovcnt = 1;
2385: auio.uio_rw = UIO_READ;
2386: auio.uio_segflg = UIO_USERSPACE;
2387: auio.uio_procp = p;
2388: auio.uio_resid = uap->count;
2389: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
2390: loff = auio.uio_offset = fp->f_offset;
2391: # if (BYTE_ORDER != LITTLE_ENDIAN)
2392: if (vp->v_mount->mnt_maxsymlinklen <= 0) {
2393: error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag,
2394: (int *)0, (u_long *)0);
2395: fp->f_offset = auio.uio_offset;
2396: } else
2397: # endif
2398: {
2399: kuio = auio;
2400: kuio.uio_iov = &kiov;
2401: kuio.uio_segflg = UIO_SYSSPACE;
2402: kiov.iov_len = uap->count;
2403: MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK);
2404: kiov.iov_base = dirbuf;
2405: error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag,
2406: (int *)0, (u_long *)0);
2407: fp->f_offset = kuio.uio_offset;
2408: if (error == 0) {
2409: readcnt = uap->count - kuio.uio_resid;
2410: edp = (struct dirent *)&dirbuf[readcnt];
2411: for (dp = (struct dirent *)dirbuf; dp < edp; ) {
2412: # if (BYTE_ORDER == LITTLE_ENDIAN)
2413: /*
2414: * The expected low byte of
2415: * dp->d_namlen is our dp->d_type.
2416: * The high MBZ byte of dp->d_namlen
2417: * is our dp->d_namlen.
2418: */
2419: dp->d_type = dp->d_namlen;
2420: dp->d_namlen = 0;
2421: # else
2422: /*
2423: * The dp->d_type is the high byte
2424: * of the expected dp->d_namlen,
2425: * so must be zero'ed.
2426: */
2427: dp->d_type = 0;
2428: # endif
2429: if (dp->d_reclen > 0) {
2430: dp = (struct dirent *)
2431: ((char *)dp + dp->d_reclen);
2432: } else {
2433: error = EIO;
2434: break;
2435: }
2436: }
2437: if (dp >= edp)
2438: error = uiomove(dirbuf, readcnt, &auio);
2439: }
2440: FREE(dirbuf, M_TEMP);
2441: }
2442: VOP_UNLOCK(vp, 0, p);
2443: if (error)
2444: return (error);
2445:
2446: #if UNION
2447: {
2448: extern int (**union_vnodeop_p)();
2449: extern struct vnode *union_dircache __P((struct vnode*, struct proc*));
2450:
2451: if ((uap->count == auio.uio_resid) &&
2452: (vp->v_op == union_vnodeop_p)) {
2453: struct vnode *lvp;
2454:
2455: lvp = union_dircache(vp, p);
2456: if (lvp != NULLVP) {
2457: struct vattr va;
2458:
2459: /*
2460: * If the directory is opaque,
2461: * then don't show lower entries
2462: */
2463: error = VOP_GETATTR(vp, &va, fp->f_cred, p);
2464: if (va.va_flags & OPAQUE) {
2465: vput(lvp);
2466: lvp = NULL;
2467: }
2468: }
2469:
2470: if (lvp != NULLVP) {
2471: error = VOP_OPEN(lvp, FREAD, fp->f_cred, p);
2472: if (error) {
2473: vput(lvp);
2474: return (error);
2475: }
2476: VOP_UNLOCK(lvp, 0, p);
2477: fp->f_data = (caddr_t) lvp;
2478: fp->f_offset = 0;
2479: error = vn_close(vp, FREAD, fp->f_cred, p);
2480: if (error)
2481: return (error);
2482: vp = lvp;
2483: goto unionread;
2484: }
2485: }
2486: }
2487: #endif /* UNION */
2488:
2489: if ((uap->count == auio.uio_resid) &&
2490: (vp->v_flag & VROOT) &&
2491: (vp->v_mount->mnt_flag & MNT_UNION)) {
2492: struct vnode *tvp = vp;
2493: vp = vp->v_mount->mnt_vnodecovered;
2494: VREF(vp);
2495: fp->f_data = (caddr_t) vp;
2496: fp->f_offset = 0;
2497: vrele(tvp);
2498: goto unionread;
2499: }
2500: error = copyout((caddr_t)&loff, (caddr_t)uap->basep,
2501: sizeof(long));
2502: *retval = uap->count - auio.uio_resid;
2503: return (error);
2504: }
2505: #endif /* COMPAT_43 */
2506:
2507: /*
2508: * Read a block of directory entries in a file system independent format.
2509: */
2510: struct getdirentries_args {
2511: int fd;
2512: char *buf;
2513: u_int count;
2514: long *basep;
2515: };
2516: int
2517: getdirentries(p, uap, retval)
2518: struct proc *p;
2519: register struct getdirentries_args *uap;
2520: register_t *retval;
2521: {
2522: register struct vnode *vp;
2523: struct file *fp;
2524: struct uio auio;
2525: struct iovec aiov;
2526: long loff;
2527: int error, eofflag;
2528:
2529: if (error = getvnode(p, uap->fd, &fp))
2530: return (error);
2531: if ((fp->f_flag & FREAD) == 0)
2532: return (EBADF);
2533: vp = (struct vnode *)fp->f_data;
2534: unionread:
2535: if (vp->v_type != VDIR)
2536: return (EINVAL);
2537: aiov.iov_base = uap->buf;
2538: aiov.iov_len = uap->count;
2539: auio.uio_iov = &aiov;
2540: auio.uio_iovcnt = 1;
2541: auio.uio_rw = UIO_READ;
2542: auio.uio_segflg = UIO_USERSPACE;
2543: auio.uio_procp = p;
2544: auio.uio_resid = uap->count;
2545: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
2546: loff = auio.uio_offset = fp->f_offset;
2547: error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag,
2548: (int *)0, (u_long *)0);
2549: fp->f_offset = auio.uio_offset;
2550: VOP_UNLOCK(vp, 0, p);
2551: if (error)
2552: return (error);
2553:
2554: #if UNION
2555: {
2556: extern int (**union_vnodeop_p)();
2557: extern struct vnode *union_dircache __P((struct vnode*, struct proc*));
2558:
2559: if ((uap->count == auio.uio_resid) &&
2560: (vp->v_op == union_vnodeop_p)) {
2561: struct vnode *lvp;
2562:
2563: lvp = union_dircache(vp, p);
2564: if (lvp != NULLVP) {
2565: struct vattr va;
2566:
2567: /*
2568: * If the directory is opaque,
2569: * then don't show lower entries
2570: */
2571: error = VOP_GETATTR(vp, &va, fp->f_cred, p);
2572: if (va.va_flags & OPAQUE) {
2573: vput(lvp);
2574: lvp = NULL;
2575: }
2576: }
2577:
2578: if (lvp != NULLVP) {
2579: error = VOP_OPEN(lvp, FREAD, fp->f_cred, p);
2580: if (error) {
2581: vput(lvp);
2582: return (error);
2583: }
2584: VOP_UNLOCK(lvp, 0, p);
2585: fp->f_data = (caddr_t) lvp;
2586: fp->f_offset = 0;
2587: error = vn_close(vp, FREAD, fp->f_cred, p);
2588: if (error)
2589: return (error);
2590: vp = lvp;
2591: goto unionread;
2592: }
2593: }
2594: }
2595: #endif /* UNION */
2596:
2597: if ((uap->count == auio.uio_resid) &&
2598: (vp->v_flag & VROOT) &&
2599: (vp->v_mount->mnt_flag & MNT_UNION)) {
2600: struct vnode *tvp = vp;
2601: vp = vp->v_mount->mnt_vnodecovered;
2602: VREF(vp);
2603: fp->f_data = (caddr_t) vp;
2604: fp->f_offset = 0;
2605: vrele(tvp);
2606: goto unionread;
2607: }
2608: error = copyout((caddr_t)&loff, (caddr_t)uap->basep,
2609: sizeof(long));
2610: *retval = uap->count - auio.uio_resid;
2611: return (error);
2612: }
2613:
2614: /*
2615: * Set the mode mask for creation of filesystem nodes.
2616: */
2617: struct umask_args {
2618: int newmask;
2619: };
2620: int
2621: umask(p, uap, retval)
2622: struct proc *p;
2623: struct umask_args *uap;
2624: register_t *retval;
2625: {
2626: register struct filedesc *fdp;
2627:
2628: fdp = p->p_fd;
2629: *retval = fdp->fd_cmask;
2630: fdp->fd_cmask = uap->newmask & ALLPERMS;
2631: return (0);
2632: }
2633:
2634: /*
2635: * Void all references to file by ripping underlying filesystem
2636: * away from vnode.
2637: */
2638: struct revoke_args {
2639: char *path;
2640: };
2641: /* ARGSUSED */
2642: int
2643: revoke(p, uap, retval)
2644: struct proc *p;
2645: register struct revoke_args *uap;
2646: register_t *retval;
2647: {
2648: register struct vnode *vp;
2649: struct vattr vattr;
2650: int error;
2651: struct nameidata nd;
2652:
2653: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
2654: if (error = namei(&nd))
2655: return (error);
2656: vp = nd.ni_vp;
2657: if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))
2658: goto out;
2659: if (p->p_ucred->cr_uid != vattr.va_uid &&
2660: (error = suser(p->p_ucred, &p->p_acflag)))
2661: goto out;
2662: if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
2663: VOP_REVOKE(vp, REVOKEALL);
2664: out:
2665: vrele(vp);
2666: return (error);
2667: }
2668:
2669: /*
2670: * Convert a user file descriptor to a kernel file entry.
2671: */
2672: int
2673: getvnode(p, fd, fpp)
2674: struct proc *p;
2675: int fd;
2676: struct file **fpp;
2677: {
2678: struct file *fp;
2679: int error;
2680:
2681: if (error = fdgetf(p, fd, &fp))
2682: return (error);
2683: if (fp->f_type != DTYPE_VNODE)
2684: return (EINVAL);
2685: *fpp = fp;
2686: return (0);
2687: }
2688: /*
2689: * HFS/HFS PlUS SPECIFIC SYSTEM CALLS
2690: * The following 10 system calls are designed to support features
2691: * which are specific to the HFS & HFS Plus volume formats
2692: */
2693:
2694:
2695: /*
2696: * Make a complex file. A complex file is one with multiple forks (data streams)
2697: */
2698: struct mkcomplex_args {
2699: const char *path; /* pathname of the file to be created */
2700: mode_t mode; /* access mode for the newly created file */
2701: u_long type; /* format of the complex file */
2702: };
2703: /* ARGSUSED */
2704: int
2705: mkcomplex(p,uap,retval)
2706: struct proc *p;
2707: register struct mkcomplex_args *uap;
2708: register_t *retval;
2709:
2710: {
2711: struct vnode *vp;
2712: struct vattr vattr;
2713: int error;
2714: struct nameidata nd;
2715:
2716: /* mkcomplex wants the directory vnode locked so do that here */
2717:
2718: NDINIT(&nd, CREATE, FOLLOW | LOCKPARENT, UIO_USERSPACE, uap->path, p);
2719: if (error = namei(&nd))
2720: return (error);
2721:
2722: /* Set the attributes as specified by the user */
2723:
2724: VATTR_NULL(&vattr);
2725: vattr.va_mode = (uap->mode & ACCESSPERMS);
2726: error = VOP_MKCOMPLEX(nd.ni_dvp, &vp, &nd.ni_cnd, &vattr, uap->type);
2727:
2728: /* The mkcomplex call promises to release the parent vnode pointer
2729: * even an an error case so don't do it here unless the operation
2730: * is not supported. In that case, there isn't anyone to unlock the parent
2731: * The vnode pointer to the file will also be released.
2732: */
2733:
2734: if (error)
2735: {
2736: if (error == EOPNOTSUPP)
2737: vput(nd.ni_dvp);
2738: return (error);
2739: }
2740:
2741: return (0);
2742:
2743: } /* end of mkcomplex system call */
2744:
2745:
2746:
2747: /*
2748: * Extended stat call which returns volumeid and vnodeid as well as other info
2749: */
2750: struct statv_args {
2751: const char *path; /* pathname of the target file */
2752: struct vstat *vsb; /* vstat structure for returned info */
2753: };
2754: /* ARGSUSED */
2755: int
2756: statv(p,uap,retval)
2757: struct proc *p;
2758: register struct statv_args *uap;
2759: register_t *retval;
2760:
2761: {
2762: return (EOPNOTSUPP); /* We'll just return an error for now */
2763:
2764: } /* end of statv system call */
2765:
2766:
2767:
2768: /*
2769: * Extended lstat call which returns volumeid and vnodeid as well as other info
2770: */
2771: struct lstatv_args {
2772: const char *path; /* pathname of the target file */
2773: struct vstat *vsb; /* vstat structure for returned info */
2774: };
2775: /* ARGSUSED */
2776: int
2777: lstatv(p,uap,retval)
2778: struct proc *p;
2779: register struct lstatv_args *uap;
2780: register_t *retval;
2781:
2782: {
2783: return (EOPNOTSUPP); /* We'll just return an error for now */
2784: } /* end of lstatv system call */
2785:
2786:
2787:
2788: /*
2789: * Extended fstat call which returns volumeid and vnodeid as well as other info
2790: */
2791: struct fstatv_args {
2792: int fd; /* file descriptor of the target file */
2793: struct vstat *vsb; /* vstat structure for returned info */
2794: };
2795: /* ARGSUSED */
2796: int
2797: fstatv(p,uap,retval)
2798: struct proc *p;
2799: register struct fstatv_args *uap;
2800: register_t *retval;
2801:
2802: {
2803: return (EOPNOTSUPP); /* We'll just return an error for now */
2804: } /* end of fstatv system call */
2805:
2806:
2807:
2808: /*
2809: * Obtain attribute information about a file system object
2810: */
2811:
2812: struct getattrlist_args {
2813: const char *path; /* pathname of the target object */
2814: struct attrlist * alist; /* Attributes desired by the user */
2815: void * attributeBuffer; /* buffer to hold returned attributes */
2816: size_t bufferSize; /* size of the return buffer */
2817: unsigned long options; /* options (follow/don't follow) */
2818: };
2819: /* ARGSUSED */
2820: int
2821: getattrlist (p,uap,retval)
2822: struct proc *p;
2823: register struct getattrlist_args *uap;
2824: register_t *retval;
2825:
2826: {
2827: int error;
2828: struct nameidata nd;
2829: struct iovec aiov;
2830: struct uio auio;
2831: struct attrlist attributelist;
2832: u_long nameiflags;
2833:
2834: /* Get the attributes desire and do our parameter checking */
2835:
2836: if (error = copyin((caddr_t)uap->alist, (caddr_t) &attributelist,
2837: sizeof (attributelist)))
2838: {
2839: return(error);
2840: }
2841:
2842: if (attributelist.bitmapcount != ATTR_BIT_MAP_COUNT
2843: #if 0
2844: || attributelist.commonattr & ~ATTR_CMN_VALIDMASK ||
2845: attributelist.volattr & ~ATTR_VOL_VALIDMASK ||
2846: attributelist.dirattr & ~ATTR_DIR_VALIDMASK ||
2847: attributelist.fileattr & ~ATTR_FILE_VALIDMASK ||
2848: attributelist.forkattr & ~ATTR_FORK_VALIDMASK
2849: #endif
2850: )
2851: {
2852: return (EINVAL);
2853: }
2854:
2855: /* Get the vnode for the file we are getting info on. */
2856: nameiflags = LOCKLEAF;
2857: if ((uap->options & FSOPT_NOFOLLOW) == 0) nameiflags |= FOLLOW;
2858: NDINIT(&nd, LOOKUP, nameiflags, UIO_USERSPACE, uap->path, p);
2859:
2860: if (error = namei(&nd))
2861: return (error);
2862:
2863: /* Set up the UIO structure for use by the vfs routine */
2864:
2865:
2866: aiov.iov_base = uap->attributeBuffer;
2867: aiov.iov_len = uap->bufferSize;
2868: auio.uio_iov = &aiov;
2869: auio.uio_iovcnt = 1;
2870: auio.uio_offset = 0;
2871: auio.uio_rw = UIO_READ;
2872: auio.uio_segflg = UIO_USERSPACE;
2873: auio.uio_procp = p;
2874: auio.uio_resid = uap->bufferSize;
2875:
2876:
2877: error = VOP_GETATTRLIST(nd.ni_vp, &attributelist, &auio, p->p_ucred, p);
2878:
2879: /* Unlock and release the vnode which will have been locked by namei */
2880:
2881: vput(nd.ni_vp);
2882:
2883: /* return the effort if we got one, otherwise return success */
2884:
2885: if (error)
2886: {
2887: return (error);
2888: }
2889:
2890: return(0);
2891:
2892: } /* end of getattrlist system call */
2893:
2894:
2895:
2896: /*
2897: * Set attribute information about a file system object
2898: */
2899:
2900: struct setattrlist_args {
2901: const char *path; /* pathname of the target object */
2902: struct attrlist * alist; /* Attributes being set by the user */
2903: void * attributeBuffer; /* buffer with attribute values to be set */
2904: size_t bufferSize; /* size of the return buffer */
2905: unsigned long options; /* options (follow/don't follow) */
2906: };
2907: /* ARGSUSED */
2908: int
2909: setattrlist (p,uap,retval)
2910: struct proc *p;
2911: register struct setattrlist_args *uap;
2912: register_t *retval;
2913:
2914: {
2915: int error;
2916: struct nameidata nd;
2917: struct iovec aiov;
2918: struct uio auio;
2919: struct attrlist attributelist;
2920: u_long nameiflags;
2921:
2922: /* Get the attributes desired and do our parameter checking */
2923:
2924: if (error = copyin((caddr_t)uap->alist, (caddr_t) &attributelist,
2925: sizeof (attributelist)))
2926: {
2927: return(error);
2928: }
2929:
2930: if (attributelist.bitmapcount != ATTR_BIT_MAP_COUNT
2931: #if 0
2932: || attributelist.commonattr & ~ATTR_CMN_VALIDMASK ||
2933: attributelist.volattr & ~ATTR_VOL_VALIDMASK ||
2934: attributelist.dirattr & ~ATTR_DIR_VALIDMASK ||
2935: attributelist.fileattr & ~ATTR_FILE_VALIDMASK ||
2936: attributelist.forkattr & ~ATTR_FORK_VALIDMASK
2937: #endif
2938: )
2939: {
2940: return (EINVAL);
2941: }
2942:
2943: /* Get the vnode for the file we are getting info on. */
2944: nameiflags = LOCKLEAF;
2945: if ((uap->options & FSOPT_NOFOLLOW) == 0) nameiflags |= FOLLOW;
2946: NDINIT(&nd, LOOKUP, nameiflags, UIO_USERSPACE, uap->path, p);
2947:
2948: if (error = namei(&nd))
2949: return (error);
2950:
2951: /* Set up the UIO structure for use by the vfs routine */
2952:
2953: aiov.iov_base = uap->attributeBuffer;
2954: aiov.iov_len = uap->bufferSize;
2955: auio.uio_iov = &aiov;
2956: auio.uio_iovcnt = 1;
2957: auio.uio_offset = 0;
2958: auio.uio_rw = UIO_WRITE;
2959: auio.uio_segflg = UIO_USERSPACE;
2960: auio.uio_procp = p;
2961: auio.uio_resid = uap->bufferSize;
2962:
2963:
2964: error = VOP_SETATTRLIST(nd.ni_vp,&attributelist, &auio, p->p_ucred, p);
2965:
2966: /* Unlock and release the vnode which will have been locked by namei */
2967:
2968: vput(nd.ni_vp);
2969:
2970: /* return the error if we got one, otherwise return success */
2971:
2972: if (error)
2973: {
2974: return (error);
2975: }
2976:
2977: return(0);
2978:
2979: } /* end of setattrlist system call */
2980:
2981:
2982: /*
2983: * Obtain attribute information on objects in a directory while enumerating
2984: * the directory. This call does not yet support union mounted directories.
2985: * TO DO
2986: * 1.union mounted directories.
2987: */
2988:
2989: struct getdirentriesattr_args {
2990: int fd; /* file descriptor */
2991: struct attrlist *alist; /* bit map of requested attributes */
2992: void *buffer; /* buffer to hold returned attribute info */
2993: size_t buffersize; /* size of the return buffer */
2994: u_long *count; /* the count of entries requested/returned */
2995: u_long *basep; /* the offset of where we are leaving off in buffer */
2996: u_long *newstate; /* a flag to inform of changes in directory */
2997: u_long options; /* maybe unused for now */
2998: };
2999: /* ARGSUSED */
3000: int
3001: getdirentriesattr (p,uap,retval)
3002: struct proc *p;
3003: register struct getdirentriesattr_args *uap;
3004: register_t *retval;
3005:
3006: {
3007: register struct vnode *vp;
3008: struct file *fp;
3009: struct uio auio;
3010: struct iovec aiov;
3011: u_long actualcount;
3012: u_long newstate;
3013: int error, eofflag;
3014: long loff;
3015: struct attrlist attributelist;
3016:
3017: /* Get the attributes into kernel space */
3018: if (error = copyin((caddr_t)uap->alist, (caddr_t) &attributelist, sizeof (attributelist)))
3019: return(error);
3020: if (error = copyin((caddr_t)uap->count, (caddr_t) &actualcount, sizeof (u_long)))
3021: return(error);
3022:
3023: if (error = getvnode(p, uap->fd, &fp))
3024: return (error);
3025: if ((fp->f_flag & FREAD) == 0)
3026: return(EBADF);
3027: vp = (struct vnode *)fp->f_data;
3028:
3029: if (vp->v_type != VDIR)
3030: return(EINVAL);
3031:
3032: /* set up the uio structure which will contain the users return buffer */
3033: aiov.iov_base = uap->buffer;
3034: aiov.iov_len = uap->buffersize;
3035: auio.uio_iov = &aiov;
3036: auio.uio_iovcnt = 1;
3037: auio.uio_rw = UIO_READ;
3038: auio.uio_segflg = UIO_USERSPACE;
3039: auio.uio_procp = p;
3040: auio.uio_resid = uap->buffersize;
3041:
3042: loff = auio.uio_offset = fp->f_offset;
3043: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
3044: error = VOP_READDIRATTR (vp, &attributelist, &auio,
3045: actualcount, uap->options, &newstate, &eofflag,
3046: &actualcount, ((u_long **)0), p->p_cred);
3047:
3048: VOP_UNLOCK(vp, 0, p);
3049: if (error) return (error);
3050: fp->f_offset = auio.uio_offset; /* should be multiple of dirent, not variable */
3051:
3052: if (error = copyout((caddr_t) &actualcount, (caddr_t) uap->count, sizeof(u_long)))
3053: return (error);
3054: if (error = copyout((caddr_t) &newstate, (caddr_t) uap->newstate, sizeof(u_long)))
3055: return (error);
3056: if (error = copyout((caddr_t)&loff, (caddr_t)uap->basep, sizeof(long)))
3057: return (error);
3058:
3059: *retval = eofflag; /* similar to getdirentries */
3060: return (0); /* return error earlier, an retval of 0 or 1 now */
3061:
3062: } /* end of getdirentryattr system call */
3063:
3064: /*
3065: * Exchange data between two files
3066: */
3067:
3068: struct exchangedata_args {
3069: const char *path1; /* pathname of the first swapee */
3070: const char *path2; /* pathname of the second swapee */
3071: unsigned long options; /* options */
3072: };
3073: /* ARGSUSED */
3074: int
3075: exchangedata (p,uap,retval)
3076: struct proc *p;
3077: register struct exchangedata_args *uap;
3078: register_t *retval;
3079:
3080: {
3081:
3082: struct nameidata fnd, snd;
3083: struct vnode *fvp, *svp;
3084: int error;
3085: u_long nameiflags;
3086:
3087: nameiflags = 0;
3088: if ((uap->options & FSOPT_NOFOLLOW) == 0) nameiflags |= FOLLOW;
3089:
3090: /* Global lock, to prevent race condition, only one exchange at a time */
3091: lockmgr(&exchangelock, LK_EXCLUSIVE , (struct slock *)0, p);
3092:
3093: NDINIT(&fnd, LOOKUP, nameiflags, UIO_USERSPACE, uap->path1, p);
3094:
3095: if (error = namei(&fnd))
3096: goto out2;
3097:
3098: fvp = fnd.ni_vp;
3099:
3100: NDINIT(&snd, LOOKUP, nameiflags, UIO_USERSPACE, uap->path2, p);
3101:
3102: if (error = namei(&snd)) {
3103: vrele(fvp);
3104: goto out2;
3105: }
3106:
3107: svp = snd.ni_vp;
3108:
3109: /* if the files are the same, return an inval error */
3110: if (svp == fvp) {
3111: vrele(fvp);
3112: vrele(svp);
3113: error = EINVAL;
3114: goto out2;
3115: }
3116:
3117: vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, p);
3118: vn_lock(svp, LK_EXCLUSIVE | LK_RETRY, p);
3119:
3120: error = VOP_ACCESS(fvp, VWRITE, p->p_ucred, p);
3121: if (error) goto out;
3122:
3123: error = VOP_ACCESS(svp, VWRITE, p->p_ucred, p);
3124: if (error) goto out;
3125:
3126: /* Ok, make the call */
3127: error = VOP_EXCHANGE (fvp, svp, p->p_ucred, p);
3128:
3129: out:
3130: vput (svp);
3131: vput (fvp);
3132:
3133: out2:
3134: lockmgr(&exchangelock, LK_RELEASE, (struct slock *)0, p);
3135:
3136: if (error) {
3137: return (error);
3138: }
3139:
3140: return (0);
3141:
3142: } /* end of exchangedata system call */
3143:
3144: /*
3145: * Check users access to a file
3146: */
3147:
3148: struct checkuseraccess_args {
3149: const char *path; /* pathname of the target file */
3150: uid_t userid; /* user for whom we are checking access */
3151: gid_t *groups; /* Group that we are checking for */
3152: int ngroups; /* Number of groups being checked */
3153: int accessrequired; /* needed access to the file */
3154: unsigned long options; /* options */
3155: };
3156:
3157: /* ARGSUSED */
3158: int
3159: checkuseraccess (p,uap,retval)
3160: struct proc *p;
3161: register struct checkuseraccess_args *uap;
3162: register_t *retval;
3163:
3164: {
3165: register struct vnode *vp;
3166: int error;
3167: struct nameidata nd;
3168: struct ucred cred;
3169: int flags; /*what will actually get passed to access*/
3170: u_long nameiflags;
3171:
3172: /* Make sure that the number of groups is correct before we do anything */
3173:
3174: if (uap->ngroups > NGROUPS)
3175: return (EINVAL);
3176:
3177: /* Verify that the caller is root */
3178:
3179: if (error = suser(p->p_ucred, &p->p_acflag))
3180: return(error);
3181:
3182: /* Fill in the credential structure */
3183:
3184: cred.cr_ref = 0;
3185: cred.cr_uid = uap->userid;
3186: cred.cr_ngroups = uap->ngroups;
3187: if (error = copyin((caddr_t) uap->groups, (caddr_t) &(cred.cr_groups), (sizeof(gid_t))*uap->ngroups))
3188: return (error);
3189:
3190: /* Get our hands on the file */
3191:
3192: nameiflags = LOCKLEAF;
3193: if ((uap->options & FSOPT_NOFOLLOW) == 0) nameiflags |= FOLLOW;
3194: NDINIT(&nd, LOOKUP, nameiflags, UIO_USERSPACE, uap->path, p);
3195:
3196: if (error = namei(&nd))
3197: return (error);
3198: vp = nd.ni_vp;
3199:
3200: /* Flags == 0 means only check for existence. */
3201:
3202: flags = 0;
3203:
3204: if (uap->accessrequired) {
3205: if (uap->accessrequired & R_OK)
3206: flags |= VREAD;
3207: if (uap->accessrequired & W_OK)
3208: flags |= VWRITE;
3209: if (uap->accessrequired & X_OK)
3210: flags |= VEXEC;
3211: }
3212: error = VOP_ACCESS(vp, flags, &cred, p);
3213:
3214: vput(vp);
3215:
3216: if (error)
3217: return (error);
3218:
3219: return (0);
3220:
3221: } /* end of checkuseraccess system call */
3222:
3223:
3224: struct searchfs_args {
3225: const char *path;
3226: struct fssearchblock *searchblock;
3227: u_long *nummatches;
3228: u_long scriptcode;
3229: u_long options;
3230: struct searchstate *state;
3231: };
3232: /* ARGSUSED */
3233:
3234: int
3235: searchfs (p,uap,retval)
3236: struct proc *p;
3237: register struct searchfs_args *uap;
3238: register_t *retval;
3239:
3240: {
3241: register struct vnode *vp;
3242: int error=0;
3243: int fserror = 0;
3244: struct nameidata nd;
3245: struct fssearchblock searchblock;
3246: struct searchstate *state;
3247: struct attrlist *returnattrs;
3248: void *searchparams1,*searchparams2;
3249: struct iovec aiov;
3250: struct uio auio;
3251: u_long nummatches;
3252: int mallocsize;
3253: u_long nameiflags;
3254:
3255:
3256: /* Start by copying in fsearchblock paramater list */
3257:
3258: if (error = copyin((caddr_t) uap->searchblock, (caddr_t) &searchblock,sizeof(struct fssearchblock)))
3259: return(error);
3260:
3261: /* Now malloc a big bunch of space to hold the search parameters, the attrlists and the search state. */
3262: /* It all has to do into local memory and it's not that big so we might as well put it all together. */
3263: /* Searchparams1 shall be first so we might as well use that to hold the base address of the allocated*/
3264: /* block. */
3265:
3266: mallocsize = searchblock.sizeofsearchparams1+searchblock.sizeofsearchparams2 +
3267: sizeof(struct attrlist) + sizeof(struct searchstate);
3268:
3269: MALLOC(searchparams1, void *, mallocsize, M_TEMP, M_WAITOK);
3270:
3271: /* Now set up the various pointers to the correct place in our newly allocated memory */
3272:
3273: searchparams2 = (void *) (((caddr_t) searchparams1) + searchblock.sizeofsearchparams1);
3274: returnattrs = (struct attrlist *) (((caddr_t) searchparams2) + searchblock.sizeofsearchparams2);
3275: state = (struct searchstate *) (((caddr_t) returnattrs) + sizeof (struct attrlist));
3276:
3277: /* Now copy in the stuff given our local variables. */
3278:
3279: if (error = copyin((caddr_t) searchblock.searchparams1, searchparams1,searchblock.sizeofsearchparams1))
3280: goto freeandexit;
3281:
3282: if (error = copyin((caddr_t) searchblock.searchparams2, searchparams2,searchblock.sizeofsearchparams2))
3283: goto freeandexit;
3284:
3285: if (error = copyin((caddr_t) searchblock.returnattrs, (caddr_t) returnattrs, sizeof(struct attrlist)))
3286: goto freeandexit;
3287:
3288: if (error = copyin((caddr_t) uap->state, (caddr_t) state, sizeof(struct searchstate)))
3289: goto freeandexit;
3290:
3291: /* set up the uio structure which will contain the users return buffer */
3292:
3293: aiov.iov_base = searchblock.returnbuffer;
3294: aiov.iov_len = searchblock.returnbuffersize;
3295: auio.uio_iov = &aiov;
3296: auio.uio_iovcnt = 1;
3297: auio.uio_rw = UIO_READ;
3298: auio.uio_segflg = UIO_USERSPACE;
3299: auio.uio_procp = p;
3300: auio.uio_resid = searchblock.returnbuffersize;
3301:
3302: nameiflags = LOCKLEAF;
3303: if ((uap->options & FSOPT_NOFOLLOW) == 0) nameiflags |= FOLLOW;
3304: NDINIT(&nd, LOOKUP, nameiflags, UIO_USERSPACE, uap->path, p);
3305:
3306: if (error = namei(&nd))
3307: goto freeandexit;
3308:
3309: vp = nd.ni_vp;
3310:
3311: /*
3312: Allright, we have everything we need, so lets make that call.
3313:
3314: We keep special track of the return value from the file system:
3315: EAGAIN is an acceptable error condition that shouldn't keep us
3316: from copying out any results...
3317: */
3318:
3319: fserror = VOP_SEARCHFS(vp,
3320: searchparams1,
3321: searchparams2,
3322: &searchblock.searchattrs,
3323: searchblock.maxmatches,
3324: &searchblock.timelimit,
3325: returnattrs,
3326: &nummatches,
3327: uap->scriptcode,
3328: uap->options,
3329: &auio,
3330: state);
3331:
3332: vput(vp);
3333:
3334: /* Now copy out the stuff that needs copying out. That means the number of matches, the
3335: search state. Everything was already put into he return buffer by the vop call. */
3336:
3337: if (error = copyout((caddr_t) state, (caddr_t) uap->state, sizeof(struct searchstate)))
3338: goto freeandexit;
3339:
3340: if (error = copyout((caddr_t) &nummatches, (caddr_t) uap->nummatches, sizeof(u_long)))
3341: goto freeandexit;
3342:
3343: error = fserror;
3344:
3345: freeandexit:
3346:
3347: FREE(searchparams1,M_TEMP);
3348:
3349: return(error);
3350:
3351:
3352: } /* end of searchfs system call */
3353:
3354:
3355: /*
3356: * Make a filesystem-specific control call:
3357: */
3358: struct fsctl_args {
3359: const char *path; /* pathname of the target object */
3360: u_long cmd; /* cmd (also encodes size/direction of arguments a la ioctl) */
3361: caddr_t data; /* pointer to argument buffer */
3362: u_long options; /* options for fsctl processing */
3363: };
3364: /* ARGSUSED */
3365: int
3366: fsctl (p,uap,retval)
3367: struct proc *p;
3368: struct fsctl_args *uap;
3369: register_t *retval;
3370:
3371: {
3372: int error;
3373: struct nameidata nd;
3374: u_long nameiflags;
3375: u_long cmd = uap->cmd;
3376: register u_int size;
3377: #define STK_PARAMS 128
3378: char stkbuf[STK_PARAMS];
3379: caddr_t data, memp;
3380:
3381: size = IOCPARM_LEN(cmd);
3382: if (size > IOCPARM_MAX) return (EINVAL);
3383:
3384: memp = NULL;
3385: if (size > sizeof (stkbuf)) {
3386: if ((memp = (caddr_t)kalloc(size)) == 0) return ENOMEM;
3387: data = memp;
3388: } else {
3389: data = stkbuf;
3390: };
3391:
3392: if (cmd & IOC_IN) {
3393: if (size) {
3394: error = copyin(uap->data, data, (u_int)size);
3395: if (error) goto FSCtl_Exit;
3396: } else {
3397: *(caddr_t *)data = uap->data;
3398: };
3399: } else if ((cmd & IOC_OUT) && size) {
3400: /*
3401: * Zero the buffer so the user always
3402: * gets back something deterministic.
3403: */
3404: bzero(data, size);
3405: } else if (cmd & IOC_VOID)
3406: *(caddr_t *)data = uap->data;
3407:
3408: /* Get the vnode for the file we are getting info on: */
3409: nameiflags = LOCKLEAF;
3410: if ((uap->options & FSOPT_NOFOLLOW) == 0) nameiflags |= FOLLOW;
3411: NDINIT(&nd, LOOKUP, nameiflags, UIO_USERSPACE, uap->path, p);
3412: if (error = namei(&nd)) goto FSCtl_Exit;
3413:
3414: /* Invoke the filesystem-specific code */
3415: error = VOP_IOCTL(nd.ni_vp, IOCBASECMD(cmd), data, uap->options, p->p_ucred, p);
3416:
3417: vput(nd.ni_vp);
3418:
3419: /*
3420: * Copy any data to user, size was
3421: * already set and checked above.
3422: */
3423: if (error == 0 && (cmd & IOC_OUT) && size) error = copyout(data, uap->data, (u_int)size);
3424:
3425: FSCtl_Exit:
3426: if (memp) kfree(memp, size);
3427:
3428: return error;
3429: }
3430: /* end of fsctl system call */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.