Annotation of sys/compat/linux/linux_misc.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: linux_misc.c,v 1.60 2007/02/06 18:42:37 art Exp $ */
2: /* $NetBSD: linux_misc.c,v 1.27 1996/05/20 01:59:21 fvdl Exp $ */
3:
4: /*-
5: * Copyright (c) 1995, 1998, 1999 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Frank van der Linden and Eric Haszlakiewicz; by Jason R. Thorpe
10: * of the Numerical Aerospace Simulation Facility, NASA Ames Research Center.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgement:
22: * This product includes software developed by the NetBSD
23: * Foundation, Inc. and its contributors.
24: * 4. Neither the name of The NetBSD Foundation nor the names of its
25: * contributors may be used to endorse or promote products derived
26: * from this software without specific prior written permission.
27: *
28: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
29: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
30: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
32: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38: * POSSIBILITY OF SUCH DAMAGE.
39: */
40:
41: /*
42: * Linux compatibility module. Try to deal with various Linux system calls.
43: */
44:
45: #include <sys/param.h>
46: #include <sys/systm.h>
47: #include <sys/namei.h>
48: #include <sys/proc.h>
49: #include <sys/dirent.h>
50: #include <sys/file.h>
51: #include <sys/stat.h>
52: #include <sys/filedesc.h>
53: #include <sys/ioctl.h>
54: #include <sys/kernel.h>
55: #include <sys/malloc.h>
56: #include <sys/mbuf.h>
57: #include <sys/mman.h>
58: #include <sys/mount.h>
59: #include <sys/ptrace.h>
60: #include <sys/resource.h>
61: #include <sys/resourcevar.h>
62: #include <sys/signal.h>
63: #include <sys/signalvar.h>
64: #include <sys/socket.h>
65: #include <sys/time.h>
66: #include <sys/times.h>
67: #include <sys/vnode.h>
68: #include <sys/uio.h>
69: #include <sys/wait.h>
70: #include <sys/utsname.h>
71: #include <sys/unistd.h>
72:
73: #include <sys/syscallargs.h>
74:
75: #include <uvm/uvm_extern.h>
76:
77: #include <compat/linux/linux_types.h>
78: #include <compat/linux/linux_fcntl.h>
79: #include <compat/linux/linux_misc.h>
80: #include <compat/linux/linux_mmap.h>
81: #include <compat/linux/linux_sched.h>
82: #include <compat/linux/linux_signal.h>
83: #include <compat/linux/linux_syscallargs.h>
84: #include <compat/linux/linux_util.h>
85: #include <compat/linux/linux_dirent.h>
86: #include <compat/linux/linux_emuldata.h>
87:
88: #include <compat/common/compat_dir.h>
89:
90: /* linux_misc.c */
91: static void bsd_to_linux_statfs(struct statfs *, struct linux_statfs *);
92: int linux_select1(struct proc *, register_t *, int, fd_set *,
93: fd_set *, fd_set *, struct timeval *);
94: static int getdents_common(struct proc *, void *, register_t *, int);
95: static void linux_to_bsd_mmap_args(struct sys_mmap_args *,
96: const struct linux_sys_mmap2_args *);
97:
98: /*
99: * The information on a terminated (or stopped) process needs
100: * to be converted in order for Linux binaries to get a valid signal
101: * number out of it.
102: */
103: void
104: bsd_to_linux_wstat(status)
105: int *status;
106: {
107:
108: if (WIFSIGNALED(*status))
109: *status = (*status & ~0177) |
110: bsd_to_linux_sig[WTERMSIG(*status)];
111: else if (WIFSTOPPED(*status))
112: *status = (*status & ~0xff00) |
113: (bsd_to_linux_sig[WSTOPSIG(*status)] << 8);
114: }
115:
116: /*
117: * waitpid(2). Just forward on to linux_sys_wait4 with a NULL rusage.
118: */
119: int
120: linux_sys_waitpid(p, v, retval)
121: struct proc *p;
122: void *v;
123: register_t *retval;
124: {
125: struct linux_sys_waitpid_args /* {
126: syscallarg(int) pid;
127: syscallarg(int *) status;
128: syscallarg(int) options;
129: } */ *uap = v;
130: struct sys_wait4_args linux_w4a;
131:
132: SCARG(&linux_w4a, pid) = SCARG(uap, pid);
133: SCARG(&linux_w4a, status) = SCARG(uap, status);
134: SCARG(&linux_w4a, options) = SCARG(uap, options);
135: SCARG(&linux_w4a, rusage) = NULL;
136:
137: return (linux_sys_wait4(p, &linux_w4a, retval));
138: }
139:
140: /*
141: * wait4(2). Passed on to the OpenBSD call, surrounded by code to reserve
142: * some space for an OpenBSD-style wait status, and converting it to what
143: * Linux wants.
144: */
145: int
146: linux_sys_wait4(p, v, retval)
147: struct proc *p;
148: void *v;
149: register_t *retval;
150: {
151: struct linux_sys_wait4_args /* {
152: syscallarg(int) pid;
153: syscallarg(int *) status;
154: syscallarg(int) options;
155: syscallarg(struct rusage *) rusage;
156: } */ *uap = v;
157: struct sys_wait4_args w4a;
158: int error, *status, tstat, linux_options, options;
159: caddr_t sg;
160:
161: if (SCARG(uap, status) != NULL) {
162: sg = stackgap_init(p->p_emul);
163: status = (int *) stackgap_alloc(&sg, sizeof status);
164: } else
165: status = NULL;
166:
167: linux_options = SCARG(uap, options);
168: options = 0;
169: if (linux_options &
170: ~(LINUX_WAIT4_WNOHANG|LINUX_WAIT4_WUNTRACED|LINUX_WAIT4_WCLONE))
171: return (EINVAL);
172:
173: if (linux_options & LINUX_WAIT4_WNOHANG)
174: options |= WNOHANG;
175: if (linux_options & LINUX_WAIT4_WUNTRACED)
176: options |= WUNTRACED;
177: if (linux_options & LINUX_WAIT4_WCLONE)
178: options |= WALTSIG;
179:
180: SCARG(&w4a, pid) = SCARG(uap, pid);
181: SCARG(&w4a, status) = status;
182: SCARG(&w4a, options) = options;
183: SCARG(&w4a, rusage) = SCARG(uap, rusage);
184:
185: if ((error = sys_wait4(p, &w4a, retval)))
186: return error;
187:
188: atomic_clearbits_int(&p->p_siglist, sigmask(SIGCHLD));
189:
190: if (status != NULL) {
191: if ((error = copyin(status, &tstat, sizeof tstat)))
192: return error;
193:
194: bsd_to_linux_wstat(&tstat);
195: return copyout(&tstat, SCARG(uap, status), sizeof tstat);
196: }
197:
198: return 0;
199: }
200:
201: int
202: linux_sys_setresgid16(p, v, retval)
203: struct proc *p;
204: void *v;
205: register_t *retval;
206: {
207: struct linux_sys_setresgid16_args /* {
208: syscallarg(u_int16_t) rgid;
209: syscallarg(u_int16_t) egid;
210: syscallarg(u_int16_t) sgid;
211: } */ *uap = v;
212: struct sys_setresgid_args nuap;
213: u_int16_t rgid, egid, sgid;
214:
215: rgid = SCARG(uap, rgid);
216: SCARG(&nuap, rgid) = (rgid == (u_int16_t)-1) ? (gid_t)-1 : rgid;
217: egid = SCARG(uap, egid);
218: SCARG(&nuap, egid) = (egid == (u_int16_t)-1) ? (gid_t)-1 : egid;
219: sgid = SCARG(uap, sgid);
220: SCARG(&nuap, sgid) = (sgid == (u_int16_t)-1) ? (gid_t)-1 : sgid;
221:
222: return sys_setresgid(p, &nuap, retval);
223: }
224:
225: int
226: linux_sys_getresgid16(p, v, retval)
227: struct proc *p;
228: void *v;
229: register_t *retval;
230: {
231: struct linux_sys_getresgid16_args /* {
232: syscallarg(u_int16_t *) rgid;
233: syscallarg(u_int16_t *) egid;
234: syscallarg(u_int16_t *) sgid;
235: } */ *uap = v;
236: struct sys_getresgid_args nuap;
237:
238: SCARG(&nuap, rgid) = (gid_t *)SCARG(uap, rgid);
239: SCARG(&nuap, egid) = (gid_t *)SCARG(uap, egid);
240: SCARG(&nuap, sgid) = (gid_t *)SCARG(uap, sgid);
241:
242: return sys_getresgid(p, &nuap, retval);
243: }
244:
245: int
246: linux_sys_setresuid16(p, v, retval)
247: struct proc *p;
248: void *v;
249: register_t *retval;
250: {
251: struct linux_sys_setresuid16_args /* {
252: syscallarg(u_int16_t) ruid;
253: syscallarg(u_int16_t) euid;
254: syscallarg(u_int16_t) suid;
255: } */ *uap = v;
256: struct sys_setresuid_args nuap;
257: u_int16_t ruid, euid, suid;
258:
259: ruid = SCARG(uap, ruid);
260: SCARG(&nuap, ruid) = (ruid == (u_int16_t)-1) ? (uid_t)-1 : ruid;
261: euid = SCARG(uap, euid);
262: SCARG(&nuap, euid) = (euid == (u_int16_t)-1) ? (uid_t)-1 : euid;
263: suid = SCARG(uap, suid);
264: SCARG(&nuap, suid) = (suid == (u_int16_t)-1) ? (uid_t)-1 : suid;
265:
266: return sys_setresuid(p, &nuap, retval);
267: }
268:
269: int
270: linux_sys_getresuid16(p, v, retval)
271: struct proc *p;
272: void *v;
273: register_t *retval;
274: {
275: struct linux_sys_getresuid16_args /* {
276: syscallarg(u_int16_t *) ruid;
277: syscallarg(u_int16_t *) euid;
278: syscallarg(u_int16_t *) suid;
279: } */ *uap = v;
280: struct sys_getresuid_args nuap;
281:
282: SCARG(&nuap, ruid) = (uid_t *)SCARG(uap, ruid);
283: SCARG(&nuap, euid) = (uid_t *)SCARG(uap, euid);
284: SCARG(&nuap, suid) = (uid_t *)SCARG(uap, suid);
285:
286: return sys_getresuid(p, &nuap, retval);
287: }
288:
289: /*
290: * This is the old brk(2) call. I don't think anything in the Linux
291: * world uses this anymore
292: */
293: int
294: linux_sys_break(p, v, retval)
295: struct proc *p;
296: void *v;
297: register_t *retval;
298: {
299: #if 0
300: struct linux_sys_brk_args /* {
301: syscallarg(char *) nsize;
302: } */ *uap = v;
303: #endif
304:
305: return ENOSYS;
306: }
307:
308: /*
309: * Linux brk(2). The check if the new address is >= the old one is
310: * done in the kernel in Linux. OpenBSD does it in the library.
311: */
312: int
313: linux_sys_brk(p, v, retval)
314: struct proc *p;
315: void *v;
316: register_t *retval;
317: {
318: struct linux_sys_brk_args /* {
319: syscallarg(char *) nsize;
320: } */ *uap = v;
321: char *nbrk = SCARG(uap, nsize);
322: struct sys_obreak_args oba;
323: struct vmspace *vm = p->p_vmspace;
324: struct linux_emuldata *ed = (struct linux_emuldata*)p->p_emuldata;
325:
326: SCARG(&oba, nsize) = nbrk;
327:
328: if ((caddr_t) nbrk > vm->vm_daddr && sys_obreak(p, &oba, retval) == 0)
329: ed->p_break = (char*)nbrk;
330: else
331: nbrk = ed->p_break;
332:
333: retval[0] = (register_t)nbrk;
334:
335: return 0;
336: }
337:
338: /*
339: * I wonder why Linux has gettimeofday() _and_ time().. Still, we
340: * need to deal with it.
341: */
342: int
343: linux_sys_time(p, v, retval)
344: struct proc *p;
345: void *v;
346: register_t *retval;
347: {
348: struct linux_sys_time_args /* {
349: linux_time_t *t;
350: } */ *uap = v;
351: struct timeval atv;
352: linux_time_t tt;
353: int error;
354:
355: microtime(&atv);
356:
357: tt = atv.tv_sec;
358: if (SCARG(uap, t) && (error = copyout(&tt, SCARG(uap, t), sizeof tt)))
359: return error;
360:
361: retval[0] = tt;
362: return 0;
363: }
364:
365: /*
366: * Convert BSD statfs structure to Linux statfs structure.
367: * The Linux structure has less fields, and it also wants
368: * the length of a name in a dir entry in a field, which
369: * we fake (probably the wrong way).
370: */
371: static void
372: bsd_to_linux_statfs(bsp, lsp)
373: struct statfs *bsp;
374: struct linux_statfs *lsp;
375: {
376:
377: /*
378: * Convert BSD filesystem names to Linux filesystem type numbers
379: * where possible. Linux statfs uses a value of -1 to indicate
380: * an unsupported field.
381: */
382: if (!strcmp(bsp->f_fstypename, MOUNT_FFS) ||
383: !strcmp(bsp->f_fstypename, MOUNT_MFS))
384: lsp->l_ftype = 0x11954;
385: else if (!strcmp(bsp->f_fstypename, MOUNT_NFS))
386: lsp->l_ftype = 0x6969;
387: else if (!strcmp(bsp->f_fstypename, MOUNT_MSDOS))
388: lsp->l_ftype = 0x4d44;
389: else if (!strcmp(bsp->f_fstypename, MOUNT_PROCFS))
390: lsp->l_ftype = 0x9fa0;
391: else if (!strcmp(bsp->f_fstypename, MOUNT_EXT2FS))
392: lsp->l_ftype = 0xef53;
393: else if (!strcmp(bsp->f_fstypename, MOUNT_CD9660))
394: lsp->l_ftype = 0x9660;
395: else if (!strcmp(bsp->f_fstypename, MOUNT_NCPFS))
396: lsp->l_ftype = 0x6969;
397: else
398: lsp->l_ftype = -1;
399:
400: lsp->l_fbsize = bsp->f_bsize;
401: lsp->l_fblocks = bsp->f_blocks;
402: lsp->l_fbfree = bsp->f_bfree;
403: lsp->l_fbavail = bsp->f_bavail;
404: lsp->l_ffiles = bsp->f_files;
405: lsp->l_fffree = bsp->f_ffree;
406: lsp->l_ffsid.val[0] = bsp->f_fsid.val[0];
407: lsp->l_ffsid.val[1] = bsp->f_fsid.val[1];
408: lsp->l_fnamelen = MAXNAMLEN; /* XXX */
409: }
410:
411: /*
412: * Implement the fs stat functions. Straightforward.
413: */
414: int
415: linux_sys_statfs(p, v, retval)
416: struct proc *p;
417: void *v;
418: register_t *retval;
419: {
420: struct linux_sys_statfs_args /* {
421: syscallarg(char *) path;
422: syscallarg(struct linux_statfs *) sp;
423: } */ *uap = v;
424: struct statfs btmp, *bsp;
425: struct linux_statfs ltmp;
426: struct sys_statfs_args bsa;
427: caddr_t sg;
428: int error;
429:
430: sg = stackgap_init(p->p_emul);
431: bsp = (struct statfs *) stackgap_alloc(&sg, sizeof (struct statfs));
432:
433: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
434:
435: SCARG(&bsa, path) = SCARG(uap, path);
436: SCARG(&bsa, buf) = bsp;
437:
438: if ((error = sys_statfs(p, &bsa, retval)))
439: return error;
440:
441: if ((error = copyin((caddr_t) bsp, (caddr_t) &btmp, sizeof btmp)))
442: return error;
443:
444: bsd_to_linux_statfs(&btmp, <mp);
445:
446: return copyout((caddr_t) <mp, (caddr_t) SCARG(uap, sp), sizeof ltmp);
447: }
448:
449: int
450: linux_sys_fstatfs(p, v, retval)
451: struct proc *p;
452: void *v;
453: register_t *retval;
454: {
455: struct linux_sys_fstatfs_args /* {
456: syscallarg(int) fd;
457: syscallarg(struct linux_statfs *) sp;
458: } */ *uap = v;
459: struct statfs btmp, *bsp;
460: struct linux_statfs ltmp;
461: struct sys_fstatfs_args bsa;
462: caddr_t sg;
463: int error;
464:
465: sg = stackgap_init(p->p_emul);
466: bsp = (struct statfs *) stackgap_alloc(&sg, sizeof (struct statfs));
467:
468: SCARG(&bsa, fd) = SCARG(uap, fd);
469: SCARG(&bsa, buf) = bsp;
470:
471: if ((error = sys_fstatfs(p, &bsa, retval)))
472: return error;
473:
474: if ((error = copyin((caddr_t) bsp, (caddr_t) &btmp, sizeof btmp)))
475: return error;
476:
477: bsd_to_linux_statfs(&btmp, <mp);
478:
479: return copyout((caddr_t) <mp, (caddr_t) SCARG(uap, sp), sizeof ltmp);
480: }
481:
482: /*
483: * uname(). Just copy the info from the various strings stored in the
484: * kernel, and put it in the Linux utsname structure. That structure
485: * is almost the same as the OpenBSD one, only it has fields 65 characters
486: * long, and an extra domainname field.
487: */
488: int
489: linux_sys_uname(p, v, retval)
490: struct proc *p;
491: void *v;
492: register_t *retval;
493: {
494: struct linux_sys_uname_args /* {
495: syscallarg(struct linux_utsname *) up;
496: } */ *uap = v;
497: extern char hostname[], machine[], domainname[];
498: struct linux_utsname luts;
499: int len;
500: char *cp;
501:
502: strlcpy(luts.l_sysname, ostype, sizeof(luts.l_sysname));
503: strlcpy(luts.l_nodename, hostname, sizeof(luts.l_nodename));
504: strlcpy(luts.l_release, osrelease, sizeof(luts.l_release));
505: strlcpy(luts.l_version, version, sizeof(luts.l_version));
506: strlcpy(luts.l_machine, machine, sizeof(luts.l_machine));
507: strlcpy(luts.l_domainname, domainname, sizeof(luts.l_domainname));
508:
509: /* This part taken from the uname() in libc */
510: len = sizeof(luts.l_version);
511: for (cp = luts.l_version; len--; ++cp)
512: if (*cp == '\n' || *cp == '\t')
513: *cp = (len > 1) ? ' ' : '\0';
514:
515: return copyout(&luts, SCARG(uap, up), sizeof(luts));
516: }
517:
518: int
519: linux_sys_olduname(p, v, retval)
520: struct proc *p;
521: void *v;
522: register_t *retval;
523: {
524: struct linux_sys_uname_args /* {
525: syscallarg(struct linux_oldutsname *) up;
526: } */ *uap = v;
527: extern char hostname[], machine[];
528: struct linux_oldutsname luts;
529: int len;
530: char *cp;
531:
532: strlcpy(luts.l_sysname, ostype, sizeof(luts.l_sysname));
533: strlcpy(luts.l_nodename, hostname, sizeof(luts.l_nodename));
534: strlcpy(luts.l_release, osrelease, sizeof(luts.l_release));
535: strlcpy(luts.l_version, version, sizeof(luts.l_version));
536: strlcpy(luts.l_machine, machine, sizeof(luts.l_machine));
537:
538: /* This part taken from the uname() in libc */
539: len = sizeof(luts.l_version);
540: for (cp = luts.l_version; len--; ++cp)
541: if (*cp == '\n' || *cp == '\t')
542: *cp = (len > 1) ? ' ' : '\0';
543:
544: return copyout(&luts, SCARG(uap, up), sizeof(luts));
545: }
546:
547: int
548: linux_sys_oldolduname(p, v, retval)
549: struct proc *p;
550: void *v;
551: register_t *retval;
552: {
553: struct linux_sys_uname_args /* {
554: syscallarg(struct linux_oldoldutsname *) up;
555: } */ *uap = v;
556: extern char hostname[], machine[];
557: struct linux_oldoldutsname luts;
558: int len;
559: char *cp;
560:
561: strlcpy(luts.l_sysname, ostype, sizeof(luts.l_sysname));
562: strlcpy(luts.l_nodename, hostname, sizeof(luts.l_nodename));
563: strlcpy(luts.l_release, osrelease, sizeof(luts.l_release));
564: strlcpy(luts.l_version, version, sizeof(luts.l_version));
565: strlcpy(luts.l_machine, machine, sizeof(luts.l_machine));
566:
567: /* This part taken from the uname() in libc */
568: len = sizeof(luts.l_version);
569: for (cp = luts.l_version; len--; ++cp)
570: if (*cp == '\n' || *cp == '\t')
571: *cp = (len > 1) ? ' ' : '\0';
572:
573: return copyout(&luts, SCARG(uap, up), sizeof(luts));
574: }
575:
576: /*
577: * Linux wants to pass everything to a syscall in registers. However,
578: * mmap() has 6 of them. Oops: out of register error. They just pass
579: * everything in a structure.
580: */
581: int
582: linux_sys_mmap(p, v, retval)
583: struct proc *p;
584: void *v;
585: register_t *retval;
586: {
587: struct linux_sys_mmap_args /* {
588: syscallarg(struct linux_mmap *) lmp;
589: } */ *uap = v;
590: struct linux_mmap lmap;
591: struct linux_sys_mmap2_args nlmap;
592: struct sys_mmap_args cma;
593: int error;
594:
595: if ((error = copyin(SCARG(uap, lmp), &lmap, sizeof lmap)))
596: return error;
597:
598: if (lmap.lm_pos & PAGE_MASK)
599: return EINVAL;
600:
601: /* repackage into something sane */
602: SCARG(&nlmap,addr) = (unsigned long)lmap.lm_addr;
603: SCARG(&nlmap,len) = lmap.lm_len;
604: SCARG(&nlmap,prot) = lmap.lm_prot;
605: SCARG(&nlmap,flags) = lmap.lm_flags;
606: SCARG(&nlmap,fd) = lmap.lm_fd;
607: SCARG(&nlmap,offset) = (unsigned)lmap.lm_pos;
608:
609: linux_to_bsd_mmap_args(&cma, &nlmap);
610: SCARG(&cma, pos) = (off_t)SCARG(&nlmap, offset);
611:
612: return sys_mmap(p, &cma, retval);
613: }
614:
615: /*
616: * Guts of most architectures' mmap64() implementations. This shares
617: * its list of arguments with linux_sys_mmap().
618: *
619: * The difference in linux_sys_mmap2() is that "offset" is actually
620: * (offset / pagesize), not an absolute byte count. This translation
621: * to pagesize offsets is done inside glibc between the mmap64() call
622: * point, and the actual syscall.
623: */
624: int
625: linux_sys_mmap2(p, v, retval)
626: struct proc *p;
627: void *v;
628: register_t *retval;
629: {
630: struct linux_sys_mmap2_args /* {
631: syscallarg(unsigned long) addr;
632: syscallarg(size_t) len;
633: syscallarg(int) prot;
634: syscallarg(int) flags;
635: syscallarg(int) fd;
636: syscallarg(linux_off_t) offset;
637: } */ *uap = v;
638: struct sys_mmap_args cma;
639:
640: linux_to_bsd_mmap_args(&cma, uap);
641: SCARG(&cma, pos) = ((off_t)SCARG(uap, offset)) << PAGE_SHIFT;
642:
643: return sys_mmap(p, &cma, retval);
644: }
645:
646: static void
647: linux_to_bsd_mmap_args(cma, uap)
648: struct sys_mmap_args *cma;
649: const struct linux_sys_mmap2_args *uap;
650: {
651: int flags = MAP_TRYFIXED, fl = SCARG(uap, flags);
652:
653: flags |= cvtto_bsd_mask(fl, LINUX_MAP_SHARED, MAP_SHARED);
654: flags |= cvtto_bsd_mask(fl, LINUX_MAP_PRIVATE, MAP_PRIVATE);
655: flags |= cvtto_bsd_mask(fl, LINUX_MAP_FIXED, MAP_FIXED);
656: flags |= cvtto_bsd_mask(fl, LINUX_MAP_ANON, MAP_ANON);
657: /* XXX XAX ERH: Any other flags here? There are more defined... */
658:
659: SCARG(cma, addr) = (void *)SCARG(uap, addr);
660: SCARG(cma, len) = SCARG(uap, len);
661: SCARG(cma, prot) = SCARG(uap, prot);
662: if (SCARG(cma, prot) & VM_PROT_WRITE) /* XXX */
663: SCARG(cma, prot) |= VM_PROT_READ;
664: SCARG(cma, flags) = flags;
665: SCARG(cma, fd) = flags & MAP_ANON ? -1 : SCARG(uap, fd);
666: SCARG(cma, pad) = 0;
667: }
668:
669: int
670: linux_sys_mremap(p, v, retval)
671: struct proc *p;
672: void *v;
673: register_t *retval;
674: {
675:
676: struct linux_sys_mremap_args /* {
677: syscallarg(void *) old_address;
678: syscallarg(size_t) old_size;
679: syscallarg(size_t) new_size;
680: syscallarg(u_long) flags;
681: } */ *uap = v;
682: struct sys_munmap_args mua;
683: size_t old_size, new_size;
684: int error;
685:
686: old_size = round_page(SCARG(uap, old_size));
687: new_size = round_page(SCARG(uap, new_size));
688:
689: /*
690: * Growing mapped region.
691: */
692: if (new_size > old_size) {
693: /*
694: * XXX Implement me. What we probably want to do is
695: * XXX dig out the guts of the old mapping, mmap that
696: * XXX object again with the new size, then munmap
697: * XXX the old mapping.
698: */
699: *retval = 0;
700: return (ENOMEM);
701: }
702: /*
703: * Shrinking mapped region.
704: */
705: if (new_size < old_size) {
706: SCARG(&mua, addr) = (caddr_t)SCARG(uap, old_address) + new_size;
707: SCARG(&mua, len) = old_size - new_size;
708: error = sys_munmap(p, &mua, retval);
709: *retval = error ? 0 : (register_t)SCARG(uap, old_address);
710: return (error);
711: }
712:
713: /*
714: * No change.
715: */
716: *retval = (register_t)SCARG(uap, old_address);
717: return (0);
718:
719: }
720:
721: /*
722: * This code is partly stolen from src/lib/libc/gen/times.c
723: * XXX - CLK_TCK isn't declared in /sys, just in <time.h>, done here
724: */
725:
726: #define CLK_TCK 100
727: #define CONVTCK(r) (r.tv_sec * CLK_TCK + r.tv_usec / (1000000 / CLK_TCK))
728:
729: int
730: linux_sys_times(p, v, retval)
731: struct proc *p;
732: void *v;
733: register_t *retval;
734: {
735: struct linux_sys_times_args /* {
736: syscallarg(struct times *) tms;
737: } */ *uap = v;
738: struct timeval t;
739: struct linux_tms ltms;
740: struct rusage ru;
741: int error;
742:
743: calcru(p, &ru.ru_utime, &ru.ru_stime, NULL);
744: ltms.ltms_utime = CONVTCK(ru.ru_utime);
745: ltms.ltms_stime = CONVTCK(ru.ru_stime);
746:
747: ltms.ltms_cutime = CONVTCK(p->p_stats->p_cru.ru_utime);
748: ltms.ltms_cstime = CONVTCK(p->p_stats->p_cru.ru_stime);
749:
750: if ((error = copyout(<ms, SCARG(uap, tms), sizeof ltms)))
751: return error;
752:
753: microuptime(&t);
754:
755: retval[0] = ((linux_clock_t)(CONVTCK(t)));
756: return 0;
757: }
758:
759: /*
760: * OpenBSD passes fd[0] in retval[0], and fd[1] in retval[1].
761: * Linux directly passes the pointer.
762: */
763: int
764: linux_sys_pipe(p, v, retval)
765: struct proc *p;
766: void *v;
767: register_t *retval;
768: {
769: struct linux_sys_pipe_args /* {
770: syscallarg(int *) pfds;
771: } */ *uap = v;
772: int error;
773: int pfds[2];
774: #ifdef __i386__
775: int reg_edx = retval[1];
776: #endif /* __i386__ */
777:
778: if ((error = sys_opipe(p, 0, retval))) {
779: #ifdef __i386__
780: retval[1] = reg_edx;
781: #endif /* __i386__ */
782: return error;
783: }
784:
785: /* Assumes register_t is an int */
786:
787: pfds[0] = retval[0];
788: pfds[1] = retval[1];
789: if ((error = copyout(pfds, SCARG(uap, pfds), 2 * sizeof (int)))) {
790: #ifdef __i386__
791: retval[1] = reg_edx;
792: #endif /* __i386__ */
793: fdrelease(p, retval[0]);
794: fdrelease(p, retval[1]);
795: return error;
796: }
797:
798: retval[0] = 0;
799: #ifdef __i386__
800: retval[1] = reg_edx;
801: #endif /* __i386__ */
802: return 0;
803: }
804:
805: /*
806: * Alarm. This is a libc call which uses setitimer(2) in OpenBSD.
807: * Fiddle with the timers to make it work.
808: */
809: int
810: linux_sys_alarm(p, v, retval)
811: struct proc *p;
812: void *v;
813: register_t *retval;
814: {
815: struct linux_sys_alarm_args /* {
816: syscallarg(unsigned int) secs;
817: } */ *uap = v;
818: int s;
819: struct itimerval *itp, it;
820: struct timeval tv;
821: int timo;
822:
823: itp = &p->p_realtimer;
824: s = splclock();
825: /*
826: * Clear any pending timer alarms.
827: */
828: getmicrouptime(&tv);
829: timeout_del(&p->p_realit_to);
830: timerclear(&itp->it_interval);
831: if (timerisset(&itp->it_value) &&
832: timercmp(&itp->it_value, &tv, >))
833: timersub(&itp->it_value, &tv, &itp->it_value);
834: /*
835: * Return how many seconds were left (rounded up)
836: */
837: retval[0] = itp->it_value.tv_sec;
838: if (itp->it_value.tv_usec)
839: retval[0]++;
840:
841: /*
842: * alarm(0) just resets the timer.
843: */
844: if (SCARG(uap, secs) == 0) {
845: timerclear(&itp->it_value);
846: splx(s);
847: return 0;
848: }
849:
850: /*
851: * Check the new alarm time for sanity, and set it.
852: */
853: timerclear(&it.it_interval);
854: it.it_value.tv_sec = SCARG(uap, secs);
855: it.it_value.tv_usec = 0;
856: if (itimerfix(&it.it_value) || itimerfix(&it.it_interval)) {
857: splx(s);
858: return (EINVAL);
859: }
860:
861: if (timerisset(&it.it_value)) {
862: timo = tvtohz(&it.it_value);
863: timeradd(&it.it_value, &tv, &it.it_value);
864: timeout_add(&p->p_realit_to, timo);
865: }
866: p->p_realtimer = it;
867: splx(s);
868:
869: return 0;
870: }
871:
872: /*
873: * utime(). Do conversion to things that utimes() understands,
874: * and pass it on.
875: */
876: int
877: linux_sys_utime(p, v, retval)
878: struct proc *p;
879: void *v;
880: register_t *retval;
881: {
882: struct linux_sys_utime_args /* {
883: syscallarg(char *) path;
884: syscallarg(struct linux_utimbuf *)times;
885: } */ *uap = v;
886: caddr_t sg;
887: int error;
888: struct sys_utimes_args ua;
889: struct timeval tv[2], *tvp;
890: struct linux_utimbuf lut;
891:
892: sg = stackgap_init(p->p_emul);
893: tvp = (struct timeval *) stackgap_alloc(&sg, sizeof(tv));
894: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
895:
896: SCARG(&ua, path) = SCARG(uap, path);
897:
898: if (SCARG(uap, times) != NULL) {
899: if ((error = copyin(SCARG(uap, times), &lut, sizeof lut)))
900: return error;
901: tv[0].tv_usec = tv[1].tv_usec = 0;
902: tv[0].tv_sec = lut.l_actime;
903: tv[1].tv_sec = lut.l_modtime;
904: if ((error = copyout(tv, tvp, sizeof tv)))
905: return error;
906: SCARG(&ua, tptr) = tvp;
907: }
908: else
909: SCARG(&ua, tptr) = NULL;
910:
911: return sys_utimes(p, &ua, retval);
912: }
913:
914: /*
915: * The old Linux readdir was only able to read one entry at a time,
916: * even though it had a 'count' argument. In fact, the emulation
917: * of the old call was better than the original, because it did handle
918: * the count arg properly. Don't bother with it anymore now, and use
919: * it to distinguish between old and new. The difference is that the
920: * newer one actually does multiple entries, and the reclen field
921: * really is the reclen, not the namelength.
922: */
923: int
924: linux_sys_readdir(p, v, retval)
925: struct proc *p;
926: void *v;
927: register_t *retval;
928: {
929: struct linux_sys_readdir_args /* {
930: syscallarg(int) fd;
931: syscallarg(struct linux_dirent *) dent;
932: syscallarg(unsigned int) count;
933: } */ *uap = v;
934:
935: SCARG(uap, count) = 1;
936:
937: return linux_sys_getdents(p, uap, retval);
938: }
939:
940: /*
941: * Linux 'readdir' call. This code is mostly taken from the
942: * SunOS getdents call (see compat/sunos/sunos_misc.c), though
943: * an attempt has been made to keep it a little cleaner (failing
944: * miserably, because of the cruft needed if count 1 is passed).
945: *
946: * The d_off field should contain the offset of the next valid entry,
947: * but in Linux it has the offset of the entry itself. We emulate
948: * that bug here.
949: *
950: * Read in BSD-style entries, convert them, and copy them out.
951: *
952: * Note that this doesn't handle union-mounted filesystems.
953: */
954: int linux_readdir_callback(void *, struct dirent *, off_t);
955:
956: struct linux_readdir_callback_args {
957: caddr_t outp;
958: int resid;
959: int oldcall;
960: int is64bit;
961: };
962:
963: int
964: linux_readdir_callback(arg, bdp, cookie)
965: void *arg;
966: struct dirent *bdp;
967: off_t cookie;
968: {
969: struct linux_dirent64 idb64;
970: struct linux_dirent idb;
971: struct linux_readdir_callback_args *cb = arg;
972: int linux_reclen;
973: int error;
974:
975: if (cb->oldcall == 2)
976: return (ENOMEM);
977:
978: linux_reclen = (cb->is64bit) ?
979: LINUX_RECLEN(&idb64, bdp->d_namlen) :
980: LINUX_RECLEN(&idb, bdp->d_namlen);
981:
982: if (cb->resid < linux_reclen)
983: return (ENOMEM);
984:
985: if (cb->is64bit) {
986: idb64.d_ino = (linux_ino64_t)bdp->d_fileno;
987: idb64.d_off = (linux_off64_t)cookie;
988: idb64.d_reclen = (u_short)linux_reclen;
989: idb64.d_type = bdp->d_type;
990: strlcpy(idb64.d_name, bdp->d_name, sizeof(idb64.d_name));
991: error = copyout((caddr_t)&idb64, cb->outp, linux_reclen);
992: } else {
993: idb.d_ino = (linux_ino_t)bdp->d_fileno;
994: if (cb->oldcall) {
995: /*
996: * The old readdir() call misuses the offset
997: * and reclen fields.
998: */
999: idb.d_off = (linux_off_t)linux_reclen;
1000: idb.d_reclen = (u_short)bdp->d_namlen;
1001: } else {
1002: idb.d_off = (linux_off_t)cookie;
1003: idb.d_reclen = (u_short)linux_reclen;
1004: }
1005: strlcpy(idb.d_name, bdp->d_name, sizeof(idb.d_name));
1006: error = copyout((caddr_t)&idb, cb->outp, linux_reclen);
1007: }
1008: if (error)
1009: return (error);
1010:
1011: /* advance output past Linux-shaped entry */
1012: cb->outp += linux_reclen;
1013: cb->resid -= linux_reclen;
1014:
1015: if (cb->oldcall == 1)
1016: ++cb->oldcall;
1017:
1018: return (0);
1019: }
1020:
1021: int
1022: linux_sys_getdents64(p, v, retval)
1023: struct proc *p;
1024: void *v;
1025: register_t *retval;
1026: {
1027: return getdents_common(p, v, retval, 1);
1028: }
1029:
1030: int
1031: linux_sys_getdents(p, v, retval)
1032: struct proc *p;
1033: void *v;
1034: register_t *retval;
1035: {
1036: return getdents_common(p, v, retval, 0);
1037: }
1038:
1039: static int
1040: getdents_common(p, v, retval, is64bit)
1041: struct proc *p;
1042: void *v;
1043: register_t *retval;
1044: int is64bit;
1045: {
1046: struct linux_sys_getdents_args /* {
1047: syscallarg(int) fd;
1048: syscallarg(void *) dirent;
1049: syscallarg(unsigned) count;
1050: } */ *uap = v;
1051: struct linux_readdir_callback_args args;
1052: struct file *fp;
1053: int error;
1054: int nbytes = SCARG(uap, count);
1055:
1056: if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
1057: return (error);
1058:
1059: if (nbytes == 1) { /* emulating old, broken behaviour */
1060: /* readdir(2) case. Always struct dirent. */
1061: if (is64bit) {
1062: FRELE(fp);
1063: return (EINVAL);
1064: }
1065: nbytes = sizeof(struct linux_dirent);
1066: args.oldcall = 1;
1067: } else {
1068: args.oldcall = 0;
1069: }
1070:
1071: args.resid = nbytes;
1072: args.outp = (caddr_t)SCARG(uap, dirent);
1073: args.is64bit = is64bit;
1074:
1075: if ((error = readdir_with_callback(fp, &fp->f_offset, nbytes,
1076: linux_readdir_callback, &args)) != 0)
1077: goto exit;
1078:
1079: *retval = nbytes - args.resid;
1080:
1081: exit:
1082: FRELE(fp);
1083: return (error);
1084: }
1085:
1086: /*
1087: * Not sure why the arguments to this older version of select() were put
1088: * into a structure, because there are 5, and that can all be handled
1089: * in registers on the i386 like Linux wants to.
1090: */
1091: int
1092: linux_sys_oldselect(p, v, retval)
1093: struct proc *p;
1094: void *v;
1095: register_t *retval;
1096: {
1097: struct linux_sys_oldselect_args /* {
1098: syscallarg(struct linux_select *) lsp;
1099: } */ *uap = v;
1100: struct linux_select ls;
1101: int error;
1102:
1103: if ((error = copyin(SCARG(uap, lsp), &ls, sizeof(ls))))
1104: return error;
1105:
1106: return linux_select1(p, retval, ls.nfds, ls.readfds, ls.writefds,
1107: ls.exceptfds, ls.timeout);
1108: }
1109:
1110: /*
1111: * Even when just using registers to pass arguments to syscalls you can
1112: * have 5 of them on the i386. So this newer version of select() does
1113: * this.
1114: */
1115: int
1116: linux_sys_select(p, v, retval)
1117: struct proc *p;
1118: void *v;
1119: register_t *retval;
1120: {
1121: struct linux_sys_select_args /* {
1122: syscallarg(int) nfds;
1123: syscallarg(fd_set *) readfds;
1124: syscallarg(fd_set *) writefds;
1125: syscallarg(fd_set *) exceptfds;
1126: syscallarg(struct timeval *) timeout;
1127: } */ *uap = v;
1128:
1129: return linux_select1(p, retval, SCARG(uap, nfds), SCARG(uap, readfds),
1130: SCARG(uap, writefds), SCARG(uap, exceptfds), SCARG(uap, timeout));
1131: }
1132:
1133: /*
1134: * Common code for the old and new versions of select(). A couple of
1135: * things are important:
1136: * 1) return the amount of time left in the 'timeout' parameter
1137: * 2) select never returns ERESTART on Linux, always return EINTR
1138: */
1139: int
1140: linux_select1(p, retval, nfds, readfds, writefds, exceptfds, timeout)
1141: struct proc *p;
1142: register_t *retval;
1143: int nfds;
1144: fd_set *readfds, *writefds, *exceptfds;
1145: struct timeval *timeout;
1146: {
1147: struct sys_select_args bsa;
1148: struct timeval tv0, tv1, utv, *tvp;
1149: caddr_t sg;
1150: int error;
1151:
1152: SCARG(&bsa, nd) = nfds;
1153: SCARG(&bsa, in) = readfds;
1154: SCARG(&bsa, ou) = writefds;
1155: SCARG(&bsa, ex) = exceptfds;
1156: SCARG(&bsa, tv) = timeout;
1157:
1158: /*
1159: * Store current time for computation of the amount of
1160: * time left.
1161: */
1162: if (timeout) {
1163: if ((error = copyin(timeout, &utv, sizeof(utv))))
1164: return error;
1165: if (itimerfix(&utv)) {
1166: /*
1167: * The timeval was invalid. Convert it to something
1168: * valid that will act as it does under Linux.
1169: */
1170: sg = stackgap_init(p->p_emul);
1171: tvp = stackgap_alloc(&sg, sizeof(utv));
1172: utv.tv_sec += utv.tv_usec / 1000000;
1173: utv.tv_usec %= 1000000;
1174: if (utv.tv_usec < 0) {
1175: utv.tv_sec -= 1;
1176: utv.tv_usec += 1000000;
1177: }
1178: if (utv.tv_sec < 0)
1179: timerclear(&utv);
1180: if ((error = copyout(&utv, tvp, sizeof(utv))))
1181: return error;
1182: SCARG(&bsa, tv) = tvp;
1183: }
1184: microtime(&tv0);
1185: }
1186:
1187: error = sys_select(p, &bsa, retval);
1188: if (error) {
1189: /*
1190: * See fs/select.c in the Linux kernel. Without this,
1191: * Maelstrom doesn't work.
1192: */
1193: if (error == ERESTART)
1194: error = EINTR;
1195: return error;
1196: }
1197:
1198: if (timeout) {
1199: if (*retval) {
1200: /*
1201: * Compute how much time was left of the timeout,
1202: * by subtracting the current time and the time
1203: * before we started the call, and subtracting
1204: * that result from the user-supplied value.
1205: */
1206: microtime(&tv1);
1207: timersub(&tv1, &tv0, &tv1);
1208: timersub(&utv, &tv1, &utv);
1209: if (utv.tv_sec < 0)
1210: timerclear(&utv);
1211: } else
1212: timerclear(&utv);
1213: if ((error = copyout(&utv, timeout, sizeof(utv))))
1214: return error;
1215: }
1216:
1217: return 0;
1218: }
1219:
1220: /*
1221: * Get the process group of a certain process. Look it up
1222: * and return the value.
1223: */
1224: int
1225: linux_sys_getpgid(p, v, retval)
1226: struct proc *p;
1227: void *v;
1228: register_t *retval;
1229: {
1230: struct linux_sys_getpgid_args /* {
1231: syscallarg(int) pid;
1232: } */ *uap = v;
1233: struct proc *targp;
1234:
1235: if (SCARG(uap, pid) != 0 && SCARG(uap, pid) != p->p_pid) {
1236: if ((targp = pfind(SCARG(uap, pid))) == 0)
1237: return ESRCH;
1238: }
1239: else
1240: targp = p;
1241:
1242: retval[0] = targp->p_pgid;
1243: return 0;
1244: }
1245:
1246: /*
1247: * Set the 'personality' (emulation mode) for the current process. Only
1248: * accept the Linux personality here (0). This call is needed because
1249: * the Linux ELF crt0 issues it in an ugly kludge to make sure that
1250: * ELF binaries run in Linux mode, not SVR4 mode.
1251: */
1252: int
1253: linux_sys_personality(p, v, retval)
1254: struct proc *p;
1255: void *v;
1256: register_t *retval;
1257: {
1258: struct linux_sys_personality_args /* {
1259: syscallarg(int) per;
1260: } */ *uap = v;
1261:
1262: if (SCARG(uap, per) != 0)
1263: return EINVAL;
1264: retval[0] = 0;
1265: return 0;
1266: }
1267:
1268: /*
1269: * The calls are here because of type conversions.
1270: */
1271: int
1272: linux_sys_setreuid16(p, v, retval)
1273: struct proc *p;
1274: void *v;
1275: register_t *retval;
1276: {
1277: struct linux_sys_setreuid16_args /* {
1278: syscallarg(int) ruid;
1279: syscallarg(int) euid;
1280: } */ *uap = v;
1281: struct sys_setreuid_args bsa;
1282:
1283: SCARG(&bsa, ruid) = ((linux_uid_t)SCARG(uap, ruid) == (linux_uid_t)-1) ?
1284: (uid_t)-1 : SCARG(uap, ruid);
1285: SCARG(&bsa, euid) = ((linux_uid_t)SCARG(uap, euid) == (linux_uid_t)-1) ?
1286: (uid_t)-1 : SCARG(uap, euid);
1287:
1288: return sys_setreuid(p, &bsa, retval);
1289: }
1290:
1291: int
1292: linux_sys_setregid16(p, v, retval)
1293: struct proc *p;
1294: void *v;
1295: register_t *retval;
1296: {
1297: struct linux_sys_setregid16_args /* {
1298: syscallarg(int) rgid;
1299: syscallarg(int) egid;
1300: } */ *uap = v;
1301: struct sys_setregid_args bsa;
1302:
1303: SCARG(&bsa, rgid) = ((linux_gid_t)SCARG(uap, rgid) == (linux_gid_t)-1) ?
1304: (uid_t)-1 : SCARG(uap, rgid);
1305: SCARG(&bsa, egid) = ((linux_gid_t)SCARG(uap, egid) == (linux_gid_t)-1) ?
1306: (uid_t)-1 : SCARG(uap, egid);
1307:
1308: return sys_setregid(p, &bsa, retval);
1309: }
1310:
1311: int
1312: linux_sys_getsid(p, v, retval)
1313: struct proc *p;
1314: void *v;
1315: register_t *retval;
1316: {
1317: struct linux_sys_getsid_args /* {
1318: syscallarg(int) pid;
1319: } */ *uap = v;
1320: struct proc *p1;
1321: pid_t pid;
1322:
1323: pid = (pid_t)SCARG(uap, pid);
1324:
1325: if (pid == 0) {
1326: retval[0] = (int)p->p_session; /* XXX Oh well */
1327: return 0;
1328: }
1329:
1330: p1 = pfind((int)pid);
1331: if (p1 == NULL)
1332: return ESRCH;
1333:
1334: retval[0] = (int)p1->p_session;
1335: return 0;
1336: }
1337:
1338: int
1339: linux_sys___sysctl(p, v, retval)
1340: struct proc *p;
1341: void *v;
1342: register_t *retval;
1343: {
1344: struct linux_sys___sysctl_args /* {
1345: syscallarg(struct linux___sysctl *) lsp;
1346: } */ *uap = v;
1347: struct linux___sysctl ls;
1348: struct sys___sysctl_args bsa;
1349: int error;
1350:
1351: if ((error = copyin(SCARG(uap, lsp), &ls, sizeof ls)))
1352: return error;
1353: SCARG(&bsa, name) = ls.name;
1354: SCARG(&bsa, namelen) = ls.namelen;
1355: SCARG(&bsa, old) = ls.old;
1356: SCARG(&bsa, oldlenp) = ls.oldlenp;
1357: SCARG(&bsa, new) = ls.new;
1358: SCARG(&bsa, newlen) = ls.newlen;
1359:
1360: return sys___sysctl(p, &bsa, retval);
1361: }
1362:
1363: /*
1364: * We have nonexistent fsuid equal to uid.
1365: * If modification is requested, refuse.
1366: */
1367: int
1368: linux_sys_setfsuid(p, v, retval)
1369: struct proc *p;
1370: void *v;
1371: register_t *retval;
1372: {
1373: struct linux_sys_setfsuid_args /* {
1374: syscallarg(uid_t) uid;
1375: } */ *uap = v;
1376: uid_t uid;
1377:
1378: uid = SCARG(uap, uid);
1379: if (p->p_cred->p_ruid != uid)
1380: return sys_nosys(p, v, retval);
1381: else
1382: return (0);
1383: }
1384:
1385: int
1386: linux_sys_getfsuid(p, v, retval)
1387: struct proc *p;
1388: void *v;
1389: register_t *retval;
1390: {
1391: return sys_getuid(p, v, retval);
1392: }
1393:
1394:
1395: int
1396: linux_sys_nice(p, v, retval)
1397: struct proc *p;
1398: void *v;
1399: register_t *retval;
1400: {
1401: struct linux_sys_nice_args /* {
1402: syscallarg(int) incr;
1403: } */ *uap = v;
1404: struct sys_setpriority_args bsa;
1405:
1406: SCARG(&bsa, which) = PRIO_PROCESS;
1407: SCARG(&bsa, who) = 0;
1408: SCARG(&bsa, prio) = SCARG(uap, incr);
1409: return sys_setpriority(p, &bsa, retval);
1410: }
1411:
1412: int
1413: linux_sys_stime(p, v, retval)
1414: struct proc *p;
1415: void *v;
1416: register_t *retval;
1417: {
1418: struct linux_sys_time_args /* {
1419: linux_time_t *t;
1420: } */ *uap = v;
1421: struct timespec ats;
1422: linux_time_t tt;
1423: int error;
1424:
1425: if ((error = suser(p, 0)) != 0)
1426: return (error);
1427:
1428: if ((error = copyin(SCARG(uap, t), &tt, sizeof(tt))) != 0)
1429: return (error);
1430:
1431: ats.tv_sec = tt;
1432: ats.tv_nsec = 0;
1433:
1434: error = settime(&ats);
1435:
1436: return (error);
1437: }
1438:
1439: int
1440: linux_sys_getpid(p, v, retval)
1441: struct proc *p;
1442: void *v;
1443: register_t *retval;
1444: {
1445:
1446: *retval = p->p_pid;
1447: return (0);
1448: }
1449:
1450: int
1451: linux_sys_getuid(p, v, retval)
1452: struct proc *p;
1453: void *v;
1454: register_t *retval;
1455: {
1456:
1457: *retval = p->p_cred->p_ruid;
1458: return (0);
1459: }
1460:
1461: int
1462: linux_sys_getgid(p, v, retval)
1463: struct proc *p;
1464: void *v;
1465: register_t *retval;
1466: {
1467:
1468: *retval = p->p_cred->p_rgid;
1469: return (0);
1470: }
1471:
1472:
1473: /*
1474: * sysinfo()
1475: */
1476: /* ARGSUSED */
1477: int
1478: linux_sys_sysinfo(p, v, retval)
1479: struct proc *p;
1480: void *v;
1481: register_t *retval;
1482: {
1483: struct linux_sys_sysinfo_args /* {
1484: syscallarg(struct linux_sysinfo *) sysinfo;
1485: } */ *uap = v;
1486: struct linux_sysinfo si;
1487: struct loadavg *la;
1488: extern int bufpages;
1489: struct timeval tv;
1490:
1491: getmicrouptime(&tv);
1492: si.uptime = tv.tv_sec;
1493: la = &averunnable;
1494: si.loads[0] = la->ldavg[0] * LINUX_SYSINFO_LOADS_SCALE / la->fscale;
1495: si.loads[1] = la->ldavg[1] * LINUX_SYSINFO_LOADS_SCALE / la->fscale;
1496: si.loads[2] = la->ldavg[2] * LINUX_SYSINFO_LOADS_SCALE / la->fscale;
1497: si.totalram = ctob(physmem);
1498: si.freeram = uvmexp.free * uvmexp.pagesize;
1499: si.sharedram = 0;/* XXX */
1500: si.bufferram = bufpages * PAGE_SIZE;
1501: si.totalswap = uvmexp.swpages * PAGE_SIZE;
1502: si.freeswap = (uvmexp.swpages - uvmexp.swpginuse) * PAGE_SIZE;
1503: si.procs = nprocs;
1504: /* The following are only present in newer Linux kernels. */
1505: si.totalbig = 0;
1506: si.freebig = 0;
1507: si.mem_unit = 1;
1508:
1509: return (copyout(&si, SCARG(uap, sysinfo), sizeof(si)));
1510: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to linux_misc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / linux