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_mm
- 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_mm(void)
358 {
359 struct vm_area_struct * mpnt;
360
361 mpnt = current->mm->mmap;
362 current->mm->mmap = NULL;
363 while (mpnt) {
364 struct vm_area_struct * next = mpnt->vm_next;
365 if (mpnt->vm_ops && mpnt->vm_ops->close)
366 mpnt->vm_ops->close(mpnt);
367 remove_shared_vm_struct(mpnt);
368 if (mpnt->vm_inode)
369 iput(mpnt->vm_inode);
370 kfree(mpnt);
371 mpnt = next;
372 }
373
374 free_page_tables(current);
375 }
376
377 static void exit_files(void)
378 {
379 int i;
380
381 for (i=0 ; i<NR_OPEN ; i++)
382 if (current->files->fd[i])
383 sys_close(i);
384 }
385
386 static void exit_fs(void)
387 {
388 iput(current->fs->pwd);
389 current->fs->pwd = NULL;
390 iput(current->fs->root);
391 current->fs->root = NULL;
392 }
393
394 NORET_TYPE void do_exit(long code)
395 {
396 struct task_struct *p;
397
398 if (intr_count) {
399 printk("Aiee, killing interrupt handler\n");
400 intr_count = 0;
401 }
402 fake_volatile:
403 if (current->semundo)
404 sem_exit();
405 exit_mm();
406 exit_files();
407 exit_fs();
408 exit_thread();
409 forget_original_parent(current);
410
411
412
413
414
415
416
417
418
419 if ((current->p_pptr->pgrp != current->pgrp) &&
420 (current->p_pptr->session == current->session) &&
421 is_orphaned_pgrp(current->pgrp) &&
422 has_stopped_jobs(current->pgrp)) {
423 kill_pg(current->pgrp,SIGHUP,1);
424 kill_pg(current->pgrp,SIGCONT,1);
425 }
426
427 notify_parent(current);
428
429
430
431
432
433
434
435
436
437 while ((p = current->p_cptr) != NULL) {
438 current->p_cptr = p->p_osptr;
439 p->p_ysptr = NULL;
440 p->flags &= ~(PF_PTRACED|PF_TRACESYS);
441 if (task[1] && task[1] != current)
442 p->p_pptr = task[1];
443 else
444 p->p_pptr = task[0];
445 p->p_osptr = p->p_pptr->p_cptr;
446 p->p_osptr->p_ysptr = p;
447 p->p_pptr->p_cptr = p;
448 if (p->state == TASK_ZOMBIE)
449 notify_parent(p);
450
451
452
453
454
455
456 if ((p->pgrp != current->pgrp) &&
457 (p->session == current->session) &&
458 is_orphaned_pgrp(p->pgrp) &&
459 has_stopped_jobs(p->pgrp)) {
460 kill_pg(p->pgrp,SIGHUP,1);
461 kill_pg(p->pgrp,SIGCONT,1);
462 }
463 }
464 if (current->leader)
465 disassociate_ctty(1);
466 if (last_task_used_math == current)
467 last_task_used_math = NULL;
468 current->state = TASK_ZOMBIE;
469 current->exit_code = code;
470 current->mm->rss = 0;
471 #ifdef DEBUG_PROC_TREE
472 audit_ptree();
473 #endif
474 if (current->exec_domain && current->exec_domain->use_count)
475 (*current->exec_domain->use_count)--;
476 if (current->binfmt && current->binfmt->use_count)
477 (*current->binfmt->use_count)--;
478 schedule();
479
480
481
482
483
484
485
486
487
488
489
490
491
492 goto fake_volatile;
493 }
494
495 asmlinkage int sys_exit(int error_code)
496 {
497 do_exit((error_code&0xff)<<8);
498 }
499
500 asmlinkage int sys_wait4(pid_t pid,unsigned long * stat_addr, int options, struct rusage * ru)
501 {
502 int flag, retval;
503 struct wait_queue wait = { current, NULL };
504 struct task_struct *p;
505
506 if (stat_addr) {
507 flag = verify_area(VERIFY_WRITE, stat_addr, 4);
508 if (flag)
509 return flag;
510 }
511 add_wait_queue(¤t->wait_chldexit,&wait);
512 repeat:
513 flag=0;
514 for (p = current->p_cptr ; p ; p = p->p_osptr) {
515 if (pid>0) {
516 if (p->pid != pid)
517 continue;
518 } else if (!pid) {
519 if (p->pgrp != current->pgrp)
520 continue;
521 } else if (pid != -1) {
522 if (p->pgrp != -pid)
523 continue;
524 }
525
526 if ((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0))
527 continue;
528 flag = 1;
529 switch (p->state) {
530 case TASK_STOPPED:
531 if (!p->exit_code)
532 continue;
533 if (!(options & WUNTRACED) && !(p->flags & PF_PTRACED))
534 continue;
535 if (stat_addr)
536 put_fs_long((p->exit_code << 8) | 0x7f,
537 stat_addr);
538 p->exit_code = 0;
539 if (ru != NULL)
540 getrusage(p, RUSAGE_BOTH, ru);
541 retval = p->pid;
542 goto end_wait4;
543 case TASK_ZOMBIE:
544 current->cutime += p->utime + p->cutime;
545 current->cstime += p->stime + p->cstime;
546 current->mm->cmin_flt += p->mm->min_flt + p->mm->cmin_flt;
547 current->mm->cmaj_flt += p->mm->maj_flt + p->mm->cmaj_flt;
548 if (ru != NULL)
549 getrusage(p, RUSAGE_BOTH, ru);
550 flag = p->pid;
551 if (stat_addr)
552 put_fs_long(p->exit_code, stat_addr);
553 if (p->p_opptr != p->p_pptr) {
554 REMOVE_LINKS(p);
555 p->p_pptr = p->p_opptr;
556 SET_LINKS(p);
557 notify_parent(p);
558 } else
559 release(p);
560 #ifdef DEBUG_PROC_TREE
561 audit_ptree();
562 #endif
563 retval = flag;
564 goto end_wait4;
565 default:
566 continue;
567 }
568 }
569 if (flag) {
570 retval = 0;
571 if (options & WNOHANG)
572 goto end_wait4;
573 current->state=TASK_INTERRUPTIBLE;
574 schedule();
575 current->signal &= ~(1<<(SIGCHLD-1));
576 retval = -ERESTARTSYS;
577 if (current->signal & ~current->blocked)
578 goto end_wait4;
579 goto repeat;
580 }
581 retval = -ECHILD;
582 end_wait4:
583 remove_wait_queue(¤t->wait_chldexit,&wait);
584 return retval;
585 }
586
587
588
589
590
591 asmlinkage int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options)
592 {
593 return sys_wait4(pid, stat_addr, options, NULL);
594 }