This source file includes following definitions.
- generate
- send_sig
- notify_parent
- release
- bad_task_ptr
- audit_ptree
- session_of_pgrp
- kill_pg
- kill_sl
- kill_proc
- sys_kill
- is_orphaned_pgrp
- has_stopped_jobs
- forget_original_parent
- exit_files
- exit_fs
- do_exit
- sys_exit
- sys_wait4
- sys_waitpid
1
2
3
4
5
6
7 #define DEBUG_PROC_TREE
8
9 #include <linux/wait.h>
10 #include <linux/errno.h>
11 #include <linux/signal.h>
12 #include <linux/sched.h>
13 #include <linux/kernel.h>
14 #include <linux/resource.h>
15 #include <linux/mm.h>
16 #include <linux/tty.h>
17 #include <linux/malloc.h>
18
19 #include <asm/segment.h>
20 extern void sem_exit (void);
21
22 int getrusage(struct task_struct *, int, struct rusage *);
23
24 static int generate(unsigned long sig, struct task_struct * p)
25 {
26 unsigned long mask = 1 << (sig-1);
27 struct sigaction * sa = sig + p->sigaction - 1;
28
29
30 if (p->flags & PF_PTRACED) {
31 p->signal |= mask;
32 return 1;
33 }
34
35 if (sa->sa_handler == SIG_IGN && sig != SIGCHLD)
36 return 0;
37
38 if ((sa->sa_handler == SIG_DFL) &&
39 (sig == SIGCONT || sig == SIGCHLD || sig == SIGWINCH))
40 return 0;
41 p->signal |= mask;
42 return 1;
43 }
44
45 int send_sig(unsigned long sig,struct task_struct * p,int priv)
46 {
47 if (!p || sig > 32)
48 return -EINVAL;
49 if (!priv && ((sig != SIGCONT) || (current->session != p->session)) &&
50 (current->euid != p->euid) && (current->uid != p->uid) && !suser())
51 return -EPERM;
52 if (!sig)
53 return 0;
54
55
56
57 if (p->state == TASK_ZOMBIE)
58 return 0;
59 if ((sig == SIGKILL) || (sig == SIGCONT)) {
60 if (p->state == TASK_STOPPED)
61 p->state = TASK_RUNNING;
62 p->exit_code = 0;
63 p->signal &= ~( (1<<(SIGSTOP-1)) | (1<<(SIGTSTP-1)) |
64 (1<<(SIGTTIN-1)) | (1<<(SIGTTOU-1)) );
65 }
66
67 if ((sig >= SIGSTOP) && (sig <= SIGTTOU))
68 p->signal &= ~(1<<(SIGCONT-1));
69
70 generate(sig,p);
71 return 0;
72 }
73
74 void notify_parent(struct task_struct * tsk)
75 {
76 if (tsk->p_pptr == task[1])
77 tsk->exit_signal = SIGCHLD;
78 send_sig(tsk->exit_signal, tsk->p_pptr, 1);
79 wake_up_interruptible(&tsk->p_pptr->wait_chldexit);
80 }
81
82 void release(struct task_struct * p)
83 {
84 int i;
85
86 if (!p)
87 return;
88 if (p == current) {
89 printk("task releasing itself\n");
90 return;
91 }
92 for (i=1 ; i<NR_TASKS ; i++)
93 if (task[i] == p) {
94 task[i] = NULL;
95 REMOVE_LINKS(p);
96 if (STACK_MAGIC != *(unsigned long *)p->kernel_stack_page)
97 printk(KERN_ALERT "release: %s kernel stack corruption. Aiee\n", p->comm);
98 free_page(p->kernel_stack_page);
99 free_page((long) p);
100 return;
101 }
102 panic("trying to release non-existent task");
103 }
104
105 #ifdef DEBUG_PROC_TREE
106
107
108
109
110 int bad_task_ptr(struct task_struct *p)
111 {
112 int i;
113
114 if (!p)
115 return 0;
116 for (i=0 ; i<NR_TASKS ; i++)
117 if (task[i] == p)
118 return 0;
119 return 1;
120 }
121
122
123
124
125
126
127
128
129
130
131 void audit_ptree(void)
132 {
133 int i;
134
135 for (i=1 ; i<NR_TASKS ; i++) {
136 if (!task[i])
137 continue;
138 if (bad_task_ptr(task[i]->p_pptr))
139 printk("Warning, pid %d's parent link is bad\n",
140 task[i]->pid);
141 if (bad_task_ptr(task[i]->p_cptr))
142 printk("Warning, pid %d's child link is bad\n",
143 task[i]->pid);
144 if (bad_task_ptr(task[i]->p_ysptr))
145 printk("Warning, pid %d's ys link is bad\n",
146 task[i]->pid);
147 if (bad_task_ptr(task[i]->p_osptr))
148 printk("Warning, pid %d's os link is bad\n",
149 task[i]->pid);
150 if (task[i]->p_pptr == task[i])
151 printk("Warning, pid %d parent link points to self\n",
152 task[i]->pid);
153 if (task[i]->p_cptr == task[i])
154 printk("Warning, pid %d child link points to self\n",
155 task[i]->pid);
156 if (task[i]->p_ysptr == task[i])
157 printk("Warning, pid %d ys link points to self\n",
158 task[i]->pid);
159 if (task[i]->p_osptr == task[i])
160 printk("Warning, pid %d os link points to self\n",
161 task[i]->pid);
162 if (task[i]->p_osptr) {
163 if (task[i]->p_pptr != task[i]->p_osptr->p_pptr)
164 printk(
165 "Warning, pid %d older sibling %d parent is %d\n",
166 task[i]->pid, task[i]->p_osptr->pid,
167 task[i]->p_osptr->p_pptr->pid);
168 if (task[i]->p_osptr->p_ysptr != task[i])
169 printk(
170 "Warning, pid %d older sibling %d has mismatched ys link\n",
171 task[i]->pid, task[i]->p_osptr->pid);
172 }
173 if (task[i]->p_ysptr) {
174 if (task[i]->p_pptr != task[i]->p_ysptr->p_pptr)
175 printk(
176 "Warning, pid %d younger sibling %d parent is %d\n",
177 task[i]->pid, task[i]->p_osptr->pid,
178 task[i]->p_osptr->p_pptr->pid);
179 if (task[i]->p_ysptr->p_osptr != task[i])
180 printk(
181 "Warning, pid %d younger sibling %d has mismatched os link\n",
182 task[i]->pid, task[i]->p_ysptr->pid);
183 }
184 if (task[i]->p_cptr) {
185 if (task[i]->p_cptr->p_pptr != task[i])
186 printk(
187 "Warning, pid %d youngest child %d has mismatched parent link\n",
188 task[i]->pid, task[i]->p_cptr->pid);
189 if (task[i]->p_cptr->p_ysptr)
190 printk(
191 "Warning, pid %d youngest child %d has non-NULL ys link\n",
192 task[i]->pid, task[i]->p_cptr->pid);
193 }
194 }
195 }
196 #endif
197
198
199
200
201
202
203 int session_of_pgrp(int pgrp)
204 {
205 struct task_struct *p;
206 int fallback;
207
208 fallback = -1;
209 for_each_task(p) {
210 if (p->session <= 0)
211 continue;
212 if (p->pgrp == pgrp)
213 return p->session;
214 if (p->pid == pgrp)
215 fallback = p->session;
216 }
217 return fallback;
218 }
219
220
221
222
223
224 int kill_pg(int pgrp, int sig, int priv)
225 {
226 struct task_struct *p;
227 int err,retval = -ESRCH;
228 int found = 0;
229
230 if (sig<0 || sig>32 || pgrp<=0)
231 return -EINVAL;
232 for_each_task(p) {
233 if (p->pgrp == pgrp) {
234 if ((err = send_sig(sig,p,priv)) != 0)
235 retval = err;
236 else
237 found++;
238 }
239 }
240 return(found ? 0 : retval);
241 }
242
243
244
245
246
247
248 int kill_sl(int sess, int sig, int priv)
249 {
250 struct task_struct *p;
251 int err,retval = -ESRCH;
252 int found = 0;
253
254 if (sig<0 || sig>32 || sess<=0)
255 return -EINVAL;
256 for_each_task(p) {
257 if (p->session == sess && p->leader) {
258 if ((err = send_sig(sig,p,priv)) != 0)
259 retval = err;
260 else
261 found++;
262 }
263 }
264 return(found ? 0 : retval);
265 }
266
267 int kill_proc(int pid, int sig, int priv)
268 {
269 struct task_struct *p;
270
271 if (sig<0 || sig>32)
272 return -EINVAL;
273 for_each_task(p) {
274 if (p && p->pid == pid)
275 return send_sig(sig,p,priv);
276 }
277 return(-ESRCH);
278 }
279
280
281
282
283
284 asmlinkage int sys_kill(int pid,int sig)
285 {
286 int err, retval = 0, count = 0;
287
288 if (!pid)
289 return(kill_pg(current->pgrp,sig,0));
290 if (pid == -1) {
291 struct task_struct * p;
292 for_each_task(p) {
293 if (p->pid > 1 && p != current) {
294 ++count;
295 if ((err = send_sig(sig,p,0)) != -EPERM)
296 retval = err;
297 }
298 }
299 return(count ? retval : -ESRCH);
300 }
301 if (pid < 0)
302 return(kill_pg(-pid,sig,0));
303
304 return(kill_proc(pid,sig,0));
305 }
306
307
308
309
310
311
312
313
314
315 int is_orphaned_pgrp(int pgrp)
316 {
317 struct task_struct *p;
318
319 for_each_task(p) {
320 if ((p->pgrp != pgrp) ||
321 (p->state == TASK_ZOMBIE) ||
322 (p->p_pptr->pid == 1))
323 continue;
324 if ((p->p_pptr->pgrp != pgrp) &&
325 (p->p_pptr->session == p->session))
326 return 0;
327 }
328 return(1);
329 }
330
331 static int has_stopped_jobs(int pgrp)
332 {
333 struct task_struct * p;
334
335 for_each_task(p) {
336 if (p->pgrp != pgrp)
337 continue;
338 if (p->state == TASK_STOPPED)
339 return(1);
340 }
341 return(0);
342 }
343
344 static void forget_original_parent(struct task_struct * father)
345 {
346 struct task_struct * p;
347
348 for_each_task(p) {
349 if (p->p_opptr == father)
350 if (task[1])
351 p->p_opptr = task[1];
352 else
353 p->p_opptr = task[0];
354 }
355 }
356
357 static void exit_files(void)
358 {
359 int i;
360
361 for (i=0 ; i<NR_OPEN ; i++)
362 if (current->files->fd[i])
363 sys_close(i);
364 }
365
366 static void exit_fs(void)
367 {
368 iput(current->fs->pwd);
369 current->fs->pwd = NULL;
370 iput(current->fs->root);
371 current->fs->root = NULL;
372 }
373
374 NORET_TYPE void do_exit(long code)
375 {
376 struct task_struct *p;
377
378 if (intr_count) {
379 printk("Aiee, killing interrupt handler\n");
380 intr_count = 0;
381 }
382 fake_volatile:
383 sem_exit();
384 exit_mmap(current);
385 free_page_tables(current);
386 exit_files();
387 exit_fs();
388 exit_thread();
389 forget_original_parent(current);
390
391
392
393
394
395
396
397
398
399 if ((current->p_pptr->pgrp != current->pgrp) &&
400 (current->p_pptr->session == current->session) &&
401 is_orphaned_pgrp(current->pgrp) &&
402 has_stopped_jobs(current->pgrp)) {
403 kill_pg(current->pgrp,SIGHUP,1);
404 kill_pg(current->pgrp,SIGCONT,1);
405 }
406
407 notify_parent(current);
408
409
410
411
412
413
414
415
416
417 while ((p = current->p_cptr) != NULL) {
418 current->p_cptr = p->p_osptr;
419 p->p_ysptr = NULL;
420 p->flags &= ~(PF_PTRACED|PF_TRACESYS);
421 if (task[1] && task[1] != current)
422 p->p_pptr = task[1];
423 else
424 p->p_pptr = task[0];
425 p->p_osptr = p->p_pptr->p_cptr;
426 p->p_osptr->p_ysptr = p;
427 p->p_pptr->p_cptr = p;
428 if (p->state == TASK_ZOMBIE)
429 notify_parent(p);
430
431
432
433
434
435
436 if ((p->pgrp != current->pgrp) &&
437 (p->session == current->session) &&
438 is_orphaned_pgrp(p->pgrp) &&
439 has_stopped_jobs(p->pgrp)) {
440 kill_pg(p->pgrp,SIGHUP,1);
441 kill_pg(p->pgrp,SIGCONT,1);
442 }
443 }
444 if (current->leader)
445 disassociate_ctty(1);
446 if (last_task_used_math == current)
447 last_task_used_math = NULL;
448 current->state = TASK_ZOMBIE;
449 current->exit_code = code;
450 current->mm->rss = 0;
451 #ifdef DEBUG_PROC_TREE
452 audit_ptree();
453 #endif
454 if (current->exec_domain && current->exec_domain->use_count)
455 (*current->exec_domain->use_count)--;
456 if (current->binfmt && current->binfmt->use_count)
457 (*current->binfmt->use_count)--;
458 schedule();
459
460
461
462
463
464
465
466
467
468
469
470
471
472 goto fake_volatile;
473 }
474
475 asmlinkage int sys_exit(int error_code)
476 {
477 do_exit((error_code&0xff)<<8);
478 }
479
480 asmlinkage int sys_wait4(pid_t pid,unsigned long * stat_addr, int options, struct rusage * ru)
481 {
482 int flag, retval;
483 struct wait_queue wait = { current, NULL };
484 struct task_struct *p;
485
486 if (stat_addr) {
487 flag = verify_area(VERIFY_WRITE, stat_addr, 4);
488 if (flag)
489 return flag;
490 }
491 add_wait_queue(¤t->wait_chldexit,&wait);
492 repeat:
493 flag=0;
494 for (p = current->p_cptr ; p ; p = p->p_osptr) {
495 if (pid>0) {
496 if (p->pid != pid)
497 continue;
498 } else if (!pid) {
499 if (p->pgrp != current->pgrp)
500 continue;
501 } else if (pid != -1) {
502 if (p->pgrp != -pid)
503 continue;
504 }
505
506 if ((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0))
507 continue;
508 flag = 1;
509 switch (p->state) {
510 case TASK_STOPPED:
511 if (!p->exit_code)
512 continue;
513 if (!(options & WUNTRACED) && !(p->flags & PF_PTRACED))
514 continue;
515 if (stat_addr)
516 put_fs_long((p->exit_code << 8) | 0x7f,
517 stat_addr);
518 p->exit_code = 0;
519 if (ru != NULL)
520 getrusage(p, RUSAGE_BOTH, ru);
521 retval = p->pid;
522 goto end_wait4;
523 case TASK_ZOMBIE:
524 current->cutime += p->utime + p->cutime;
525 current->cstime += p->stime + p->cstime;
526 current->mm->cmin_flt += p->mm->min_flt + p->mm->cmin_flt;
527 current->mm->cmaj_flt += p->mm->maj_flt + p->mm->cmaj_flt;
528 if (ru != NULL)
529 getrusage(p, RUSAGE_BOTH, ru);
530 flag = p->pid;
531 if (stat_addr)
532 put_fs_long(p->exit_code, stat_addr);
533 if (p->p_opptr != p->p_pptr) {
534 REMOVE_LINKS(p);
535 p->p_pptr = p->p_opptr;
536 SET_LINKS(p);
537 notify_parent(p);
538 } else
539 release(p);
540 #ifdef DEBUG_PROC_TREE
541 audit_ptree();
542 #endif
543 retval = flag;
544 goto end_wait4;
545 default:
546 continue;
547 }
548 }
549 if (flag) {
550 retval = 0;
551 if (options & WNOHANG)
552 goto end_wait4;
553 current->state=TASK_INTERRUPTIBLE;
554 schedule();
555 current->signal &= ~(1<<(SIGCHLD-1));
556 retval = -ERESTARTSYS;
557 if (current->signal & ~current->blocked)
558 goto end_wait4;
559 goto repeat;
560 }
561 retval = -ECHILD;
562 end_wait4:
563 remove_wait_queue(¤t->wait_chldexit,&wait);
564 return retval;
565 }
566
567
568
569
570
571 asmlinkage int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options)
572 {
573 return sys_wait4(pid, stat_addr, options, NULL);
574 }