Annotation of src/sys/compat/linux/arch/i386/linux_machdep.c, Revision 1.48
1.48 ! augustss 1: /* $NetBSD: linux_machdep.c,v 1.47 1999/10/04 17:46:37 fvdl Exp $ */
1.1 fvdl 2:
1.45 fvdl 3: /*-
4: * Copyright (c) 1995 The NetBSD Foundation, Inc.
1.1 fvdl 5: * All rights reserved.
6: *
1.45 fvdl 7: * This code is derived from software contributed to The NetBSD Foundation
8: * by Frank van der Linden.
9: *
1.1 fvdl 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:
1.45 fvdl 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.
1.1 fvdl 25: *
1.45 fvdl 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.
1.1 fvdl 37: */
1.35 thorpej 38:
39: #include "opt_vm86.h"
1.36 thorpej 40: #include "opt_user_ldt.h"
1.1 fvdl 41:
42: #include <sys/param.h>
43: #include <sys/systm.h>
44: #include <sys/signalvar.h>
45: #include <sys/kernel.h>
46: #include <sys/map.h>
47: #include <sys/proc.h>
48: #include <sys/user.h>
49: #include <sys/buf.h>
50: #include <sys/reboot.h>
51: #include <sys/conf.h>
1.31 thorpej 52: #include <sys/exec.h>
1.1 fvdl 53: #include <sys/file.h>
54: #include <sys/callout.h>
55: #include <sys/malloc.h>
56: #include <sys/mbuf.h>
57: #include <sys/msgbuf.h>
58: #include <sys/mount.h>
59: #include <sys/vnode.h>
60: #include <sys/device.h>
61: #include <sys/syscallargs.h>
1.13 fvdl 62: #include <sys/filedesc.h>
1.39 mycroft 63: #include <sys/exec_elf.h>
1.7 mycroft 64:
1.44 christos 65: #include <compat/linux/common/linux_types.h>
66: #include <compat/linux/common/linux_signal.h>
67: #include <compat/linux/common/linux_util.h>
68: #include <compat/linux/common/linux_ioctl.h>
69: #include <compat/linux/common/linux_exec.h>
70: #include <compat/linux/common/linux_machdep.h>
71:
1.1 fvdl 72: #include <compat/linux/linux_syscallargs.h>
73:
74: #include <machine/cpu.h>
75: #include <machine/cpufunc.h>
76: #include <machine/psl.h>
77: #include <machine/reg.h>
1.7 mycroft 78: #include <machine/segments.h>
1.1 fvdl 79: #include <machine/specialreg.h>
1.7 mycroft 80: #include <machine/sysarch.h>
1.26 mycroft 81: #include <machine/vm86.h>
1.34 mycroft 82: #include <machine/vmparam.h>
1.1 fvdl 83:
84: /*
1.13 fvdl 85: * To see whether pcvt is configured (for virtual console ioctl calls).
86: */
1.33 sommerfe 87: #ifndef NVT
1.13 fvdl 88: #include "vt.h"
1.33 sommerfe 89: #endif
1.13 fvdl 90: #if NVT > 0
91: #include <arch/i386/isa/pcvt/pcvt_ioctl.h>
92: #endif
93:
1.41 drochner 94: #include "wsdisplay.h"
95: #if (NWSDISPLAY > 0)
96: #include <sys/ioctl.h>
97: #include <dev/wscons/wsdisplay_usl_io.h>
98: #include "opt_xserver.h"
99: #endif
100:
1.29 christos 101: #ifdef USER_LDT
102: #include <machine/cpu.h>
103: int linux_read_ldt __P((struct proc *, struct linux_sys_modify_ldt_args *,
104: register_t *));
105: int linux_write_ldt __P((struct proc *, struct linux_sys_modify_ldt_args *,
106: register_t *));
107: #endif
108:
1.13 fvdl 109: /*
1.1 fvdl 110: * Deal with some i386-specific things in the Linux emulation code.
111: */
1.37 mycroft 112:
113: void
114: linux_setregs(p, epp, stack)
115: struct proc *p;
116: struct exec_package *epp;
117: u_long stack;
118: {
1.48 ! augustss 119: struct pcb *pcb = &p->p_addr->u_pcb;
1.37 mycroft 120:
1.46 kleink 121: setregs(p, epp, stack);
1.39 mycroft 122: pcb->pcb_savefpu.sv_env.en_cw = __Linux_NPXCW__;
1.37 mycroft 123: }
1.1 fvdl 124:
125: /*
126: * Send an interrupt to process.
127: *
128: * Stack is set up to allow sigcode stored
129: * in u. to call routine, followed by kcall
130: * to sigreturn routine below. After sigreturn
131: * resets the signal mask, the stack, and the
132: * frame pointer, it returns to the user
133: * specified pc, psl.
134: */
135:
136: void
137: linux_sendsig(catcher, sig, mask, code)
138: sig_t catcher;
1.42 mycroft 139: int sig;
140: sigset_t *mask;
1.1 fvdl 141: u_long code;
142: {
1.48 ! augustss 143: struct proc *p = curproc;
! 144: struct trapframe *tf;
1.1 fvdl 145: struct linux_sigframe *fp, frame;
146: struct sigacts *psp = p->p_sigacts;
147:
1.3 mycroft 148: tf = p->p_md.md_regs;
1.1 fvdl 149:
1.42 mycroft 150: /* Allocate space for the signal handler context. */
151: /* XXX Linux doesn't support the signal stack. */
152: fp = (struct linux_sigframe *)tf->tf_esp;
153: fp--;
1.1 fvdl 154:
1.42 mycroft 155: /* Build stack frame for signal trampoline. */
1.7 mycroft 156: frame.sf_handler = catcher;
1.42 mycroft 157: frame.sf_sig = native_to_linux_sig[sig];
1.1 fvdl 158:
1.42 mycroft 159: /* Save register context. */
1.4 mycroft 160: #ifdef VM86
161: if (tf->tf_eflags & PSL_VM) {
1.7 mycroft 162: frame.sf_sc.sc_gs = tf->tf_vm86_gs;
163: frame.sf_sc.sc_fs = tf->tf_vm86_fs;
164: frame.sf_sc.sc_es = tf->tf_vm86_es;
165: frame.sf_sc.sc_ds = tf->tf_vm86_ds;
1.26 mycroft 166: frame.sf_sc.sc_eflags = get_vflags(p);
1.4 mycroft 167: } else
1.18 fvdl 168: #endif
1.4 mycroft 169: {
1.7 mycroft 170: __asm("movl %%gs,%w0" : "=r" (frame.sf_sc.sc_gs));
171: __asm("movl %%fs,%w0" : "=r" (frame.sf_sc.sc_fs));
172: frame.sf_sc.sc_es = tf->tf_es;
173: frame.sf_sc.sc_ds = tf->tf_ds;
1.26 mycroft 174: frame.sf_sc.sc_eflags = tf->tf_eflags;
1.4 mycroft 175: }
1.26 mycroft 176: frame.sf_sc.sc_edi = tf->tf_edi;
177: frame.sf_sc.sc_esi = tf->tf_esi;
178: frame.sf_sc.sc_ebp = tf->tf_ebp;
179: frame.sf_sc.sc_ebx = tf->tf_ebx;
180: frame.sf_sc.sc_edx = tf->tf_edx;
181: frame.sf_sc.sc_ecx = tf->tf_ecx;
182: frame.sf_sc.sc_eax = tf->tf_eax;
183: frame.sf_sc.sc_eip = tf->tf_eip;
184: frame.sf_sc.sc_cs = tf->tf_cs;
1.7 mycroft 185: frame.sf_sc.sc_esp_at_signal = tf->tf_esp;
1.26 mycroft 186: frame.sf_sc.sc_ss = tf->tf_ss;
187: frame.sf_sc.sc_err = tf->tf_err;
1.7 mycroft 188: frame.sf_sc.sc_trapno = tf->tf_trapno;
1.1 fvdl 189:
1.42 mycroft 190: /* Save signal stack. */
191: /* XXX Linux doesn't support the signal stack. */
192:
193: /* Save signal mask. */
1.47 fvdl 194: native_to_linux_old_sigset(mask, &frame.sf_sc.sc_mask);
1.42 mycroft 195:
1.1 fvdl 196: if (copyout(&frame, fp, sizeof(frame)) != 0) {
197: /*
198: * Process has trashed its stack; give it an illegal
199: * instruction to halt it in its tracks.
200: */
201: sigexit(p, SIGILL);
202: /* NOTREACHED */
203: }
204:
205: /*
206: * Build context to run handler in.
207: */
1.26 mycroft 208: tf->tf_es = GSEL(GUDATA_SEL, SEL_UPL);
209: tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL);
1.42 mycroft 210: tf->tf_eip = (int)psp->ps_sigcode;
1.23 mycroft 211: tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL);
1.28 mycroft 212: tf->tf_eflags &= ~(PSL_T|PSL_VM|PSL_AC);
1.26 mycroft 213: tf->tf_esp = (int)fp;
1.23 mycroft 214: tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL);
1.42 mycroft 215:
216: /* Remember that we're now on the signal stack. */
217: /* XXX Linux doesn't support the signal stack. */
1.1 fvdl 218: }
219:
220: /*
221: * System call to cleanup state after a signal
222: * has been taken. Reset signal mask and
223: * stack state from context left by sendsig (above).
224: * Return to previous pc and psl as specified by
225: * context left by sendsig. Check carefully to
226: * make sure that the user has not modified the
227: * psl to gain improper privileges or to cause
228: * a machine fault.
229: */
1.43 erh 230: int
231: linux_sys_rt_sigreturn(p, v, retval)
232: struct proc *p;
233: void *v;
234: register_t *retval;
235: {
236: /* XXX XAX write me */
237: return(ENOSYS);
238: }
239:
1.1 fvdl 240: int
1.20 mycroft 241: linux_sys_sigreturn(p, v, retval)
1.1 fvdl 242: struct proc *p;
1.19 thorpej 243: void *v;
244: register_t *retval;
245: {
1.20 mycroft 246: struct linux_sys_sigreturn_args /* {
1.1 fvdl 247: syscallarg(struct linux_sigcontext *) scp;
1.19 thorpej 248: } */ *uap = v;
1.1 fvdl 249: struct linux_sigcontext *scp, context;
1.48 ! augustss 250: struct trapframe *tf;
1.42 mycroft 251: sigset_t mask;
1.1 fvdl 252:
253: /*
254: * The trampoline code hands us the context.
255: * It is unsafe to keep track of it ourselves, in the event that a
256: * program jumps out of a signal handler.
257: */
258: scp = SCARG(uap, scp);
259: if (copyin((caddr_t)scp, &context, sizeof(*scp)) != 0)
260: return (EFAULT);
261:
1.42 mycroft 262: /* Restore register context. */
263: tf = p->p_md.md_regs;
1.4 mycroft 264: #ifdef VM86
1.7 mycroft 265: if (context.sc_eflags & PSL_VM) {
266: tf->tf_vm86_gs = context.sc_gs;
267: tf->tf_vm86_fs = context.sc_fs;
268: tf->tf_vm86_es = context.sc_es;
269: tf->tf_vm86_ds = context.sc_ds;
1.26 mycroft 270: set_vflags(p, context.sc_eflags);
1.4 mycroft 271: } else
272: #endif
273: {
1.26 mycroft 274: /*
275: * Check for security violations. If we're returning to
276: * protected mode, the CPU will validate the segment registers
277: * automatically and generate a trap on violations. We handle
278: * the trap, rather than doing all of the checking here.
279: */
280: if (((context.sc_eflags ^ tf->tf_eflags) & PSL_USERSTATIC) != 0 ||
281: !USERMODE(context.sc_cs, context.sc_eflags))
282: return (EINVAL);
283:
1.4 mycroft 284: /* %fs and %gs were restored by the trampoline. */
1.7 mycroft 285: tf->tf_es = context.sc_es;
286: tf->tf_ds = context.sc_ds;
1.26 mycroft 287: tf->tf_eflags = context.sc_eflags;
1.4 mycroft 288: }
1.26 mycroft 289: tf->tf_edi = context.sc_edi;
290: tf->tf_esi = context.sc_esi;
291: tf->tf_ebp = context.sc_ebp;
292: tf->tf_ebx = context.sc_ebx;
293: tf->tf_edx = context.sc_edx;
294: tf->tf_ecx = context.sc_ecx;
295: tf->tf_eax = context.sc_eax;
296: tf->tf_eip = context.sc_eip;
297: tf->tf_cs = context.sc_cs;
298: tf->tf_esp = context.sc_esp_at_signal;
299: tf->tf_ss = context.sc_ss;
300:
1.42 mycroft 301: /* Restore signal stack. */
1.26 mycroft 302: p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
1.42 mycroft 303:
304: /* Restore signal mask. */
1.47 fvdl 305: linux_old_to_native_sigset(&context.sc_mask, &mask);
1.42 mycroft 306: (void) sigprocmask1(p, SIG_SETMASK, &mask, 0);
1.1 fvdl 307:
308: return (EJUSTRETURN);
1.6 mycroft 309: }
310:
1.7 mycroft 311: #ifdef USER_LDT
312:
313: int
314: linux_read_ldt(p, uap, retval)
315: struct proc *p;
1.20 mycroft 316: struct linux_sys_modify_ldt_args /* {
1.7 mycroft 317: syscallarg(int) func;
318: syscallarg(void *) ptr;
319: syscallarg(size_t) bytecount;
320: } */ *uap;
321: register_t *retval;
322: {
323: struct i386_get_ldt_args gl;
324: int error;
325: caddr_t sg;
326: char *parms;
327:
1.10 christos 328: sg = stackgap_init(p->p_emul);
1.7 mycroft 329:
330: gl.start = 0;
331: gl.desc = SCARG(uap, ptr);
332: gl.num = SCARG(uap, bytecount) / sizeof(union descriptor);
333:
334: parms = stackgap_alloc(&sg, sizeof(gl));
335:
1.29 christos 336: if ((error = copyout(&gl, parms, sizeof(gl))) != 0)
1.7 mycroft 337: return (error);
338:
1.29 christos 339: if ((error = i386_get_ldt(p, parms, retval)) != 0)
1.7 mycroft 340: return (error);
341:
342: *retval *= sizeof(union descriptor);
343: return (0);
344: }
345:
346: struct linux_ldt_info {
347: u_int entry_number;
348: u_long base_addr;
349: u_int limit;
350: u_int seg_32bit:1;
351: u_int contents:2;
352: u_int read_exec_only:1;
353: u_int limit_in_pages:1;
354: u_int seg_not_present:1;
355: };
356:
357: int
358: linux_write_ldt(p, uap, retval)
359: struct proc *p;
1.20 mycroft 360: struct linux_sys_modify_ldt_args /* {
1.7 mycroft 361: syscallarg(int) func;
362: syscallarg(void *) ptr;
363: syscallarg(size_t) bytecount;
364: } */ *uap;
365: register_t *retval;
366: {
367: struct linux_ldt_info ldt_info;
368: struct segment_descriptor sd;
369: struct i386_set_ldt_args sl;
370: int error;
371: caddr_t sg;
372: char *parms;
373:
374: if (SCARG(uap, bytecount) != sizeof(ldt_info))
375: return (EINVAL);
1.29 christos 376: if ((error = copyin(SCARG(uap, ptr), &ldt_info, sizeof(ldt_info))) != 0)
1.7 mycroft 377: return error;
378: if (ldt_info.contents == 3)
379: return (EINVAL);
380:
1.10 christos 381: sg = stackgap_init(p->p_emul);
1.7 mycroft 382:
383: sd.sd_lobase = ldt_info.base_addr & 0xffffff;
384: sd.sd_hibase = (ldt_info.base_addr >> 24) & 0xff;
385: sd.sd_lolimit = ldt_info.limit & 0xffff;
386: sd.sd_hilimit = (ldt_info.limit >> 16) & 0xf;
387: sd.sd_type =
388: 16 | (ldt_info.contents << 2) | (!ldt_info.read_exec_only << 1);
389: sd.sd_dpl = SEL_UPL;
390: sd.sd_p = !ldt_info.seg_not_present;
391: sd.sd_def32 = ldt_info.seg_32bit;
392: sd.sd_gran = ldt_info.limit_in_pages;
393:
394: sl.start = ldt_info.entry_number;
395: sl.desc = stackgap_alloc(&sg, sizeof(sd));
396: sl.num = 1;
397:
1.8 mycroft 398: #if 0
1.32 christos 399: printf("linux_write_ldt: idx=%d, base=%x, limit=%x\n",
1.7 mycroft 400: ldt_info.entry_number, ldt_info.base_addr, ldt_info.limit);
1.8 mycroft 401: #endif
1.7 mycroft 402:
403: parms = stackgap_alloc(&sg, sizeof(sl));
404:
1.29 christos 405: if ((error = copyout(&sd, sl.desc, sizeof(sd))) != 0)
1.7 mycroft 406: return (error);
1.29 christos 407: if ((error = copyout(&sl, parms, sizeof(sl))) != 0)
1.7 mycroft 408: return (error);
409:
1.29 christos 410: if ((error = i386_set_ldt(p, parms, retval)) != 0)
1.7 mycroft 411: return (error);
412:
413: *retval = 0;
414: return (0);
415: }
416:
417: #endif /* USER_LDT */
418:
1.6 mycroft 419: int
1.20 mycroft 420: linux_sys_modify_ldt(p, v, retval)
1.6 mycroft 421: struct proc *p;
1.19 thorpej 422: void *v;
423: register_t *retval;
424: {
1.20 mycroft 425: struct linux_sys_modify_ldt_args /* {
1.6 mycroft 426: syscallarg(int) func;
427: syscallarg(void *) ptr;
428: syscallarg(size_t) bytecount;
1.19 thorpej 429: } */ *uap = v;
1.6 mycroft 430:
431: switch (SCARG(uap, func)) {
1.7 mycroft 432: #ifdef USER_LDT
1.6 mycroft 433: case 0:
1.7 mycroft 434: return (linux_read_ldt(p, uap, retval));
435:
1.6 mycroft 436: case 1:
1.7 mycroft 437: return (linux_write_ldt(p, uap, retval));
438: #endif /* USER_LDT */
439:
1.6 mycroft 440: default:
441: return (ENOSYS);
442: }
1.13 fvdl 443: }
444:
445: /*
446: * XXX Pathetic hack to make svgalib work. This will fake the major
447: * device number of an opened VT so that svgalib likes it. grmbl.
448: * Should probably do it 'wrong the right way' and use a mapping
449: * array for all major device numbers, and map linux_mknod too.
450: */
451: dev_t
452: linux_fakedev(dev)
453: dev_t dev;
454: {
1.41 drochner 455: #if (NVT > 0)
456: if (major(dev) == NETBSD_PCCONS_MAJOR)
457: return makedev(LINUX_CONS_MAJOR, (minor(dev) + 1));
458: #endif
459: #if (NWSDISPLAY > 0)
460: if (major(dev) == NETBSD_WSCONS_MAJOR)
1.17 fvdl 461: return makedev(LINUX_CONS_MAJOR, (minor(dev) + 1));
1.41 drochner 462: #endif
1.13 fvdl 463: return dev;
464: }
465:
1.41 drochner 466: #if (NWSDISPLAY > 0) && defined(XSERVER)
467: /*
468: * That's not complete, but enough to get an X server running.
469: */
470: #define NR_KEYS 128
471: static u_short plain_map[NR_KEYS] = {
472: 0x0200, 0x001b, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036,
473: 0x0037, 0x0038, 0x0039, 0x0030, 0x002d, 0x003d, 0x007f, 0x0009,
474: 0x0b71, 0x0b77, 0x0b65, 0x0b72, 0x0b74, 0x0b79, 0x0b75, 0x0b69,
475: 0x0b6f, 0x0b70, 0x005b, 0x005d, 0x0201, 0x0702, 0x0b61, 0x0b73,
476: 0x0b64, 0x0b66, 0x0b67, 0x0b68, 0x0b6a, 0x0b6b, 0x0b6c, 0x003b,
477: 0x0027, 0x0060, 0x0700, 0x005c, 0x0b7a, 0x0b78, 0x0b63, 0x0b76,
478: 0x0b62, 0x0b6e, 0x0b6d, 0x002c, 0x002e, 0x002f, 0x0700, 0x030c,
479: 0x0703, 0x0020, 0x0207, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104,
480: 0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x0208, 0x0209, 0x0307,
481: 0x0308, 0x0309, 0x030b, 0x0304, 0x0305, 0x0306, 0x030a, 0x0301,
482: 0x0302, 0x0303, 0x0300, 0x0310, 0x0206, 0x0200, 0x003c, 0x010a,
483: 0x010b, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
484: 0x030e, 0x0702, 0x030d, 0x001c, 0x0701, 0x0205, 0x0114, 0x0603,
485: 0x0118, 0x0601, 0x0602, 0x0117, 0x0600, 0x0119, 0x0115, 0x0116,
486: 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d,
487: 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
488: }, shift_map[NR_KEYS] = {
489: 0x0200, 0x001b, 0x0021, 0x0040, 0x0023, 0x0024, 0x0025, 0x005e,
490: 0x0026, 0x002a, 0x0028, 0x0029, 0x005f, 0x002b, 0x007f, 0x0009,
491: 0x0b51, 0x0b57, 0x0b45, 0x0b52, 0x0b54, 0x0b59, 0x0b55, 0x0b49,
492: 0x0b4f, 0x0b50, 0x007b, 0x007d, 0x0201, 0x0702, 0x0b41, 0x0b53,
493: 0x0b44, 0x0b46, 0x0b47, 0x0b48, 0x0b4a, 0x0b4b, 0x0b4c, 0x003a,
494: 0x0022, 0x007e, 0x0700, 0x007c, 0x0b5a, 0x0b58, 0x0b43, 0x0b56,
495: 0x0b42, 0x0b4e, 0x0b4d, 0x003c, 0x003e, 0x003f, 0x0700, 0x030c,
496: 0x0703, 0x0020, 0x0207, 0x010a, 0x010b, 0x010c, 0x010d, 0x010e,
497: 0x010f, 0x0110, 0x0111, 0x0112, 0x0113, 0x0213, 0x0203, 0x0307,
498: 0x0308, 0x0309, 0x030b, 0x0304, 0x0305, 0x0306, 0x030a, 0x0301,
499: 0x0302, 0x0303, 0x0300, 0x0310, 0x0206, 0x0200, 0x003e, 0x010a,
500: 0x010b, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
501: 0x030e, 0x0702, 0x030d, 0x0200, 0x0701, 0x0205, 0x0114, 0x0603,
502: 0x020b, 0x0601, 0x0602, 0x0117, 0x0600, 0x020a, 0x0115, 0x0116,
503: 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d,
504: 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
505: }, altgr_map[NR_KEYS] = {
506: 0x0200, 0x0200, 0x0200, 0x0040, 0x0200, 0x0024, 0x0200, 0x0200,
507: 0x007b, 0x005b, 0x005d, 0x007d, 0x005c, 0x0200, 0x0200, 0x0200,
508: 0x0b71, 0x0b77, 0x0918, 0x0b72, 0x0b74, 0x0b79, 0x0b75, 0x0b69,
509: 0x0b6f, 0x0b70, 0x0200, 0x007e, 0x0201, 0x0702, 0x0914, 0x0b73,
510: 0x0917, 0x0919, 0x0b67, 0x0b68, 0x0b6a, 0x0b6b, 0x0b6c, 0x0200,
511: 0x0200, 0x0200, 0x0700, 0x0200, 0x0b7a, 0x0b78, 0x0916, 0x0b76,
512: 0x0915, 0x0b6e, 0x0b6d, 0x0200, 0x0200, 0x0200, 0x0700, 0x030c,
513: 0x0703, 0x0200, 0x0207, 0x050c, 0x050d, 0x050e, 0x050f, 0x0510,
514: 0x0511, 0x0512, 0x0513, 0x0514, 0x0515, 0x0208, 0x0202, 0x0911,
515: 0x0912, 0x0913, 0x030b, 0x090e, 0x090f, 0x0910, 0x030a, 0x090b,
516: 0x090c, 0x090d, 0x090a, 0x0310, 0x0206, 0x0200, 0x007c, 0x0516,
517: 0x0517, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
518: 0x030e, 0x0702, 0x030d, 0x0200, 0x0701, 0x0205, 0x0114, 0x0603,
519: 0x0118, 0x0601, 0x0602, 0x0117, 0x0600, 0x0119, 0x0115, 0x0116,
520: 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d,
521: 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
522: }, ctrl_map[NR_KEYS] = {
523: 0x0200, 0x0200, 0x0200, 0x0000, 0x001b, 0x001c, 0x001d, 0x001e,
524: 0x001f, 0x007f, 0x0200, 0x0200, 0x001f, 0x0200, 0x0008, 0x0200,
525: 0x0011, 0x0017, 0x0005, 0x0012, 0x0014, 0x0019, 0x0015, 0x0009,
526: 0x000f, 0x0010, 0x001b, 0x001d, 0x0201, 0x0702, 0x0001, 0x0013,
527: 0x0004, 0x0006, 0x0007, 0x0008, 0x000a, 0x000b, 0x000c, 0x0200,
528: 0x0007, 0x0000, 0x0700, 0x001c, 0x001a, 0x0018, 0x0003, 0x0016,
529: 0x0002, 0x000e, 0x000d, 0x0200, 0x020e, 0x007f, 0x0700, 0x030c,
530: 0x0703, 0x0000, 0x0207, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104,
531: 0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x0208, 0x0204, 0x0307,
532: 0x0308, 0x0309, 0x030b, 0x0304, 0x0305, 0x0306, 0x030a, 0x0301,
533: 0x0302, 0x0303, 0x0300, 0x0310, 0x0206, 0x0200, 0x0200, 0x010a,
534: 0x010b, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
535: 0x030e, 0x0702, 0x030d, 0x001c, 0x0701, 0x0205, 0x0114, 0x0603,
536: 0x0118, 0x0601, 0x0602, 0x0117, 0x0600, 0x0119, 0x0115, 0x0116,
537: 0x011a, 0x010c, 0x010d, 0x011b, 0x011c, 0x0110, 0x0311, 0x011d,
538: 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
539: };
540:
541: u_short *linux_keytabs[] = {
542: plain_map, shift_map, altgr_map, altgr_map, ctrl_map
543: };
544: #endif
545:
1.13 fvdl 546: /*
547: * We come here in a last attempt to satisfy a Linux ioctl() call
548: */
549: int
1.19 thorpej 550: linux_machdepioctl(p, v, retval)
1.13 fvdl 551: struct proc *p;
1.19 thorpej 552: void *v;
553: register_t *retval;
554: {
1.20 mycroft 555: struct linux_sys_ioctl_args /* {
1.13 fvdl 556: syscallarg(int) fd;
557: syscallarg(u_long) com;
558: syscallarg(caddr_t) data;
1.19 thorpej 559: } */ *uap = v;
1.29 christos 560: struct sys_ioctl_args bia;
1.15 fvdl 561: u_long com;
1.41 drochner 562: #if (NVT > 0) || (NWSDISPLAY > 0)
1.29 christos 563: int error;
1.13 fvdl 564: struct vt_mode lvt;
565: caddr_t bvtp, sg;
1.15 fvdl 566: #endif
1.41 drochner 567: #if (NWSDISPLAY > 0) && defined(XSERVER)
568: struct kbentry kbe;
569: #endif
1.13 fvdl 570:
571: SCARG(&bia, fd) = SCARG(uap, fd);
572: SCARG(&bia, data) = SCARG(uap, data);
573: com = SCARG(uap, com);
574:
575: switch (com) {
1.41 drochner 576: #if (NVT > 0) || (NWSDISPLAY > 0)
1.13 fvdl 577: case LINUX_KDGKBMODE:
1.21 fvdl 578: com = KDGKBMODE;
579: break;
1.13 fvdl 580: case LINUX_KDSKBMODE:
581: com = KDSKBMODE;
582: if ((unsigned)SCARG(uap, data) == LINUX_K_MEDIUMRAW)
583: SCARG(&bia, data) = (caddr_t)K_RAW;
584: break;
585: case LINUX_KDMKTONE:
586: com = KDMKTONE;
587: break;
588: case LINUX_KDSETMODE:
589: com = KDSETMODE;
590: break;
591: case LINUX_KDENABIO:
592: com = KDENABIO;
593: break;
594: case LINUX_KDDISABIO:
595: com = KDDISABIO;
596: break;
597: case LINUX_KDGETLED:
598: com = KDGETLED;
599: break;
600: case LINUX_KDSETLED:
601: com = KDSETLED;
602: break;
603: case LINUX_VT_OPENQRY:
604: com = VT_OPENQRY;
605: break;
606: case LINUX_VT_GETMODE:
607: SCARG(&bia, com) = VT_GETMODE;
1.20 mycroft 608: if ((error = sys_ioctl(p, &bia, retval)))
1.13 fvdl 609: return error;
610: if ((error = copyin(SCARG(uap, data), (caddr_t)&lvt,
611: sizeof (struct vt_mode))))
612: return error;
1.42 mycroft 613: lvt.relsig = native_to_linux_sig[lvt.relsig];
614: lvt.acqsig = native_to_linux_sig[lvt.acqsig];
615: lvt.frsig = native_to_linux_sig[lvt.frsig];
1.13 fvdl 616: return copyout((caddr_t)&lvt, SCARG(uap, data),
617: sizeof (struct vt_mode));
618: case LINUX_VT_SETMODE:
619: com = VT_SETMODE;
620: if ((error = copyin(SCARG(uap, data), (caddr_t)&lvt,
621: sizeof (struct vt_mode))))
622: return error;
1.42 mycroft 623: lvt.relsig = linux_to_native_sig[lvt.relsig];
624: lvt.acqsig = linux_to_native_sig[lvt.acqsig];
625: lvt.frsig = linux_to_native_sig[lvt.frsig];
1.13 fvdl 626: sg = stackgap_init(p->p_emul);
627: bvtp = stackgap_alloc(&sg, sizeof (struct vt_mode));
628: if ((error = copyout(&lvt, bvtp, sizeof (struct vt_mode))))
629: return error;
630: SCARG(&bia, data) = bvtp;
631: break;
632: case LINUX_VT_RELDISP:
633: com = VT_RELDISP;
634: break;
635: case LINUX_VT_ACTIVATE:
636: com = VT_ACTIVATE;
637: break;
638: case LINUX_VT_WAITACTIVE:
639: com = VT_WAITACTIVE;
640: break;
1.41 drochner 641: #endif
642: #if (NWSDISPLAY > 0)
643: case LINUX_VT_GETSTATE:
644: com = VT_GETSTATE;
645: break;
646: #ifdef XSERVER
647: case LINUX_KDGKBTYPE:
648: /* This is what Linux does. */
649: return (subyte(SCARG(uap, data), KB_101));
650: case LINUX_KDGKBENT:
651: /*
652: * The Linux KDGKBENT ioctl is different from the
653: * SYSV original. So we handle it in machdep code.
654: * XXX We should use keyboard mapping information
655: * from wsdisplay, but this would be expensive.
656: */
657: if ((error = copyin(SCARG(uap, data), &kbe,
658: sizeof(struct kbentry))))
659: return (error);
660: if (kbe.kb_table >= sizeof(linux_keytabs) / sizeof(u_short *)
661: || kbe.kb_index >= NR_KEYS)
662: return (EINVAL);
663: kbe.kb_value = linux_keytabs[kbe.kb_table][kbe.kb_index];
664: return (copyout(&kbe, SCARG(uap, data),
665: sizeof(struct kbentry)));
666: #endif
1.13 fvdl 667: #endif
668: default:
1.32 christos 669: printf("linux_machdepioctl: invalid ioctl %08lx\n", com);
1.13 fvdl 670: return EINVAL;
671: }
672: SCARG(&bia, com) = com;
1.20 mycroft 673: return sys_ioctl(p, &bia, retval);
1.13 fvdl 674: }
675:
676: /*
677: * Set I/O permissions for a process. Just set the maximum level
678: * right away (ignoring the argument), otherwise we would have
679: * to rely on I/O permission maps, which are not implemented.
680: */
681: int
1.20 mycroft 682: linux_sys_iopl(p, v, retval)
1.13 fvdl 683: struct proc *p;
1.19 thorpej 684: void *v;
685: register_t *retval;
686: {
1.29 christos 687: #if 0
1.20 mycroft 688: struct linux_sys_iopl_args /* {
1.13 fvdl 689: syscallarg(int) level;
1.19 thorpej 690: } */ *uap = v;
1.29 christos 691: #endif
1.13 fvdl 692: struct trapframe *fp = p->p_md.md_regs;
693:
694: if (suser(p->p_ucred, &p->p_acflag) != 0)
695: return EPERM;
696: fp->tf_eflags |= PSL_IOPL;
697: *retval = 0;
698: return 0;
699: }
700:
701: /*
702: * See above. If a root process tries to set access to an I/O port,
703: * just let it have the whole range.
704: */
705: int
1.20 mycroft 706: linux_sys_ioperm(p, v, retval)
1.13 fvdl 707: struct proc *p;
1.19 thorpej 708: void *v;
709: register_t *retval;
710: {
1.20 mycroft 711: struct linux_sys_ioperm_args /* {
1.13 fvdl 712: syscallarg(unsigned int) lo;
713: syscallarg(unsigned int) hi;
714: syscallarg(int) val;
1.19 thorpej 715: } */ *uap = v;
1.13 fvdl 716: struct trapframe *fp = p->p_md.md_regs;
717:
718: if (suser(p->p_ucred, &p->p_acflag) != 0)
719: return EPERM;
720: if (SCARG(uap, val))
721: fp->tf_eflags |= PSL_IOPL;
722: *retval = 0;
723: return 0;
1.1 fvdl 724: }
CVSweb <webmaster@jp.NetBSD.org>