Deleted Added
sdiff udiff text old ( 78962 ) new ( 83221 )
full compact
linux_machdep.c (78962) linux_machdep.c (83221)
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

--- 11 unchanged lines hidden (view full) ---

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 *
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

--- 11 unchanged lines hidden (view full) ---

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 * $FreeBSD: head/sys/i386/linux/linux_machdep.c 78962 2001-06-29 11:10:41Z jhb $
28 * $FreeBSD: head/sys/i386/linux/linux_machdep.c 83221 2001-09-08 19:07:04Z marcel $
29 */
30
31#include <sys/param.h>
32#include <sys/systm.h>
33#include <sys/mman.h>
34#include <sys/mutex.h>
35#include <sys/proc.h>
36#include <sys/resource.h>

--- 12 unchanged lines hidden (view full) ---

49#include <vm/vm_map.h>
50
51#include <i386/linux/linux.h>
52#include <i386/linux/linux_proto.h>
53#include <compat/linux/linux_ipc.h>
54#include <compat/linux/linux_signal.h>
55#include <compat/linux/linux_util.h>
56
29 */
30
31#include <sys/param.h>
32#include <sys/systm.h>
33#include <sys/mman.h>
34#include <sys/mutex.h>
35#include <sys/proc.h>
36#include <sys/resource.h>

--- 12 unchanged lines hidden (view full) ---

49#include <vm/vm_map.h>
50
51#include <i386/linux/linux.h>
52#include <i386/linux/linux_proto.h>
53#include <compat/linux/linux_ipc.h>
54#include <compat/linux/linux_signal.h>
55#include <compat/linux/linux_util.h>
56
57struct linux_descriptor {
58 unsigned int entry_number;
59 unsigned long base_addr;
60 unsigned int limit;
61 unsigned int seg_32bit:1;
62 unsigned int contents:2;
63 unsigned int read_exec_only:1;
64 unsigned int limit_in_pages:1;
65 unsigned int seg_not_present:1;
66 unsigned int useable:1;
57struct l_descriptor {
58 l_uint entry_number;
59 l_ulong base_addr;
60 l_uint limit;
61 l_uint seg_32bit:1;
62 l_uint contents:2;
63 l_uint read_exec_only:1;
64 l_uint limit_in_pages:1;
65 l_uint seg_not_present:1;
66 l_uint useable:1;
67};
68
67};
68
69struct linux_select_argv {
70 int nfds;
71 fd_set *readfds;
72 fd_set *writefds;
73 fd_set *exceptfds;
74 struct timeval *timeout;
69struct l_old_select_argv {
70 l_int nfds;
71 l_fd_set *readfds;
72 l_fd_set *writefds;
73 l_fd_set *exceptfds;
74 struct l_timeval *timeout;
75};
76
77int
78linux_to_bsd_sigaltstack(int lsa)
79{
80 int bsa = 0;
81
82 if (lsa & LINUX_SS_DISABLE)

--- 30 unchanged lines hidden (view full) ---

113#endif
114
115 bsd.fname = args->path;
116 bsd.argv = args->argp;
117 bsd.envv = args->envp;
118 return (execve(p, &bsd));
119}
120
75};
76
77int
78linux_to_bsd_sigaltstack(int lsa)
79{
80 int bsa = 0;
81
82 if (lsa & LINUX_SS_DISABLE)

--- 30 unchanged lines hidden (view full) ---

113#endif
114
115 bsd.fname = args->path;
116 bsd.argv = args->argp;
117 bsd.envv = args->envp;
118 return (execve(p, &bsd));
119}
120
121struct l_ipc_kludge {
122 struct l_msgbuf *msgp;
123 l_long msgtyp;
124};
125
121int
122linux_ipc(struct proc *p, struct linux_ipc_args *args)
123{
126int
127linux_ipc(struct proc *p, struct linux_ipc_args *args)
128{
124 switch (args->what) {
125 case LINUX_SEMOP:
126 return (linux_semop(p, args));
127 case LINUX_SEMGET:
128 return (linux_semget(p, args));
129 case LINUX_SEMCTL:
130 return (linux_semctl(p, args));
131 case LINUX_MSGSND:
132 return (linux_msgsnd(p, args));
133 case LINUX_MSGRCV:
134 return (linux_msgrcv(p, args));
135 case LINUX_MSGGET:
136 return (linux_msgget(p, args));
137 case LINUX_MSGCTL:
138 return (linux_msgctl(p, args));
139 case LINUX_SHMAT:
140 return (linux_shmat(p, args));
141 case LINUX_SHMDT:
142 return (linux_shmdt(p, args));
143 case LINUX_SHMGET:
144 return (linux_shmget(p, args));
145 case LINUX_SHMCTL:
146 return (linux_shmctl(p, args));
129
130 switch (args->what & 0xFFFF) {
131 case LINUX_SEMOP: {
132 struct linux_semop_args a;
133
134 a.semid = args->arg1;
135 a.tsops = args->ptr;
136 a.nsops = args->arg2;
137 return (linux_semop(p, &a));
147 }
138 }
139 case LINUX_SEMGET: {
140 struct linux_semget_args a;
148
141
149 uprintf("LINUX: 'ipc' typ=%d not implemented\n", args->what);
150 return (ENOSYS);
142 a.key = args->arg1;
143 a.nsems = args->arg2;
144 a.semflg = args->arg3;
145 return (linux_semget(p, &a));
146 }
147 case LINUX_SEMCTL: {
148 struct linux_semctl_args a;
149 int error;
150
151 a.semid = args->arg1;
152 a.semnum = args->arg2;
153 a.cmd = args->arg3;
154 error = copyin((caddr_t)args->ptr, &a.arg, sizeof(a.arg));
155 if (error)
156 return (error);
157 return (linux_semctl(p, &a));
158 }
159 case LINUX_MSGSND: {
160 struct linux_msgsnd_args a;
161
162 a.msqid = args->arg1;
163 a.msgp = args->ptr;
164 a.msgsz = args->arg2;
165 a.msgflg = args->arg3;
166 return (linux_msgsnd(p, &a));
167 }
168 case LINUX_MSGRCV: {
169 struct linux_msgrcv_args a;
170
171 a.msqid = args->arg1;
172 a.msgsz = args->arg2;
173 a.msgflg = args->arg3;
174 if ((args->what >> 16) == 0) {
175 struct l_ipc_kludge tmp;
176 int error;
177
178 if (args->ptr == NULL)
179 return (EINVAL);
180 error = copyin((caddr_t)args->ptr, &tmp, sizeof(tmp));
181 if (error)
182 return (error);
183 a.msgp = tmp.msgp;
184 a.msgtyp = tmp.msgtyp;
185 } else {
186 a.msgp = args->ptr;
187 a.msgtyp = args->arg5;
188 }
189 return (linux_msgrcv(p, &a));
190 }
191 case LINUX_MSGGET: {
192 struct linux_msgget_args a;
193
194 a.key = args->arg1;
195 a.msgflg = args->arg2;
196 return (linux_msgget(p, &a));
197 }
198 case LINUX_MSGCTL: {
199 struct linux_msgctl_args a;
200
201 a.msqid = args->arg1;
202 a.cmd = args->arg2;
203 a.buf = args->ptr;
204 return (linux_msgctl(p, &a));
205 }
206 case LINUX_SHMAT: {
207 struct linux_shmat_args a;
208
209 a.shmid = args->arg1;
210 a.shmaddr = args->ptr;
211 a.shmflg = args->arg2;
212 a.raddr = (l_ulong *)args->arg3;
213 return (linux_shmat(p, &a));
214 }
215 case LINUX_SHMDT: {
216 struct linux_shmdt_args a;
217
218 a.shmaddr = args->ptr;
219 return (linux_shmdt(p, &a));
220 }
221 case LINUX_SHMGET: {
222 struct linux_shmget_args a;
223
224 a.key = args->arg1;
225 a.size = args->arg2;
226 a.shmflg = args->arg3;
227 return (linux_shmget(p, &a));
228 }
229 case LINUX_SHMCTL: {
230 struct linux_shmctl_args a;
231
232 a.shmid = args->arg1;
233 a.cmd = args->arg2;
234 a.buf = args->ptr;
235 return (linux_shmctl(p, &a));
236 }
237 default:
238 break;
239 }
240
241 return (EINVAL);
151}
152
153int
242}
243
244int
154linux_select(struct proc *p, struct linux_select_args *args)
245linux_old_select(struct proc *p, struct linux_old_select_args *args)
155{
246{
156 struct linux_select_argv linux_args;
157 struct linux_newselect_args newsel;
247 struct l_old_select_argv linux_args;
248 struct linux_select_args newsel;
158 int error;
159
249 int error;
250
160#ifdef SELECT_DEBUG
161 if (ldebug(select))
162 printf(ARGS(select, "%x"), args->ptr);
251#ifdef DEBUG
252 if (ldebug(old_select))
253 printf(ARGS(old_select, "%x"), args->ptr);
163#endif
164
254#endif
255
165 error = copyin(args->ptr, &linux_args, sizeof(linux_args));
256 error = copyin((caddr_t)args->ptr, &linux_args, sizeof(linux_args));
166 if (error)
167 return (error);
168
169 newsel.nfds = linux_args.nfds;
170 newsel.readfds = linux_args.readfds;
171 newsel.writefds = linux_args.writefds;
172 newsel.exceptfds = linux_args.exceptfds;
173 newsel.timeout = linux_args.timeout;
257 if (error)
258 return (error);
259
260 newsel.nfds = linux_args.nfds;
261 newsel.readfds = linux_args.readfds;
262 newsel.writefds = linux_args.writefds;
263 newsel.exceptfds = linux_args.exceptfds;
264 newsel.timeout = linux_args.timeout;
174 return (linux_newselect(p, &newsel));
265 return (linux_select(p, &newsel));
175}
176
177int
178linux_fork(struct proc *p, struct linux_fork_args *args)
179{
180 int error;
181
182#ifdef DEBUG

--- 34 unchanged lines hidden (view full) ---

217#define CLONE_PID 0x1000
218
219int
220linux_clone(struct proc *p, struct linux_clone_args *args)
221{
222 int error, ff = RFPROC | RFSTOPPED;
223 struct proc *p2;
224 int exit_signal;
266}
267
268int
269linux_fork(struct proc *p, struct linux_fork_args *args)
270{
271 int error;
272
273#ifdef DEBUG

--- 34 unchanged lines hidden (view full) ---

308#define CLONE_PID 0x1000
309
310int
311linux_clone(struct proc *p, struct linux_clone_args *args)
312{
313 int error, ff = RFPROC | RFSTOPPED;
314 struct proc *p2;
315 int exit_signal;
225 vm_offset_t start;
226
227#ifdef DEBUG
228 if (ldebug(clone)) {
229 printf(ARGS(clone, "flags %x, stack %x"),
230 (unsigned int)args->flags, (unsigned int)args->stack);
231 if (args->flags & CLONE_PID)
232 printf(LMSG("CLONE_PID not yet supported"));
233 }

--- 4 unchanged lines hidden (view full) ---

238
239 exit_signal = args->flags & 0x000000ff;
240 if (exit_signal >= LINUX_NSIG)
241 return (EINVAL);
242
243 if (exit_signal <= LINUX_SIGTBLSZ)
244 exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)];
245
316
317#ifdef DEBUG
318 if (ldebug(clone)) {
319 printf(ARGS(clone, "flags %x, stack %x"),
320 (unsigned int)args->flags, (unsigned int)args->stack);
321 if (args->flags & CLONE_PID)
322 printf(LMSG("CLONE_PID not yet supported"));
323 }

--- 4 unchanged lines hidden (view full) ---

328
329 exit_signal = args->flags & 0x000000ff;
330 if (exit_signal >= LINUX_NSIG)
331 return (EINVAL);
332
333 if (exit_signal <= LINUX_SIGTBLSZ)
334 exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)];
335
246 /* RFTHREAD probably not necessary here, but it shouldn't hurt */
247 ff |= RFTHREAD;
248
249 if (args->flags & CLONE_VM)
250 ff |= RFMEM;
251 if (args->flags & CLONE_SIGHAND)
252 ff |= RFSIGSHARE;
253 if (!(args->flags & CLONE_FILES))
254 ff |= RFFDG;
255
336 if (args->flags & CLONE_VM)
337 ff |= RFMEM;
338 if (args->flags & CLONE_SIGHAND)
339 ff |= RFSIGSHARE;
340 if (!(args->flags & CLONE_FILES))
341 ff |= RFFDG;
342
256 error = 0;
257 start = 0;
343 mtx_lock(&Giant);
344 error = fork1(p, ff, &p2);
345 if (error == 0) {
346 p->p_retval[0] = p2->p_pid;
347 p->p_retval[1] = 0;
258
348
259 if ((error = fork1(p, ff, &p2)) != 0)
260 return (error);
349 PROC_LOCK(p2);
350 p2->p_sigparent = exit_signal;
351 p2->p_frame->tf_esp = (unsigned int)args->stack;
261
352
262 PROC_LOCK(p2);
263 p2->p_sigparent = exit_signal;
264 PROC_UNLOCK(p2);
265 p2->p_frame->tf_esp = (unsigned int)args->stack;
266
267#ifdef DEBUG
353#ifdef DEBUG
268 if (ldebug(clone))
269 printf(LMSG("clone: successful rfork to %ld"),
270 (long)p2->p_pid);
354 if (ldebug(clone))
355 printf(LMSG("clone: successful rfork to %ld"),
356 (long)p2->p_pid);
271#endif
272
357#endif
358
273 /*
274 * Make this runnable after we are finished with it.
275 */
276 mtx_lock_spin(&sched_lock);
277 p2->p_stat = SRUN;
278 setrunqueue(p2);
279 mtx_unlock_spin(&sched_lock);
359 /*
360 * Make this runnable after we are finished with it.
361 */
362 mtx_lock_spin(&sched_lock);
363 p2->p_stat = SRUN;
364 setrunqueue(p2);
365 mtx_unlock_spin(&sched_lock);
366 PROC_UNLOCK(p2);
367 }
368 mtx_unlock(&Giant);
280
369
281 p->p_retval[0] = p2->p_pid;
282 p->p_retval[1] = 0;
283 return (0);
370 return (error);
284}
285
286/* XXX move */
371}
372
373/* XXX move */
287struct linux_mmap_argv {
288 linux_caddr_t addr;
289 int len;
290 int prot;
291 int flags;
292 int fd;
293 int pos;
374struct l_mmap_argv {
375 l_caddr_t addr;
376 l_int len;
377 l_int prot;
378 l_int flags;
379 l_int fd;
380 l_int pos;
294};
295
296#define STACK_SIZE (2 * 1024 * 1024)
297#define GUARD_SIZE (4 * PAGE_SIZE)
298
299int
300linux_mmap(struct proc *p, struct linux_mmap_args *args)
301{
302 struct mmap_args /* {
303 caddr_t addr;
304 size_t len;
305 int prot;
306 int flags;
307 int fd;
308 long pad;
309 off_t pos;
310 } */ bsd_args;
311 int error;
381};
382
383#define STACK_SIZE (2 * 1024 * 1024)
384#define GUARD_SIZE (4 * PAGE_SIZE)
385
386int
387linux_mmap(struct proc *p, struct linux_mmap_args *args)
388{
389 struct mmap_args /* {
390 caddr_t addr;
391 size_t len;
392 int prot;
393 int flags;
394 int fd;
395 long pad;
396 off_t pos;
397 } */ bsd_args;
398 int error;
312 struct linux_mmap_argv linux_args;
399 struct l_mmap_argv linux_args;
313
400
314 error = copyin(args->ptr, &linux_args, sizeof(linux_args));
401 error = copyin((caddr_t)args->ptr, &linux_args, sizeof(linux_args));
315 if (error)
316 return (error);
317
318#ifdef DEBUG
319 if (ldebug(mmap))
320 printf(ARGS(mmap, "%p, %d, %d, 0x%08x, %d, %d"),
321 (void *)linux_args.addr, linux_args.len, linux_args.prot,
322 linux_args.flags, linux_args.fd, linux_args.pos);

--- 160 unchanged lines hidden (view full) ---

483linux_modify_ldt(p, uap)
484 struct proc *p;
485 struct linux_modify_ldt_args *uap;
486{
487 int error;
488 caddr_t sg;
489 struct sysarch_args args;
490 struct i386_ldt_args *ldt;
402 if (error)
403 return (error);
404
405#ifdef DEBUG
406 if (ldebug(mmap))
407 printf(ARGS(mmap, "%p, %d, %d, 0x%08x, %d, %d"),
408 (void *)linux_args.addr, linux_args.len, linux_args.prot,
409 linux_args.flags, linux_args.fd, linux_args.pos);

--- 160 unchanged lines hidden (view full) ---

570linux_modify_ldt(p, uap)
571 struct proc *p;
572 struct linux_modify_ldt_args *uap;
573{
574 int error;
575 caddr_t sg;
576 struct sysarch_args args;
577 struct i386_ldt_args *ldt;
491 struct linux_descriptor ld;
578 struct l_descriptor ld;
492 union descriptor *desc;
493
494 sg = stackgap_init();
495
496 if (uap->ptr == NULL)
497 return (EINVAL);
498
499 switch (uap->func) {

--- 47 unchanged lines hidden (view full) ---

547 }
548
549 return (error);
550}
551
552int
553linux_sigaction(struct proc *p, struct linux_sigaction_args *args)
554{
579 union descriptor *desc;
580
581 sg = stackgap_init();
582
583 if (uap->ptr == NULL)
584 return (EINVAL);
585
586 switch (uap->func) {

--- 47 unchanged lines hidden (view full) ---

634 }
635
636 return (error);
637}
638
639int
640linux_sigaction(struct proc *p, struct linux_sigaction_args *args)
641{
555 linux_osigaction_t osa;
556 linux_sigaction_t act, oact;
642 l_osigaction_t osa;
643 l_sigaction_t act, oact;
557 int error;
558
559#ifdef DEBUG
560 if (ldebug(sigaction))
561 printf(ARGS(sigaction, "%d, %p, %p"),
562 args->sig, (void *)args->nsa, (void *)args->osa);
563#endif
564
565 if (args->nsa != NULL) {
644 int error;
645
646#ifdef DEBUG
647 if (ldebug(sigaction))
648 printf(ARGS(sigaction, "%d, %p, %p"),
649 args->sig, (void *)args->nsa, (void *)args->osa);
650#endif
651
652 if (args->nsa != NULL) {
566 error = copyin(args->nsa, &osa, sizeof(linux_osigaction_t));
653 error = copyin((caddr_t)args->nsa, &osa,
654 sizeof(l_osigaction_t));
567 if (error)
568 return (error);
569 act.lsa_handler = osa.lsa_handler;
570 act.lsa_flags = osa.lsa_flags;
571 act.lsa_restorer = osa.lsa_restorer;
572 LINUX_SIGEMPTYSET(act.lsa_mask);
573 act.lsa_mask.__bits[0] = osa.lsa_mask;
574 }
575
576 error = linux_do_sigaction(p, args->sig, args->nsa ? &act : NULL,
577 args->osa ? &oact : NULL);
578
579 if (args->osa != NULL && !error) {
580 osa.lsa_handler = oact.lsa_handler;
581 osa.lsa_flags = oact.lsa_flags;
582 osa.lsa_restorer = oact.lsa_restorer;
583 osa.lsa_mask = oact.lsa_mask.__bits[0];
655 if (error)
656 return (error);
657 act.lsa_handler = osa.lsa_handler;
658 act.lsa_flags = osa.lsa_flags;
659 act.lsa_restorer = osa.lsa_restorer;
660 LINUX_SIGEMPTYSET(act.lsa_mask);
661 act.lsa_mask.__bits[0] = osa.lsa_mask;
662 }
663
664 error = linux_do_sigaction(p, args->sig, args->nsa ? &act : NULL,
665 args->osa ? &oact : NULL);
666
667 if (args->osa != NULL && !error) {
668 osa.lsa_handler = oact.lsa_handler;
669 osa.lsa_flags = oact.lsa_flags;
670 osa.lsa_restorer = oact.lsa_restorer;
671 osa.lsa_mask = oact.lsa_mask.__bits[0];
584 error = copyout(&osa, args->osa, sizeof(linux_osigaction_t));
672 error = copyout(&osa, (caddr_t)args->osa,
673 sizeof(l_osigaction_t));
585 }
586
587 return (error);
588}
589
590/*
591 * Linux has two extra args, restart and oldmask. We dont use these,
592 * but it seems that "restart" is actually a context pointer that
593 * enables the signal to happen with a different register set.
594 */
595int
596linux_sigsuspend(struct proc *p, struct linux_sigsuspend_args *args)
597{
598 struct sigsuspend_args bsd;
599 sigset_t *sigmask;
674 }
675
676 return (error);
677}
678
679/*
680 * Linux has two extra args, restart and oldmask. We dont use these,
681 * but it seems that "restart" is actually a context pointer that
682 * enables the signal to happen with a different register set.
683 */
684int
685linux_sigsuspend(struct proc *p, struct linux_sigsuspend_args *args)
686{
687 struct sigsuspend_args bsd;
688 sigset_t *sigmask;
600 linux_sigset_t mask;
689 l_sigset_t mask;
601 caddr_t sg = stackgap_init();
602
603#ifdef DEBUG
604 if (ldebug(sigsuspend))
605 printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask);
606#endif
607
608 sigmask = stackgap_alloc(&sg, sizeof(sigset_t));

--- 4 unchanged lines hidden (view full) ---

613 return (sigsuspend(p, &bsd));
614}
615
616int
617linux_rt_sigsuspend(p, uap)
618 struct proc *p;
619 struct linux_rt_sigsuspend_args *uap;
620{
690 caddr_t sg = stackgap_init();
691
692#ifdef DEBUG
693 if (ldebug(sigsuspend))
694 printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask);
695#endif
696
697 sigmask = stackgap_alloc(&sg, sizeof(sigset_t));

--- 4 unchanged lines hidden (view full) ---

702 return (sigsuspend(p, &bsd));
703}
704
705int
706linux_rt_sigsuspend(p, uap)
707 struct proc *p;
708 struct linux_rt_sigsuspend_args *uap;
709{
621 linux_sigset_t lmask;
710 l_sigset_t lmask;
622 sigset_t *bmask;
623 struct sigsuspend_args bsd;
624 caddr_t sg = stackgap_init();
625 int error;
626
627#ifdef DEBUG
628 if (ldebug(rt_sigsuspend))
629 printf(ARGS(rt_sigsuspend, "%p, %d"),
630 (void *)uap->newset, uap->sigsetsize);
631#endif
632
711 sigset_t *bmask;
712 struct sigsuspend_args bsd;
713 caddr_t sg = stackgap_init();
714 int error;
715
716#ifdef DEBUG
717 if (ldebug(rt_sigsuspend))
718 printf(ARGS(rt_sigsuspend, "%p, %d"),
719 (void *)uap->newset, uap->sigsetsize);
720#endif
721
633 if (uap->sigsetsize != sizeof(linux_sigset_t))
722 if (uap->sigsetsize != sizeof(l_sigset_t))
634 return (EINVAL);
635
723 return (EINVAL);
724
636 error = copyin(uap->newset, &lmask, sizeof(linux_sigset_t));
725 error = copyin(uap->newset, &lmask, sizeof(l_sigset_t));
637 if (error)
638 return (error);
639
640 bmask = stackgap_alloc(&sg, sizeof(sigset_t));
641 linux_to_bsd_sigset(&lmask, bmask);
642 bsd.sigmask = bmask;
643 return (sigsuspend(p, &bsd));
644}

--- 20 unchanged lines hidden (view full) ---

665
666int
667linux_sigaltstack(p, uap)
668 struct proc *p;
669 struct linux_sigaltstack_args *uap;
670{
671 struct sigaltstack_args bsd;
672 stack_t *ss, *oss;
726 if (error)
727 return (error);
728
729 bmask = stackgap_alloc(&sg, sizeof(sigset_t));
730 linux_to_bsd_sigset(&lmask, bmask);
731 bsd.sigmask = bmask;
732 return (sigsuspend(p, &bsd));
733}

--- 20 unchanged lines hidden (view full) ---

754
755int
756linux_sigaltstack(p, uap)
757 struct proc *p;
758 struct linux_sigaltstack_args *uap;
759{
760 struct sigaltstack_args bsd;
761 stack_t *ss, *oss;
673 linux_stack_t lss;
762 l_stack_t lss;
674 int error;
675 caddr_t sg = stackgap_init();
676
677#ifdef DEBUG
678 if (ldebug(sigaltstack))
679 printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss);
680#endif
681
682 if (uap->uss == NULL) {
683 ss = NULL;
684 } else {
763 int error;
764 caddr_t sg = stackgap_init();
765
766#ifdef DEBUG
767 if (ldebug(sigaltstack))
768 printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss);
769#endif
770
771 if (uap->uss == NULL) {
772 ss = NULL;
773 } else {
685 error = copyin(uap->uss, &lss, sizeof(linux_stack_t));
774 error = copyin(uap->uss, &lss, sizeof(l_stack_t));
686 if (error)
687 return (error);
688
689 ss = stackgap_alloc(&sg, sizeof(stack_t));
690 ss->ss_sp = lss.ss_sp;
691 ss->ss_size = lss.ss_size;
692 ss->ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
693 }

--- 4 unchanged lines hidden (view full) ---

698 bsd.ss = ss;
699 bsd.oss = oss;
700 error = sigaltstack(p, &bsd);
701
702 if (!error && oss != NULL) {
703 lss.ss_sp = oss->ss_sp;
704 lss.ss_size = oss->ss_size;
705 lss.ss_flags = bsd_to_linux_sigaltstack(oss->ss_flags);
775 if (error)
776 return (error);
777
778 ss = stackgap_alloc(&sg, sizeof(stack_t));
779 ss->ss_sp = lss.ss_sp;
780 ss->ss_size = lss.ss_size;
781 ss->ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
782 }

--- 4 unchanged lines hidden (view full) ---

787 bsd.ss = ss;
788 bsd.oss = oss;
789 error = sigaltstack(p, &bsd);
790
791 if (!error && oss != NULL) {
792 lss.ss_sp = oss->ss_sp;
793 lss.ss_size = oss->ss_size;
794 lss.ss_flags = bsd_to_linux_sigaltstack(oss->ss_flags);
706 error = copyout(&lss, uap->uoss, sizeof(linux_stack_t));
795 error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
707 }
708
709 return (error);
710}
796 }
797
798 return (error);
799}