1/*- 2 * Copyright (c) 2004 Tim J. Robbins 3 * Copyright (c) 2002 Doug Rabson 4 * Copyright (c) 2000 Marcel Moolenaar 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer 12 * in this position and unchanged. 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. The name of the author may not be used to endorse or promote products 17 * derived from this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31#include <sys/cdefs.h> 32__FBSDID("$FreeBSD$"); 33 34#include <sys/param.h> 35#include <sys/kernel.h> 36#include <sys/systm.h> 37#include <sys/capability.h> 38#include <sys/file.h> 39#include <sys/fcntl.h> 40#include <sys/clock.h> 41#include <sys/imgact.h> 42#include <sys/limits.h> 43#include <sys/lock.h> 44#include <sys/malloc.h> 45#include <sys/mman.h> 46#include <sys/mutex.h> 47#include <sys/priv.h> 48#include <sys/proc.h> 49#include <sys/resource.h> 50#include <sys/resourcevar.h> 51#include <sys/sched.h> 52#include <sys/syscallsubr.h> 53#include <sys/sysproto.h> 54#include <sys/unistd.h> 55#include <sys/wait.h> 56 57#include <machine/frame.h> 58#include <machine/pcb.h> 59#include <machine/psl.h> 60#include <machine/segments.h> 61#include <machine/specialreg.h> 62 63#include <vm/vm.h> 64#include <vm/pmap.h> 65#include <vm/vm_map.h> 66 67#include <compat/freebsd32/freebsd32_util.h> 68#include <amd64/linux32/linux.h> 69#include <amd64/linux32/linux32_proto.h> 70#include <compat/linux/linux_ipc.h> 71#include <compat/linux/linux_misc.h> 72#include <compat/linux/linux_signal.h> 73#include <compat/linux/linux_util.h> 74#include <compat/linux/linux_emul.h> 75 76struct l_old_select_argv { 77 l_int nfds; 78 l_uintptr_t readfds; 79 l_uintptr_t writefds; 80 l_uintptr_t exceptfds; 81 l_uintptr_t timeout; 82} __packed; 83 84int 85linux_to_bsd_sigaltstack(int lsa) 86{ 87 int bsa = 0; 88 89 if (lsa & LINUX_SS_DISABLE) 90 bsa |= SS_DISABLE; 91 if (lsa & LINUX_SS_ONSTACK) 92 bsa |= SS_ONSTACK; 93 return (bsa); 94} 95 96static int linux_mmap_common(struct thread *td, l_uintptr_t addr, 97 l_size_t len, l_int prot, l_int flags, l_int fd, 98 l_loff_t pos); 99 100int 101bsd_to_linux_sigaltstack(int bsa) 102{ 103 int lsa = 0; 104 105 if (bsa & SS_DISABLE) 106 lsa |= LINUX_SS_DISABLE; 107 if (bsa & SS_ONSTACK) 108 lsa |= LINUX_SS_ONSTACK; 109 return (lsa); 110} 111 112static void 113bsd_to_linux_rusage(struct rusage *ru, struct l_rusage *lru) 114{ 115 116 lru->ru_utime.tv_sec = ru->ru_utime.tv_sec; 117 lru->ru_utime.tv_usec = ru->ru_utime.tv_usec; 118 lru->ru_stime.tv_sec = ru->ru_stime.tv_sec; 119 lru->ru_stime.tv_usec = ru->ru_stime.tv_usec; 120 lru->ru_maxrss = ru->ru_maxrss; 121 lru->ru_ixrss = ru->ru_ixrss; 122 lru->ru_idrss = ru->ru_idrss; 123 lru->ru_isrss = ru->ru_isrss; 124 lru->ru_minflt = ru->ru_minflt; 125 lru->ru_majflt = ru->ru_majflt; 126 lru->ru_nswap = ru->ru_nswap; 127 lru->ru_inblock = ru->ru_inblock; 128 lru->ru_oublock = ru->ru_oublock; 129 lru->ru_msgsnd = ru->ru_msgsnd; 130 lru->ru_msgrcv = ru->ru_msgrcv; 131 lru->ru_nsignals = ru->ru_nsignals; 132 lru->ru_nvcsw = ru->ru_nvcsw; 133 lru->ru_nivcsw = ru->ru_nivcsw; 134} 135 136int 137linux_execve(struct thread *td, struct linux_execve_args *args) 138{ 139 struct image_args eargs; 140 char *path; 141 int error; 142 143 LCONVPATHEXIST(td, args->path, &path); 144 145#ifdef DEBUG 146 if (ldebug(execve)) 147 printf(ARGS(execve, "%s"), path); 148#endif 149 150 error = freebsd32_exec_copyin_args(&eargs, path, UIO_SYSSPACE, 151 args->argp, args->envp); 152 free(path, M_TEMP); 153 if (error == 0) 154 error = kern_execve(td, &eargs, NULL); 155 if (error == 0) 156 /* Linux process can execute FreeBSD one, do not attempt 157 * to create emuldata for such process using 158 * linux_proc_init, this leads to a panic on KASSERT 159 * because such process has p->p_emuldata == NULL. 160 */ 161 if (SV_PROC_ABI(td->td_proc) == SV_ABI_LINUX) 162 error = linux_proc_init(td, 0, 0); 163 return (error); 164} 165 166CTASSERT(sizeof(struct l_iovec32) == 8); 167 168static int 169linux32_copyinuio(struct l_iovec32 *iovp, l_ulong iovcnt, struct uio **uiop) 170{ 171 struct l_iovec32 iov32; 172 struct iovec *iov; 173 struct uio *uio; 174 uint32_t iovlen; 175 int error, i; 176 177 *uiop = NULL; 178 if (iovcnt > UIO_MAXIOV) 179 return (EINVAL); 180 iovlen = iovcnt * sizeof(struct iovec); 181 uio = malloc(iovlen + sizeof(*uio), M_IOV, M_WAITOK); 182 iov = (struct iovec *)(uio + 1); 183 for (i = 0; i < iovcnt; i++) { 184 error = copyin(&iovp[i], &iov32, sizeof(struct l_iovec32)); 185 if (error) { 186 free(uio, M_IOV); 187 return (error); 188 } 189 iov[i].iov_base = PTRIN(iov32.iov_base); 190 iov[i].iov_len = iov32.iov_len; 191 } 192 uio->uio_iov = iov; 193 uio->uio_iovcnt = iovcnt; 194 uio->uio_segflg = UIO_USERSPACE; 195 uio->uio_offset = -1; 196 uio->uio_resid = 0; 197 for (i = 0; i < iovcnt; i++) { 198 if (iov->iov_len > INT_MAX - uio->uio_resid) { 199 free(uio, M_IOV); 200 return (EINVAL); 201 } 202 uio->uio_resid += iov->iov_len; 203 iov++; 204 } 205 *uiop = uio; 206 return (0); 207} 208 209int 210linux32_copyiniov(struct l_iovec32 *iovp32, l_ulong iovcnt, struct iovec **iovp, 211 int error) 212{ 213 struct l_iovec32 iov32; 214 struct iovec *iov; 215 uint32_t iovlen; 216 int i; 217 218 *iovp = NULL; 219 if (iovcnt > UIO_MAXIOV) 220 return (error); 221 iovlen = iovcnt * sizeof(struct iovec); 222 iov = malloc(iovlen, M_IOV, M_WAITOK); 223 for (i = 0; i < iovcnt; i++) { 224 error = copyin(&iovp32[i], &iov32, sizeof(struct l_iovec32)); 225 if (error) { 226 free(iov, M_IOV); 227 return (error); 228 } 229 iov[i].iov_base = PTRIN(iov32.iov_base); 230 iov[i].iov_len = iov32.iov_len; 231 } 232 *iovp = iov; 233 return(0); 234 235} 236 237int 238linux_readv(struct thread *td, struct linux_readv_args *uap) 239{ 240 struct uio *auio; 241 int error; 242 243 error = linux32_copyinuio(uap->iovp, uap->iovcnt, &auio); 244 if (error) 245 return (error); 246 error = kern_readv(td, uap->fd, auio); 247 free(auio, M_IOV); 248 return (error); 249} 250 251int 252linux_writev(struct thread *td, struct linux_writev_args *uap) 253{ 254 struct uio *auio; 255 int error; 256 257 error = linux32_copyinuio(uap->iovp, uap->iovcnt, &auio); 258 if (error) 259 return (error); 260 error = kern_writev(td, uap->fd, auio); 261 free(auio, M_IOV); 262 return (error); 263} 264 265struct l_ipc_kludge { 266 l_uintptr_t msgp; 267 l_long msgtyp; 268} __packed; 269 270int 271linux_ipc(struct thread *td, struct linux_ipc_args *args) 272{ 273 274 switch (args->what & 0xFFFF) { 275 case LINUX_SEMOP: { 276 struct linux_semop_args a; 277 278 a.semid = args->arg1; 279 a.tsops = args->ptr; 280 a.nsops = args->arg2; 281 return (linux_semop(td, &a)); 282 } 283 case LINUX_SEMGET: { 284 struct linux_semget_args a; 285 286 a.key = args->arg1; 287 a.nsems = args->arg2; 288 a.semflg = args->arg3; 289 return (linux_semget(td, &a)); 290 } 291 case LINUX_SEMCTL: { 292 struct linux_semctl_args a; 293 int error; 294 295 a.semid = args->arg1; 296 a.semnum = args->arg2; 297 a.cmd = args->arg3; 298 error = copyin(args->ptr, &a.arg, sizeof(a.arg)); 299 if (error) 300 return (error); 301 return (linux_semctl(td, &a)); 302 } 303 case LINUX_MSGSND: { 304 struct linux_msgsnd_args a; 305 306 a.msqid = args->arg1; 307 a.msgp = args->ptr; 308 a.msgsz = args->arg2; 309 a.msgflg = args->arg3; 310 return (linux_msgsnd(td, &a)); 311 } 312 case LINUX_MSGRCV: { 313 struct linux_msgrcv_args a; 314 315 a.msqid = args->arg1; 316 a.msgsz = args->arg2; 317 a.msgflg = args->arg3; 318 if ((args->what >> 16) == 0) { 319 struct l_ipc_kludge tmp; 320 int error; 321 322 if (args->ptr == 0) 323 return (EINVAL); 324 error = copyin(args->ptr, &tmp, sizeof(tmp)); 325 if (error) 326 return (error); 327 a.msgp = PTRIN(tmp.msgp); 328 a.msgtyp = tmp.msgtyp; 329 } else { 330 a.msgp = args->ptr; 331 a.msgtyp = args->arg5; 332 } 333 return (linux_msgrcv(td, &a)); 334 } 335 case LINUX_MSGGET: { 336 struct linux_msgget_args a; 337 338 a.key = args->arg1; 339 a.msgflg = args->arg2; 340 return (linux_msgget(td, &a)); 341 } 342 case LINUX_MSGCTL: { 343 struct linux_msgctl_args a; 344 345 a.msqid = args->arg1; 346 a.cmd = args->arg2; 347 a.buf = args->ptr; 348 return (linux_msgctl(td, &a)); 349 } 350 case LINUX_SHMAT: { 351 struct linux_shmat_args a; 352 353 a.shmid = args->arg1; 354 a.shmaddr = args->ptr; 355 a.shmflg = args->arg2; 356 a.raddr = PTRIN((l_uint)args->arg3); 357 return (linux_shmat(td, &a)); 358 } 359 case LINUX_SHMDT: { 360 struct linux_shmdt_args a; 361 362 a.shmaddr = args->ptr; 363 return (linux_shmdt(td, &a)); 364 } 365 case LINUX_SHMGET: { 366 struct linux_shmget_args a; 367 368 a.key = args->arg1; 369 a.size = args->arg2; 370 a.shmflg = args->arg3; 371 return (linux_shmget(td, &a)); 372 } 373 case LINUX_SHMCTL: { 374 struct linux_shmctl_args a; 375 376 a.shmid = args->arg1; 377 a.cmd = args->arg2; 378 a.buf = args->ptr; 379 return (linux_shmctl(td, &a)); 380 } 381 default: 382 break; 383 } 384 385 return (EINVAL); 386} 387 388int 389linux_old_select(struct thread *td, struct linux_old_select_args *args) 390{ 391 struct l_old_select_argv linux_args; 392 struct linux_select_args newsel; 393 int error; 394 395#ifdef DEBUG 396 if (ldebug(old_select)) 397 printf(ARGS(old_select, "%p"), args->ptr); 398#endif 399 400 error = copyin(args->ptr, &linux_args, sizeof(linux_args)); 401 if (error) 402 return (error); 403 404 newsel.nfds = linux_args.nfds; 405 newsel.readfds = PTRIN(linux_args.readfds); 406 newsel.writefds = PTRIN(linux_args.writefds); 407 newsel.exceptfds = PTRIN(linux_args.exceptfds); 408 newsel.timeout = PTRIN(linux_args.timeout); 409 return (linux_select(td, &newsel)); 410} 411 412int 413linux_set_cloned_tls(struct thread *td, void *desc) 414{ 415 struct user_segment_descriptor sd; 416 struct l_user_desc info; 417 struct pcb *pcb; 418 int error; 419 int a[2]; 420 421 error = copyin(desc, &info, sizeof(struct l_user_desc)); 422 if (error) { 423 printf(LMSG("copyin failed!")); 424 } else { 425 /* We might copy out the entry_number as GUGS32_SEL. */ 426 info.entry_number = GUGS32_SEL; 427 error = copyout(&info, desc, sizeof(struct l_user_desc)); 428 if (error) 429 printf(LMSG("copyout failed!")); 430 431 a[0] = LINUX_LDT_entry_a(&info); 432 a[1] = LINUX_LDT_entry_b(&info); 433 434 memcpy(&sd, &a, sizeof(a)); 435#ifdef DEBUG 436 if (ldebug(clone)) 437 printf("Segment created in clone with " 438 "CLONE_SETTLS: lobase: %x, hibase: %x, " 439 "lolimit: %x, hilimit: %x, type: %i, " 440 "dpl: %i, p: %i, xx: %i, long: %i, " 441 "def32: %i, gran: %i\n", sd.sd_lobase, 442 sd.sd_hibase, sd.sd_lolimit, sd.sd_hilimit, 443 sd.sd_type, sd.sd_dpl, sd.sd_p, sd.sd_xx, 444 sd.sd_long, sd.sd_def32, sd.sd_gran); 445#endif 446 pcb = td->td_pcb; 447 pcb->pcb_gsbase = (register_t)info.base_addr; 448/* XXXKIB pcb->pcb_gs32sd = sd; */ 449 td->td_frame->tf_gs = GSEL(GUGS32_SEL, SEL_UPL); 450 set_pcb_flags(pcb, PCB_32BIT); 451 } 452 453 return (error); 454} 455 456int 457linux_set_upcall_kse(struct thread *td, register_t stack) 458{ 459 460 td->td_frame->tf_rsp = stack; 461 462 return (0); 463} 464 465#define STACK_SIZE (2 * 1024 * 1024) 466#define GUARD_SIZE (4 * PAGE_SIZE) 467 468int 469linux_mmap2(struct thread *td, struct linux_mmap2_args *args) 470{ 471 472#ifdef DEBUG 473 if (ldebug(mmap2)) 474 printf(ARGS(mmap2, "0x%08x, %d, %d, 0x%08x, %d, %d"), 475 args->addr, args->len, args->prot, 476 args->flags, args->fd, args->pgoff); 477#endif 478 479 return (linux_mmap_common(td, PTROUT(args->addr), args->len, args->prot, 480 args->flags, args->fd, (uint64_t)(uint32_t)args->pgoff * 481 PAGE_SIZE)); 482} 483 484int 485linux_mmap(struct thread *td, struct linux_mmap_args *args) 486{ 487 int error; 488 struct l_mmap_argv linux_args; 489 490 error = copyin(args->ptr, &linux_args, sizeof(linux_args)); 491 if (error) 492 return (error); 493 494#ifdef DEBUG 495 if (ldebug(mmap)) 496 printf(ARGS(mmap, "0x%08x, %d, %d, 0x%08x, %d, %d"), 497 linux_args.addr, linux_args.len, linux_args.prot, 498 linux_args.flags, linux_args.fd, linux_args.pgoff); 499#endif 500 501 return (linux_mmap_common(td, linux_args.addr, linux_args.len, 502 linux_args.prot, linux_args.flags, linux_args.fd, 503 (uint32_t)linux_args.pgoff)); 504} 505 506static int 507linux_mmap_common(struct thread *td, l_uintptr_t addr, l_size_t len, l_int prot, 508 l_int flags, l_int fd, l_loff_t pos) 509{ 510 struct proc *p = td->td_proc; 511 struct mmap_args /* { 512 caddr_t addr; 513 size_t len; 514 int prot; 515 int flags; 516 int fd; 517 long pad; 518 off_t pos; 519 } */ bsd_args; 520 int error; 521 struct file *fp; 522 523 error = 0; 524 bsd_args.flags = 0; 525 fp = NULL; 526 527 /* 528 * Linux mmap(2): 529 * You must specify exactly one of MAP_SHARED and MAP_PRIVATE 530 */ 531 if (!((flags & LINUX_MAP_SHARED) ^ (flags & LINUX_MAP_PRIVATE))) 532 return (EINVAL); 533 534 if (flags & LINUX_MAP_SHARED) 535 bsd_args.flags |= MAP_SHARED; 536 if (flags & LINUX_MAP_PRIVATE) 537 bsd_args.flags |= MAP_PRIVATE; 538 if (flags & LINUX_MAP_FIXED) 539 bsd_args.flags |= MAP_FIXED; 540 if (flags & LINUX_MAP_ANON) { 541 /* Enforce pos to be on page boundary, then ignore. */ 542 if ((pos & PAGE_MASK) != 0) 543 return (EINVAL); 544 pos = 0; 545 bsd_args.flags |= MAP_ANON; 546 } else 547 bsd_args.flags |= MAP_NOSYNC; 548 if (flags & LINUX_MAP_GROWSDOWN) 549 bsd_args.flags |= MAP_STACK; 550 551 /* 552 * PROT_READ, PROT_WRITE, or PROT_EXEC implies PROT_READ and PROT_EXEC 553 * on Linux/i386. We do this to ensure maximum compatibility. 554 * Linux/ia64 does the same in i386 emulation mode. 555 */ 556 bsd_args.prot = prot; 557 if (bsd_args.prot & (PROT_READ | PROT_WRITE | PROT_EXEC)) 558 bsd_args.prot |= PROT_READ | PROT_EXEC; 559 560 /* Linux does not check file descriptor when MAP_ANONYMOUS is set. */ 561 bsd_args.fd = (bsd_args.flags & MAP_ANON) ? -1 : fd; 562 if (bsd_args.fd != -1) { 563 /* 564 * Linux follows Solaris mmap(2) description: 565 * The file descriptor fildes is opened with 566 * read permission, regardless of the 567 * protection options specified. 568 */ 569 570 if ((error = fget(td, bsd_args.fd, CAP_MMAP, &fp)) != 0) 571 return (error); 572 if (fp->f_type != DTYPE_VNODE) { 573 fdrop(fp, td); 574 return (EINVAL); 575 } 576 577 /* Linux mmap() just fails for O_WRONLY files */ 578 if (!(fp->f_flag & FREAD)) { 579 fdrop(fp, td); 580 return (EACCES); 581 } 582 583 fdrop(fp, td); 584 } 585 586 if (flags & LINUX_MAP_GROWSDOWN) { 587 /* 588 * The Linux MAP_GROWSDOWN option does not limit auto 589 * growth of the region. Linux mmap with this option 590 * takes as addr the inital BOS, and as len, the initial 591 * region size. It can then grow down from addr without 592 * limit. However, Linux threads has an implicit internal 593 * limit to stack size of STACK_SIZE. Its just not 594 * enforced explicitly in Linux. But, here we impose 595 * a limit of (STACK_SIZE - GUARD_SIZE) on the stack 596 * region, since we can do this with our mmap. 597 * 598 * Our mmap with MAP_STACK takes addr as the maximum 599 * downsize limit on BOS, and as len the max size of 600 * the region. It then maps the top SGROWSIZ bytes, 601 * and auto grows the region down, up to the limit 602 * in addr. 603 * 604 * If we don't use the MAP_STACK option, the effect 605 * of this code is to allocate a stack region of a 606 * fixed size of (STACK_SIZE - GUARD_SIZE). 607 */ 608 609 if ((caddr_t)PTRIN(addr) + len > p->p_vmspace->vm_maxsaddr) { 610 /* 611 * Some Linux apps will attempt to mmap 612 * thread stacks near the top of their 613 * address space. If their TOS is greater 614 * than vm_maxsaddr, vm_map_growstack() 615 * will confuse the thread stack with the 616 * process stack and deliver a SEGV if they 617 * attempt to grow the thread stack past their 618 * current stacksize rlimit. To avoid this, 619 * adjust vm_maxsaddr upwards to reflect 620 * the current stacksize rlimit rather 621 * than the maximum possible stacksize. 622 * It would be better to adjust the 623 * mmap'ed region, but some apps do not check 624 * mmap's return value. 625 */ 626 PROC_LOCK(p); 627 p->p_vmspace->vm_maxsaddr = (char *)LINUX32_USRSTACK - 628 lim_cur(p, RLIMIT_STACK); 629 PROC_UNLOCK(p); 630 } 631 632 /* 633 * This gives us our maximum stack size and a new BOS. 634 * If we're using VM_STACK, then mmap will just map 635 * the top SGROWSIZ bytes, and let the stack grow down 636 * to the limit at BOS. If we're not using VM_STACK 637 * we map the full stack, since we don't have a way 638 * to autogrow it. 639 */ 640 if (len > STACK_SIZE - GUARD_SIZE) { 641 bsd_args.addr = (caddr_t)PTRIN(addr); 642 bsd_args.len = len; 643 } else { 644 bsd_args.addr = (caddr_t)PTRIN(addr) - 645 (STACK_SIZE - GUARD_SIZE - len); 646 bsd_args.len = STACK_SIZE - GUARD_SIZE; 647 } 648 } else { 649 bsd_args.addr = (caddr_t)PTRIN(addr); 650 bsd_args.len = len; 651 } 652 bsd_args.pos = pos; 653 654#ifdef DEBUG 655 if (ldebug(mmap)) 656 printf("-> %s(%p, %d, %d, 0x%08x, %d, 0x%x)\n", 657 __func__, 658 (void *)bsd_args.addr, (int)bsd_args.len, bsd_args.prot, 659 bsd_args.flags, bsd_args.fd, (int)bsd_args.pos); 660#endif 661 error = sys_mmap(td, &bsd_args); 662#ifdef DEBUG 663 if (ldebug(mmap)) 664 printf("-> %s() return: 0x%x (0x%08x)\n", 665 __func__, error, (u_int)td->td_retval[0]); 666#endif 667 return (error); 668} 669 670int 671linux_mprotect(struct thread *td, struct linux_mprotect_args *uap) 672{ 673 struct mprotect_args bsd_args; 674 675 bsd_args.addr = uap->addr; 676 bsd_args.len = uap->len; 677 bsd_args.prot = uap->prot; 678 if (bsd_args.prot & (PROT_READ | PROT_WRITE | PROT_EXEC)) 679 bsd_args.prot |= PROT_READ | PROT_EXEC; 680 return (sys_mprotect(td, &bsd_args)); 681} 682 683int 684linux_iopl(struct thread *td, struct linux_iopl_args *args) 685{ 686 int error; 687 688 if (args->level < 0 || args->level > 3) 689 return (EINVAL); 690 if ((error = priv_check(td, PRIV_IO)) != 0) 691 return (error); 692 if ((error = securelevel_gt(td->td_ucred, 0)) != 0) 693 return (error); 694 td->td_frame->tf_rflags = (td->td_frame->tf_rflags & ~PSL_IOPL) | 695 (args->level * (PSL_IOPL / 3)); 696 697 return (0); 698} 699 700int 701linux_sigaction(struct thread *td, struct linux_sigaction_args *args) 702{ 703 l_osigaction_t osa; 704 l_sigaction_t act, oact; 705 int error; 706 707#ifdef DEBUG 708 if (ldebug(sigaction)) 709 printf(ARGS(sigaction, "%d, %p, %p"), 710 args->sig, (void *)args->nsa, (void *)args->osa); 711#endif 712 713 if (args->nsa != NULL) { 714 error = copyin(args->nsa, &osa, sizeof(l_osigaction_t)); 715 if (error) 716 return (error); 717 act.lsa_handler = osa.lsa_handler; 718 act.lsa_flags = osa.lsa_flags; 719 act.lsa_restorer = osa.lsa_restorer; 720 LINUX_SIGEMPTYSET(act.lsa_mask); 721 act.lsa_mask.__bits[0] = osa.lsa_mask; 722 } 723 724 error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL, 725 args->osa ? &oact : NULL); 726 727 if (args->osa != NULL && !error) { 728 osa.lsa_handler = oact.lsa_handler; 729 osa.lsa_flags = oact.lsa_flags; 730 osa.lsa_restorer = oact.lsa_restorer; 731 osa.lsa_mask = oact.lsa_mask.__bits[0]; 732 error = copyout(&osa, args->osa, sizeof(l_osigaction_t)); 733 } 734 735 return (error); 736} 737 738/* 739 * Linux has two extra args, restart and oldmask. We don't use these, 740 * but it seems that "restart" is actually a context pointer that 741 * enables the signal to happen with a different register set. 742 */ 743int 744linux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args) 745{ 746 sigset_t sigmask; 747 l_sigset_t mask; 748 749#ifdef DEBUG 750 if (ldebug(sigsuspend)) 751 printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask); 752#endif 753 754 LINUX_SIGEMPTYSET(mask); 755 mask.__bits[0] = args->mask; 756 linux_to_bsd_sigset(&mask, &sigmask); 757 return (kern_sigsuspend(td, sigmask)); 758} 759 760int 761linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap) 762{ 763 l_sigset_t lmask; 764 sigset_t sigmask; 765 int error; 766 767#ifdef DEBUG 768 if (ldebug(rt_sigsuspend)) 769 printf(ARGS(rt_sigsuspend, "%p, %d"), 770 (void *)uap->newset, uap->sigsetsize); 771#endif 772 773 if (uap->sigsetsize != sizeof(l_sigset_t)) 774 return (EINVAL); 775 776 error = copyin(uap->newset, &lmask, sizeof(l_sigset_t)); 777 if (error) 778 return (error); 779 780 linux_to_bsd_sigset(&lmask, &sigmask); 781 return (kern_sigsuspend(td, sigmask)); 782} 783 784int 785linux_pause(struct thread *td, struct linux_pause_args *args) 786{ 787 struct proc *p = td->td_proc; 788 sigset_t sigmask; 789 790#ifdef DEBUG 791 if (ldebug(pause)) 792 printf(ARGS(pause, "")); 793#endif 794 795 PROC_LOCK(p); 796 sigmask = td->td_sigmask; 797 PROC_UNLOCK(p); 798 return (kern_sigsuspend(td, sigmask)); 799} 800 801int 802linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap) 803{ 804 stack_t ss, oss; 805 l_stack_t lss; 806 int error; 807 808#ifdef DEBUG 809 if (ldebug(sigaltstack)) 810 printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss); 811#endif 812 813 if (uap->uss != NULL) { 814 error = copyin(uap->uss, &lss, sizeof(l_stack_t)); 815 if (error) 816 return (error); 817 818 ss.ss_sp = PTRIN(lss.ss_sp); 819 ss.ss_size = lss.ss_size; 820 ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags); 821 } 822 error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL, 823 (uap->uoss != NULL) ? &oss : NULL); 824 if (!error && uap->uoss != NULL) { 825 lss.ss_sp = PTROUT(oss.ss_sp); 826 lss.ss_size = oss.ss_size; 827 lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags); 828 error = copyout(&lss, uap->uoss, sizeof(l_stack_t)); 829 } 830 831 return (error); 832} 833 834int 835linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args) 836{ 837 struct ftruncate_args sa; 838 839#ifdef DEBUG 840 if (ldebug(ftruncate64)) 841 printf(ARGS(ftruncate64, "%u, %jd"), args->fd, 842 (intmax_t)args->length); 843#endif 844 845 sa.fd = args->fd; 846 sa.length = args->length; 847 return sys_ftruncate(td, &sa); 848} 849 850int 851linux_gettimeofday(struct thread *td, struct linux_gettimeofday_args *uap) 852{ 853 struct timeval atv; 854 l_timeval atv32; 855 struct timezone rtz; 856 int error = 0; 857 858 if (uap->tp) { 859 microtime(&atv); 860 atv32.tv_sec = atv.tv_sec; 861 atv32.tv_usec = atv.tv_usec; 862 error = copyout(&atv32, uap->tp, sizeof(atv32)); 863 } 864 if (error == 0 && uap->tzp != NULL) { 865 rtz.tz_minuteswest = tz_minuteswest; 866 rtz.tz_dsttime = tz_dsttime; 867 error = copyout(&rtz, uap->tzp, sizeof(rtz)); 868 } 869 return (error); 870} 871 872int 873linux_settimeofday(struct thread *td, struct linux_settimeofday_args *uap) 874{ 875 l_timeval atv32; 876 struct timeval atv, *tvp; 877 struct timezone atz, *tzp; 878 int error; 879 880 if (uap->tp) { 881 error = copyin(uap->tp, &atv32, sizeof(atv32)); 882 if (error) 883 return (error); 884 atv.tv_sec = atv32.tv_sec; 885 atv.tv_usec = atv32.tv_usec; 886 tvp = &atv; 887 } else 888 tvp = NULL; 889 if (uap->tzp) { 890 error = copyin(uap->tzp, &atz, sizeof(atz)); 891 if (error) 892 return (error); 893 tzp = &atz; 894 } else 895 tzp = NULL; 896 return (kern_settimeofday(td, tvp, tzp)); 897} 898 899int 900linux_getrusage(struct thread *td, struct linux_getrusage_args *uap) 901{ 902 struct l_rusage s32; 903 struct rusage s; 904 int error; 905 906 error = kern_getrusage(td, uap->who, &s); 907 if (error != 0) 908 return (error); 909 if (uap->rusage != NULL) { 910 bsd_to_linux_rusage(&s, &s32); 911 error = copyout(&s32, uap->rusage, sizeof(s32)); 912 } 913 return (error); 914} 915 916int 917linux_sched_rr_get_interval(struct thread *td, 918 struct linux_sched_rr_get_interval_args *uap) 919{ 920 struct timespec ts; 921 struct l_timespec ts32; 922 int error; 923 924 error = kern_sched_rr_get_interval(td, uap->pid, &ts); 925 if (error != 0) 926 return (error); 927 ts32.tv_sec = ts.tv_sec; 928 ts32.tv_nsec = ts.tv_nsec; 929 return (copyout(&ts32, uap->interval, sizeof(ts32))); 930} 931 932int 933linux_set_thread_area(struct thread *td, 934 struct linux_set_thread_area_args *args) 935{ 936 struct l_user_desc info; 937 struct user_segment_descriptor sd; 938 struct pcb *pcb; 939 int a[2]; 940 int error; 941 942 error = copyin(args->desc, &info, sizeof(struct l_user_desc)); 943 if (error) 944 return (error); 945 946#ifdef DEBUG 947 if (ldebug(set_thread_area)) 948 printf(ARGS(set_thread_area, "%i, %x, %x, %i, %i, %i, " 949 "%i, %i, %i"), info.entry_number, info.base_addr, 950 info.limit, info.seg_32bit, info.contents, 951 info.read_exec_only, info.limit_in_pages, 952 info.seg_not_present, info.useable); 953#endif 954 955 /* 956 * Semantics of Linux version: every thread in the system has array 957 * of three TLS descriptors. 1st is GLIBC TLS, 2nd is WINE, 3rd unknown. 958 * This syscall loads one of the selected TLS decriptors with a value 959 * and also loads GDT descriptors 6, 7 and 8 with the content of 960 * the per-thread descriptors. 961 * 962 * Semantics of FreeBSD version: I think we can ignore that Linux has 963 * three per-thread descriptors and use just the first one. 964 * The tls_array[] is used only in [gs]et_thread_area() syscalls and 965 * for loading the GDT descriptors. We use just one GDT descriptor 966 * for TLS, so we will load just one. 967 * 968 * XXX: This doesn't work when a user space process tries to use more 969 * than one TLS segment. Comment in the Linux source says wine might 970 * do this. 971 */ 972 973 /* 974 * GLIBC reads current %gs and call set_thread_area() with it. 975 * We should let GUDATA_SEL and GUGS32_SEL proceed as well because 976 * we use these segments. 977 */ 978 switch (info.entry_number) { 979 case GUGS32_SEL: 980 case GUDATA_SEL: 981 case 6: 982 case -1: 983 info.entry_number = GUGS32_SEL; 984 break; 985 default: 986 return (EINVAL); 987 } 988 989 /* 990 * We have to copy out the GDT entry we use. 991 * 992 * XXX: What if a user space program does not check the return value 993 * and tries to use 6, 7 or 8? 994 */ 995 error = copyout(&info, args->desc, sizeof(struct l_user_desc)); 996 if (error) 997 return (error); 998 999 if (LINUX_LDT_empty(&info)) { 1000 a[0] = 0; 1001 a[1] = 0; 1002 } else { 1003 a[0] = LINUX_LDT_entry_a(&info); 1004 a[1] = LINUX_LDT_entry_b(&info); 1005 } 1006 1007 memcpy(&sd, &a, sizeof(a)); 1008#ifdef DEBUG 1009 if (ldebug(set_thread_area)) 1010 printf("Segment created in set_thread_area: " 1011 "lobase: %x, hibase: %x, lolimit: %x, hilimit: %x, " 1012 "type: %i, dpl: %i, p: %i, xx: %i, long: %i, " 1013 "def32: %i, gran: %i\n", 1014 sd.sd_lobase, 1015 sd.sd_hibase, 1016 sd.sd_lolimit, 1017 sd.sd_hilimit, 1018 sd.sd_type, 1019 sd.sd_dpl, 1020 sd.sd_p, 1021 sd.sd_xx, 1022 sd.sd_long, 1023 sd.sd_def32, 1024 sd.sd_gran); 1025#endif 1026 1027 pcb = td->td_pcb; 1028 pcb->pcb_gsbase = (register_t)info.base_addr; 1029 set_pcb_flags(pcb, PCB_32BIT); 1030 update_gdt_gsbase(td, info.base_addr); 1031 1032 return (0); 1033} 1034 1035int 1036linux_wait4(struct thread *td, struct linux_wait4_args *args) 1037{ 1038 int error, options; 1039 struct rusage ru, *rup; 1040 struct l_rusage lru; 1041 1042#ifdef DEBUG 1043 if (ldebug(wait4)) 1044 printf(ARGS(wait4, "%d, %p, %d, %p"), 1045 args->pid, (void *)args->status, args->options, 1046 (void *)args->rusage); 1047#endif 1048 1049 options = (args->options & (WNOHANG | WUNTRACED)); 1050 /* WLINUXCLONE should be equal to __WCLONE, but we make sure */ 1051 if (args->options & __WCLONE) 1052 options |= WLINUXCLONE; 1053 1054 if (args->rusage != NULL) 1055 rup = &ru; 1056 else 1057 rup = NULL; 1058 error = linux_common_wait(td, args->pid, args->status, options, rup); 1059 if (error) 1060 return (error); 1061 if (args->rusage != NULL) { 1062 bsd_to_linux_rusage(rup, &lru); 1063 error = copyout(&lru, args->rusage, sizeof(lru)); 1064 } 1065 1066 return (error); 1067} 1068