linux_machdep.c revision 1.62.2.8
1 /* $NetBSD: linux_machdep.c,v 1.62.2.8 2002/04/17 00:04:57 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.8 2002/04/17 00:04:57 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/lwp.h> 53 #include <sys/proc.h> 54 #include <sys/user.h> 55 #include <sys/buf.h> 56 #include <sys/reboot.h> 57 #include <sys/conf.h> 58 #include <sys/exec.h> 59 #include <sys/file.h> 60 #include <sys/callout.h> 61 #include <sys/malloc.h> 62 #include <sys/mbuf.h> 63 #include <sys/msgbuf.h> 64 #include <sys/mount.h> 65 #include <sys/vnode.h> 66 #include <sys/device.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(catcher, sig, mask, code) 190 sig_t catcher; 191 int sig; 192 sigset_t *mask; 193 u_long code; 194 { 195 struct lwp *l = curproc; 196 struct proc *p = l->l_proc; 197 struct trapframe *tf; 198 struct linux_sigframe *fp, frame; 199 int onstack; 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 return 0; 568 } else { 569 return dev; 570 } 571 } 572 573 #if (NWSDISPLAY > 0) 574 /* 575 * That's not complete, but enough to get an X server running. 576 */ 577 #define NR_KEYS 128 578 static const u_short plain_map[NR_KEYS] = { 579 0x0200, 0x001b, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 580 0x0037, 0x0038, 0x0039, 0x0030, 0x002d, 0x003d, 0x007f, 0x0009, 581 0x0b71, 0x0b77, 0x0b65, 0x0b72, 0x0b74, 0x0b79, 0x0b75, 0x0b69, 582 0x0b6f, 0x0b70, 0x005b, 0x005d, 0x0201, 0x0702, 0x0b61, 0x0b73, 583 0x0b64, 0x0b66, 0x0b67, 0x0b68, 0x0b6a, 0x0b6b, 0x0b6c, 0x003b, 584 0x0027, 0x0060, 0x0700, 0x005c, 0x0b7a, 0x0b78, 0x0b63, 0x0b76, 585 0x0b62, 0x0b6e, 0x0b6d, 0x002c, 0x002e, 0x002f, 0x0700, 0x030c, 586 0x0703, 0x0020, 0x0207, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 587 0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x0208, 0x0209, 0x0307, 588 0x0308, 0x0309, 0x030b, 0x0304, 0x0305, 0x0306, 0x030a, 0x0301, 589 0x0302, 0x0303, 0x0300, 0x0310, 0x0206, 0x0200, 0x003c, 0x010a, 590 0x010b, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 591 0x030e, 0x0702, 0x030d, 0x001c, 0x0701, 0x0205, 0x0114, 0x0603, 592 0x0118, 0x0601, 0x0602, 0x0117, 0x0600, 0x0119, 0x0115, 0x0116, 593 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d, 594 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 595 }, shift_map[NR_KEYS] = { 596 0x0200, 0x001b, 0x0021, 0x0040, 0x0023, 0x0024, 0x0025, 0x005e, 597 0x0026, 0x002a, 0x0028, 0x0029, 0x005f, 0x002b, 0x007f, 0x0009, 598 0x0b51, 0x0b57, 0x0b45, 0x0b52, 0x0b54, 0x0b59, 0x0b55, 0x0b49, 599 0x0b4f, 0x0b50, 0x007b, 0x007d, 0x0201, 0x0702, 0x0b41, 0x0b53, 600 0x0b44, 0x0b46, 0x0b47, 0x0b48, 0x0b4a, 0x0b4b, 0x0b4c, 0x003a, 601 0x0022, 0x007e, 0x0700, 0x007c, 0x0b5a, 0x0b58, 0x0b43, 0x0b56, 602 0x0b42, 0x0b4e, 0x0b4d, 0x003c, 0x003e, 0x003f, 0x0700, 0x030c, 603 0x0703, 0x0020, 0x0207, 0x010a, 0x010b, 0x010c, 0x010d, 0x010e, 604 0x010f, 0x0110, 0x0111, 0x0112, 0x0113, 0x0213, 0x0203, 0x0307, 605 0x0308, 0x0309, 0x030b, 0x0304, 0x0305, 0x0306, 0x030a, 0x0301, 606 0x0302, 0x0303, 0x0300, 0x0310, 0x0206, 0x0200, 0x003e, 0x010a, 607 0x010b, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 608 0x030e, 0x0702, 0x030d, 0x0200, 0x0701, 0x0205, 0x0114, 0x0603, 609 0x020b, 0x0601, 0x0602, 0x0117, 0x0600, 0x020a, 0x0115, 0x0116, 610 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d, 611 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 612 }, altgr_map[NR_KEYS] = { 613 0x0200, 0x0200, 0x0200, 0x0040, 0x0200, 0x0024, 0x0200, 0x0200, 614 0x007b, 0x005b, 0x005d, 0x007d, 0x005c, 0x0200, 0x0200, 0x0200, 615 0x0b71, 0x0b77, 0x0918, 0x0b72, 0x0b74, 0x0b79, 0x0b75, 0x0b69, 616 0x0b6f, 0x0b70, 0x0200, 0x007e, 0x0201, 0x0702, 0x0914, 0x0b73, 617 0x0917, 0x0919, 0x0b67, 0x0b68, 0x0b6a, 0x0b6b, 0x0b6c, 0x0200, 618 0x0200, 0x0200, 0x0700, 0x0200, 0x0b7a, 0x0b78, 0x0916, 0x0b76, 619 0x0915, 0x0b6e, 0x0b6d, 0x0200, 0x0200, 0x0200, 0x0700, 0x030c, 620 0x0703, 0x0200, 0x0207, 0x050c, 0x050d, 0x050e, 0x050f, 0x0510, 621 0x0511, 0x0512, 0x0513, 0x0514, 0x0515, 0x0208, 0x0202, 0x0911, 622 0x0912, 0x0913, 0x030b, 0x090e, 0x090f, 0x0910, 0x030a, 0x090b, 623 0x090c, 0x090d, 0x090a, 0x0310, 0x0206, 0x0200, 0x007c, 0x0516, 624 0x0517, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 625 0x030e, 0x0702, 0x030d, 0x0200, 0x0701, 0x0205, 0x0114, 0x0603, 626 0x0118, 0x0601, 0x0602, 0x0117, 0x0600, 0x0119, 0x0115, 0x0116, 627 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d, 628 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 629 }, ctrl_map[NR_KEYS] = { 630 0x0200, 0x0200, 0x0200, 0x0000, 0x001b, 0x001c, 0x001d, 0x001e, 631 0x001f, 0x007f, 0x0200, 0x0200, 0x001f, 0x0200, 0x0008, 0x0200, 632 0x0011, 0x0017, 0x0005, 0x0012, 0x0014, 0x0019, 0x0015, 0x0009, 633 0x000f, 0x0010, 0x001b, 0x001d, 0x0201, 0x0702, 0x0001, 0x0013, 634 0x0004, 0x0006, 0x0007, 0x0008, 0x000a, 0x000b, 0x000c, 0x0200, 635 0x0007, 0x0000, 0x0700, 0x001c, 0x001a, 0x0018, 0x0003, 0x0016, 636 0x0002, 0x000e, 0x000d, 0x0200, 0x020e, 0x007f, 0x0700, 0x030c, 637 0x0703, 0x0000, 0x0207, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 638 0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x0208, 0x0204, 0x0307, 639 0x0308, 0x0309, 0x030b, 0x0304, 0x0305, 0x0306, 0x030a, 0x0301, 640 0x0302, 0x0303, 0x0300, 0x0310, 0x0206, 0x0200, 0x0200, 0x010a, 641 0x010b, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 642 0x030e, 0x0702, 0x030d, 0x001c, 0x0701, 0x0205, 0x0114, 0x0603, 643 0x0118, 0x0601, 0x0602, 0x0117, 0x0600, 0x0119, 0x0115, 0x0116, 644 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d, 645 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 646 }; 647 648 const u_short * const linux_keytabs[] = { 649 plain_map, shift_map, altgr_map, altgr_map, ctrl_map 650 }; 651 #endif 652 653 static struct biosdisk_info * 654 fd2biosinfo(p, fp) 655 struct proc *p; 656 struct file *fp; 657 { 658 struct vnode *vp; 659 const char *blkname; 660 char diskname[16]; 661 int i; 662 struct nativedisk_info *nip; 663 struct disklist *dl = i386_alldisks; 664 665 if (fp->f_type != DTYPE_VNODE) 666 return NULL; 667 vp = (struct vnode *)fp->f_data; 668 669 if (vp->v_type != VBLK) 670 return NULL; 671 672 blkname = findblkname(major(vp->v_rdev)); 673 snprintf(diskname, sizeof diskname, "%s%u", blkname, 674 DISKUNIT(vp->v_rdev)); 675 676 for (i = 0; i < dl->dl_nnativedisks; i++) { 677 nip = &dl->dl_nativedisks[i]; 678 if (strcmp(diskname, nip->ni_devname)) 679 continue; 680 if (nip->ni_nmatches != 0) 681 return &dl->dl_biosdisks[nip->ni_biosmatches[0]]; 682 } 683 684 return NULL; 685 } 686 687 688 /* 689 * We come here in a last attempt to satisfy a Linux ioctl() call 690 */ 691 int 692 linux_machdepioctl(p, v, retval) 693 struct proc *p; 694 void *v; 695 register_t *retval; 696 { 697 struct linux_sys_ioctl_args /* { 698 syscallarg(int) fd; 699 syscallarg(u_long) com; 700 syscallarg(caddr_t) data; 701 } */ *uap = v; 702 struct sys_ioctl_args bia; 703 u_long com; 704 int error, error1; 705 #if (NWSDISPLAY > 0) 706 struct vt_mode lvt; 707 caddr_t bvtp, sg; 708 struct kbentry kbe; 709 #endif 710 struct linux_hd_geometry hdg; 711 struct linux_hd_big_geometry hdg_big; 712 struct biosdisk_info *bip; 713 struct filedesc *fdp; 714 struct file *fp; 715 int fd; 716 struct disklabel label, *labp; 717 struct partinfo partp; 718 int (*ioctlf) __P((struct file *, u_long, caddr_t, struct proc *)); 719 u_long start, biostotal, realtotal; 720 u_char heads, sectors; 721 u_int cylinders; 722 struct ioctl_pt pt; 723 724 fd = SCARG(uap, fd); 725 SCARG(&bia, fd) = fd; 726 SCARG(&bia, data) = SCARG(uap, data); 727 com = SCARG(uap, com); 728 729 fdp = p->p_fd; 730 731 if ((fp = fd_getfile(fdp, fd)) == NULL) 732 return (EBADF); 733 734 switch (com) { 735 #if (NWSDISPLAY > 0) 736 case LINUX_KDGKBMODE: 737 com = KDGKBMODE; 738 break; 739 case LINUX_KDSKBMODE: 740 com = KDSKBMODE; 741 if ((unsigned)SCARG(uap, data) == LINUX_K_MEDIUMRAW) 742 SCARG(&bia, data) = (caddr_t)K_RAW; 743 break; 744 case LINUX_KIOCSOUND: 745 SCARG(&bia, data) = 746 (caddr_t)(((unsigned long)SCARG(&bia, data)) & 0xffff); 747 /* fall through */ 748 case LINUX_KDMKTONE: 749 com = KDMKTONE; 750 break; 751 case LINUX_KDSETMODE: 752 com = KDSETMODE; 753 break; 754 case LINUX_KDGETMODE: 755 /* KD_* values are equal to the wscons numbers */ 756 com = WSDISPLAYIO_GMODE; 757 break; 758 case LINUX_KDENABIO: 759 com = KDENABIO; 760 break; 761 case LINUX_KDDISABIO: 762 com = KDDISABIO; 763 break; 764 case LINUX_KDGETLED: 765 com = KDGETLED; 766 break; 767 case LINUX_KDSETLED: 768 com = KDSETLED; 769 break; 770 case LINUX_VT_OPENQRY: 771 com = VT_OPENQRY; 772 break; 773 case LINUX_VT_GETMODE: 774 SCARG(&bia, com) = VT_GETMODE; 775 /* XXX NJWLWP */ 776 if ((error = sys_ioctl(curproc, &bia, retval))) 777 return error; 778 if ((error = copyin(SCARG(uap, data), (caddr_t)&lvt, 779 sizeof (struct vt_mode)))) 780 return error; 781 lvt.relsig = native_to_linux_signo[lvt.relsig]; 782 lvt.acqsig = native_to_linux_signo[lvt.acqsig]; 783 lvt.frsig = native_to_linux_signo[lvt.frsig]; 784 return copyout((caddr_t)&lvt, SCARG(uap, data), 785 sizeof (struct vt_mode)); 786 case LINUX_VT_SETMODE: 787 com = VT_SETMODE; 788 if ((error = copyin(SCARG(uap, data), (caddr_t)&lvt, 789 sizeof (struct vt_mode)))) 790 return error; 791 lvt.relsig = linux_to_native_signo[lvt.relsig]; 792 lvt.acqsig = linux_to_native_signo[lvt.acqsig]; 793 lvt.frsig = linux_to_native_signo[lvt.frsig]; 794 sg = stackgap_init(p, 0); 795 bvtp = stackgap_alloc(p, &sg, sizeof (struct vt_mode)); 796 if ((error = copyout(&lvt, bvtp, sizeof (struct vt_mode)))) 797 return error; 798 SCARG(&bia, data) = bvtp; 799 break; 800 case LINUX_VT_DISALLOCATE: 801 /* XXX should use WSDISPLAYIO_DELSCREEN */ 802 return 0; 803 case LINUX_VT_RELDISP: 804 com = VT_RELDISP; 805 break; 806 case LINUX_VT_ACTIVATE: 807 com = VT_ACTIVATE; 808 break; 809 case LINUX_VT_WAITACTIVE: 810 com = VT_WAITACTIVE; 811 break; 812 case LINUX_VT_GETSTATE: 813 com = VT_GETSTATE; 814 break; 815 case LINUX_KDGKBTYPE: 816 /* This is what Linux does. */ 817 return (subyte(SCARG(uap, data), KB_101)); 818 case LINUX_KDGKBENT: 819 /* 820 * The Linux KDGKBENT ioctl is different from the 821 * SYSV original. So we handle it in machdep code. 822 * XXX We should use keyboard mapping information 823 * from wsdisplay, but this would be expensive. 824 */ 825 if ((error = copyin(SCARG(uap, data), &kbe, 826 sizeof(struct kbentry)))) 827 return (error); 828 if (kbe.kb_table >= sizeof(linux_keytabs) / sizeof(u_short *) 829 || kbe.kb_index >= NR_KEYS) 830 return (EINVAL); 831 kbe.kb_value = linux_keytabs[kbe.kb_table][kbe.kb_index]; 832 return (copyout(&kbe, SCARG(uap, data), 833 sizeof(struct kbentry))); 834 #endif 835 case LINUX_HDIO_GETGEO: 836 case LINUX_HDIO_GETGEO_BIG: 837 /* 838 * Try to mimic Linux behaviour: return the BIOS geometry 839 * if possible (extending its # of cylinders if it's beyond 840 * the 1023 limit), fall back to the MI geometry (i.e. 841 * the real geometry) if not found, by returning an 842 * error. See common/linux_hdio.c 843 */ 844 FILE_USE(fp); 845 bip = fd2biosinfo(p, fp); 846 ioctlf = fp->f_ops->fo_ioctl; 847 error = ioctlf(fp, DIOCGDEFLABEL, (caddr_t)&label, p); 848 error1 = ioctlf(fp, DIOCGPART, (caddr_t)&partp, p); 849 FILE_UNUSE(fp, p); 850 if (error != 0 && error1 != 0) 851 return error1; 852 labp = error != 0 ? &label : partp.disklab; 853 start = error1 != 0 ? partp.part->p_offset : 0; 854 if (bip != NULL && bip->bi_head != 0 && bip->bi_sec != 0 855 && bip->bi_cyl != 0) { 856 heads = bip->bi_head; 857 sectors = bip->bi_sec; 858 cylinders = bip->bi_cyl; 859 biostotal = heads * sectors * cylinders; 860 realtotal = labp->d_ntracks * labp->d_nsectors * 861 labp->d_ncylinders; 862 if (realtotal > biostotal) 863 cylinders = realtotal / (heads * sectors); 864 } else { 865 heads = labp->d_ntracks; 866 cylinders = labp->d_ncylinders; 867 sectors = labp->d_nsectors; 868 } 869 if (com == LINUX_HDIO_GETGEO) { 870 hdg.start = start; 871 hdg.heads = heads; 872 hdg.cylinders = cylinders; 873 hdg.sectors = sectors; 874 return copyout(&hdg, SCARG(uap, data), sizeof hdg); 875 } else { 876 hdg_big.start = start; 877 hdg_big.heads = heads; 878 hdg_big.cylinders = cylinders; 879 hdg_big.sectors = sectors; 880 return copyout(&hdg_big, SCARG(uap, data), 881 sizeof hdg_big); 882 } 883 return 0; 884 885 default: 886 /* 887 * Unknown to us. If it's on a device, just pass it through 888 * using PTIOCLINUX, the device itself might be able to 889 * make some sense of it. 890 * XXX hack: if the function returns EJUSTRETURN, 891 * it has stuffed a sysctl return value in pt.data. 892 */ 893 FILE_USE(fp); 894 ioctlf = fp->f_ops->fo_ioctl; 895 pt.com = SCARG(uap, com); 896 pt.data = SCARG(uap, data); 897 error = ioctlf(fp, PTIOCLINUX, (caddr_t)&pt, p); 898 FILE_UNUSE(fp, p); 899 if (error == EJUSTRETURN) { 900 retval[0] = (register_t)pt.data; 901 error = 0; 902 } 903 904 if (error == ENOTTY) 905 DPRINTF(("linux_machdepioctl: invalid ioctl %08lx\n", 906 com)); 907 return error; 908 } 909 SCARG(&bia, com) = com; 910 /* XXX NJWLWP */ 911 return sys_ioctl(curproc, &bia, retval); 912 } 913 914 /* 915 * Set I/O permissions for a process. Just set the maximum level 916 * right away (ignoring the argument), otherwise we would have 917 * to rely on I/O permission maps, which are not implemented. 918 */ 919 int 920 linux_sys_iopl(l, v, retval) 921 struct lwp *l; 922 void *v; 923 register_t *retval; 924 { 925 #if 0 926 struct linux_sys_iopl_args /* { 927 syscallarg(int) level; 928 } */ *uap = v; 929 #endif 930 struct proc *p = l->l_proc; 931 struct trapframe *fp = l->l_md.md_regs; 932 933 if (suser(p->p_ucred, &p->p_acflag) != 0) 934 return EPERM; 935 fp->tf_eflags |= PSL_IOPL; 936 *retval = 0; 937 return 0; 938 } 939 940 /* 941 * See above. If a root process tries to set access to an I/O port, 942 * just let it have the whole range. 943 */ 944 int 945 linux_sys_ioperm(l, v, retval) 946 struct lwp *l; 947 void *v; 948 register_t *retval; 949 { 950 struct linux_sys_ioperm_args /* { 951 syscallarg(unsigned int) lo; 952 syscallarg(unsigned int) hi; 953 syscallarg(int) val; 954 } */ *uap = v; 955 struct proc *p = l->l_proc; 956 struct trapframe *fp = l->l_md.md_regs; 957 958 if (suser(p->p_ucred, &p->p_acflag) != 0) 959 return EPERM; 960 if (SCARG(uap, val)) 961 fp->tf_eflags |= PSL_IOPL; 962 *retval = 0; 963 return 0; 964 } 965
Indexes created Wed Oct 01 19:09:53 GMT 2025