Annotation of sys/arch/i386/i386/linux_machdep.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: linux_machdep.c,v 1.34 2007/02/14 00:53:47 jsg Exp $ */
2: /* $NetBSD: linux_machdep.c,v 1.29 1996/05/03 19:42:11 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Frank van der Linden
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
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. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed for the NetBSD Project
19: * by Frank van der Linden
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33: */
34:
35: #include <sys/param.h>
36: #include <sys/systm.h>
37: #include <sys/signalvar.h>
38: #include <sys/kernel.h>
39: #include <sys/proc.h>
40: #include <sys/user.h>
41: #include <sys/buf.h>
42: #include <sys/reboot.h>
43: #include <sys/conf.h>
44: #include <sys/file.h>
45: #include <sys/malloc.h>
46: #include <sys/mbuf.h>
47: #include <sys/msgbuf.h>
48: #include <sys/mount.h>
49: #include <sys/vnode.h>
50: #include <sys/device.h>
51: #include <sys/sysctl.h>
52: #include <sys/syscallargs.h>
53: #include <sys/filedesc.h>
54:
55: #include <compat/linux/linux_types.h>
56: #include <compat/linux/linux_signal.h>
57: #include <compat/linux/linux_syscallargs.h>
58: #include <compat/linux/linux_util.h>
59: #include <compat/linux/linux_ioctl.h>
60:
61: #include <machine/cpu.h>
62: #include <machine/cpufunc.h>
63: #include <machine/psl.h>
64: #include <machine/reg.h>
65: #include <machine/segments.h>
66: #include <machine/specialreg.h>
67: #include <machine/sysarch.h>
68: #include <machine/vm86.h>
69: #include <machine/linux_machdep.h>
70:
71: /*
72: * To see whether wsdisplay is configured (for virtual console ioctl calls).
73: */
74: #include "wsdisplay.h"
75: #include <sys/ioctl.h>
76: #if NWSDISPLAY > 0 && defined(WSDISPLAY_COMPAT_USL)
77: #include <dev/wscons/wsconsio.h>
78: #include <dev/wscons/wsdisplay_usl_io.h>
79: #endif
80:
81: #ifdef USER_LDT
82: #include <machine/cpu.h>
83: int linux_read_ldt(struct proc *, struct linux_sys_modify_ldt_args *,
84: register_t *);
85: int linux_write_ldt(struct proc *, struct linux_sys_modify_ldt_args *,
86: register_t *);
87: #endif
88:
89: /*
90: * Deal with some i386-specific things in the Linux emulation code.
91: * This means just signals for now, will include stuff like
92: * I/O map permissions and V86 mode sometime.
93: */
94:
95: /*
96: * Send an interrupt to process.
97: *
98: * Stack is set up to allow sigcode stored
99: * in u. to call routine, followed by kcall
100: * to sigreturn routine below. After sigreturn
101: * resets the signal mask, the stack, and the
102: * frame pointer, it returns to the user
103: * specified pc, psl.
104: */
105:
106: void
107: linux_sendsig(sig_t catcher, int sig, int mask, u_long code, int type,
108: union sigval val)
109: {
110: struct proc *p = curproc;
111: struct trapframe *tf;
112: struct linux_sigframe *fp, frame;
113: struct sigacts *psp = p->p_sigacts;
114: int oonstack;
115:
116: tf = p->p_md.md_regs;
117: oonstack = psp->ps_sigstk.ss_flags & SS_ONSTACK;
118:
119: /*
120: * Allocate space for the signal handler context.
121: */
122: if ((psp->ps_flags & SAS_ALTSTACK) && !oonstack &&
123: (psp->ps_sigonstack & sigmask(sig))) {
124: fp = (struct linux_sigframe *)((char *)psp->ps_sigstk.ss_sp +
125: psp->ps_sigstk.ss_size - sizeof(struct linux_sigframe));
126: psp->ps_sigstk.ss_flags |= SS_ONSTACK;
127: } else {
128: fp = (struct linux_sigframe *)tf->tf_esp - 1;
129: }
130:
131: frame.sf_handler = catcher;
132: frame.sf_sig = bsd_to_linux_sig[sig];
133:
134: /*
135: * Build the signal context to be used by sigreturn.
136: */
137: frame.sf_sc.sc_mask = mask;
138: #ifdef VM86
139: if (tf->tf_eflags & PSL_VM) {
140: frame.sf_sc.sc_gs = tf->tf_vm86_gs;
141: frame.sf_sc.sc_fs = tf->tf_vm86_fs;
142: frame.sf_sc.sc_es = tf->tf_vm86_es;
143: frame.sf_sc.sc_ds = tf->tf_vm86_ds;
144: frame.sf_sc.sc_eflags = get_vflags(p);
145: } else
146: #endif
147: {
148: frame.sf_sc.sc_fs = tf->tf_fs;
149: frame.sf_sc.sc_gs = tf->tf_gs;
150: frame.sf_sc.sc_es = tf->tf_es;
151: frame.sf_sc.sc_ds = tf->tf_ds;
152: frame.sf_sc.sc_eflags = tf->tf_eflags;
153: }
154: frame.sf_sc.sc_edi = tf->tf_edi;
155: frame.sf_sc.sc_esi = tf->tf_esi;
156: frame.sf_sc.sc_ebp = tf->tf_ebp;
157: frame.sf_sc.sc_ebx = tf->tf_ebx;
158: frame.sf_sc.sc_edx = tf->tf_edx;
159: frame.sf_sc.sc_ecx = tf->tf_ecx;
160: frame.sf_sc.sc_eax = tf->tf_eax;
161: frame.sf_sc.sc_eip = tf->tf_eip;
162: frame.sf_sc.sc_cs = tf->tf_cs;
163: frame.sf_sc.sc_esp_at_signal = tf->tf_esp;
164: frame.sf_sc.sc_ss = tf->tf_ss;
165: frame.sf_sc.sc_err = tf->tf_err;
166: frame.sf_sc.sc_trapno = tf->tf_trapno;
167:
168: if (copyout(&frame, fp, sizeof(frame)) != 0) {
169: /*
170: * Process has trashed its stack; give it an illegal
171: * instruction to halt it in its tracks.
172: */
173: sigexit(p, SIGILL);
174: /* NOTREACHED */
175: }
176:
177: /*
178: * Build context to run handler in.
179: */
180: tf->tf_es = GSEL(GUDATA_SEL, SEL_UPL);
181: tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL);
182: tf->tf_eip = p->p_sigcode;
183: tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL);
184: tf->tf_eflags &= ~(PSL_T|PSL_VM|PSL_AC);
185: tf->tf_esp = (int)fp;
186: tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL);
187: }
188:
189: /*
190: * System call to cleanup state after a signal
191: * has been taken. Reset signal mask and
192: * stack state from context left by sendsig (above).
193: * Return to previous pc and psl as specified by
194: * context left by sendsig. Check carefully to
195: * make sure that the user has not modified the
196: * psl to gain improper privileges or to cause
197: * a machine fault.
198: */
199: int
200: linux_sys_sigreturn(struct proc *p, void *v, register_t *retval)
201: {
202: struct linux_sys_sigreturn_args /* {
203: syscallarg(struct linux_sigcontext *) scp;
204: } */ *uap = v;
205: struct linux_sigcontext *scp, context;
206: struct trapframe *tf;
207:
208: tf = p->p_md.md_regs;
209:
210: /*
211: * The trampoline code hands us the context.
212: * It is unsafe to keep track of it ourselves, in the event that a
213: * program jumps out of a signal handler.
214: */
215: scp = SCARG(uap, scp);
216: if (copyin((caddr_t)scp, &context, sizeof(*scp)) != 0)
217: return (EFAULT);
218:
219: /*
220: * Restore signal context.
221: */
222: #ifdef VM86
223: if (context.sc_eflags & PSL_VM) {
224: tf->tf_vm86_gs = context.sc_gs;
225: tf->tf_vm86_fs = context.sc_fs;
226: tf->tf_vm86_es = context.sc_es;
227: tf->tf_vm86_ds = context.sc_ds;
228: set_vflags(p, context.sc_eflags);
229: } else
230: #endif
231: {
232: /*
233: * Check for security violations. If we're returning to
234: * protected mode, the CPU will validate the segment registers
235: * automatically and generate a trap on violations. We handle
236: * the trap, rather than doing all of the checking here.
237: */
238: if (((context.sc_eflags ^ tf->tf_eflags) & PSL_USERSTATIC) != 0 ||
239: !USERMODE(context.sc_cs, context.sc_eflags))
240: return (EINVAL);
241:
242: tf->tf_fs = context.sc_fs;
243: tf->tf_gs = context.sc_gs;
244: tf->tf_es = context.sc_es;
245: tf->tf_ds = context.sc_ds;
246: tf->tf_eflags = context.sc_eflags;
247: }
248: tf->tf_edi = context.sc_edi;
249: tf->tf_esi = context.sc_esi;
250: tf->tf_ebp = context.sc_ebp;
251: tf->tf_ebx = context.sc_ebx;
252: tf->tf_edx = context.sc_edx;
253: tf->tf_ecx = context.sc_ecx;
254: tf->tf_eax = context.sc_eax;
255: tf->tf_eip = context.sc_eip;
256: tf->tf_cs = context.sc_cs;
257: tf->tf_esp = context.sc_esp_at_signal;
258: tf->tf_ss = context.sc_ss;
259:
260: p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
261: p->p_sigmask = context.sc_mask & ~sigcantmask;
262:
263: return (EJUSTRETURN);
264: }
265:
266: int
267: linux_sys_rt_sigreturn(struct proc *p, void *v, register_t *retval)
268: {
269: return(ENOSYS);
270: }
271:
272: #ifdef USER_LDT
273:
274: int
275: linux_read_ldt(struct proc *p, struct linux_sys_modify_ldt_args *uap,
276: register_t *retval)
277: {
278: struct i386_get_ldt_args gl;
279: int error;
280: caddr_t sg;
281: char *parms;
282:
283: if (user_ldt_enable == 0)
284: return (ENOSYS);
285:
286: sg = stackgap_init(p->p_emul);
287:
288: gl.start = 0;
289: gl.desc = SCARG(uap, ptr);
290: gl.num = SCARG(uap, bytecount) / sizeof(union descriptor);
291:
292: parms = stackgap_alloc(&sg, sizeof(gl));
293:
294: if ((error = copyout(&gl, parms, sizeof(gl))) != 0)
295: return (error);
296:
297: if ((error = i386_get_ldt(p, parms, retval)) != 0)
298: return (error);
299:
300: *retval *= sizeof(union descriptor);
301: return (0);
302: }
303:
304: struct linux_ldt_info {
305: u_int entry_number;
306: u_long base_addr;
307: u_int limit;
308: u_int seg_32bit:1;
309: u_int contents:2;
310: u_int read_exec_only:1;
311: u_int limit_in_pages:1;
312: u_int seg_not_present:1;
313: };
314:
315: int
316: linux_write_ldt(struct proc *p, struct linux_sys_modify_ldt_args *uap,
317: register_t *retval)
318: {
319: struct linux_ldt_info ldt_info;
320: struct segment_descriptor sd;
321: struct i386_set_ldt_args sl;
322: int error;
323: caddr_t sg;
324: char *parms;
325:
326: if (user_ldt_enable == 0)
327: return (ENOSYS);
328:
329: if (SCARG(uap, bytecount) != sizeof(ldt_info))
330: return (EINVAL);
331: if ((error = copyin(SCARG(uap, ptr), &ldt_info, sizeof(ldt_info))) != 0)
332: return error;
333: if (ldt_info.contents == 3)
334: return (EINVAL);
335:
336: sg = stackgap_init(p->p_emul);
337:
338: sd.sd_lobase = ldt_info.base_addr & 0xffffff;
339: sd.sd_hibase = (ldt_info.base_addr >> 24) & 0xff;
340: sd.sd_lolimit = ldt_info.limit & 0xffff;
341: sd.sd_hilimit = (ldt_info.limit >> 16) & 0xf;
342: sd.sd_type =
343: 16 | (ldt_info.contents << 2) | (!ldt_info.read_exec_only << 1);
344: sd.sd_dpl = SEL_UPL;
345: sd.sd_p = !ldt_info.seg_not_present;
346: sd.sd_def32 = ldt_info.seg_32bit;
347: sd.sd_gran = ldt_info.limit_in_pages;
348:
349: sl.start = ldt_info.entry_number;
350: sl.desc = stackgap_alloc(&sg, sizeof(sd));
351: sl.num = 1;
352:
353: #if 0
354: printf("linux_write_ldt: idx=%d, base=%x, limit=%x\n",
355: ldt_info.entry_number, ldt_info.base_addr, ldt_info.limit);
356: #endif
357:
358: parms = stackgap_alloc(&sg, sizeof(sl));
359:
360: if ((error = copyout(&sd, sl.desc, sizeof(sd))) != 0)
361: return (error);
362: if ((error = copyout(&sl, parms, sizeof(sl))) != 0)
363: return (error);
364:
365: if ((error = i386_set_ldt(p, parms, retval)) != 0)
366: return (error);
367:
368: *retval = 0;
369: return (0);
370: }
371:
372: #endif /* USER_LDT */
373:
374: int
375: linux_sys_modify_ldt(struct proc *p, void *v, register_t *retval)
376: {
377: struct linux_sys_modify_ldt_args /* {
378: syscallarg(int) func;
379: syscallarg(void *) ptr;
380: syscallarg(size_t) bytecount;
381: } */ *uap = v;
382:
383: switch (SCARG(uap, func)) {
384: #ifdef USER_LDT
385: case 0:
386: return (linux_read_ldt(p, uap, retval));
387:
388: case 1:
389: return (linux_write_ldt(p, uap, retval));
390: #endif /* USER_LDT */
391:
392: default:
393: return (ENOSYS);
394: }
395: }
396:
397: /*
398: * XXX Pathetic hack to make svgalib work. This will fake the major
399: * device number of an opened VT so that svgalib likes it. grmbl.
400: * Should probably do it 'wrong the right way' and use a mapping
401: * array for all major device numbers, and map linux_mknod too.
402: */
403: dev_t
404: linux_fakedev(dev_t dev)
405: {
406:
407: if (major(dev) == NATIVE_CONS_MAJOR)
408: return makedev(LINUX_CONS_MAJOR, (minor(dev) + 1));
409: return dev;
410: }
411:
412: /*
413: * We come here in a last attempt to satisfy a Linux ioctl() call
414: */
415: int
416: linux_machdepioctl(struct proc *p, void *v, register_t *retval)
417: {
418: struct linux_sys_ioctl_args /* {
419: syscallarg(int) fd;
420: syscallarg(u_long) com;
421: syscallarg(caddr_t) data;
422: } */ *uap = v;
423: struct sys_ioctl_args bia;
424: u_long com;
425: int error;
426: #if (NWSDISPLAY > 0 && defined(WSDISPLAY_COMPAT_USL))
427: struct vt_mode lvt;
428: caddr_t bvtp, sg;
429: #endif
430: struct filedesc *fdp;
431: struct file *fp;
432: int fd;
433: int (*ioctlf)(struct file *, u_long, caddr_t, struct proc *);
434: struct ioctl_pt pt;
435:
436: fd = SCARG(uap, fd);
437: SCARG(&bia, fd) = SCARG(uap, fd);
438: SCARG(&bia, data) = SCARG(uap, data);
439: com = SCARG(uap, com);
440:
441: fdp = p->p_fd;
442: if ((fp = fd_getfile(fdp, fd)) == NULL)
443: return (EBADF);
444:
445: switch (com) {
446: #if (NWSDISPLAY > 0 && defined(WSDISPLAY_COMPAT_USL))
447: case LINUX_KDGKBMODE:
448: com = KDGKBMODE;
449: break;
450: case LINUX_KDSKBMODE:
451: com = KDSKBMODE;
452: if ((unsigned)SCARG(uap, data) == LINUX_K_MEDIUMRAW)
453: SCARG(&bia, data) = (caddr_t)K_RAW;
454: break;
455: case LINUX_KIOCSOUND:
456: SCARG(&bia, data) =
457: (caddr_t)(((unsigned long)SCARG(&bia, data)) & 0xffff);
458: /* FALLTHROUGH */
459: case LINUX_KDMKTONE:
460: com = KDMKTONE;
461: break;
462: case LINUX_KDSETMODE:
463: com = KDSETMODE;
464: break;
465: case LINUX_KDGETMODE:
466: #if NWSDISPLAY > 0 && defined(WSDISPLAY_COMPAT_USL)
467: com = WSDISPLAYIO_GMODE;
468: #else
469: com = KDGETMODE;
470: #endif
471: break;
472: case LINUX_KDENABIO:
473: com = KDENABIO;
474: break;
475: case LINUX_KDDISABIO:
476: com = KDDISABIO;
477: break;
478: case LINUX_KDGETLED:
479: com = KDGETLED;
480: break;
481: case LINUX_KDSETLED:
482: com = KDSETLED;
483: break;
484: case LINUX_VT_OPENQRY:
485: com = VT_OPENQRY;
486: break;
487: case LINUX_VT_GETMODE: {
488: int sig;
489:
490: SCARG(&bia, com) = VT_GETMODE;
491: if ((error = sys_ioctl(p, &bia, retval)))
492: return error;
493: if ((error = copyin(SCARG(uap, data), (caddr_t)&lvt,
494: sizeof (struct vt_mode))))
495: return error;
496: /* We need to bounds check here in case there
497: is a race with another thread */
498: if ((error = bsd_to_linux_signal(lvt.relsig, &sig)))
499: return error;
500: lvt.relsig = sig;
501:
502: if ((error = bsd_to_linux_signal(lvt.acqsig, &sig)))
503: return error;
504: lvt.acqsig = sig;
505:
506: if ((error = bsd_to_linux_signal(lvt.frsig, &sig)))
507: return error;
508: lvt.frsig = sig;
509:
510: return copyout((caddr_t)&lvt, SCARG(uap, data),
511: sizeof (struct vt_mode));
512: }
513: case LINUX_VT_SETMODE: {
514: int sig;
515:
516: com = VT_SETMODE;
517: if ((error = copyin(SCARG(uap, data), (caddr_t)&lvt,
518: sizeof (struct vt_mode))))
519: return error;
520: if ((error = linux_to_bsd_signal(lvt.relsig, &sig)))
521: return error;
522: lvt.relsig = sig;
523:
524: if ((error = linux_to_bsd_signal(lvt.acqsig, &sig)))
525: return error;
526: lvt.acqsig = sig;
527:
528: if ((error = linux_to_bsd_signal(lvt.frsig, &sig)))
529: return error;
530: lvt.frsig = sig;
531:
532: sg = stackgap_init(p->p_emul);
533: bvtp = stackgap_alloc(&sg, sizeof (struct vt_mode));
534: if ((error = copyout(&lvt, bvtp, sizeof (struct vt_mode))))
535: return error;
536: SCARG(&bia, data) = bvtp;
537: break;
538: }
539: case LINUX_VT_DISALLOCATE:
540: /* XXX should use WSDISPLAYIO_DELSCREEN */
541: return 0;
542: case LINUX_VT_RELDISP:
543: com = VT_RELDISP;
544: break;
545: case LINUX_VT_ACTIVATE:
546: com = VT_ACTIVATE;
547: break;
548: case LINUX_VT_WAITACTIVE:
549: com = VT_WAITACTIVE;
550: break;
551: case LINUX_VT_GETSTATE:
552: com = VT_GETSTATE;
553: break;
554: case LINUX_KDGKBTYPE:
555: {
556: char tmp = KB_101;
557:
558: /* This is what Linux does */
559: return copyout(&tmp, SCARG(uap, data), sizeof(char));
560: }
561: #endif
562: default:
563: /*
564: * Unknown to us. If it's on a device, just pass it through
565: * using PTIOCLINUX, the device itself might be able to
566: * make some sense of it.
567: * XXX hack: if the function returns EJUSTRETURN,
568: * it has stuffed a sysctl return value in pt.data.
569: */
570: FREF(fp);
571: ioctlf = fp->f_ops->fo_ioctl;
572: pt.com = SCARG(uap, com);
573: pt.data = SCARG(uap, data);
574: error = ioctlf(fp, PTIOCLINUX, (caddr_t)&pt, p);
575: FRELE(fp);
576: if (error == EJUSTRETURN) {
577: retval[0] = (register_t)pt.data;
578: error = 0;
579: }
580:
581: if (error == ENOTTY)
582: printf("linux_machdepioctl: invalid ioctl %08lx\n",
583: com);
584: return (error);
585: }
586: SCARG(&bia, com) = com;
587: return sys_ioctl(p, &bia, retval);
588: }
589:
590: /*
591: * Set I/O permissions for a process. Just set the maximum level
592: * right away (ignoring the argument), otherwise we would have
593: * to rely on I/O permission maps, which are not implemented.
594: */
595: int
596: linux_sys_iopl(struct proc *p, void *v, register_t *retval)
597: {
598: #if 0
599: struct linux_sys_iopl_args /* {
600: syscallarg(int) level;
601: } */ *uap = v;
602: #endif
603: struct trapframe *fp = p->p_md.md_regs;
604:
605: if (suser(p, 0) != 0)
606: return EPERM;
607: if (securelevel > 0)
608: return EPERM;
609: fp->tf_eflags |= PSL_IOPL;
610: *retval = 0;
611: return 0;
612: }
613:
614: /*
615: * See above. If a root process tries to set access to an I/O port,
616: * just let it have the whole range.
617: */
618: int
619: linux_sys_ioperm(struct proc *p, void *v, register_t *retval)
620: {
621: struct linux_sys_ioperm_args /* {
622: syscallarg(unsigned int) lo;
623: syscallarg(unsigned int) hi;
624: syscallarg(int) val;
625: } */ *uap = v;
626: struct trapframe *fp = p->p_md.md_regs;
627:
628: if (suser(p, 0) != 0)
629: return EPERM;
630: if (securelevel > 0)
631: return EPERM;
632: if (SCARG(uap, val))
633: fp->tf_eflags |= PSL_IOPL;
634: *retval = 0;
635: return 0;
636: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to linux_machdep.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / i386 / i386