linux_misc_notalpha.c revision 1.78 1 /* $NetBSD: linux_misc_notalpha.c,v 1.78 2006/05/10 11:05:34 yamt Exp $ */
2
3 /*-
4 * Copyright (c) 1995, 1998 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Frank van der Linden and Eric Haszlakiewicz; by Jason R. Thorpe
9 * of the Numerical Aerospace Simulation Facility, NASA Ames Research Center.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39
40 #include <sys/cdefs.h>
41 __KERNEL_RCSID(0, "$NetBSD: linux_misc_notalpha.c,v 1.78 2006/05/10 11:05:34 yamt Exp $");
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/kernel.h>
46 #include <sys/mman.h>
47 #include <sys/mount.h>
48 #include <sys/malloc.h>
49 #include <sys/mbuf.h>
50 #include <sys/namei.h>
51 #include <sys/proc.h>
52 #include <sys/ptrace.h>
53 #include <sys/resource.h>
54 #include <sys/resourcevar.h>
55 #include <sys/time.h>
56 #include <sys/wait.h>
57
58 #include <sys/sa.h>
59 #include <sys/syscallargs.h>
60
61 #include <compat/linux/common/linux_types.h>
62 #include <compat/linux/common/linux_fcntl.h>
63 #include <compat/linux/common/linux_misc.h>
64 #include <compat/linux/common/linux_mmap.h>
65 #include <compat/linux/common/linux_signal.h>
66 #include <compat/linux/common/linux_util.h>
67
68 #include <compat/linux/linux_syscallargs.h>
69
70 /*
71 * This file contains routines which are used
72 * on every linux architechture except the Alpha.
73 */
74
75 /* Used on: arm, i386, m68k, mips, ppc, sparc, sparc64 */
76 /* Not used on: alpha */
77
78 #ifdef DEBUG_LINUX
79 #define DPRINTF(a) uprintf a
80 #else
81 #define DPRINTF(a)
82 #endif
83
84 #ifndef COMPAT_LINUX32
85 #if !defined(__m68k__)
86 static void bsd_to_linux_statfs64(const struct statvfs *,
87 struct linux_statfs64 *);
88 #endif
89
90 /*
91 * Alarm. This is a libc call which uses setitimer(2) in NetBSD.
92 * Fiddle with the timers to make it work.
93 */
94 int
95 linux_sys_alarm(l, v, retval)
96 struct lwp *l;
97 void *v;
98 register_t *retval;
99 {
100 struct linux_sys_alarm_args /* {
101 syscallarg(unsigned int) secs;
102 } */ *uap = v;
103 struct proc *p = l->l_proc;
104 int s;
105 struct itimerval *itp, it;
106 struct ptimer *ptp;
107
108 if (p->p_timers && p->p_timers->pts_timers[ITIMER_REAL])
109 itp = &p->p_timers->pts_timers[ITIMER_REAL]->pt_time;
110 else
111 itp = NULL;
112 s = splclock();
113 /*
114 * Clear any pending timer alarms.
115 */
116 if (itp) {
117 callout_stop(&p->p_timers->pts_timers[ITIMER_REAL]->pt_ch);
118 timerclear(&itp->it_interval);
119 if (timerisset(&itp->it_value) &&
120 timercmp(&itp->it_value, &time, >))
121 timersub(&itp->it_value, &time, &itp->it_value);
122 /*
123 * Return how many seconds were left (rounded up)
124 */
125 retval[0] = itp->it_value.tv_sec;
126 if (itp->it_value.tv_usec)
127 retval[0]++;
128 } else {
129 retval[0] = 0;
130 }
131
132 /*
133 * alarm(0) just resets the timer.
134 */
135 if (SCARG(uap, secs) == 0) {
136 if (itp)
137 timerclear(&itp->it_value);
138 splx(s);
139 return 0;
140 }
141
142 /*
143 * Check the new alarm time for sanity, and set it.
144 */
145 timerclear(&it.it_interval);
146 it.it_value.tv_sec = SCARG(uap, secs);
147 it.it_value.tv_usec = 0;
148 if (itimerfix(&it.it_value) || itimerfix(&it.it_interval)) {
149 splx(s);
150 return (EINVAL);
151 }
152
153 if (p->p_timers == NULL)
154 timers_alloc(p);
155 ptp = p->p_timers->pts_timers[ITIMER_REAL];
156 if (ptp == NULL) {
157 ptp = pool_get(&ptimer_pool, PR_WAITOK);
158 ptp->pt_ev.sigev_notify = SIGEV_SIGNAL;
159 ptp->pt_ev.sigev_signo = SIGALRM;
160 ptp->pt_overruns = 0;
161 ptp->pt_proc = p;
162 ptp->pt_type = CLOCK_REALTIME;
163 ptp->pt_entry = CLOCK_REALTIME;
164 callout_init(&ptp->pt_ch);
165 p->p_timers->pts_timers[ITIMER_REAL] = ptp;
166 }
167
168 if (timerisset(&it.it_value)) {
169 /*
170 * Don't need to check hzto() return value, here.
171 * callout_reset() does it for us.
172 */
173 timeradd(&it.it_value, &time, &it.it_value);
174 callout_reset(&ptp->pt_ch, hzto(&it.it_value),
175 realtimerexpire, ptp);
176 }
177 ptp->pt_time = it;
178 splx(s);
179
180 return 0;
181 }
182 #endif /* !COMPAT_LINUX32 */
183
184 #if !defined(__amd64__) || defined(COMPAT_LINUX32)
185 int
186 linux_sys_nice(l, v, retval)
187 struct lwp *l;
188 void *v;
189 register_t *retval;
190 {
191 struct linux_sys_nice_args /* {
192 syscallarg(int) incr;
193 } */ *uap = v;
194 struct sys_setpriority_args bsa;
195
196 SCARG(&bsa, which) = PRIO_PROCESS;
197 SCARG(&bsa, who) = 0;
198 SCARG(&bsa, prio) = SCARG(uap, incr);
199 return sys_setpriority(l, &bsa, retval);
200 }
201 #endif /* !__amd64__ || COMPAT_LINUX32 */
202
203 #ifndef COMPAT_LINUX32
204 #ifndef __amd64__
205 /*
206 * The old Linux readdir was only able to read one entry at a time,
207 * even though it had a 'count' argument. In fact, the emulation
208 * of the old call was better than the original, because it did handle
209 * the count arg properly. Don't bother with it anymore now, and use
210 * it to distinguish between old and new. The difference is that the
211 * newer one actually does multiple entries, and the reclen field
212 * really is the reclen, not the namelength.
213 */
214 int
215 linux_sys_readdir(l, v, retval)
216 struct lwp *l;
217 void *v;
218 register_t *retval;
219 {
220 struct linux_sys_readdir_args /* {
221 syscallarg(int) fd;
222 syscallarg(struct linux_dirent *) dent;
223 syscallarg(unsigned int) count;
224 } */ *uap = v;
225
226 SCARG(uap, count) = 1;
227 return linux_sys_getdents(l, uap, retval);
228 }
229 #endif /* !amd64 */
230
231 /*
232 * I wonder why Linux has gettimeofday() _and_ time().. Still, we
233 * need to deal with it.
234 */
235 int
236 linux_sys_time(l, v, retval)
237 struct lwp *l;
238 void *v;
239 register_t *retval;
240 {
241 struct linux_sys_time_args /* {
242 linux_time_t *t;
243 } */ *uap = v;
244 struct timeval atv;
245 linux_time_t tt;
246 int error;
247
248 microtime(&atv);
249
250 tt = atv.tv_sec;
251 if (SCARG(uap, t) && (error = copyout(&tt, SCARG(uap, t), sizeof tt)))
252 return error;
253
254 retval[0] = tt;
255 return 0;
256 }
257
258 /*
259 * utime(). Do conversion to things that utimes() understands,
260 * and pass it on.
261 */
262 int
263 linux_sys_utime(l, v, retval)
264 struct lwp *l;
265 void *v;
266 register_t *retval;
267 {
268 struct linux_sys_utime_args /* {
269 syscallarg(const char *) path;
270 syscallarg(struct linux_utimbuf *)times;
271 } */ *uap = v;
272 struct proc *p = l->l_proc;
273 caddr_t sg;
274 int error;
275 struct sys_utimes_args ua;
276 struct timeval tv[2], *tvp;
277 struct linux_utimbuf lut;
278
279 sg = stackgap_init(p, 0);
280 tvp = (struct timeval *) stackgap_alloc(p, &sg, sizeof(tv));
281 CHECK_ALT_EXIST(l, &sg, SCARG(uap, path));
282
283 SCARG(&ua, path) = SCARG(uap, path);
284
285 if (SCARG(uap, times) != NULL) {
286 if ((error = copyin(SCARG(uap, times), &lut, sizeof lut)))
287 return error;
288 tv[0].tv_usec = tv[1].tv_usec = 0;
289 tv[0].tv_sec = lut.l_actime;
290 tv[1].tv_sec = lut.l_modtime;
291 if ((error = copyout(tv, tvp, sizeof tv)))
292 return error;
293 SCARG(&ua, tptr) = tvp;
294 }
295 else
296 SCARG(&ua, tptr) = NULL;
297
298 return sys_utimes(l, &ua, retval);
299 }
300
301 #ifndef __amd64__
302 /*
303 * waitpid(2). Just forward on to linux_sys_wait4 with a NULL rusage.
304 */
305 int
306 linux_sys_waitpid(l, v, retval)
307 struct lwp *l;
308 void *v;
309 register_t *retval;
310 {
311 struct linux_sys_waitpid_args /* {
312 syscallarg(int) pid;
313 syscallarg(int *) status;
314 syscallarg(int) options;
315 } */ *uap = v;
316 struct linux_sys_wait4_args linux_w4a;
317
318 SCARG(&linux_w4a, pid) = SCARG(uap, pid);
319 SCARG(&linux_w4a, status) = SCARG(uap, status);
320 SCARG(&linux_w4a, options) = SCARG(uap, options);
321 SCARG(&linux_w4a, rusage) = NULL;
322
323 return linux_sys_wait4(l, &linux_w4a, retval);
324 }
325 #endif /* !amd64 */
326
327 int
328 linux_sys_setresgid(l, v, retval)
329 struct lwp *l;
330 void *v;
331 register_t *retval;
332 {
333 struct linux_sys_setresgid_args /* {
334 syscallarg(gid_t) rgid;
335 syscallarg(gid_t) egid;
336 syscallarg(gid_t) sgid;
337 } */ *uap = v;
338
339 /*
340 * Note: These checks are a little different than the NetBSD
341 * setregid(2) call performs. This precisely follows the
342 * behavior of the Linux kernel.
343 */
344 return do_setresgid(l, SCARG(uap,rgid), SCARG(uap, egid),
345 SCARG(uap, sgid),
346 ID_R_EQ_R | ID_R_EQ_E | ID_R_EQ_S |
347 ID_E_EQ_R | ID_E_EQ_E | ID_E_EQ_S |
348 ID_S_EQ_R | ID_S_EQ_E | ID_S_EQ_S );
349 }
350
351 int
352 linux_sys_getresgid(l, v, retval)
353 struct lwp *l;
354 void *v;
355 register_t *retval;
356 {
357 struct linux_sys_getresgid_args /* {
358 syscallarg(gid_t *) rgid;
359 syscallarg(gid_t *) egid;
360 syscallarg(gid_t *) sgid;
361 } */ *uap = v;
362 struct proc *p = l->l_proc;
363 struct pcred *pc = p->p_cred;
364 int error;
365
366 /*
367 * Linux copies these values out to userspace like so:
368 *
369 * 1. Copy out rgid.
370 * 2. If that succeeds, copy out egid.
371 * 3. If both of those succeed, copy out sgid.
372 */
373 if ((error = copyout(&pc->p_rgid, SCARG(uap, rgid),
374 sizeof(gid_t))) != 0)
375 return (error);
376
377 if ((error = copyout(&pc->pc_ucred->cr_gid, SCARG(uap, egid),
378 sizeof(gid_t))) != 0)
379 return (error);
380
381 return (copyout(&pc->p_svgid, SCARG(uap, sgid), sizeof(gid_t)));
382 }
383
384 #ifndef __amd64__
385 /*
386 * I wonder why Linux has settimeofday() _and_ stime().. Still, we
387 * need to deal with it.
388 */
389 int
390 linux_sys_stime(l, v, retval)
391 struct lwp *l;
392 void *v;
393 register_t *retval;
394 {
395 struct linux_sys_time_args /* {
396 linux_time_t *t;
397 } */ *uap = v;
398 struct proc *p = l->l_proc;
399 struct timespec ats;
400 linux_time_t tt;
401 int error;
402
403 if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
404 return (error);
405
406 if ((error = copyin(&tt, SCARG(uap, t), sizeof tt)) != 0)
407 return error;
408
409 ats.tv_sec = tt;
410 ats.tv_nsec = 0;
411
412 if ((error = settime(p, &ats)))
413 return (error);
414
415 return 0;
416 }
417 #endif /* !amd64 */
418
419 #if !defined(__m68k__)
420 /*
421 * Convert NetBSD statvfs structure to Linux statfs64 structure.
422 * See comments in bsd_to_linux_statfs() for further background.
423 * We can safely pass correct bsize and frsize here, since Linux glibc
424 * statvfs() doesn't use statfs64().
425 */
426 static void
427 bsd_to_linux_statfs64(bsp, lsp)
428 const struct statvfs *bsp;
429 struct linux_statfs64 *lsp;
430 {
431 int i, div;
432
433 for (i = 0; i < linux_fstypes_cnt; i++) {
434 if (strcmp(bsp->f_fstypename, linux_fstypes[i].bsd) == 0) {
435 lsp->l_ftype = linux_fstypes[i].linux;
436 break;
437 }
438 }
439
440 if (i == linux_fstypes_cnt) {
441 DPRINTF(("unhandled fstype in linux emulation: %s\n",
442 bsp->f_fstypename));
443 lsp->l_ftype = LINUX_DEFAULT_SUPER_MAGIC;
444 }
445
446 div = bsp->f_bsize / bsp->f_frsize;
447 lsp->l_fbsize = bsp->f_bsize;
448 lsp->l_ffrsize = bsp->f_frsize;
449 lsp->l_fblocks = bsp->f_blocks / div;
450 lsp->l_fbfree = bsp->f_bfree / div;
451 lsp->l_fbavail = bsp->f_bavail / div;
452 lsp->l_ffiles = bsp->f_files;
453 lsp->l_fffree = bsp->f_ffree / div;
454 /* Linux sets the fsid to 0..., we don't */
455 lsp->l_ffsid.val[0] = bsp->f_fsidx.__fsid_val[0];
456 lsp->l_ffsid.val[1] = bsp->f_fsidx.__fsid_val[1];
457 lsp->l_fnamelen = bsp->f_namemax;
458 (void)memset(lsp->l_fspare, 0, sizeof(lsp->l_fspare));
459 }
460
461 /*
462 * Implement the fs stat functions. Straightforward.
463 */
464 int
465 linux_sys_statfs64(l, v, retval)
466 struct lwp *l;
467 void *v;
468 register_t *retval;
469 {
470 struct linux_sys_statfs64_args /* {
471 syscallarg(const char *) path;
472 syscallarg(size_t) sz;
473 syscallarg(struct linux_statfs64 *) sp;
474 } */ *uap = v;
475 struct proc *p = l->l_proc;
476 struct statvfs *btmp, *bsp;
477 struct linux_statfs64 ltmp;
478 struct sys_statvfs1_args bsa;
479 caddr_t sg;
480 int error;
481
482 if (SCARG(uap, sz) != sizeof ltmp)
483 return (EINVAL);
484
485 sg = stackgap_init(p, 0);
486 bsp = stackgap_alloc(p, &sg, sizeof (struct statvfs));
487
488 CHECK_ALT_EXIST(l, &sg, SCARG(uap, path));
489
490 SCARG(&bsa, path) = SCARG(uap, path);
491 SCARG(&bsa, buf) = bsp;
492 SCARG(&bsa, flags) = ST_WAIT;
493
494 if ((error = sys_statvfs1(l, &bsa, retval)))
495 return error;
496
497 btmp = STATVFSBUF_GET();
498 error = copyin(bsp, btmp, sizeof(*btmp));
499 if (error) {
500 goto out;
501 }
502 bsd_to_linux_statfs64(btmp, <mp);
503 error = copyout(<mp, SCARG(uap, sp), sizeof ltmp);
504 out:
505 STATVFSBUF_PUT(btmp);
506 return error;
507 }
508
509 int
510 linux_sys_fstatfs64(l, v, retval)
511 struct lwp *l;
512 void *v;
513 register_t *retval;
514 {
515 struct linux_sys_fstatfs64_args /* {
516 syscallarg(int) fd;
517 syscallarg(size_t) sz;
518 syscallarg(struct linux_statfs64 *) sp;
519 } */ *uap = v;
520 struct proc *p = l->l_proc;
521 struct statvfs *btmp, *bsp;
522 struct linux_statfs64 ltmp;
523 struct sys_fstatvfs1_args bsa;
524 caddr_t sg;
525 int error;
526
527 if (SCARG(uap, sz) != sizeof ltmp)
528 return (EINVAL);
529
530 sg = stackgap_init(p, 0);
531 bsp = stackgap_alloc(p, &sg, sizeof (struct statvfs));
532
533 SCARG(&bsa, fd) = SCARG(uap, fd);
534 SCARG(&bsa, buf) = bsp;
535 SCARG(&bsa, flags) = ST_WAIT;
536
537 if ((error = sys_fstatvfs1(l, &bsa, retval)))
538 return error;
539
540 btmp = STATVFSBUF_GET();
541 error = copyin(bsp, btmp, sizeof(*btmp));
542 if (error) {
543 goto out;
544 }
545 bsd_to_linux_statfs64(btmp, <mp);
546 error = copyout(<mp, SCARG(uap, sp), sizeof ltmp);
547 out:
548 STATVFSBUF_PUT(btmp);
549 return error;
550 }
551 #endif /* !__m68k__ */
552 #endif /* !COMPAT_LINUX32 */
553