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