1 /* $NetBSD: linux_misc_notalpha.c,v 1.64 2003/01/18 08:02:54 thorpej 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.64 2003/01/18 08:02:54 thorpej 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 /* 79 * Alarm. This is a libc call which uses setitimer(2) in NetBSD. 80 * Fiddle with the timers to make it work. 81 */ 82 int 83 linux_sys_alarm(l, v, retval) 84 struct lwp *l; 85 void *v; 86 register_t *retval; 87 { 88 struct linux_sys_alarm_args /* { 89 syscallarg(unsigned int) secs; 90 } */ *uap = v; 91 struct proc *p = l->l_proc; 92 int s; 93 struct itimerval *itp, it; 94 struct ptimer *ptp; 95 96 if (p->p_timers && p->p_timers->pts_timers[ITIMER_REAL]) 97 itp = &p->p_timers->pts_timers[ITIMER_REAL]->pt_time; 98 else 99 itp = NULL; 100 s = splclock(); 101 /* 102 * Clear any pending timer alarms. 103 */ 104 if (itp) { 105 callout_stop(&p->p_timers->pts_timers[ITIMER_REAL]->pt_ch); 106 timerclear(&itp->it_interval); 107 if (timerisset(&itp->it_value) && 108 timercmp(&itp->it_value, &time, >)) 109 timersub(&itp->it_value, &time, &itp->it_value); 110 /* 111 * Return how many seconds were left (rounded up) 112 */ 113 retval[0] = itp->it_value.tv_sec; 114 if (itp->it_value.tv_usec) 115 retval[0]++; 116 } else { 117 retval[0] = 0; 118 } 119 120 /* 121 * alarm(0) just resets the timer. 122 */ 123 if (SCARG(uap, secs) == 0) { 124 if (itp) 125 timerclear(&itp->it_value); 126 splx(s); 127 return 0; 128 } 129 130 /* 131 * Check the new alarm time for sanity, and set it. 132 */ 133 timerclear(&it.it_interval); 134 it.it_value.tv_sec = SCARG(uap, secs); 135 it.it_value.tv_usec = 0; 136 if (itimerfix(&it.it_value) || itimerfix(&it.it_interval)) { 137 splx(s); 138 return (EINVAL); 139 } 140 141 if (p->p_timers == NULL) 142 timers_alloc(p); 143 ptp = p->p_timers->pts_timers[ITIMER_REAL]; 144 if (ptp == NULL) { 145 ptp = pool_get(&ptimer_pool, PR_WAITOK); 146 ptp->pt_ev.sigev_notify = SIGEV_SIGNAL; 147 ptp->pt_ev.sigev_signo = SIGALRM; 148 ptp->pt_type = CLOCK_REALTIME; 149 callout_init(&ptp->pt_ch); 150 } 151 152 if (timerisset(&it.it_value)) { 153 /* 154 * Don't need to check hzto() return value, here. 155 * callout_reset() does it for us. 156 */ 157 timeradd(&it.it_value, &time, &it.it_value); 158 callout_reset(&ptp->pt_ch, hzto(&it.it_value), 159 realtimerexpire, ptp); 160 } 161 ptp->pt_time = it; 162 splx(s); 163 164 return 0; 165 } 166 167 int 168 linux_sys_nice(l, v, retval) 169 struct lwp *l; 170 void *v; 171 register_t *retval; 172 { 173 struct linux_sys_nice_args /* { 174 syscallarg(int) incr; 175 } */ *uap = v; 176 struct sys_setpriority_args bsa; 177 178 SCARG(&bsa, which) = PRIO_PROCESS; 179 SCARG(&bsa, who) = 0; 180 SCARG(&bsa, prio) = SCARG(uap, incr); 181 return sys_setpriority(l, &bsa, retval); 182 } 183 184 /* 185 * The old Linux readdir was only able to read one entry at a time, 186 * even though it had a 'count' argument. In fact, the emulation 187 * of the old call was better than the original, because it did handle 188 * the count arg properly. Don't bother with it anymore now, and use 189 * it to distinguish between old and new. The difference is that the 190 * newer one actually does multiple entries, and the reclen field 191 * really is the reclen, not the namelength. 192 */ 193 int 194 linux_sys_readdir(l, v, retval) 195 struct lwp *l; 196 void *v; 197 register_t *retval; 198 { 199 struct linux_sys_readdir_args /* { 200 syscallarg(int) fd; 201 syscallarg(struct linux_dirent *) dent; 202 syscallarg(unsigned int) count; 203 } */ *uap = v; 204 205 SCARG(uap, count) = 1; 206 return linux_sys_getdents(l, uap, retval); 207 } 208 209 /* 210 * I wonder why Linux has gettimeofday() _and_ time().. Still, we 211 * need to deal with it. 212 */ 213 int 214 linux_sys_time(l, v, retval) 215 struct lwp *l; 216 void *v; 217 register_t *retval; 218 { 219 struct linux_sys_time_args /* { 220 linux_time_t *t; 221 } */ *uap = v; 222 struct timeval atv; 223 linux_time_t tt; 224 int error; 225 226 microtime(&atv); 227 228 tt = atv.tv_sec; 229 if (SCARG(uap, t) && (error = copyout(&tt, SCARG(uap, t), sizeof tt))) 230 return error; 231 232 retval[0] = tt; 233 return 0; 234 } 235 236 /* 237 * utime(). Do conversion to things that utimes() understands, 238 * and pass it on. 239 */ 240 int 241 linux_sys_utime(l, v, retval) 242 struct lwp *l; 243 void *v; 244 register_t *retval; 245 { 246 struct linux_sys_utime_args /* { 247 syscallarg(const char *) path; 248 syscallarg(struct linux_utimbuf *)times; 249 } */ *uap = v; 250 struct proc *p = l->l_proc; 251 caddr_t sg; 252 int error; 253 struct sys_utimes_args ua; 254 struct timeval tv[2], *tvp; 255 struct linux_utimbuf lut; 256 257 sg = stackgap_init(p, 0); 258 tvp = (struct timeval *) stackgap_alloc(p, &sg, sizeof(tv)); 259 CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); 260 261 SCARG(&ua, path) = SCARG(uap, path); 262 263 if (SCARG(uap, times) != NULL) { 264 if ((error = copyin(SCARG(uap, times), &lut, sizeof lut))) 265 return error; 266 tv[0].tv_usec = tv[1].tv_usec = 0; 267 tv[0].tv_sec = lut.l_actime; 268 tv[1].tv_sec = lut.l_modtime; 269 if ((error = copyout(tv, tvp, sizeof tv))) 270 return error; 271 SCARG(&ua, tptr) = tvp; 272 } 273 else 274 SCARG(&ua, tptr) = NULL; 275 276 return sys_utimes(l, &ua, retval); 277 } 278 279 /* 280 * waitpid(2). Passed on to the NetBSD call, surrounded by code to 281 * reserve some space for a NetBSD-style wait status, and converting 282 * it to what Linux wants. 283 */ 284 int 285 linux_sys_waitpid(l, v, retval) 286 struct lwp *l; 287 void *v; 288 register_t *retval; 289 { 290 struct linux_sys_waitpid_args /* { 291 syscallarg(int) pid; 292 syscallarg(int *) status; 293 syscallarg(int) options; 294 } */ *uap = v; 295 struct proc *p = l->l_proc; 296 struct sys_wait4_args w4a; 297 int error, *status, tstat; 298 caddr_t sg; 299 300 if (SCARG(uap, status) != NULL) { 301 sg = stackgap_init(p, 0); 302 status = (int *) stackgap_alloc(p, &sg, sizeof status); 303 } else 304 status = NULL; 305 306 SCARG(&w4a, pid) = SCARG(uap, pid); 307 SCARG(&w4a, status) = status; 308 SCARG(&w4a, options) = SCARG(uap, options); 309 SCARG(&w4a, rusage) = NULL; 310 311 if ((error = sys_wait4(l, &w4a, retval))) 312 return error; 313 314 sigdelset(&p->p_sigctx.ps_siglist, SIGCHLD); 315 316 if (status != NULL) { 317 if ((error = copyin(status, &tstat, sizeof tstat))) 318 return error; 319 320 bsd_to_linux_wstat(&tstat); 321 return copyout(&tstat, SCARG(uap, status), sizeof tstat); 322 } 323 324 return 0; 325 } 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 struct proc *p = l->l_proc; 339 struct pcred *pc = p->p_cred; 340 gid_t rgid, egid, sgid; 341 int error; 342 343 rgid = SCARG(uap, rgid); 344 egid = SCARG(uap, egid); 345 sgid = SCARG(uap, sgid); 346 347 /* 348 * Note: These checks are a little different than the NetBSD 349 * setregid(2) call performs. This precisely follows the 350 * behavior of the Linux kernel. 351 */ 352 if (rgid != (gid_t)-1 && 353 rgid != pc->p_rgid && 354 rgid != pc->pc_ucred->cr_gid && 355 rgid != pc->p_svgid && 356 (error = suser(pc->pc_ucred, &p->p_acflag))) 357 return (error); 358 359 if (egid != (gid_t)-1 && 360 egid != pc->p_rgid && 361 egid != pc->pc_ucred->cr_gid && 362 egid != pc->p_svgid && 363 (error = suser(pc->pc_ucred, &p->p_acflag))) 364 return (error); 365 366 if (sgid != (gid_t)-1 && 367 sgid != pc->p_rgid && 368 sgid != pc->pc_ucred->cr_gid && 369 sgid != pc->p_svgid && 370 (error = suser(pc->pc_ucred, &p->p_acflag))) 371 return (error); 372 373 /* 374 * Now assign the real, effective, and saved GIDs. 375 * Note that Linux, unlike NetBSD in setregid(2), does not 376 * set the saved UID in this call unless the user specifies 377 * it. 378 */ 379 if (rgid != (gid_t)-1) 380 pc->p_rgid = rgid; 381 382 if (egid != (gid_t)-1) { 383 pc->pc_ucred = crcopy(pc->pc_ucred); 384 pc->pc_ucred->cr_gid = egid; 385 } 386 387 if (sgid != (gid_t)-1) 388 pc->p_svgid = sgid; 389 390 if (rgid != (gid_t)-1 && egid != (gid_t)-1 && sgid != (gid_t)-1) 391 p->p_flag |= P_SUGID; 392 return (0); 393 } 394 395 int 396 linux_sys_getresgid(l, v, retval) 397 struct lwp *l; 398 void *v; 399 register_t *retval; 400 { 401 struct linux_sys_getresgid_args /* { 402 syscallarg(gid_t *) rgid; 403 syscallarg(gid_t *) egid; 404 syscallarg(gid_t *) sgid; 405 } */ *uap = v; 406 struct proc *p = l->l_proc; 407 struct pcred *pc = p->p_cred; 408 int error; 409 410 /* 411 * Linux copies these values out to userspace like so: 412 * 413 * 1. Copy out rgid. 414 * 2. If that succeeds, copy out egid. 415 * 3. If both of those succeed, copy out sgid. 416 */ 417 if ((error = copyout(&pc->p_rgid, SCARG(uap, rgid), 418 sizeof(gid_t))) != 0) 419 return (error); 420 421 if ((error = copyout(&pc->pc_ucred->cr_gid, SCARG(uap, egid), 422 sizeof(gid_t))) != 0) 423 return (error); 424 425 return (copyout(&pc->p_svgid, SCARG(uap, sgid), sizeof(gid_t))); 426 } 427 428 /* 429 * I wonder why Linux has settimeofday() _and_ stime().. Still, we 430 * need to deal with it. 431 */ 432 int 433 linux_sys_stime(l, v, retval) 434 struct lwp *l; 435 void *v; 436 register_t *retval; 437 { 438 struct linux_sys_time_args /* { 439 linux_time_t *t; 440 } */ *uap = v; 441 struct proc *p = l->l_proc; 442 struct timeval atv; 443 linux_time_t tt; 444 int error; 445 446 if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) 447 return (error); 448 449 if ((error = copyin(&tt, SCARG(uap, t), sizeof tt)) != 0) 450 return error; 451 452 atv.tv_sec = tt; 453 atv.tv_usec = 0; 454 455 if ((error = settime(&atv))) 456 return (error); 457 458 return 0; 459 } 460