]> CyberLeo.Net >> Repos - FreeBSD/releng/8.2.git/blob - sys/i386/linux/linux_machdep.c
MFC r217548:
[FreeBSD/releng/8.2.git] / sys / i386 / linux / linux_machdep.c
1 /*-
2  * Copyright (c) 2000 Marcel Moolenaar
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer
10  *    in this position and unchanged.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/file.h>
35 #include <sys/fcntl.h>
36 #include <sys/imgact.h>
37 #include <sys/lock.h>
38 #include <sys/malloc.h>
39 #include <sys/mman.h>
40 #include <sys/mutex.h>
41 #include <sys/sx.h>
42 #include <sys/priv.h>
43 #include <sys/proc.h>
44 #include <sys/queue.h>
45 #include <sys/resource.h>
46 #include <sys/resourcevar.h>
47 #include <sys/signalvar.h>
48 #include <sys/syscallsubr.h>
49 #include <sys/sysproto.h>
50 #include <sys/unistd.h>
51 #include <sys/wait.h>
52 #include <sys/sched.h>
53
54 #include <machine/frame.h>
55 #include <machine/psl.h>
56 #include <machine/segments.h>
57 #include <machine/sysarch.h>
58
59 #include <vm/vm.h>
60 #include <vm/pmap.h>
61 #include <vm/vm_map.h>
62
63 #include <i386/linux/linux.h>
64 #include <i386/linux/linux_proto.h>
65 #include <compat/linux/linux_ipc.h>
66 #include <compat/linux/linux_signal.h>
67 #include <compat/linux/linux_util.h>
68 #include <compat/linux/linux_emul.h>
69
70 #include <i386/include/pcb.h>                   /* needed for pcb definition in linux_set_thread_area */
71
72 #include "opt_posix.h"
73
74 extern struct sysentvec elf32_freebsd_sysvec;   /* defined in i386/i386/elf_machdep.c */
75
76 struct l_descriptor {
77         l_uint          entry_number;
78         l_ulong         base_addr;
79         l_uint          limit;
80         l_uint          seg_32bit:1;
81         l_uint          contents:2;
82         l_uint          read_exec_only:1;
83         l_uint          limit_in_pages:1;
84         l_uint          seg_not_present:1;
85         l_uint          useable:1;
86 };
87
88 struct l_old_select_argv {
89         l_int           nfds;
90         l_fd_set        *readfds;
91         l_fd_set        *writefds;
92         l_fd_set        *exceptfds;
93         struct l_timeval        *timeout;
94 };
95
96 static int      linux_mmap_common(struct thread *td, l_uintptr_t addr,
97                     l_size_t len, l_int prot, l_int flags, l_int fd,
98                     l_loff_t pos);
99
100 int
101 linux_to_bsd_sigaltstack(int lsa)
102 {
103         int bsa = 0;
104
105         if (lsa & LINUX_SS_DISABLE)
106                 bsa |= SS_DISABLE;
107         if (lsa & LINUX_SS_ONSTACK)
108                 bsa |= SS_ONSTACK;
109         return (bsa);
110 }
111
112 int
113 bsd_to_linux_sigaltstack(int bsa)
114 {
115         int lsa = 0;
116
117         if (bsa & SS_DISABLE)
118                 lsa |= LINUX_SS_DISABLE;
119         if (bsa & SS_ONSTACK)
120                 lsa |= LINUX_SS_ONSTACK;
121         return (lsa);
122 }
123
124 int
125 linux_execve(struct thread *td, struct linux_execve_args *args)
126 {
127         int error;
128         char *newpath;
129         struct image_args eargs;
130
131         LCONVPATHEXIST(td, args->path, &newpath);
132
133 #ifdef DEBUG
134         if (ldebug(execve))
135                 printf(ARGS(execve, "%s"), newpath);
136 #endif
137
138         error = exec_copyin_args(&eargs, newpath, UIO_SYSSPACE,
139             args->argp, args->envp);
140         free(newpath, M_TEMP);
141         if (error == 0)
142                 error = kern_execve(td, &eargs, NULL);
143         if (error == 0)
144                 /* linux process can exec fbsd one, dont attempt
145                  * to create emuldata for such process using
146                  * linux_proc_init, this leads to a panic on KASSERT
147                  * because such process has p->p_emuldata == NULL
148                  */
149                 if (td->td_proc->p_sysent == &elf_linux_sysvec)
150                         error = linux_proc_init(td, 0, 0);
151         return (error);
152 }
153
154 struct l_ipc_kludge {
155         struct l_msgbuf *msgp;
156         l_long msgtyp;
157 };
158
159 int
160 linux_ipc(struct thread *td, struct linux_ipc_args *args)
161 {
162
163         switch (args->what & 0xFFFF) {
164         case LINUX_SEMOP: {
165                 struct linux_semop_args a;
166
167                 a.semid = args->arg1;
168                 a.tsops = args->ptr;
169                 a.nsops = args->arg2;
170                 return (linux_semop(td, &a));
171         }
172         case LINUX_SEMGET: {
173                 struct linux_semget_args a;
174
175                 a.key = args->arg1;
176                 a.nsems = args->arg2;
177                 a.semflg = args->arg3;
178                 return (linux_semget(td, &a));
179         }
180         case LINUX_SEMCTL: {
181                 struct linux_semctl_args a;
182                 int error;
183
184                 a.semid = args->arg1;
185                 a.semnum = args->arg2;
186                 a.cmd = args->arg3;
187                 error = copyin(args->ptr, &a.arg, sizeof(a.arg));
188                 if (error)
189                         return (error);
190                 return (linux_semctl(td, &a));
191         }
192         case LINUX_MSGSND: {
193                 struct linux_msgsnd_args a;
194
195                 a.msqid = args->arg1;
196                 a.msgp = args->ptr;
197                 a.msgsz = args->arg2;
198                 a.msgflg = args->arg3;
199                 return (linux_msgsnd(td, &a));
200         }
201         case LINUX_MSGRCV: {
202                 struct linux_msgrcv_args a;
203
204                 a.msqid = args->arg1;
205                 a.msgsz = args->arg2;
206                 a.msgflg = args->arg3;
207                 if ((args->what >> 16) == 0) {
208                         struct l_ipc_kludge tmp;
209                         int error;
210
211                         if (args->ptr == NULL)
212                                 return (EINVAL);
213                         error = copyin(args->ptr, &tmp, sizeof(tmp));
214                         if (error)
215                                 return (error);
216                         a.msgp = tmp.msgp;
217                         a.msgtyp = tmp.msgtyp;
218                 } else {
219                         a.msgp = args->ptr;
220                         a.msgtyp = args->arg5;
221                 }
222                 return (linux_msgrcv(td, &a));
223         }
224         case LINUX_MSGGET: {
225                 struct linux_msgget_args a;
226
227                 a.key = args->arg1;
228                 a.msgflg = args->arg2;
229                 return (linux_msgget(td, &a));
230         }
231         case LINUX_MSGCTL: {
232                 struct linux_msgctl_args a;
233
234                 a.msqid = args->arg1;
235                 a.cmd = args->arg2;
236                 a.buf = args->ptr;
237                 return (linux_msgctl(td, &a));
238         }
239         case LINUX_SHMAT: {
240                 struct linux_shmat_args a;
241
242                 a.shmid = args->arg1;
243                 a.shmaddr = args->ptr;
244                 a.shmflg = args->arg2;
245                 a.raddr = (l_ulong *)args->arg3;
246                 return (linux_shmat(td, &a));
247         }
248         case LINUX_SHMDT: {
249                 struct linux_shmdt_args a;
250
251                 a.shmaddr = args->ptr;
252                 return (linux_shmdt(td, &a));
253         }
254         case LINUX_SHMGET: {
255                 struct linux_shmget_args a;
256
257                 a.key = args->arg1;
258                 a.size = args->arg2;
259                 a.shmflg = args->arg3;
260                 return (linux_shmget(td, &a));
261         }
262         case LINUX_SHMCTL: {
263                 struct linux_shmctl_args a;
264
265                 a.shmid = args->arg1;
266                 a.cmd = args->arg2;
267                 a.buf = args->ptr;
268                 return (linux_shmctl(td, &a));
269         }
270         default:
271                 break;
272         }
273
274         return (EINVAL);
275 }
276
277 int
278 linux_old_select(struct thread *td, struct linux_old_select_args *args)
279 {
280         struct l_old_select_argv linux_args;
281         struct linux_select_args newsel;
282         int error;
283
284 #ifdef DEBUG
285         if (ldebug(old_select))
286                 printf(ARGS(old_select, "%p"), args->ptr);
287 #endif
288
289         error = copyin(args->ptr, &linux_args, sizeof(linux_args));
290         if (error)
291                 return (error);
292
293         newsel.nfds = linux_args.nfds;
294         newsel.readfds = linux_args.readfds;
295         newsel.writefds = linux_args.writefds;
296         newsel.exceptfds = linux_args.exceptfds;
297         newsel.timeout = linux_args.timeout;
298         return (linux_select(td, &newsel));
299 }
300
301 int
302 linux_fork(struct thread *td, struct linux_fork_args *args)
303 {
304         int error;
305         struct proc *p2;
306         struct thread *td2;
307
308 #ifdef DEBUG
309         if (ldebug(fork))
310                 printf(ARGS(fork, ""));
311 #endif
312
313         if ((error = fork1(td, RFFDG | RFPROC | RFSTOPPED, 0, &p2)) != 0)
314                 return (error);
315         
316         if (error == 0) {
317                 td->td_retval[0] = p2->p_pid;
318                 td->td_retval[1] = 0;
319         }
320
321         if (td->td_retval[1] == 1)
322                 td->td_retval[0] = 0;
323         error = linux_proc_init(td, td->td_retval[0], 0);
324         if (error)
325                 return (error);
326
327         td2 = FIRST_THREAD_IN_PROC(p2);
328
329         /*
330          * Make this runnable after we are finished with it.
331          */
332         thread_lock(td2);
333         TD_SET_CAN_RUN(td2);
334         sched_add(td2, SRQ_BORING);
335         thread_unlock(td2);
336
337         return (0);
338 }
339
340 int
341 linux_vfork(struct thread *td, struct linux_vfork_args *args)
342 {
343         int error;
344         struct proc *p2;
345         struct thread *td2;
346
347 #ifdef DEBUG
348         if (ldebug(vfork))
349                 printf(ARGS(vfork, ""));
350 #endif
351
352         /* exclude RFPPWAIT */
353         if ((error = fork1(td, RFFDG | RFPROC | RFMEM | RFSTOPPED, 0, &p2)) != 0)
354                 return (error);
355         if (error == 0) {
356                 td->td_retval[0] = p2->p_pid;
357                 td->td_retval[1] = 0;
358         }
359         /* Are we the child? */
360         if (td->td_retval[1] == 1)
361                 td->td_retval[0] = 0;
362         error = linux_proc_init(td, td->td_retval[0], 0);
363         if (error)
364                 return (error);
365
366         PROC_LOCK(p2);
367         p2->p_flag |= P_PPWAIT;
368         PROC_UNLOCK(p2);
369
370         td2 = FIRST_THREAD_IN_PROC(p2);
371         
372         /*
373          * Make this runnable after we are finished with it.
374          */
375         thread_lock(td2);
376         TD_SET_CAN_RUN(td2);
377         sched_add(td2, SRQ_BORING);
378         thread_unlock(td2);
379
380         /* wait for the children to exit, ie. emulate vfork */
381         PROC_LOCK(p2);
382         while (p2->p_flag & P_PPWAIT)
383                 cv_wait(&p2->p_pwait, &p2->p_mtx);
384         PROC_UNLOCK(p2);
385
386         return (0);
387 }
388
389 int
390 linux_clone(struct thread *td, struct linux_clone_args *args)
391 {
392         int error, ff = RFPROC | RFSTOPPED;
393         struct proc *p2;
394         struct thread *td2;
395         int exit_signal;
396         struct linux_emuldata *em;
397
398 #ifdef DEBUG
399         if (ldebug(clone)) {
400                 printf(ARGS(clone, "flags %x, stack %x, parent tid: %x, child tid: %x"),
401                     (unsigned int)args->flags, (unsigned int)args->stack, 
402                     (unsigned int)args->parent_tidptr, (unsigned int)args->child_tidptr);
403         }
404 #endif
405
406         exit_signal = args->flags & 0x000000ff;
407         if (LINUX_SIG_VALID(exit_signal)) {
408                 if (exit_signal <= LINUX_SIGTBLSZ)
409                         exit_signal =
410                             linux_to_bsd_signal[_SIG_IDX(exit_signal)];
411         } else if (exit_signal != 0)
412                 return (EINVAL);
413
414         if (args->flags & LINUX_CLONE_VM)
415                 ff |= RFMEM;
416         if (args->flags & LINUX_CLONE_SIGHAND)
417                 ff |= RFSIGSHARE;
418         /* 
419          * XXX: in linux sharing of fs info (chroot/cwd/umask)
420          * and open files is independant. in fbsd its in one
421          * structure but in reality it doesn't cause any problems
422          * because both of these flags are usually set together.
423          */
424         if (!(args->flags & (LINUX_CLONE_FILES | LINUX_CLONE_FS)))
425                 ff |= RFFDG;
426
427         /*
428          * Attempt to detect when linux_clone(2) is used for creating
429          * kernel threads. Unfortunately despite the existence of the
430          * CLONE_THREAD flag, version of linuxthreads package used in
431          * most popular distros as of beginning of 2005 doesn't make
432          * any use of it. Therefore, this detection relies on
433          * empirical observation that linuxthreads sets certain
434          * combination of flags, so that we can make more or less
435          * precise detection and notify the FreeBSD kernel that several
436          * processes are in fact part of the same threading group, so
437          * that special treatment is necessary for signal delivery
438          * between those processes and fd locking.
439          */
440         if ((args->flags & 0xffffff00) == LINUX_THREADING_FLAGS)
441                 ff |= RFTHREAD;
442
443         if (args->flags & LINUX_CLONE_PARENT_SETTID)
444                 if (args->parent_tidptr == NULL)
445                         return (EINVAL);
446
447         error = fork1(td, ff, 0, &p2);
448         if (error)
449                 return (error);
450
451         if (args->flags & (LINUX_CLONE_PARENT | LINUX_CLONE_THREAD)) {
452                 sx_xlock(&proctree_lock);
453                 PROC_LOCK(p2);
454                 proc_reparent(p2, td->td_proc->p_pptr);
455                 PROC_UNLOCK(p2);
456                 sx_xunlock(&proctree_lock);
457         }
458         
459         /* create the emuldata */
460         error = linux_proc_init(td, p2->p_pid, args->flags);
461         /* reference it - no need to check this */
462         em = em_find(p2, EMUL_DOLOCK);
463         KASSERT(em != NULL, ("clone: emuldata not found.\n"));
464         /* and adjust it */
465
466         if (args->flags & LINUX_CLONE_THREAD) {
467                 /* XXX: linux mangles pgrp and pptr somehow
468                  * I think it might be this but I am not sure.
469                  */
470 #ifdef notyet
471                 PROC_LOCK(p2);
472                 p2->p_pgrp = td->td_proc->p_pgrp;
473                 PROC_UNLOCK(p2);
474 #endif
475                 exit_signal = 0;
476         }
477
478         if (args->flags & LINUX_CLONE_CHILD_SETTID)
479                 em->child_set_tid = args->child_tidptr;
480         else
481                 em->child_set_tid = NULL;
482
483         if (args->flags & LINUX_CLONE_CHILD_CLEARTID)
484                 em->child_clear_tid = args->child_tidptr;
485         else
486                 em->child_clear_tid = NULL;
487
488         EMUL_UNLOCK(&emul_lock);
489
490         if (args->flags & LINUX_CLONE_PARENT_SETTID) {
491                 error = copyout(&p2->p_pid, args->parent_tidptr, sizeof(p2->p_pid));
492                 if (error)
493                         printf(LMSG("copyout failed!"));
494         }
495
496         PROC_LOCK(p2);
497         p2->p_sigparent = exit_signal;
498         PROC_UNLOCK(p2);
499         td2 = FIRST_THREAD_IN_PROC(p2);
500         /* 
501          * in a case of stack = NULL we are supposed to COW calling process stack
502          * this is what normal fork() does so we just keep the tf_esp arg intact
503          */
504         if (args->stack)
505                 td2->td_frame->tf_esp = (unsigned int)args->stack;
506
507         if (args->flags & LINUX_CLONE_SETTLS) {
508                 struct l_user_desc info;
509                 int idx;
510                 int a[2];
511                 struct segment_descriptor sd;
512
513                 error = copyin((void *)td->td_frame->tf_esi, &info, sizeof(struct l_user_desc));
514                 if (error) {
515                         printf(LMSG("copyin failed!"));
516                 } else {
517                 
518                         idx = info.entry_number;
519                 
520                         /* 
521                          * looks like we're getting the idx we returned
522                          * in the set_thread_area() syscall
523                          */
524                         if (idx != 6 && idx != 3) {
525                                 printf(LMSG("resetting idx!"));
526                                 idx = 3;
527                         }
528
529                         /* this doesnt happen in practice */
530                         if (idx == 6) {
531                                 /* we might copy out the entry_number as 3 */
532                                 info.entry_number = 3;
533                                 error = copyout(&info, (void *) td->td_frame->tf_esi, sizeof(struct l_user_desc));
534                                 if (error)
535                                         printf(LMSG("copyout failed!"));
536                         }
537
538                         a[0] = LINUX_LDT_entry_a(&info);
539                         a[1] = LINUX_LDT_entry_b(&info);
540
541                         memcpy(&sd, &a, sizeof(a));
542 #ifdef DEBUG
543                 if (ldebug(clone))
544                         printf("Segment created in clone with CLONE_SETTLS: lobase: %x, hibase: %x, lolimit: %x, hilimit: %x, type: %i, dpl: %i, p: %i, xx: %i, def32: %i, gran: %i\n", sd.sd_lobase,
545                         sd.sd_hibase,
546                         sd.sd_lolimit,
547                         sd.sd_hilimit,
548                         sd.sd_type,
549                         sd.sd_dpl,
550                         sd.sd_p,
551                         sd.sd_xx,
552                         sd.sd_def32,
553                         sd.sd_gran);
554 #endif
555
556                         /* set %gs */
557                         td2->td_pcb->pcb_gsd = sd;
558                         td2->td_pcb->pcb_gs = GSEL(GUGS_SEL, SEL_UPL);
559                 }
560         } 
561
562 #ifdef DEBUG
563         if (ldebug(clone))
564                 printf(LMSG("clone: successful rfork to %ld, stack %p sig = %d"),
565                     (long)p2->p_pid, args->stack, exit_signal);
566 #endif
567         if (args->flags & LINUX_CLONE_VFORK) {
568                 PROC_LOCK(p2);
569                 p2->p_flag |= P_PPWAIT;
570                 PROC_UNLOCK(p2);
571         }
572
573         /*
574          * Make this runnable after we are finished with it.
575          */
576         thread_lock(td2);
577         TD_SET_CAN_RUN(td2);
578         sched_add(td2, SRQ_BORING);
579         thread_unlock(td2);
580
581         td->td_retval[0] = p2->p_pid;
582         td->td_retval[1] = 0;
583
584         if (args->flags & LINUX_CLONE_VFORK) {
585                 /* wait for the children to exit, ie. emulate vfork */
586                 PROC_LOCK(p2);
587                 while (p2->p_flag & P_PPWAIT)
588                         cv_wait(&p2->p_pwait, &p2->p_mtx);
589                 PROC_UNLOCK(p2);
590         }
591
592         return (0);
593 }
594
595 #define STACK_SIZE  (2 * 1024 * 1024)
596 #define GUARD_SIZE  (4 * PAGE_SIZE)
597
598 int
599 linux_mmap2(struct thread *td, struct linux_mmap2_args *args)
600 {
601
602 #ifdef DEBUG
603         if (ldebug(mmap2))
604                 printf(ARGS(mmap2, "%p, %d, %d, 0x%08x, %d, %d"),
605                     (void *)args->addr, args->len, args->prot,
606                     args->flags, args->fd, args->pgoff);
607 #endif
608
609         return (linux_mmap_common(td, args->addr, args->len, args->prot,
610                 args->flags, args->fd, (uint64_t)(uint32_t)args->pgoff *
611                 PAGE_SIZE));
612 }
613
614 int
615 linux_mmap(struct thread *td, struct linux_mmap_args *args)
616 {
617         int error;
618         struct l_mmap_argv linux_args;
619
620         error = copyin(args->ptr, &linux_args, sizeof(linux_args));
621         if (error)
622                 return (error);
623
624 #ifdef DEBUG
625         if (ldebug(mmap))
626                 printf(ARGS(mmap, "%p, %d, %d, 0x%08x, %d, %d"),
627                     (void *)linux_args.addr, linux_args.len, linux_args.prot,
628                     linux_args.flags, linux_args.fd, linux_args.pgoff);
629 #endif
630
631         return (linux_mmap_common(td, linux_args.addr, linux_args.len,
632             linux_args.prot, linux_args.flags, linux_args.fd,
633             (uint32_t)linux_args.pgoff));
634 }
635
636 static int
637 linux_mmap_common(struct thread *td, l_uintptr_t addr, l_size_t len, l_int prot,
638     l_int flags, l_int fd, l_loff_t pos)
639 {
640         struct proc *p = td->td_proc;
641         struct mmap_args /* {
642                 caddr_t addr;
643                 size_t len;
644                 int prot;
645                 int flags;
646                 int fd;
647                 long pad;
648                 off_t pos;
649         } */ bsd_args;
650         int error;
651         struct file *fp;
652
653         error = 0;
654         bsd_args.flags = 0;
655         fp = NULL;
656
657         /*
658          * Linux mmap(2):
659          * You must specify exactly one of MAP_SHARED and MAP_PRIVATE
660          */
661         if (!((flags & LINUX_MAP_SHARED) ^ (flags & LINUX_MAP_PRIVATE)))
662                 return (EINVAL);
663
664         if (flags & LINUX_MAP_SHARED)
665                 bsd_args.flags |= MAP_SHARED;
666         if (flags & LINUX_MAP_PRIVATE)
667                 bsd_args.flags |= MAP_PRIVATE;
668         if (flags & LINUX_MAP_FIXED)
669                 bsd_args.flags |= MAP_FIXED;
670         if (flags & LINUX_MAP_ANON) {
671                 /* Enforce pos to be on page boundary, then ignore. */
672                 if ((pos & PAGE_MASK) != 0)
673                         return (EINVAL);
674                 pos = 0;
675                 bsd_args.flags |= MAP_ANON;
676         } else
677                 bsd_args.flags |= MAP_NOSYNC;
678         if (flags & LINUX_MAP_GROWSDOWN)
679                 bsd_args.flags |= MAP_STACK;
680
681         /*
682          * PROT_READ, PROT_WRITE, or PROT_EXEC implies PROT_READ and PROT_EXEC
683          * on Linux/i386. We do this to ensure maximum compatibility.
684          * Linux/ia64 does the same in i386 emulation mode.
685          */
686         bsd_args.prot = prot;
687         if (bsd_args.prot & (PROT_READ | PROT_WRITE | PROT_EXEC))
688                 bsd_args.prot |= PROT_READ | PROT_EXEC;
689
690         /* Linux does not check file descriptor when MAP_ANONYMOUS is set. */
691         bsd_args.fd = (bsd_args.flags & MAP_ANON) ? -1 : fd;
692         if (bsd_args.fd != -1) {
693                 /*
694                  * Linux follows Solaris mmap(2) description:
695                  * The file descriptor fildes is opened with
696                  * read permission, regardless of the
697                  * protection options specified.
698                  */
699
700                 if ((error = fget(td, bsd_args.fd, &fp)) != 0)
701                         return (error);
702                 if (fp->f_type != DTYPE_VNODE) {
703                         fdrop(fp, td);
704                         return (EINVAL);
705                 }
706
707                 /* Linux mmap() just fails for O_WRONLY files */
708                 if (!(fp->f_flag & FREAD)) {
709                         fdrop(fp, td);
710                         return (EACCES);
711                 }
712
713                 fdrop(fp, td);
714         }
715
716         if (flags & LINUX_MAP_GROWSDOWN) {
717                 /* 
718                  * The Linux MAP_GROWSDOWN option does not limit auto
719                  * growth of the region.  Linux mmap with this option
720                  * takes as addr the inital BOS, and as len, the initial
721                  * region size.  It can then grow down from addr without
722                  * limit.  However, linux threads has an implicit internal
723                  * limit to stack size of STACK_SIZE.  Its just not
724                  * enforced explicitly in linux.  But, here we impose
725                  * a limit of (STACK_SIZE - GUARD_SIZE) on the stack
726                  * region, since we can do this with our mmap.
727                  *
728                  * Our mmap with MAP_STACK takes addr as the maximum
729                  * downsize limit on BOS, and as len the max size of
730                  * the region.  It them maps the top SGROWSIZ bytes,
731                  * and auto grows the region down, up to the limit
732                  * in addr.
733                  *
734                  * If we don't use the MAP_STACK option, the effect
735                  * of this code is to allocate a stack region of a
736                  * fixed size of (STACK_SIZE - GUARD_SIZE).
737                  */
738
739                 if ((caddr_t)PTRIN(addr) + len > p->p_vmspace->vm_maxsaddr) {
740                         /* 
741                          * Some linux apps will attempt to mmap
742                          * thread stacks near the top of their
743                          * address space.  If their TOS is greater
744                          * than vm_maxsaddr, vm_map_growstack()
745                          * will confuse the thread stack with the
746                          * process stack and deliver a SEGV if they
747                          * attempt to grow the thread stack past their
748                          * current stacksize rlimit.  To avoid this,
749                          * adjust vm_maxsaddr upwards to reflect
750                          * the current stacksize rlimit rather
751                          * than the maximum possible stacksize.
752                          * It would be better to adjust the
753                          * mmap'ed region, but some apps do not check
754                          * mmap's return value.
755                          */
756                         PROC_LOCK(p);
757                         p->p_vmspace->vm_maxsaddr = (char *)USRSTACK -
758                             lim_cur(p, RLIMIT_STACK);
759                         PROC_UNLOCK(p);
760                 }
761
762                 /*
763                  * This gives us our maximum stack size and a new BOS.
764                  * If we're using VM_STACK, then mmap will just map
765                  * the top SGROWSIZ bytes, and let the stack grow down
766                  * to the limit at BOS.  If we're not using VM_STACK
767                  * we map the full stack, since we don't have a way
768                  * to autogrow it.
769                  */
770                 if (len > STACK_SIZE - GUARD_SIZE) {
771                         bsd_args.addr = (caddr_t)PTRIN(addr);
772                         bsd_args.len = len;
773                 } else {
774                         bsd_args.addr = (caddr_t)PTRIN(addr) -
775                             (STACK_SIZE - GUARD_SIZE - len);
776                         bsd_args.len = STACK_SIZE - GUARD_SIZE;
777                 }
778         } else {
779                 bsd_args.addr = (caddr_t)PTRIN(addr);
780                 bsd_args.len  = len;
781         }
782         bsd_args.pos = pos;
783
784 #ifdef DEBUG
785         if (ldebug(mmap))
786                 printf("-> %s(%p, %d, %d, 0x%08x, %d, 0x%x)\n",
787                     __func__,
788                     (void *)bsd_args.addr, bsd_args.len, bsd_args.prot,
789                     bsd_args.flags, bsd_args.fd, (int)bsd_args.pos);
790 #endif
791         error = mmap(td, &bsd_args);
792 #ifdef DEBUG
793         if (ldebug(mmap))
794                 printf("-> %s() return: 0x%x (0x%08x)\n",
795                         __func__, error, (u_int)td->td_retval[0]);
796 #endif
797         return (error);
798 }
799
800 int
801 linux_mprotect(struct thread *td, struct linux_mprotect_args *uap)
802 {
803         struct mprotect_args bsd_args;
804
805         bsd_args.addr = uap->addr;
806         bsd_args.len = uap->len;
807         bsd_args.prot = uap->prot;
808         if (bsd_args.prot & (PROT_READ | PROT_WRITE | PROT_EXEC))
809                 bsd_args.prot |= PROT_READ | PROT_EXEC;
810         return (mprotect(td, &bsd_args));
811 }
812
813 int
814 linux_pipe(struct thread *td, struct linux_pipe_args *args)
815 {
816         int error;
817         int fildes[2];
818
819 #ifdef DEBUG
820         if (ldebug(pipe))
821                 printf(ARGS(pipe, "*"));
822 #endif
823
824         error = kern_pipe(td, fildes);
825         if (error)
826                 return (error);
827
828         /* XXX: Close descriptors on error. */
829         return (copyout(fildes, args->pipefds, sizeof fildes));
830 }
831
832 int
833 linux_ioperm(struct thread *td, struct linux_ioperm_args *args)
834 {
835         int error;
836         struct i386_ioperm_args iia;
837
838         iia.start = args->start;
839         iia.length = args->length;
840         iia.enable = args->enable;
841         error = i386_set_ioperm(td, &iia);
842         return (error);
843 }
844
845 int
846 linux_iopl(struct thread *td, struct linux_iopl_args *args)
847 {
848         int error;
849
850         if (args->level < 0 || args->level > 3)
851                 return (EINVAL);
852         if ((error = priv_check(td, PRIV_IO)) != 0)
853                 return (error);
854         if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
855                 return (error);
856         td->td_frame->tf_eflags = (td->td_frame->tf_eflags & ~PSL_IOPL) |
857             (args->level * (PSL_IOPL / 3));
858         return (0);
859 }
860
861 int
862 linux_modify_ldt(struct thread *td, struct linux_modify_ldt_args *uap)
863 {
864         int error;
865         struct i386_ldt_args ldt;
866         struct l_descriptor ld;
867         union descriptor desc;
868         int size, written;
869
870         switch (uap->func) {
871         case 0x00: /* read_ldt */
872                 ldt.start = 0;
873                 ldt.descs = uap->ptr;
874                 ldt.num = uap->bytecount / sizeof(union descriptor);
875                 error = i386_get_ldt(td, &ldt);
876                 td->td_retval[0] *= sizeof(union descriptor);
877                 break;
878         case 0x02: /* read_default_ldt = 0 */
879                 size = 5*sizeof(struct l_desc_struct);
880                 if (size > uap->bytecount)
881                         size = uap->bytecount;
882                 for (written = error = 0; written < size && error == 0; written++)
883                         error = subyte((char *)uap->ptr + written, 0);
884                 td->td_retval[0] = written;
885                 break;
886         case 0x01: /* write_ldt */
887         case 0x11: /* write_ldt */
888                 if (uap->bytecount != sizeof(ld))
889                         return (EINVAL);
890
891                 error = copyin(uap->ptr, &ld, sizeof(ld));
892                 if (error)
893                         return (error);
894
895                 ldt.start = ld.entry_number;
896                 ldt.descs = &desc;
897                 ldt.num = 1;
898                 desc.sd.sd_lolimit = (ld.limit & 0x0000ffff);
899                 desc.sd.sd_hilimit = (ld.limit & 0x000f0000) >> 16;
900                 desc.sd.sd_lobase = (ld.base_addr & 0x00ffffff);
901                 desc.sd.sd_hibase = (ld.base_addr & 0xff000000) >> 24;
902                 desc.sd.sd_type = SDT_MEMRO | ((ld.read_exec_only ^ 1) << 1) |
903                         (ld.contents << 2);
904                 desc.sd.sd_dpl = 3;
905                 desc.sd.sd_p = (ld.seg_not_present ^ 1);
906                 desc.sd.sd_xx = 0;
907                 desc.sd.sd_def32 = ld.seg_32bit;
908                 desc.sd.sd_gran = ld.limit_in_pages;
909                 error = i386_set_ldt(td, &ldt, &desc);
910                 break;
911         default:
912                 error = ENOSYS;
913                 break;
914         }
915
916         if (error == EOPNOTSUPP) {
917                 printf("linux: modify_ldt needs kernel option USER_LDT\n");
918                 error = ENOSYS;
919         }
920
921         return (error);
922 }
923
924 int
925 linux_sigaction(struct thread *td, struct linux_sigaction_args *args)
926 {
927         l_osigaction_t osa;
928         l_sigaction_t act, oact;
929         int error;
930
931 #ifdef DEBUG
932         if (ldebug(sigaction))
933                 printf(ARGS(sigaction, "%d, %p, %p"),
934                     args->sig, (void *)args->nsa, (void *)args->osa);
935 #endif
936
937         if (args->nsa != NULL) {
938                 error = copyin(args->nsa, &osa, sizeof(l_osigaction_t));
939                 if (error)
940                         return (error);
941                 act.lsa_handler = osa.lsa_handler;
942                 act.lsa_flags = osa.lsa_flags;
943                 act.lsa_restorer = osa.lsa_restorer;
944                 LINUX_SIGEMPTYSET(act.lsa_mask);
945                 act.lsa_mask.__bits[0] = osa.lsa_mask;
946         }
947
948         error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL,
949             args->osa ? &oact : NULL);
950
951         if (args->osa != NULL && !error) {
952                 osa.lsa_handler = oact.lsa_handler;
953                 osa.lsa_flags = oact.lsa_flags;
954                 osa.lsa_restorer = oact.lsa_restorer;
955                 osa.lsa_mask = oact.lsa_mask.__bits[0];
956                 error = copyout(&osa, args->osa, sizeof(l_osigaction_t));
957         }
958
959         return (error);
960 }
961
962 /*
963  * Linux has two extra args, restart and oldmask.  We dont use these,
964  * but it seems that "restart" is actually a context pointer that
965  * enables the signal to happen with a different register set.
966  */
967 int
968 linux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args)
969 {
970         sigset_t sigmask;
971         l_sigset_t mask;
972
973 #ifdef DEBUG
974         if (ldebug(sigsuspend))
975                 printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask);
976 #endif
977
978         LINUX_SIGEMPTYSET(mask);
979         mask.__bits[0] = args->mask;
980         linux_to_bsd_sigset(&mask, &sigmask);
981         return (kern_sigsuspend(td, sigmask));
982 }
983
984 int
985 linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap)
986 {
987         l_sigset_t lmask;
988         sigset_t sigmask;
989         int error;
990
991 #ifdef DEBUG
992         if (ldebug(rt_sigsuspend))
993                 printf(ARGS(rt_sigsuspend, "%p, %d"),
994                     (void *)uap->newset, uap->sigsetsize);
995 #endif
996
997         if (uap->sigsetsize != sizeof(l_sigset_t))
998                 return (EINVAL);
999
1000         error = copyin(uap->newset, &lmask, sizeof(l_sigset_t));
1001         if (error)
1002                 return (error);
1003
1004         linux_to_bsd_sigset(&lmask, &sigmask);
1005         return (kern_sigsuspend(td, sigmask));
1006 }
1007
1008 int
1009 linux_pause(struct thread *td, struct linux_pause_args *args)
1010 {
1011         struct proc *p = td->td_proc;
1012         sigset_t sigmask;
1013
1014 #ifdef DEBUG
1015         if (ldebug(pause))
1016                 printf(ARGS(pause, ""));
1017 #endif
1018
1019         PROC_LOCK(p);
1020         sigmask = td->td_sigmask;
1021         PROC_UNLOCK(p);
1022         return (kern_sigsuspend(td, sigmask));
1023 }
1024
1025 int
1026 linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap)
1027 {
1028         stack_t ss, oss;
1029         l_stack_t lss;
1030         int error;
1031
1032 #ifdef DEBUG
1033         if (ldebug(sigaltstack))
1034                 printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss);
1035 #endif
1036
1037         if (uap->uss != NULL) {
1038                 error = copyin(uap->uss, &lss, sizeof(l_stack_t));
1039                 if (error)
1040                         return (error);
1041
1042                 ss.ss_sp = lss.ss_sp;
1043                 ss.ss_size = lss.ss_size;
1044                 ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
1045         }
1046         error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL,
1047             (uap->uoss != NULL) ? &oss : NULL);
1048         if (!error && uap->uoss != NULL) {
1049                 lss.ss_sp = oss.ss_sp;
1050                 lss.ss_size = oss.ss_size;
1051                 lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags);
1052                 error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
1053         }
1054
1055         return (error);
1056 }
1057
1058 int
1059 linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args)
1060 {
1061         struct ftruncate_args sa;
1062
1063 #ifdef DEBUG
1064         if (ldebug(ftruncate64))
1065                 printf(ARGS(ftruncate64, "%u, %jd"), args->fd,
1066                     (intmax_t)args->length);
1067 #endif
1068
1069         sa.fd = args->fd;
1070         sa.length = args->length;
1071         return ftruncate(td, &sa);
1072 }
1073
1074 int
1075 linux_set_thread_area(struct thread *td, struct linux_set_thread_area_args *args)
1076 {
1077         struct l_user_desc info;
1078         int error;
1079         int idx;
1080         int a[2];
1081         struct segment_descriptor sd;
1082
1083         error = copyin(args->desc, &info, sizeof(struct l_user_desc));
1084         if (error)
1085                 return (error);
1086
1087 #ifdef DEBUG
1088         if (ldebug(set_thread_area))
1089                 printf(ARGS(set_thread_area, "%i, %x, %x, %i, %i, %i, %i, %i, %i\n"),
1090                       info.entry_number,
1091                       info.base_addr,
1092                       info.limit,
1093                       info.seg_32bit,
1094                       info.contents,
1095                       info.read_exec_only,
1096                       info.limit_in_pages,
1097                       info.seg_not_present,
1098                       info.useable);
1099 #endif
1100
1101         idx = info.entry_number;
1102         /* 
1103          * Semantics of linux version: every thread in the system has array of
1104          * 3 tls descriptors. 1st is GLIBC TLS, 2nd is WINE, 3rd unknown. This 
1105          * syscall loads one of the selected tls decriptors with a value and
1106          * also loads GDT descriptors 6, 7 and 8 with the content of the
1107          * per-thread descriptors.
1108          *
1109          * Semantics of fbsd version: I think we can ignore that linux has 3 
1110          * per-thread descriptors and use just the 1st one. The tls_array[]
1111          * is used only in set/get-thread_area() syscalls and for loading the
1112          * GDT descriptors. In fbsd we use just one GDT descriptor for TLS so
1113          * we will load just one. 
1114          *
1115          * XXX: this doesn't work when a user space process tries to use more
1116          * than 1 TLS segment. Comment in the linux sources says wine might do
1117          * this.
1118          */
1119
1120         /* 
1121          * we support just GLIBC TLS now 
1122          * we should let 3 proceed as well because we use this segment so
1123          * if code does two subsequent calls it should succeed
1124          */
1125         if (idx != 6 && idx != -1 && idx != 3)
1126                 return (EINVAL);
1127
1128         /* 
1129          * we have to copy out the GDT entry we use
1130          * FreeBSD uses GDT entry #3 for storing %gs so load that
1131          *
1132          * XXX: what if a user space program doesn't check this value and tries
1133          * to use 6, 7 or 8? 
1134          */
1135         idx = info.entry_number = 3;
1136         error = copyout(&info, args->desc, sizeof(struct l_user_desc));
1137         if (error)
1138                 return (error);
1139
1140         if (LINUX_LDT_empty(&info)) {
1141                 a[0] = 0;
1142                 a[1] = 0;
1143         } else {
1144                 a[0] = LINUX_LDT_entry_a(&info);
1145                 a[1] = LINUX_LDT_entry_b(&info);
1146         }
1147
1148         memcpy(&sd, &a, sizeof(a));
1149 #ifdef DEBUG
1150         if (ldebug(set_thread_area))
1151                 printf("Segment created in set_thread_area: lobase: %x, hibase: %x, lolimit: %x, hilimit: %x, type: %i, dpl: %i, p: %i, xx: %i, def32: %i, gran: %i\n", sd.sd_lobase,
1152                         sd.sd_hibase,
1153                         sd.sd_lolimit,
1154                         sd.sd_hilimit,
1155                         sd.sd_type,
1156                         sd.sd_dpl,
1157                         sd.sd_p,
1158                         sd.sd_xx,
1159                         sd.sd_def32,
1160                         sd.sd_gran);
1161 #endif
1162
1163         /* this is taken from i386 version of cpu_set_user_tls() */
1164         critical_enter();
1165         /* set %gs */
1166         td->td_pcb->pcb_gsd = sd;
1167         PCPU_GET(fsgs_gdt)[1] = sd;
1168         load_gs(GSEL(GUGS_SEL, SEL_UPL));
1169         critical_exit();
1170    
1171         return (0);
1172 }
1173
1174 int
1175 linux_get_thread_area(struct thread *td, struct linux_get_thread_area_args *args)
1176 {
1177         
1178         struct l_user_desc info;
1179         int error;
1180         int idx;
1181         struct l_desc_struct desc;
1182         struct segment_descriptor sd;
1183
1184 #ifdef DEBUG
1185         if (ldebug(get_thread_area))
1186                 printf(ARGS(get_thread_area, "%p"), args->desc);
1187 #endif
1188
1189         error = copyin(args->desc, &info, sizeof(struct l_user_desc));
1190         if (error)
1191                 return (error);
1192
1193         idx = info.entry_number;
1194         /* XXX: I am not sure if we want 3 to be allowed too. */
1195         if (idx != 6 && idx != 3)
1196                 return (EINVAL);
1197
1198         idx = 3;
1199
1200         memset(&info, 0, sizeof(info));
1201
1202         sd = PCPU_GET(fsgs_gdt)[1];
1203
1204         memcpy(&desc, &sd, sizeof(desc));
1205
1206         info.entry_number = idx;
1207         info.base_addr = LINUX_GET_BASE(&desc);
1208         info.limit = LINUX_GET_LIMIT(&desc);
1209         info.seg_32bit = LINUX_GET_32BIT(&desc);
1210         info.contents = LINUX_GET_CONTENTS(&desc);
1211         info.read_exec_only = !LINUX_GET_WRITABLE(&desc);
1212         info.limit_in_pages = LINUX_GET_LIMIT_PAGES(&desc);
1213         info.seg_not_present = !LINUX_GET_PRESENT(&desc);
1214         info.useable = LINUX_GET_USEABLE(&desc);
1215
1216         error = copyout(&info, args->desc, sizeof(struct l_user_desc));
1217         if (error)
1218                 return (EFAULT);
1219
1220         return (0);
1221 }
1222
1223 /* copied from kern/kern_time.c */
1224 int
1225 linux_timer_create(struct thread *td, struct linux_timer_create_args *args)
1226 {
1227         return ktimer_create(td, (struct ktimer_create_args *) args);
1228 }
1229
1230 int
1231 linux_timer_settime(struct thread *td, struct linux_timer_settime_args *args)
1232 {
1233         return ktimer_settime(td, (struct ktimer_settime_args *) args);
1234 }
1235
1236 int
1237 linux_timer_gettime(struct thread *td, struct linux_timer_gettime_args *args)
1238 {
1239         return ktimer_gettime(td, (struct ktimer_gettime_args *) args);
1240 }
1241
1242 int
1243 linux_timer_getoverrun(struct thread *td, struct linux_timer_getoverrun_args *args)
1244 {
1245         return ktimer_getoverrun(td, (struct ktimer_getoverrun_args *) args);
1246 }
1247
1248 int
1249 linux_timer_delete(struct thread *td, struct linux_timer_delete_args *args)
1250 {
1251         return ktimer_delete(td, (struct ktimer_delete_args *) args);
1252 }
1253
1254 /* XXX: this wont work with module - convert it */
1255 int
1256 linux_mq_open(struct thread *td, struct linux_mq_open_args *args)
1257 {
1258 #ifdef P1003_1B_MQUEUE
1259         return kmq_open(td, (struct kmq_open_args *) args);
1260 #else
1261         return (ENOSYS);
1262 #endif
1263 }
1264
1265 int
1266 linux_mq_unlink(struct thread *td, struct linux_mq_unlink_args *args)
1267 {
1268 #ifdef P1003_1B_MQUEUE
1269         return kmq_unlink(td, (struct kmq_unlink_args *) args);
1270 #else
1271         return (ENOSYS);
1272 #endif
1273 }
1274
1275 int
1276 linux_mq_timedsend(struct thread *td, struct linux_mq_timedsend_args *args)
1277 {
1278 #ifdef P1003_1B_MQUEUE
1279         return kmq_timedsend(td, (struct kmq_timedsend_args *) args);
1280 #else
1281         return (ENOSYS);
1282 #endif
1283 }
1284
1285 int
1286 linux_mq_timedreceive(struct thread *td, struct linux_mq_timedreceive_args *args)
1287 {
1288 #ifdef P1003_1B_MQUEUE
1289         return kmq_timedreceive(td, (struct kmq_timedreceive_args *) args);
1290 #else
1291         return (ENOSYS);
1292 #endif
1293 }
1294
1295 int
1296 linux_mq_notify(struct thread *td, struct linux_mq_notify_args *args)
1297 {
1298 #ifdef P1003_1B_MQUEUE
1299         return kmq_notify(td, (struct kmq_notify_args *) args);
1300 #else
1301         return (ENOSYS);
1302 #endif
1303 }
1304
1305 int
1306 linux_mq_getsetattr(struct thread *td, struct linux_mq_getsetattr_args *args)
1307 {
1308 #ifdef P1003_1B_MQUEUE
1309         return kmq_setattr(td, (struct kmq_setattr_args *) args);
1310 #else
1311         return (ENOSYS);
1312 #endif
1313 }
1314