linux_machdep.c revision 1.62.2.13
1 /* $NetBSD: linux_machdep.c,v 1.62.2.13 2002/08/01 02:44:14 nathanw Exp $ */ 2 3 /*- 4 * Copyright (c) 1995, 2000 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. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: linux_machdep.c,v 1.62.2.13 2002/08/01 02:44:14 nathanw Exp $"); 41 42 #if defined(_KERNEL_OPT) 43 #include "opt_vm86.h" 44 #include "opt_user_ldt.h" 45 #endif 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/signalvar.h> 50 #include <sys/kernel.h> 51 #include <sys/map.h> 52 #include <sys/proc.h> 53 #include <sys/user.h> 54 #include <sys/buf.h> 55 #include <sys/reboot.h> 56 #include <sys/conf.h> 57 #include <sys/exec.h> 58 #include <sys/file.h> 59 #include <sys/callout.h> 60 #include <sys/malloc.h> 61 #include <sys/mbuf.h> 62 #include <sys/msgbuf.h> 63 #include <sys/mount.h> 64 #include <sys/vnode.h> 65 #include <sys/device.h> 66 #include <sys/sa.h> 67 #include <sys/syscallargs.h> 68 #include <sys/filedesc.h> 69 #include <sys/exec_elf.h> 70 #include <sys/disklabel.h> 71 #include <sys/ioctl.h> 72 #include <miscfs/specfs/specdev.h> 73 74 #include <compat/linux/common/linux_types.h> 75 #include <compat/linux/common/linux_signal.h> 76 #include <compat/linux/common/linux_util.h> 77 #include <compat/linux/common/linux_ioctl.h> 78 #include <compat/linux/common/linux_hdio.h> 79 #include <compat/linux/common/linux_exec.h> 80 #include <compat/linux/common/linux_machdep.h> 81 82 #include <compat/linux/linux_syscallargs.h> 83 84 #include <machine/cpu.h> 85 #include <machine/cpufunc.h> 86 #include <machine/psl.h> 87 #include <machine/reg.h> 88 #include <machine/segments.h> 89 #include <machine/specialreg.h> 90 #include <machine/sysarch.h> 91 #include <machine/vm86.h> 92 #include <machine/vmparam.h> 93 94 /* 95 * To see whether wscons is configured (for virtual console ioctl calls). 96 */ 97 #if defined(_KERNEL_OPT) 98 #include "wsdisplay.h" 99 #endif 100 #if (NWSDISPLAY > 0) 101 #include <dev/wscons/wsconsio.h> 102 #include <dev/wscons/wsdisplay_usl_io.h> 103 #if defined(_KERNEL_OPT) 104 #include "opt_xserver.h" 105 #endif 106 #endif 107 108 #ifdef USER_LDT 109 #include <machine/cpu.h> 110 int linux_read_ldt __P((struct lwp *, struct linux_sys_modify_ldt_args *, 111 register_t *)); 112 int linux_write_ldt __P((struct lwp *, struct linux_sys_modify_ldt_args *, 113 register_t *)); 114 #endif 115 116 #ifdef DEBUG_LINUX 117 #define DPRINTF(a) uprintf a 118 #else 119 #define DPRINTF(a) 120 #endif 121 122 static struct biosdisk_info *fd2biosinfo __P((struct proc *, struct file *)); 123 extern struct disklist *i386_alldisks; 124 extern const char *findblkname __P((int)); 125 126 /* 127 * Deal with some i386-specific things in the Linux emulation code. 128 */ 129 130 void 131 linux_setregs(l, epp, stack) 132 struct lwp *l; 133 struct exec_package *epp; 134 u_long stack; 135 { 136 struct pcb *pcb = &l->l_addr->u_pcb; 137 struct trapframe *tf; 138 139 #if NNPX > 0 140 /* If we were using the FPU, forget about it. */ 141 if (npxproc == l) 142 npxdrop(); 143 #endif 144 145 #ifdef USER_LDT 146 pmap_ldt_cleanup(l); 147 #endif 148 149 l->l_md.md_flags &= ~MDP_USEDFPU; 150 pcb->pcb_flags = 0; 151 152 if (i386_use_fxsave) { 153 pcb->pcb_savefpu.sv_xmm.sv_env.en_cw = __Linux_NPXCW__; 154 pcb->pcb_savefpu.sv_xmm.sv_env.en_mxcsr = __INITIAL_MXCSR__; 155 } else 156 pcb->pcb_savefpu.sv_87.sv_env.en_cw = __Linux_NPXCW__; 157 158 tf = l->l_md.md_regs; 159 tf->tf_gs = GSEL(GUDATA_SEL, SEL_UPL); 160 tf->tf_fs = GSEL(GUDATA_SEL, SEL_UPL); 161 tf->tf_es = GSEL(GUDATA_SEL, SEL_UPL); 162 tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL); 163 tf->tf_edi = 0; 164 tf->tf_esi = 0; 165 tf->tf_ebp = 0; 166 tf->tf_ebx = (int)l->l_proc->p_psstr; 167 tf->tf_edx = 0; 168 tf->tf_ecx = 0; 169 tf->tf_eax = 0; 170 tf->tf_eip = epp->ep_entry; 171 tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL); 172 tf->tf_eflags = PSL_USERSET; 173 tf->tf_esp = stack; 174 tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL); 175 } 176 177 /* 178 * Send an interrupt to process. 179 * 180 * Stack is set up to allow sigcode stored 181 * in u. to call routine, followed by kcall 182 * to sigreturn routine below. After sigreturn 183 * resets the signal mask, the stack, and the 184 * frame pointer, it returns to the user 185 * specified pc, psl. 186 */ 187 188 void 189 linux_sendsig(sig, mask, code) 190 int sig; 191 sigset_t *mask; 192 u_long code; 193 { 194 struct lwp *l = curlwp; 195 struct proc *p = l->l_proc; 196 struct trapframe *tf; 197 struct linux_sigframe *fp, frame; 198 int onstack; 199 sig_t catcher = SIGACTION(p, sig).sa_handler; 200 201 tf = l->l_md.md_regs; 202 /* Do we need to jump onto the signal stack? */ 203 onstack = 204 (p->p_sigctx.ps_sigstk.ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 && 205 (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0; 206 207 /* Allocate space for the signal handler context. */ 208 if (onstack) 209 fp = (struct linux_sigframe *)((caddr_t)p->p_sigctx.ps_sigstk.ss_sp + 210 p->p_sigctx.ps_sigstk.ss_size); 211 else 212 fp = (struct linux_sigframe *)tf->tf_esp; 213 fp--; 214 215 /* Build stack frame for signal trampoline. */ 216 frame.sf_handler = catcher; 217 frame.sf_sig = native_to_linux_signo[sig]; 218 219 /* Save register context. */ 220 #ifdef VM86 221 if (tf->tf_eflags & PSL_VM) { 222 frame.sf_sc.sc_gs = tf->tf_vm86_gs; 223 frame.sf_sc.sc_fs = tf->tf_vm86_fs; 224 frame.sf_sc.sc_es = tf->tf_vm86_es; 225 frame.sf_sc.sc_ds = tf->tf_vm86_ds; 226 frame.sf_sc.sc_eflags = get_vflags(l); 227 } else 228 #endif 229 { 230 frame.sf_sc.sc_gs = tf->tf_gs; 231 frame.sf_sc.sc_fs = tf->tf_fs; 232 frame.sf_sc.sc_es = tf->tf_es; 233 frame.sf_sc.sc_ds = tf->tf_ds; 234 frame.sf_sc.sc_eflags = tf->tf_eflags; 235 } 236 frame.sf_sc.sc_edi = tf->tf_edi; 237 frame.sf_sc.sc_esi = tf->tf_esi; 238 frame.sf_sc.sc_ebp = tf->tf_ebp; 239 frame.sf_sc.sc_ebx = tf->tf_ebx; 240 frame.sf_sc.sc_edx = tf->tf_edx; 241 frame.sf_sc.sc_ecx = tf->tf_ecx; 242 frame.sf_sc.sc_eax = tf->tf_eax; 243 frame.sf_sc.sc_eip = tf->tf_eip; 244 frame.sf_sc.sc_cs = tf->tf_cs; 245 frame.sf_sc.sc_esp_at_signal = tf->tf_esp; 246 frame.sf_sc.sc_ss = tf->tf_ss; 247 frame.sf_sc.sc_err = tf->tf_err; 248 frame.sf_sc.sc_trapno = tf->tf_trapno; 249 frame.sf_sc.sc_cr2 = l->l_addr->u_pcb.pcb_cr2; 250 251 /* Save signal stack. */ 252 /* Linux doesn't save the onstack flag in sigframe */ 253 254 /* Save signal mask. */ 255 native_to_linux_old_sigset(&frame.sf_sc.sc_mask, mask); 256 257 if (copyout(&frame, fp, sizeof(frame)) != 0) { 258 /* 259 * Process has trashed its stack; give it an illegal 260 * instruction to halt it in its tracks. 261 */ 262 sigexit(l, SIGILL); 263 /* NOTREACHED */ 264 } 265 266 /* 267 * Build context to run handler in. 268 */ 269 tf->tf_gs = GSEL(GUDATA_SEL, SEL_UPL); 270 tf->tf_fs = GSEL(GUDATA_SEL, SEL_UPL); 271 tf->tf_es = GSEL(GUDATA_SEL, SEL_UPL); 272 tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL); 273 tf->tf_eip = (int)p->p_sigctx.ps_sigcode; 274 tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL); 275 tf->tf_eflags &= ~(PSL_T|PSL_VM|PSL_AC); 276 tf->tf_esp = (int)fp; 277 tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL); 278 279 /* Remember that we're now on the signal stack. */ 280 if (onstack) 281 p->p_sigctx.ps_sigstk.ss_flags |= SS_ONSTACK; 282 } 283 284 /* 285 * System call to cleanup state after a signal 286 * has been taken. Reset signal mask and 287 * stack state from context left by sendsig (above). 288 * Return to previous pc and psl as specified by 289 * context left by sendsig. Check carefully to 290 * make sure that the user has not modified the 291 * psl to gain improper privileges or to cause 292 * a machine fault. 293 */ 294 int 295 linux_sys_rt_sigreturn(l, v, retval) 296 struct lwp *l; 297 void *v; 298 register_t *retval; 299 { 300 /* XXX XAX write me */ 301 return(ENOSYS); 302 } 303 304 int 305 linux_sys_sigreturn(l, v, retval) 306 struct lwp *l; 307 void *v; 308 register_t *retval; 309 { 310 struct linux_sys_sigreturn_args /* { 311 syscallarg(struct linux_sigcontext *) scp; 312 } */ *uap = v; 313 struct proc *p = l->l_proc; 314 struct linux_sigcontext *scp, context; 315 struct trapframe *tf; 316 sigset_t mask; 317 ssize_t ss_gap; 318 319 /* 320 * The trampoline code hands us the context. 321 * It is unsafe to keep track of it ourselves, in the event that a 322 * program jumps out of a signal handler. 323 */ 324 scp = SCARG(uap, scp); 325 if (copyin((caddr_t)scp, &context, sizeof(*scp)) != 0) 326 return (EFAULT); 327 328 /* Restore register context. */ 329 tf = l->l_md.md_regs; 330 #ifdef VM86 331 if (context.sc_eflags & PSL_VM) { 332 tf->tf_vm86_gs = context.sc_gs; 333 tf->tf_vm86_fs = context.sc_fs; 334 tf->tf_vm86_es = context.sc_es; 335 tf->tf_vm86_ds = context.sc_ds; 336 set_vflags(l, context.sc_eflags); 337 } else 338 #endif 339 { 340 /* 341 * Check for security violations. If we're returning to 342 * protected mode, the CPU will validate the segment registers 343 * automatically and generate a trap on violations. We handle 344 * the trap, rather than doing all of the checking here. 345 */ 346 if (((context.sc_eflags ^ tf->tf_eflags) & PSL_USERSTATIC) != 0 || 347 !USERMODE(context.sc_cs, context.sc_eflags)) 348 return (EINVAL); 349 350 tf->tf_gs = context.sc_gs; 351 tf->tf_fs = context.sc_fs; 352 tf->tf_es = context.sc_es; 353 tf->tf_ds = context.sc_ds; 354 tf->tf_eflags = context.sc_eflags; 355 } 356 tf->tf_edi = context.sc_edi; 357 tf->tf_esi = context.sc_esi; 358 tf->tf_ebp = context.sc_ebp; 359 tf->tf_ebx = context.sc_ebx; 360 tf->tf_edx = context.sc_edx; 361 tf->tf_ecx = context.sc_ecx; 362 tf->tf_eax = context.sc_eax; 363 tf->tf_eip = context.sc_eip; 364 tf->tf_cs = context.sc_cs; 365 tf->tf_esp = context.sc_esp_at_signal; 366 tf->tf_ss = context.sc_ss; 367 368 /* Restore signal stack. */ 369 /* 370 * Linux really does it this way; it doesn't have space in sigframe 371 * to save the onstack flag. 372 */ 373 ss_gap = (ssize_t) 374 ((caddr_t) context.sc_esp_at_signal - (caddr_t) p->p_sigctx.ps_sigstk.ss_sp); 375 if (ss_gap >= 0 && ss_gap < p->p_sigctx.ps_sigstk.ss_size) 376 p->p_sigctx.ps_sigstk.ss_flags |= SS_ONSTACK; 377 else 378 p->p_sigctx.ps_sigstk.ss_flags &= ~SS_ONSTACK; 379 380 /* Restore signal mask. */ 381 linux_old_to_native_sigset(&mask, &context.sc_mask); 382 (void) sigprocmask1(p, SIG_SETMASK, &mask, 0); 383 384 return (EJUSTRETURN); 385 } 386 387 #ifdef USER_LDT 388 389 int 390 linux_read_ldt(l, uap, retval) 391 struct lwp *l; 392 struct linux_sys_modify_ldt_args /* { 393 syscallarg(int) func; 394 syscallarg(void *) ptr; 395 syscallarg(size_t) bytecount; 396 } */ *uap; 397 register_t *retval; 398 { 399 struct proc *p = l->l_proc; 400 struct i386_get_ldt_args gl; 401 int error; 402 caddr_t sg; 403 char *parms; 404 405 DPRINTF(("linux_read_ldt!")); 406 sg = stackgap_init(p, 0); 407 408 gl.start = 0; 409 gl.desc = SCARG(uap, ptr); 410 gl.num = SCARG(uap, bytecount) / sizeof(union descriptor); 411 412 parms = stackgap_alloc(p, &sg, sizeof(gl)); 413 414 if ((error = copyout(&gl, parms, sizeof(gl))) != 0) 415 return (error); 416 417 if ((error = i386_get_ldt(l, parms, retval)) != 0) 418 return (error); 419 420 *retval *= sizeof(union descriptor); 421 return (0); 422 } 423 424 struct linux_ldt_info { 425 u_int entry_number; 426 u_long base_addr; 427 u_int limit; 428 u_int seg_32bit:1; 429 u_int contents:2; 430 u_int read_exec_only:1; 431 u_int limit_in_pages:1; 432 u_int seg_not_present:1; 433 u_int useable:1; 434 }; 435 436 int 437 linux_write_ldt(l, uap, retval) 438 struct lwp *l; 439 struct linux_sys_modify_ldt_args /* { 440 syscallarg(int) func; 441 syscallarg(void *) ptr; 442 syscallarg(size_t) bytecount; 443 } */ *uap; 444 register_t *retval; 445 { 446 struct proc *p = l->l_proc; 447 struct linux_ldt_info ldt_info; 448 struct segment_descriptor sd; 449 struct i386_set_ldt_args sl; 450 int error; 451 caddr_t sg; 452 char *parms; 453 int oldmode = (int)retval[0]; 454 455 DPRINTF(("linux_write_ldt %d\n", oldmode)); 456 if (SCARG(uap, bytecount) != sizeof(ldt_info)) 457 return (EINVAL); 458 if ((error = copyin(SCARG(uap, ptr), &ldt_info, sizeof(ldt_info))) != 0) 459 return error; 460 if (ldt_info.entry_number >= 8192) 461 return (EINVAL); 462 if (ldt_info.contents == 3) { 463 if (oldmode) 464 return (EINVAL); 465 if (ldt_info.seg_not_present) 466 return (EINVAL); 467 } 468 469 if (ldt_info.base_addr == 0 && ldt_info.limit == 0 && 470 (oldmode || (ldt_info.contents == 0 && 471 ldt_info.read_exec_only == 1 && ldt_info.seg_32bit == 0 && 472 ldt_info.limit_in_pages == 0 && ldt_info.seg_not_present == 1 && 473 ldt_info.useable == 0))) { 474 /* this means you should zero the ldt */ 475 (void)memset(&sd, 0, sizeof(sd)); 476 } else { 477 sd.sd_lobase = ldt_info.base_addr & 0xffffff; 478 sd.sd_hibase = (ldt_info.base_addr >> 24) & 0xff; 479 sd.sd_lolimit = ldt_info.limit & 0xffff; 480 sd.sd_hilimit = (ldt_info.limit >> 16) & 0xf; 481 sd.sd_type = 16 | (ldt_info.contents << 2) | 482 (!ldt_info.read_exec_only << 1); 483 sd.sd_dpl = SEL_UPL; 484 sd.sd_p = !ldt_info.seg_not_present; 485 sd.sd_def32 = ldt_info.seg_32bit; 486 sd.sd_gran = ldt_info.limit_in_pages; 487 if (!oldmode) 488 sd.sd_xx = ldt_info.useable; 489 else 490 sd.sd_xx = 0; 491 } 492 sg = stackgap_init(p, 0); 493 sl.start = ldt_info.entry_number; 494 sl.desc = stackgap_alloc(p, &sg, sizeof(sd)); 495 sl.num = 1; 496 497 DPRINTF(("linux_write_ldt: idx=%d, base=0x%lx, limit=0x%x\n", 498 ldt_info.entry_number, ldt_info.base_addr, ldt_info.limit)); 499 500 parms = stackgap_alloc(p, &sg, sizeof(sl)); 501 502 if ((error = copyout(&sd, sl.desc, sizeof(sd))) != 0) 503 return (error); 504 if ((error = copyout(&sl, parms, sizeof(sl))) != 0) 505 return (error); 506 507 if ((error = i386_set_ldt(l, parms, retval)) != 0) 508 return (error); 509 510 *retval = 0; 511 return (0); 512 } 513 514 #endif /* USER_LDT */ 515 516 int 517 linux_sys_modify_ldt(l, v, retval) 518 struct lwp *l; 519 void *v; 520 register_t *retval; 521 { 522 struct linux_sys_modify_ldt_args /* { 523 syscallarg(int) func; 524 syscallarg(void *) ptr; 525 syscallarg(size_t) bytecount; 526 } */ *uap = v; 527 528 switch (SCARG(uap, func)) { 529 #ifdef USER_LDT 530 case 0: 531 return linux_read_ldt(l, uap, retval); 532 case 1: 533 retval[0] = 1; 534 return linux_write_ldt(l, uap, retval); 535 case 2: 536 #ifdef notyet 537 return (linux_read_default_ldt(l, uap, retval); 538 #else 539 return (ENOSYS); 540 #endif 541 case 0x11: 542 retval[0] = 0; 543 return linux_write_ldt(l, uap, retval); 544 #endif /* USER_LDT */ 545 546 default: 547 return (ENOSYS); 548 } 549 } 550 551 /* 552 * XXX Pathetic hack to make svgalib work. This will fake the major 553 * device number of an opened VT so that svgalib likes it. grmbl. 554 * Should probably do it 'wrong the right way' and use a mapping 555 * array for all major device numbers, and map linux_mknod too. 556 */ 557 dev_t 558 linux_fakedev(dev, raw) 559 dev_t dev; 560 int raw; 561 { 562 if (raw) { 563 #if (NWSDISPLAY > 0) 564 if (major(dev) == NETBSD_WSCONS_MAJOR) 565 return makedev(LINUX_CONS_MAJOR, (minor(dev) + 1)); 566 #endif 567 } 568 569 return dev; 570 } 571 572 #if (NWSDISPLAY > 0) 573 /* 574 * That's not complete, but enough to get an X server running. 575 */ 576 #define NR_KEYS 128 577 static const u_short plain_map[NR_KEYS] = { 578 0x0200, 0x001b, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 579 0x0037, 0x0038, 0x0039, 0x0030, 0x002d, 0x003d, 0x007f, 0x0009, 580 0x0b71, 0x0b77, 0x0b65, 0x0b72, 0x0b74, 0x0b79, 0x0b75, 0x0b69, 581 0x0b6f, 0x0b70, 0x005b, 0x005d, 0x0201, 0x0702, 0x0b61, 0x0b73, 582 0x0b64, 0x0b66, 0x0b67, 0x0b68, 0x0b6a, 0x0b6b, 0x0b6c, 0x003b, 583 0x0027, 0x0060, 0x0700, 0x005c, 0x0b7a, 0x0b78, 0x0b63, 0x0b76, 584 0x0b62, 0x0b6e, 0x0b6d, 0x002c, 0x002e, 0x002f, 0x0700, 0x030c, 585 0x0703, 0x0020, 0x0207, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 586 0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x0208, 0x0209, 0x0307, 587 0x0308, 0x0309, 0x030b, 0x0304, 0x0305, 0x0306, 0x030a, 0x0301, 588 0x0302, 0x0303, 0x0300, 0x0310, 0x0206, 0x0200, 0x003c, 0x010a, 589 0x010b, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 590 0x030e, 0x0702, 0x030d, 0x001c, 0x0701, 0x0205, 0x0114, 0x0603, 591 0x0118, 0x0601, 0x0602, 0x0117, 0x0600, 0x0119, 0x0115, 0x0116, 592 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d, 593 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 594 }, shift_map[NR_KEYS] = { 595 0x0200, 0x001b, 0x0021, 0x0040, 0x0023, 0x0024, 0x0025, 0x005e, 596 0x0026, 0x002a, 0x0028, 0x0029, 0x005f, 0x002b, 0x007f, 0x0009, 597 0x0b51, 0x0b57, 0x0b45, 0x0b52, 0x0b54, 0x0b59, 0x0b55, 0x0b49, 598 0x0b4f, 0x0b50, 0x007b, 0x007d, 0x0201, 0x0702, 0x0b41, 0x0b53, 599 0x0b44, 0x0b46, 0x0b47, 0x0b48, 0x0b4a, 0x0b4b, 0x0b4c, 0x003a, 600 0x0022, 0x007e, 0x0700, 0x007c, 0x0b5a, 0x0b58, 0x0b43, 0x0b56, 601 0x0b42, 0x0b4e, 0x0b4d, 0x003c, 0x003e, 0x003f, 0x0700, 0x030c, 602 0x0703, 0x0020, 0x0207, 0x010a, 0x010b, 0x010c, 0x010d, 0x010e, 603 0x010f, 0x0110, 0x0111, 0x0112, 0x0113, 0x0213, 0x0203, 0x0307, 604 0x0308, 0x0309, 0x030b, 0x0304, 0x0305, 0x0306, 0x030a, 0x0301, 605 0x0302, 0x0303, 0x0300, 0x0310, 0x0206, 0x0200, 0x003e, 0x010a, 606 0x010b, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 607 0x030e, 0x0702, 0x030d, 0x0200, 0x0701, 0x0205, 0x0114, 0x0603, 608 0x020b, 0x0601, 0x0602, 0x0117, 0x0600, 0x020a, 0x0115, 0x0116, 609 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d, 610 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 611 }, altgr_map[NR_KEYS] = { 612 0x0200, 0x0200, 0x0200, 0x0040, 0x0200, 0x0024, 0x0200, 0x0200, 613 0x007b, 0x005b, 0x005d, 0x007d, 0x005c, 0x0200, 0x0200, 0x0200, 614 0x0b71, 0x0b77, 0x0918, 0x0b72, 0x0b74, 0x0b79, 0x0b75, 0x0b69, 615 0x0b6f, 0x0b70, 0x0200, 0x007e, 0x0201, 0x0702, 0x0914, 0x0b73, 616 0x0917, 0x0919, 0x0b67, 0x0b68, 0x0b6a, 0x0b6b, 0x0b6c, 0x0200, 617 0x0200, 0x0200, 0x0700, 0x0200, 0x0b7a, 0x0b78, 0x0916, 0x0b76, 618 0x0915, 0x0b6e, 0x0b6d, 0x0200, 0x0200, 0x0200, 0x0700, 0x030c, 619 0x0703, 0x0200, 0x0207, 0x050c, 0x050d, 0x050e, 0x050f, 0x0510, 620 0x0511, 0x0512, 0x0513, 0x0514, 0x0515, 0x0208, 0x0202, 0x0911, 621 0x0912, 0x0913, 0x030b, 0x090e, 0x090f, 0x0910, 0x030a, 0x090b, 622 0x090c, 0x090d, 0x090a, 0x0310, 0x0206, 0x0200, 0x007c, 0x0516, 623 0x0517, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 624 0x030e, 0x0702, 0x030d, 0x0200, 0x0701, 0x0205, 0x0114, 0x0603, 625 0x0118, 0x0601, 0x0602, 0x0117, 0x0600, 0x0119, 0x0115, 0x0116, 626 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d, 627 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 628 }, ctrl_map[NR_KEYS] = { 629 0x0200, 0x0200, 0x0200, 0x0000, 0x001b, 0x001c, 0x001d, 0x001e, 630 0x001f, 0x007f, 0x0200, 0x0200, 0x001f, 0x0200, 0x0008, 0x0200, 631 0x0011, 0x0017, 0x0005, 0x0012, 0x0014, 0x0019, 0x0015, 0x0009, 632 0x000f, 0x0010, 0x001b, 0x001d, 0x0201, 0x0702, 0x0001, 0x0013, 633 0x0004, 0x0006, 0x0007, 0x0008, 0x000a, 0x000b, 0x000c, 0x0200, 634 0x0007, 0x0000, 0x0700, 0x001c, 0x001a, 0x0018, 0x0003, 0x0016, 635 0x0002, 0x000e, 0x000d, 0x0200, 0x020e, 0x007f, 0x0700, 0x030c, 636 0x0703, 0x0000, 0x0207, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 637 0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x0208, 0x0204, 0x0307, 638 0x0308, 0x0309, 0x030b, 0x0304, 0x0305, 0x0306, 0x030a, 0x0301, 639 0x0302, 0x0303, 0x0300, 0x0310, 0x0206, 0x0200, 0x0200, 0x010a, 640 0x010b, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 641 0x030e, 0x0702, 0x030d, 0x001c, 0x0701, 0x0205, 0x0114, 0x0603, 642 0x0118, 0x0601, 0x0602, 0x0117, 0x0600, 0x0119, 0x0115, 0x0116, 643 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d, 644 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 645 }; 646 647 const u_short * const linux_keytabs[] = { 648 plain_map, shift_map, altgr_map, altgr_map, ctrl_map 649 }; 650 #endif 651 652 static struct biosdisk_info * 653 fd2biosinfo(p, fp) 654 struct proc *p; 655 struct file *fp; 656 { 657 struct vnode *vp; 658 const char *blkname; 659 char diskname[16]; 660 int i; 661 struct nativedisk_info *nip; 662 struct disklist *dl = i386_alldisks; 663 664 if (fp->f_type != DTYPE_VNODE) 665 return NULL; 666 vp = (struct vnode *)fp->f_data; 667 668 if (vp->v_type != VBLK) 669 return NULL; 670 671 blkname = findblkname(major(vp->v_rdev)); 672 snprintf(diskname, sizeof diskname, "%s%u", blkname, 673 DISKUNIT(vp->v_rdev)); 674 675 for (i = 0; i < dl->dl_nnativedisks; i++) { 676 nip = &dl->dl_nativedisks[i]; 677 if (strcmp(diskname, nip->ni_devname)) 678 continue; 679 if (nip->ni_nmatches != 0) 680 return &dl->dl_biosdisks[nip->ni_biosmatches[0]]; 681 } 682 683 return NULL; 684 } 685 686 687 /* 688 * We come here in a last attempt to satisfy a Linux ioctl() call 689 */ 690 int 691 linux_machdepioctl(p, v, retval) 692 struct proc *p; 693 void *v; 694 register_t *retval; 695 { 696 struct linux_sys_ioctl_args /* { 697 syscallarg(int) fd; 698 syscallarg(u_long) com; 699 syscallarg(caddr_t) data; 700 } */ *uap = v; 701 struct sys_ioctl_args bia; 702 u_long com; 703 int error, error1; 704 #if (NWSDISPLAY > 0) 705 struct vt_mode lvt; 706 caddr_t bvtp, sg; 707 struct kbentry kbe; 708 #endif 709 struct linux_hd_geometry hdg; 710 struct linux_hd_big_geometry hdg_big; 711 struct biosdisk_info *bip; 712 struct filedesc *fdp; 713 struct file *fp; 714 int fd; 715 struct disklabel label, *labp; 716 struct partinfo partp; 717 int (*ioctlf) __P((struct file *, u_long, caddr_t, struct proc *)); 718 u_long start, biostotal, realtotal; 719 u_char heads, sectors; 720 u_int cylinders; 721 struct ioctl_pt pt; 722 723 fd = SCARG(uap, fd); 724 SCARG(&bia, fd) = fd; 725 SCARG(&bia, data) = SCARG(uap, data); 726 com = SCARG(uap, com); 727 728 fdp = p->p_fd; 729 730 if ((fp = fd_getfile(fdp, fd)) == NULL) 731 return (EBADF); 732 733 switch (com) { 734 #if (NWSDISPLAY > 0) 735 case LINUX_KDGKBMODE: 736 com = KDGKBMODE; 737 break; 738 case LINUX_KDSKBMODE: 739 com = KDSKBMODE; 740 if ((unsigned)SCARG(uap, data) == LINUX_K_MEDIUMRAW) 741 SCARG(&bia, data) = (caddr_t)K_RAW; 742 break; 743 case LINUX_KIOCSOUND: 744 SCARG(&bia, data) = 745 (caddr_t)(((unsigned long)SCARG(&bia, data)) & 0xffff); 746 /* fall through */ 747 case LINUX_KDMKTONE: 748 com = KDMKTONE; 749 break; 750 case LINUX_KDSETMODE: 751 com = KDSETMODE; 752 break; 753 case LINUX_KDGETMODE: 754 /* KD_* values are equal to the wscons numbers */ 755 com = WSDISPLAYIO_GMODE; 756 break; 757 case LINUX_KDENABIO: 758 com = KDENABIO; 759 break; 760 case LINUX_KDDISABIO: 761 com = KDDISABIO; 762 break; 763 case LINUX_KDGETLED: 764 com = KDGETLED; 765 break; 766 case LINUX_KDSETLED: 767 com = KDSETLED; 768 break; 769 case LINUX_VT_OPENQRY: 770 com = VT_OPENQRY; 771 break; 772 case LINUX_VT_GETMODE: 773 SCARG(&bia, com) = VT_GETMODE; 774 /* XXX NJWLWP */ 775 if ((error = sys_ioctl(curlwp, &bia, retval))) 776 return error; 777 if ((error = copyin(SCARG(uap, data), (caddr_t)&lvt, 778 sizeof (struct vt_mode)))) 779 return error; 780 lvt.relsig = native_to_linux_signo[lvt.relsig]; 781 lvt.acqsig = native_to_linux_signo[lvt.acqsig]; 782 lvt.frsig = native_to_linux_signo[lvt.frsig]; 783 return copyout((caddr_t)&lvt, SCARG(uap, data), 784 sizeof (struct vt_mode)); 785 case LINUX_VT_SETMODE: 786 com = VT_SETMODE; 787 if ((error = copyin(SCARG(uap, data), (caddr_t)&lvt, 788 sizeof (struct vt_mode)))) 789 return error; 790 lvt.relsig = linux_to_native_signo[lvt.relsig]; 791 lvt.acqsig = linux_to_native_signo[lvt.acqsig]; 792 lvt.frsig = linux_to_native_signo[lvt.frsig]; 793 sg = stackgap_init(p, 0); 794 bvtp = stackgap_alloc(p, &sg, sizeof (struct vt_mode)); 795 if ((error = copyout(&lvt, bvtp, sizeof (struct vt_mode)))) 796 return error; 797 SCARG(&bia, data) = bvtp; 798 break; 799 case LINUX_VT_DISALLOCATE: 800 /* XXX should use WSDISPLAYIO_DELSCREEN */ 801 return 0; 802 case LINUX_VT_RELDISP: 803 com = VT_RELDISP; 804 break; 805 case LINUX_VT_ACTIVATE: 806 com = VT_ACTIVATE; 807 break; 808 case LINUX_VT_WAITACTIVE: 809 com = VT_WAITACTIVE; 810 break; 811 case LINUX_VT_GETSTATE: 812 com = VT_GETSTATE; 813 break; 814 case LINUX_KDGKBTYPE: 815 /* This is what Linux does. */ 816 return (subyte(SCARG(uap, data), KB_101)); 817 case LINUX_KDGKBENT: 818 /* 819 * The Linux KDGKBENT ioctl is different from the 820 * SYSV original. So we handle it in machdep code. 821 * XXX We should use keyboard mapping information 822 * from wsdisplay, but this would be expensive. 823 */ 824 if ((error = copyin(SCARG(uap, data), &kbe, 825 sizeof(struct kbentry)))) 826 return (error); 827 if (kbe.kb_table >= sizeof(linux_keytabs) / sizeof(u_short *) 828 || kbe.kb_index >= NR_KEYS) 829 return (EINVAL); 830 kbe.kb_value = linux_keytabs[kbe.kb_table][kbe.kb_index]; 831 return (copyout(&kbe, SCARG(uap, data), 832 sizeof(struct kbentry))); 833 #endif 834 case LINUX_HDIO_GETGEO: 835 case LINUX_HDIO_GETGEO_BIG: 836 /* 837 * Try to mimic Linux behaviour: return the BIOS geometry 838 * if possible (extending its # of cylinders if it's beyond 839 * the 1023 limit), fall back to the MI geometry (i.e. 840 * the real geometry) if not found, by returning an 841 * error. See common/linux_hdio.c 842 */ 843 FILE_USE(fp); 844 bip = fd2biosinfo(p, fp); 845 ioctlf = fp->f_ops->fo_ioctl; 846 error = ioctlf(fp, DIOCGDEFLABEL, (caddr_t)&label, p); 847 error1 = ioctlf(fp, DIOCGPART, (caddr_t)&partp, p); 848 FILE_UNUSE(fp, p); 849 if (error != 0 && error1 != 0) 850 return error1; 851 labp = error != 0 ? &label : partp.disklab; 852 start = error1 != 0 ? partp.part->p_offset : 0; 853 if (bip != NULL && bip->bi_head != 0 && bip->bi_sec != 0 854 && bip->bi_cyl != 0) { 855 heads = bip->bi_head; 856 sectors = bip->bi_sec; 857 cylinders = bip->bi_cyl; 858 biostotal = heads * sectors * cylinders; 859 realtotal = labp->d_ntracks * labp->d_nsectors * 860 labp->d_ncylinders; 861 if (realtotal > biostotal) 862 cylinders = realtotal / (heads * sectors); 863 } else { 864 heads = labp->d_ntracks; 865 cylinders = labp->d_ncylinders; 866 sectors = labp->d_nsectors; 867 } 868 if (com == LINUX_HDIO_GETGEO) { 869 hdg.start = start; 870 hdg.heads = heads; 871 hdg.cylinders = cylinders; 872 hdg.sectors = sectors; 873 return copyout(&hdg, SCARG(uap, data), sizeof hdg); 874 } else { 875 hdg_big.start = start; 876 hdg_big.heads = heads; 877 hdg_big.cylinders = cylinders; 878 hdg_big.sectors = sectors; 879 return copyout(&hdg_big, SCARG(uap, data), 880 sizeof hdg_big); 881 } 882 883 default: 884 /* 885 * Unknown to us. If it's on a device, just pass it through 886 * using PTIOCLINUX, the device itself might be able to 887 * make some sense of it. 888 * XXX hack: if the function returns EJUSTRETURN, 889 * it has stuffed a sysctl return value in pt.data. 890 */ 891 FILE_USE(fp); 892 ioctlf = fp->f_ops->fo_ioctl; 893 pt.com = SCARG(uap, com); 894 pt.data = SCARG(uap, data); 895 error = ioctlf(fp, PTIOCLINUX, (caddr_t)&pt, p); 896 FILE_UNUSE(fp, p); 897 if (error == EJUSTRETURN) { 898 retval[0] = (register_t)pt.data; 899 error = 0; 900 } 901 902 if (error == ENOTTY) 903 DPRINTF(("linux_machdepioctl: invalid ioctl %08lx\n", 904 com)); 905 return error; 906 } 907 SCARG(&bia, com) = com; 908 /* XXX NJWLWP */ 909 return sys_ioctl(curlwp, &bia, retval); 910 } 911 912 /* 913 * Set I/O permissions for a process. Just set the maximum level 914 * right away (ignoring the argument), otherwise we would have 915 * to rely on I/O permission maps, which are not implemented. 916 */ 917 int 918 linux_sys_iopl(l, v, retval) 919 struct lwp *l; 920 void *v; 921 register_t *retval; 922 { 923 #if 0 924 struct linux_sys_iopl_args /* { 925 syscallarg(int) level; 926 } */ *uap = v; 927 #endif 928 struct proc *p = l->l_proc; 929 struct trapframe *fp = l->l_md.md_regs; 930 931 if (suser(p->p_ucred, &p->p_acflag) != 0) 932 return EPERM; 933 fp->tf_eflags |= PSL_IOPL; 934 *retval = 0; 935 return 0; 936 } 937 938 /* 939 * See above. If a root process tries to set access to an I/O port, 940 * just let it have the whole range. 941 */ 942 int 943 linux_sys_ioperm(l, v, retval) 944 struct lwp *l; 945 void *v; 946 register_t *retval; 947 { 948 struct linux_sys_ioperm_args /* { 949 syscallarg(unsigned int) lo; 950 syscallarg(unsigned int) hi; 951 syscallarg(int) val; 952 } */ *uap = v; 953 struct proc *p = l->l_proc; 954 struct trapframe *fp = l->l_md.md_regs; 955 956 if (suser(p->p_ucred, &p->p_acflag) != 0) 957 return EPERM; 958 if (SCARG(uap, val)) 959 fp->tf_eflags |= PSL_IOPL; 960 *retval = 0; 961 return 0; 962 } 963
Indexes created Wed Oct 01 19:09:53 GMT 2025