This source file includes following definitions.
- sys_sgetmask
- sys_ssetmask
- sys_sigpending
- sys_sigsuspend
- check_pending
- sys_signal
- sys_sigaction
- sys_sigreturn
- setup_frame
- do_signal
1
2
3
4
5
6
7 #include <linux/sched.h>
8 #include <linux/kernel.h>
9 #include <linux/signal.h>
10 #include <linux/errno.h>
11 #include <linux/wait.h>
12 #include <linux/ptrace.h>
13 #include <linux/unistd.h>
14
15 #include <asm/segment.h>
16
17 #define _S(nr) (1<<((nr)-1))
18
19 #define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
20
21 extern int core_dump(long signr,struct pt_regs * regs);
22
23 asmlinkage int do_signal(unsigned long oldmask, struct pt_regs * regs);
24
25 struct sigcontext_struct {
26 unsigned short gs, __gsh;
27 unsigned short fs, __fsh;
28 unsigned short es, __esh;
29 unsigned short ds, __dsh;
30 unsigned long edi;
31 unsigned long esi;
32 unsigned long ebp;
33 unsigned long esp;
34 unsigned long ebx;
35 unsigned long edx;
36 unsigned long ecx;
37 unsigned long eax;
38 unsigned long trapno;
39 unsigned long err;
40 unsigned long eip;
41 unsigned short cs, __csh;
42 unsigned long eflags;
43 unsigned long esp_at_signal;
44 unsigned short ss, __ssh;
45 unsigned long i387;
46 unsigned long oldmask;
47 unsigned long cr2;
48 };
49
50 asmlinkage int sys_sgetmask(void)
51 {
52 return current->blocked;
53 }
54
55 asmlinkage int sys_ssetmask(int newmask)
56 {
57 int old=current->blocked;
58
59 current->blocked = newmask & _BLOCKABLE;
60 return old;
61 }
62
63 asmlinkage int sys_sigpending(sigset_t *set)
64 {
65 int error;
66
67 error = verify_area(VERIFY_WRITE, set, 4);
68 if (!error)
69 put_fs_long(current->blocked & current->signal, (unsigned long *)set);
70 return error;
71 }
72
73
74
75
76 asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, unsigned long set)
77 {
78 unsigned long mask;
79 struct pt_regs * regs = (struct pt_regs *) &restart;
80
81 mask = current->blocked;
82 current->blocked = set & _BLOCKABLE;
83 regs->eax = -EINTR;
84 while (1) {
85 current->state = TASK_INTERRUPTIBLE;
86 schedule();
87 if (do_signal(mask,regs))
88 return -EINTR;
89 }
90 }
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107 static void check_pending(int signum)
108 {
109 struct sigaction *p;
110
111 p = signum - 1 + current->sigaction;
112 if (p->sa_handler == SIG_IGN) {
113 if (signum == SIGCHLD)
114 return;
115 current->signal &= ~_S(signum);
116 return;
117 }
118 if (p->sa_handler == SIG_DFL) {
119 if (signum != SIGCONT && signum != SIGCHLD && signum != SIGWINCH)
120 return;
121 current->signal &= ~_S(signum);
122 return;
123 }
124 }
125
126 asmlinkage int sys_signal(int signum, unsigned long handler)
127 {
128 struct sigaction tmp;
129
130 if (signum<1 || signum>32 || signum==SIGKILL || signum==SIGSTOP)
131 return -EINVAL;
132 if (handler >= TASK_SIZE)
133 return -EFAULT;
134 tmp.sa_handler = (void (*)(int)) handler;
135 tmp.sa_mask = 0;
136 tmp.sa_flags = SA_ONESHOT | SA_NOMASK;
137 tmp.sa_restorer = NULL;
138 handler = (long) current->sigaction[signum-1].sa_handler;
139 current->sigaction[signum-1] = tmp;
140 check_pending(signum);
141 return handler;
142 }
143
144 asmlinkage int sys_sigaction(int signum, const struct sigaction * action,
145 struct sigaction * oldaction)
146 {
147 struct sigaction new_sa, *p;
148
149 if (signum<1 || signum>32 || signum==SIGKILL || signum==SIGSTOP)
150 return -EINVAL;
151 p = signum - 1 + current->sigaction;
152 if (action) {
153 memcpy_fromfs(&new_sa, action, sizeof(struct sigaction));
154 if (new_sa.sa_flags & SA_NOMASK)
155 new_sa.sa_mask = 0;
156 else {
157 new_sa.sa_mask |= _S(signum);
158 new_sa.sa_mask &= _BLOCKABLE;
159 }
160 if (TASK_SIZE <= (unsigned long) new_sa.sa_handler)
161 return -EFAULT;
162 }
163 if (oldaction) {
164 if (!verify_area(VERIFY_WRITE,oldaction, sizeof(struct sigaction)))
165 memcpy_tofs(oldaction, p, sizeof(struct sigaction));
166 }
167 if (action) {
168 *p = new_sa;
169 check_pending(signum);
170 }
171 return 0;
172 }
173
174 asmlinkage int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options);
175
176
177
178
179 asmlinkage int sys_sigreturn(unsigned long __unused)
180 {
181 #define CHECK_SEG(x) if (x) x |= 3
182 #define COPY(x) regs->x = context.x
183 struct sigcontext_struct context;
184 struct pt_regs * regs;
185
186 regs = (struct pt_regs *) &__unused;
187 memcpy_fromfs(&context,(void *) regs->esp, sizeof(context));
188 current->blocked = context.oldmask & _BLOCKABLE;
189 CHECK_SEG(context.ss);
190 CHECK_SEG(context.cs);
191 CHECK_SEG(context.ds);
192 CHECK_SEG(context.es);
193 CHECK_SEG(context.fs);
194 CHECK_SEG(context.gs);
195 COPY(eip); COPY(eflags);
196 COPY(ecx); COPY(edx);
197 COPY(ebx);
198 COPY(esp); COPY(ebp);
199 COPY(edi); COPY(esi);
200 COPY(cs); COPY(ss);
201 COPY(ds); COPY(es);
202 COPY(fs); COPY(gs);
203 regs->orig_eax = -1;
204 return context.eax;
205 }
206
207
208
209
210
211 static void setup_frame(struct sigaction * sa, unsigned long ** fp, unsigned long eip,
212 struct pt_regs * regs, int signr, unsigned long oldmask)
213 {
214 unsigned long * frame;
215
216 #define __CODE ((unsigned long)(frame+24))
217 #define CODE(x) ((unsigned long *) ((x)+__CODE))
218 frame = *fp;
219 if (regs->ss != USER_DS)
220 frame = (unsigned long *) sa->sa_restorer;
221 frame -= 32;
222 verify_area(VERIFY_WRITE,frame,32*4);
223
224 put_fs_long(__CODE,frame);
225 put_fs_long(signr, frame+1);
226 put_fs_long(regs->gs, frame+2);
227 put_fs_long(regs->fs, frame+3);
228 put_fs_long(regs->es, frame+4);
229 put_fs_long(regs->ds, frame+5);
230 put_fs_long(regs->edi, frame+6);
231 put_fs_long(regs->esi, frame+7);
232 put_fs_long(regs->ebp, frame+8);
233 put_fs_long((long)*fp, frame+9);
234 put_fs_long(regs->ebx, frame+10);
235 put_fs_long(regs->edx, frame+11);
236 put_fs_long(regs->ecx, frame+12);
237 put_fs_long(regs->eax, frame+13);
238 put_fs_long(0, frame+14);
239 put_fs_long(0, frame+15);
240 put_fs_long(eip, frame+16);
241 put_fs_long(regs->cs, frame+17);
242 put_fs_long(regs->eflags, frame+18);
243 put_fs_long(regs->esp, frame+19);
244 put_fs_long(regs->ss, frame+20);
245 put_fs_long(0,frame+21);
246
247 put_fs_long(oldmask, frame+22);
248 put_fs_long(0, frame+23);
249
250 put_fs_long(0x0000b858, CODE(0));
251 put_fs_long(0x80cd0000, CODE(4));
252 put_fs_long(__NR_sigreturn, CODE(2));
253 *fp = frame;
254 #undef __CODE
255 #undef CODE
256 }
257
258
259
260
261
262
263
264
265
266
267 asmlinkage int do_signal(unsigned long oldmask, struct pt_regs * regs)
268 {
269 unsigned long mask = ~current->blocked;
270 unsigned long handler_signal = 0;
271 unsigned long *frame = NULL;
272 unsigned long eip = 0;
273 unsigned long signr;
274 struct sigaction * sa;
275
276 while ((signr = current->signal & mask)) {
277 __asm__("bsf %2,%1\n\t"
278 "btrl %1,%0"
279 :"=m" (current->signal),"=r" (signr)
280 :"1" (signr));
281 sa = current->sigaction + signr;
282 signr++;
283 if ((current->flags & PF_PTRACED) && signr != SIGKILL) {
284 current->exit_code = signr;
285 current->state = TASK_STOPPED;
286 notify_parent(current);
287 schedule();
288 if (!(signr = current->exit_code))
289 continue;
290 current->exit_code = 0;
291 if (signr == SIGSTOP)
292 continue;
293 if (_S(signr) & current->blocked) {
294 current->signal |= _S(signr);
295 continue;
296 }
297 sa = current->sigaction + signr - 1;
298 }
299 if (sa->sa_handler == SIG_IGN) {
300 if (signr != SIGCHLD)
301 continue;
302
303 while (sys_waitpid(-1,NULL,WNOHANG) > 0)
304 ;
305 continue;
306 }
307 if (sa->sa_handler == SIG_DFL) {
308 if (current->pid == 1)
309 continue;
310 switch (signr) {
311 case SIGCONT: case SIGCHLD: case SIGWINCH:
312 continue;
313
314 case SIGSTOP: case SIGTSTP: case SIGTTIN: case SIGTTOU:
315 current->state = TASK_STOPPED;
316 current->exit_code = signr;
317 if (!(current->p_pptr->sigaction[SIGCHLD-1].sa_flags &
318 SA_NOCLDSTOP))
319 notify_parent(current);
320 schedule();
321 continue;
322
323 case SIGQUIT: case SIGILL: case SIGTRAP:
324 case SIGIOT: case SIGFPE: case SIGSEGV:
325 if (core_dump(signr,regs))
326 signr |= 0x80;
327
328 default:
329 current->signal |= _S(signr & 0x7f);
330 do_exit(signr);
331 }
332 }
333
334
335
336 if (regs->orig_eax >= 0) {
337 if (regs->eax == -ERESTARTNOHAND ||
338 (regs->eax == -ERESTARTSYS && !(sa->sa_flags & SA_RESTART)))
339 regs->eax = -EINTR;
340 }
341 handler_signal |= 1 << (signr-1);
342 mask &= ~sa->sa_mask;
343 }
344 if (regs->orig_eax >= 0 &&
345 (regs->eax == -ERESTARTNOHAND ||
346 regs->eax == -ERESTARTSYS ||
347 regs->eax == -ERESTARTNOINTR)) {
348 regs->eax = regs->orig_eax;
349 regs->eip -= 2;
350 }
351 if (!handler_signal)
352 return 0;
353 eip = regs->eip;
354 frame = (unsigned long *) regs->esp;
355 signr = 1;
356 sa = current->sigaction;
357 for (mask = 1 ; mask ; sa++,signr++,mask += mask) {
358 if (mask > handler_signal)
359 break;
360 if (!(mask & handler_signal))
361 continue;
362 setup_frame(sa,&frame,eip,regs,signr,oldmask);
363 eip = (unsigned long) sa->sa_handler;
364 if (sa->sa_flags & SA_ONESHOT)
365 sa->sa_handler = NULL;
366
367 __asm__("testb $0,%%fs:%0": :"m" (*(char *) eip));
368 regs->cs = USER_CS; regs->ss = USER_DS;
369 regs->ds = USER_DS; regs->es = USER_DS;
370 regs->gs = USER_DS; regs->fs = USER_DS;
371 current->blocked |= sa->sa_mask;
372 oldmask |= sa->sa_mask;
373 }
374 regs->esp = (unsigned long) frame;
375 regs->eip = eip;
376 return 1;
377 }