Annotation of sys/compat/freebsd/freebsd_file.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: freebsd_file.c,v 1.25 2006/06/25 15:01:53 sturm Exp $ */
2: /* $NetBSD: freebsd_file.c,v 1.3 1996/05/03 17:03:09 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Frank van der Linden
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed for the NetBSD Project
19: * by Frank van der Linden
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33: *
34: * from: linux_file.c,v 1.3 1995/04/04 04:21:30 mycroft Exp
35: */
36:
37: #include <sys/param.h>
38: #include <sys/systm.h>
39: #include <sys/namei.h>
40: #include <sys/proc.h>
41: #include <sys/file.h>
42: #include <sys/stat.h>
43: #include <sys/filedesc.h>
44: #include <sys/ioctl.h>
45: #include <sys/kernel.h>
46: #include <sys/vnode.h>
47: #include <sys/mount.h>
48: #include <sys/malloc.h>
49:
50: #include <sys/syscallargs.h>
51:
52: #include <compat/freebsd/freebsd_signal.h>
53: #include <compat/freebsd/freebsd_syscallargs.h>
54: #include <compat/freebsd/freebsd_util.h>
55:
56: #define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0]))
57:
58: const char freebsd_emul_path[] = "/emul/freebsd";
59:
60: static char * convert_from_freebsd_mount_type(int);
61: void statfs_to_freebsd_statfs(struct proc *, struct mount *, struct statfs *, struct freebsd_statfs *);
62:
63: struct freebsd_statfs {
64: long f_spare2; /* placeholder */
65: long f_bsize; /* fundamental file system block size */
66: long f_iosize; /* optimal transfer block size */
67: long f_blocks; /* total data blocks in file system */
68: long f_bfree; /* free blocks in fs */
69: long f_bavail; /* free blocks avail to non-superuser */
70: long f_files; /* total file nodes in file system */
71: long f_ffree; /* free file nodes in fs */
72: fsid_t f_fsid; /* file system id */
73: uid_t f_owner; /* user that mounted the filesystem */
74: int f_type; /* type of filesystem */
75: int f_flags; /* copy of mount exported flags */
76: long f_syncwrites; /* count of sync writes since mount */
77: long f_asyncwrites; /* count of async writes since mount */
78: char f_fstypename[MFSNAMELEN]; /* fs type name */
79: char f_mntonname[MNAMELEN]; /* directory on which mounted */
80: char f_mntfromname[MNAMELEN];/* mounted filesystem */
81: };
82:
83: static char *
84: convert_from_freebsd_mount_type(type)
85: int type;
86: {
87: static char *freebsd_mount_type[] = {
88: NULL, /* 0 = MOUNT_NONE */
89: "ffs", /* 1 = "Fast" Filesystem */
90: "nfs", /* 2 = Network Filesystem */
91: "mfs", /* 3 = Memory Filesystem */
92: "msdos", /* 4 = MSDOS Filesystem */
93: "lfs", /* 5 = Log-based Filesystem */
94: "lofs", /* 6 = Loopback filesystem */
95: "fdesc", /* 7 = File Descriptor Filesystem */
96: "portal", /* 8 = Portal Filesystem */
97: "null", /* 9 = Minimal Filesystem Layer */
98: "umap", /* 10 = User/Group Identifier Remapping Filesystem */
99: "kernfs", /* 11 = Kernel Information Filesystem */
100: "procfs", /* 12 = /proc Filesystem */
101: "afs", /* 13 = Andrew Filesystem */
102: "cd9660", /* 14 = ISO9660 (aka CDROM) Filesystem */
103: "union", /* 15 = Union (translucent) Filesystem */
104: NULL, /* 16 = "devfs" - existing device Filesystem */
105: #if 0 /* These filesystems don't exist in FreeBSD */
106: "adosfs", /* ?? = AmigaDOS Filesystem */
107: #endif
108: };
109:
110: if (type < 0 || type >= ARRAY_LENGTH(freebsd_mount_type))
111: return (NULL);
112: return (freebsd_mount_type[type]);
113: }
114:
115: int
116: freebsd_sys_mount(p, v, retval)
117: struct proc *p;
118: void *v;
119: register_t *retval;
120: {
121: struct freebsd_sys_mount_args /* {
122: syscallarg(int) type;
123: syscallarg(char *) path;
124: syscallarg(int) flags;
125: syscallarg(caddr_t) data;
126: } */ *uap = v;
127: int error;
128: char *type, *s;
129: caddr_t sg = stackgap_init(p->p_emul);
130: struct sys_mount_args bma;
131:
132: if ((type = convert_from_freebsd_mount_type(SCARG(uap, type))) == NULL)
133: return ENODEV;
134: s = stackgap_alloc(&sg, MFSNAMELEN + 1);
135: if ((error = copyout(type, s, strlen(type) + 1)) != 0)
136: return error;
137: SCARG(&bma, type) = s;
138: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
139: SCARG(&bma, path) = SCARG(uap, path);
140: SCARG(&bma, flags) = SCARG(uap, flags);
141: SCARG(&bma, data) = SCARG(uap, data);
142: return sys_mount(p, &bma, retval);
143: }
144:
145: /*
146: * The following syscalls are only here because of the alternate path check.
147: */
148:
149: /* XXX - UNIX domain: int freebsd_sys_bind(int s, caddr_t name, int namelen); */
150: /* XXX - UNIX domain: int freebsd_sys_connect(int s, caddr_t name, int namelen); */
151:
152:
153: int
154: freebsd_sys_open(p, v, retval)
155: struct proc *p;
156: void *v;
157: register_t *retval;
158: {
159: struct freebsd_sys_open_args /* {
160: syscallarg(char *) path;
161: syscallarg(int) flags;
162: syscallarg(int) mode;
163: } */ *uap = v;
164: caddr_t sg = stackgap_init(p->p_emul);
165:
166: if (SCARG(uap, flags) & O_CREAT)
167: FREEBSD_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
168: else
169: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
170: return sys_open(p, uap, retval);
171: }
172:
173: int
174: compat_43_freebsd_sys_creat(p, v, retval)
175: struct proc *p;
176: void *v;
177: register_t *retval;
178: {
179: struct compat_43_freebsd_sys_creat_args /* {
180: syscallarg(char *) path;
181: syscallarg(int) mode;
182: } */ *uap = v;
183: caddr_t sg = stackgap_init(p->p_emul);
184:
185: FREEBSD_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
186: return compat_43_sys_creat(p, uap, retval);
187: }
188:
189: int
190: freebsd_sys_link(p, v, retval)
191: struct proc *p;
192: void *v;
193: register_t *retval;
194: {
195: struct freebsd_sys_link_args /* {
196: syscallarg(char *) path;
197: syscallarg(char *) link;
198: } */ *uap = v;
199: caddr_t sg = stackgap_init(p->p_emul);
200:
201: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
202: FREEBSD_CHECK_ALT_CREAT(p, &sg, SCARG(uap, link));
203: return sys_link(p, uap, retval);
204: }
205:
206: int
207: freebsd_sys_unlink(p, v, retval)
208: struct proc *p;
209: void *v;
210: register_t *retval;
211: {
212: struct freebsd_sys_unlink_args /* {
213: syscallarg(char *) path;
214: } */ *uap = v;
215: caddr_t sg = stackgap_init(p->p_emul);
216:
217: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
218: return sys_unlink(p, uap, retval);
219: }
220:
221: int
222: freebsd_sys_chdir(p, v, retval)
223: struct proc *p;
224: void *v;
225: register_t *retval;
226: {
227: struct freebsd_sys_chdir_args /* {
228: syscallarg(char *) path;
229: } */ *uap = v;
230: caddr_t sg = stackgap_init(p->p_emul);
231:
232: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
233: return sys_chdir(p, uap, retval);
234: }
235:
236: int
237: freebsd_sys_mknod(p, v, retval)
238: struct proc *p;
239: void *v;
240: register_t *retval;
241: {
242: struct freebsd_sys_mknod_args /* {
243: syscallarg(char *) path;
244: syscallarg(int) mode;
245: syscallarg(int) dev;
246: } */ *uap = v;
247: caddr_t sg = stackgap_init(p->p_emul);
248:
249: FREEBSD_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
250: return sys_mknod(p, uap, retval);
251: }
252:
253: int
254: freebsd_sys_chmod(p, v, retval)
255: struct proc *p;
256: void *v;
257: register_t *retval;
258: {
259: struct freebsd_sys_chmod_args /* {
260: syscallarg(char *) path;
261: syscallarg(int) mode;
262: } */ *uap = v;
263: caddr_t sg = stackgap_init(p->p_emul);
264:
265: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
266: return sys_chmod(p, uap, retval);
267: }
268:
269: int
270: freebsd_sys_chown(p, v, retval)
271: struct proc *p;
272: void *v;
273: register_t *retval;
274: {
275: struct freebsd_sys_chown_args /* {
276: syscallarg(char *) path;
277: syscallarg(int) uid;
278: syscallarg(int) gid;
279: } */ *uap = v;
280: caddr_t sg = stackgap_init(p->p_emul);
281:
282: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
283: return sys_chown(p, uap, retval);
284: }
285:
286: int
287: freebsd_sys_unmount(p, v, retval)
288: struct proc *p;
289: void *v;
290: register_t *retval;
291: {
292: struct freebsd_sys_unmount_args /* {
293: syscallarg(char *) path;
294: syscallarg(int) flags;
295: } */ *uap = v;
296: caddr_t sg = stackgap_init(p->p_emul);
297:
298: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
299: return sys_unmount(p, uap, retval);
300: }
301:
302: int
303: freebsd_sys_access(p, v, retval)
304: struct proc *p;
305: void *v;
306: register_t *retval;
307: {
308: struct freebsd_sys_access_args /* {
309: syscallarg(char *) path;
310: syscallarg(int) flags;
311: } */ *uap = v;
312: caddr_t sg = stackgap_init(p->p_emul);
313:
314: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
315: return sys_access(p, uap, retval);
316: }
317:
318: int
319: freebsd_sys_chflags(p, v, retval)
320: struct proc *p;
321: void *v;
322: register_t *retval;
323: {
324: struct freebsd_sys_chflags_args /* {
325: syscallarg(char *) path;
326: syscallarg(int) flags;
327: } */ *uap = v;
328: caddr_t sg = stackgap_init(p->p_emul);
329:
330: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
331: return sys_chflags(p, uap, retval);
332: }
333:
334: int
335: compat_43_freebsd_sys_stat(p, v, retval)
336: struct proc *p;
337: void *v;
338: register_t *retval;
339: {
340: struct compat_43_freebsd_sys_stat_args /* {
341: syscallarg(char *) path;
342: syscallarg(struct stat43 *) ub;
343: } */ *uap = v;
344: caddr_t sg = stackgap_init(p->p_emul);
345:
346: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
347: return compat_43_sys_stat(p, uap, retval);
348: }
349:
350: int
351: compat_43_freebsd_sys_lstat(p, v, retval)
352: struct proc *p;
353: void *v;
354: register_t *retval;
355: {
356: struct compat_43_freebsd_sys_lstat_args /* {
357: syscallarg(char *) path;
358: syscallarg(struct stat43 *) ub;
359: } */ *uap = v;
360: caddr_t sg = stackgap_init(p->p_emul);
361:
362: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
363: return compat_43_sys_lstat(p, uap, retval);
364: }
365:
366: int
367: freebsd_sys_revoke(p, v, retval)
368: struct proc *p;
369: void *v;
370: register_t *retval;
371: {
372: struct freebsd_sys_revoke_args /* {
373: syscallarg(char *) path;
374: } */ *uap = v;
375: caddr_t sg = stackgap_init(p->p_emul);
376:
377: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
378: return sys_revoke(p, uap, retval);
379: }
380:
381: int
382: freebsd_sys_symlink(p, v, retval)
383: struct proc *p;
384: void *v;
385: register_t *retval;
386: {
387: struct freebsd_sys_symlink_args /* {
388: syscallarg(char *) path;
389: syscallarg(char *) link;
390: } */ *uap = v;
391: caddr_t sg = stackgap_init(p->p_emul);
392:
393: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
394: FREEBSD_CHECK_ALT_CREAT(p, &sg, SCARG(uap, link));
395: return sys_symlink(p, uap, retval);
396: }
397:
398: int
399: freebsd_sys_readlink(p, v, retval)
400: struct proc *p;
401: void *v;
402: register_t *retval;
403: {
404: struct freebsd_sys_readlink_args /* {
405: syscallarg(char *) path;
406: syscallarg(char *) buf;
407: syscallarg(int) count;
408: } */ *uap = v;
409: caddr_t sg = stackgap_init(p->p_emul);
410:
411: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
412: return sys_readlink(p, uap, retval);
413: }
414:
415: int
416: freebsd_sys_execve(p, v, retval)
417: struct proc *p;
418: void *v;
419: register_t *retval;
420: {
421: struct freebsd_sys_execve_args /* {
422: syscallarg(char *) path;
423: syscallarg(char **) argp;
424: syscallarg(char **) envp;
425: } */ *uap = v;
426: struct sys_execve_args ap;
427: caddr_t sg;
428:
429: sg = stackgap_init(p->p_emul);
430: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
431:
432: SCARG(&ap, path) = SCARG(uap, path);
433: SCARG(&ap, argp) = SCARG(uap, argp);
434: SCARG(&ap, envp) = SCARG(uap, envp);
435:
436: return sys_execve(p, &ap, retval);
437: }
438:
439: int
440: freebsd_sys_chroot(p, v, retval)
441: struct proc *p;
442: void *v;
443: register_t *retval;
444: {
445: struct freebsd_sys_chroot_args /* {
446: syscallarg(char *) path;
447: } */ *uap = v;
448: caddr_t sg = stackgap_init(p->p_emul);
449:
450: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
451: return sys_chroot(p, uap, retval);
452: }
453:
454: int
455: freebsd_sys_rename(p, v, retval)
456: struct proc *p;
457: void *v;
458: register_t *retval;
459: {
460: struct freebsd_sys_rename_args /* {
461: syscallarg(char *) from;
462: syscallarg(char *) to;
463: } */ *uap = v;
464: caddr_t sg = stackgap_init(p->p_emul);
465:
466: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, from));
467: FREEBSD_CHECK_ALT_CREAT(p, &sg, SCARG(uap, to));
468: return sys_rename(p, uap, retval);
469: }
470:
471: int
472: compat_43_freebsd_sys_truncate(p, v, retval)
473: struct proc *p;
474: void *v;
475: register_t *retval;
476: {
477: struct compat_43_freebsd_sys_truncate_args /* {
478: syscallarg(char *) path;
479: syscallarg(long) length;
480: } */ *uap = v;
481: caddr_t sg = stackgap_init(p->p_emul);
482:
483: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
484: return compat_43_sys_truncate(p, uap, retval);
485: }
486:
487: int
488: freebsd_sys_mkfifo(p, v, retval)
489: struct proc *p;
490: void *v;
491: register_t *retval;
492: {
493: struct freebsd_sys_mkfifo_args /* {
494: syscallarg(char *) path;
495: syscallarg(int) mode;
496: } */ *uap = v;
497: caddr_t sg = stackgap_init(p->p_emul);
498:
499: FREEBSD_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
500: return sys_mkfifo(p, uap, retval);
501: }
502:
503: int
504: freebsd_sys_mkdir(p, v, retval)
505: struct proc *p;
506: void *v;
507: register_t *retval;
508: {
509: struct freebsd_sys_mkdir_args /* {
510: syscallarg(char *) path;
511: syscallarg(int) mode;
512: } */ *uap = v;
513: caddr_t sg = stackgap_init(p->p_emul);
514:
515: FREEBSD_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
516: return sys_mkdir(p, uap, retval);
517: }
518:
519: int
520: freebsd_sys_rmdir(p, v, retval)
521: struct proc *p;
522: void *v;
523: register_t *retval;
524: {
525: struct freebsd_sys_rmdir_args /* {
526: syscallarg(char *) path;
527: } */ *uap = v;
528: caddr_t sg = stackgap_init(p->p_emul);
529:
530: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
531: return sys_rmdir(p, uap, retval);
532: }
533:
534: /*
535: * Convert struct statfs -> struct freebsd_statfs
536: */
537: void
538: statfs_to_freebsd_statfs(p, mp, sp, fsp)
539: struct proc *p;
540: struct mount *mp;
541: struct statfs *sp;
542: struct freebsd_statfs *fsp;
543: {
544: fsp->f_bsize = sp->f_bsize;
545: fsp->f_iosize = sp->f_iosize;
546: fsp->f_blocks = sp->f_blocks;
547: fsp->f_bfree = sp->f_bfree;
548: fsp->f_bavail = sp->f_bavail;
549: fsp->f_files = sp->f_files;
550: fsp->f_ffree = sp->f_ffree;
551: /* Don't let non-root see filesystem id (for NFS security) */
552: if (suser(p, 0))
553: fsp->f_fsid.val[0] = fsp->f_fsid.val[1] = 0;
554: else
555: bcopy(&sp->f_fsid, &fsp->f_fsid, sizeof(fsp->f_fsid));
556: fsp->f_owner = sp->f_owner;
557: fsp->f_type = mp->mnt_vfc->vfc_typenum;
558: fsp->f_flags = sp->f_flags;
559: fsp->f_syncwrites = sp->f_syncwrites;
560: fsp->f_asyncwrites = sp->f_asyncwrites;
561: bcopy(sp->f_fstypename, fsp->f_fstypename, MFSNAMELEN);
562: bcopy(sp->f_mntonname, fsp->f_mntonname, MNAMELEN);
563: bcopy(sp->f_mntfromname, fsp->f_mntfromname, MNAMELEN);
564: }
565:
566: /*
567: * Get filesystem statistics.
568: */
569: /* ARGSUSED */
570: int
571: freebsd_sys_statfs(p, v, retval)
572: struct proc *p;
573: void *v;
574: register_t *retval;
575: {
576: register struct freebsd_sys_statfs_args /* {
577: syscallarg(char *) path;
578: syscallarg(struct freebsd_statfs *) buf;
579: } */ *uap = v;
580: register struct mount *mp;
581: register struct statfs *sp;
582: struct freebsd_statfs fsb;
583: int error;
584: struct nameidata nd;
585: caddr_t sg = stackgap_init(p->p_emul);
586:
587: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
588: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
589: if ((error = namei(&nd)) != 0)
590: return (error);
591: mp = nd.ni_vp->v_mount;
592: sp = &mp->mnt_stat;
593: vrele(nd.ni_vp);
594: if ((error = VFS_STATFS(mp, sp, p)) != 0)
595: return (error);
596: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
597:
598: statfs_to_freebsd_statfs(p, mp, sp, &fsb);
599: return (copyout((caddr_t)&fsb, (caddr_t)SCARG(uap, buf), sizeof(fsb)));
600: }
601:
602: /*
603: * Get filesystem statistics.
604: */
605: /* ARGSUSED */
606: int
607: freebsd_sys_fstatfs(p, v, retval)
608: struct proc *p;
609: void *v;
610: register_t *retval;
611: {
612: register struct freebsd_sys_fstatfs_args /* {
613: syscallarg(int) fd;
614: syscallarg(struct freebsd_statfs *) buf;
615: } */ *uap = v;
616: struct file *fp;
617: struct mount *mp;
618: register struct statfs *sp;
619: struct freebsd_statfs fsb;
620: int error;
621:
622: if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
623: return (error);
624: mp = ((struct vnode *)fp->f_data)->v_mount;
625: sp = &mp->mnt_stat;
626: error = VFS_STATFS(mp, sp, p);
627: FRELE(fp);
628: if (error)
629: return (error);
630: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
631:
632: statfs_to_freebsd_statfs(p, mp, sp, &fsb);
633: return (copyout((caddr_t)&fsb, (caddr_t)SCARG(uap, buf), sizeof(fsb)));
634: }
635:
636: /*
637: * Get statistics on all filesystems.
638: */
639: int
640: freebsd_sys_getfsstat(p, v, retval)
641: struct proc *p;
642: void *v;
643: register_t *retval;
644: {
645: register struct freebsd_sys_getfsstat_args /* {
646: syscallarg(struct freebsd_statfs *) buf;
647: syscallarg(long) bufsize;
648: syscallarg(int) flags;
649: } */ *uap = v;
650: register struct mount *mp, *nmp;
651: register struct statfs *sp;
652: struct freebsd_statfs fsb;
653: caddr_t sfsp;
654: long count, maxcount;
655: int error, flags = SCARG(uap, flags);
656:
657: maxcount = SCARG(uap, bufsize) / sizeof(struct freebsd_statfs);
658: sfsp = (caddr_t)SCARG(uap, buf);
659: count = 0;
660:
661: for (mp = CIRCLEQ_FIRST(&mountlist); mp != CIRCLEQ_END(&mountlist);
662: mp = nmp) {
663: if (vfs_busy(mp, VB_READ|VB_NOWAIT)) {
664: nmp = CIRCLEQ_NEXT(mp, mnt_list);
665: continue;
666: }
667: if (sfsp && count < maxcount) {
668: sp = &mp->mnt_stat;
669:
670: /* Refresh stats unless MNT_NOWAIT is specified */
671: if (flags != MNT_NOWAIT &&
672: flags != MNT_LAZY &&
673: (flags == MNT_WAIT ||
674: flags == 0) &&
675: (error = VFS_STATFS(mp, sp, p))) {
676: nmp = CIRCLEQ_NEXT(mp, mnt_list);
677: vfs_unbusy(mp);
678: continue;
679: }
680: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
681:
682: statfs_to_freebsd_statfs(p, mp, sp, &fsb);
683: error = copyout((caddr_t)&fsb, sfsp, sizeof(fsb));
684: if (error) {
685: vfs_unbusy(mp);
686: return (error);
687: }
688: sfsp += sizeof(fsb);
689: }
690: count++;
691: nmp = CIRCLEQ_NEXT(mp, mnt_list);
692: vfs_unbusy(mp);
693: }
694:
695: if (sfsp && count > maxcount)
696: *retval = maxcount;
697: else
698: *retval = count;
699:
700: return (0);
701: }
702:
703: #ifdef NFSCLIENT
704: int
705: freebsd_sys_getfh(p, v, retval)
706: struct proc *p;
707: void *v;
708: register_t *retval;
709: {
710: struct freebsd_sys_getfh_args /* {
711: syscallarg(char *) fname;
712: syscallarg(fhandle_t *) fhp;
713: } */ *uap = v;
714: caddr_t sg = stackgap_init(p->p_emul);
715:
716: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, fname));
717: return sys_getfh(p, uap, retval);
718: }
719: #endif /* NFSCLIENT */
720:
721: int
722: freebsd_sys_stat(p, v, retval)
723: struct proc *p;
724: void *v;
725: register_t *retval;
726: {
727: struct freebsd_sys_stat_args /* {
728: syscallarg(char *) path;
729: syscallarg(struct stat35 *) ub;
730: } */ *uap = v;
731: caddr_t sg = stackgap_init(p->p_emul);
732:
733: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
734: return compat_35_sys_stat(p, uap, retval);
735: }
736:
737: int
738: freebsd_sys_lstat(p, v, retval)
739: struct proc *p;
740: void *v;
741: register_t *retval;
742: {
743: struct freebsd_sys_lstat_args /* {
744: syscallarg(char *) path;
745: syscallarg(struct stat35 *) ub;
746: } */ *uap = v;
747: caddr_t sg = stackgap_init(p->p_emul);
748:
749: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
750: return compat_35_sys_lstat(p, uap, retval);
751: }
752:
753: int
754: freebsd_sys_pathconf(p, v, retval)
755: struct proc *p;
756: void *v;
757: register_t *retval;
758: {
759: struct freebsd_sys_pathconf_args /* {
760: syscallarg(char *) path;
761: syscallarg(int) name;
762: } */ *uap = v;
763: caddr_t sg = stackgap_init(p->p_emul);
764:
765: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
766: return sys_pathconf(p, uap, retval);
767: }
768:
769: int
770: freebsd_sys_truncate(p, v, retval)
771: struct proc *p;
772: void *v;
773: register_t *retval;
774: {
775: struct freebsd_sys_truncate_args /* {
776: syscallarg(char *) path;
777: syscallarg(int) pad;
778: syscallarg(off_t) length;
779: } */ *uap = v;
780: caddr_t sg = stackgap_init(p->p_emul);
781:
782: FREEBSD_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
783: return sys_truncate(p, uap, retval);
784: }
785:
786: /*
787: * Just pass on everything to our fcntl, except for F_[GS]ETOWN on pipes,
788: * where we translate to SIOC[GS]PGRP.
789: */
790: int
791: freebsd_sys_fcntl(p, v, retval)
792: struct proc *p;
793: void *v;
794: register_t *retval;
795: {
796: struct freebsd_sys_fcntl_args /* {
797: syscallarg(int) fd;
798: syscallarg(int) cmd;
799: syscallarg(void *) arg;
800: } */ *uap = v;
801: int fd, cmd, error;
802: struct filedesc *fdp;
803: struct file *fp;
804:
805: fd = SCARG(uap, fd);
806: cmd = SCARG(uap, cmd);
807:
808: switch (cmd) {
809: case F_GETOWN:
810: case F_SETOWN:
811: /* Our pipes does not understand F_[GS]ETOWN. */
812: fdp = p->p_fd;
813: if ((fp = fd_getfile(fdp, fd)) == NULL)
814: return (EBADF);
815: if (fp->f_type == DTYPE_PIPE) {
816: FREF(fp);
817: error = (*fp->f_ops->fo_ioctl)(fp,
818: cmd == F_GETOWN ? SIOCGPGRP : SIOCSPGRP,
819: (caddr_t)&SCARG(uap, arg), p);
820: FRELE(fp);
821: return (error);
822: }
823: break;
824: }
825:
826: return (sys_fcntl(p, uap, retval));
827: }
828:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to freebsd_file.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / freebsd