fork的一个例子，好像人家是讲得很详细了，我还是不明白

huntrsky

谁人把fork()函数的源码贴出来研究一下啊~~~不胜感激

old-cow

系统调用，看 kernel 。

langue

原帖由 huntrsky 于 2006-11-19 14:54 发表
谁人把fork()函数的源码贴出来研究一下啊~~~不胜感激

我把它贴出来，只怕你看不懂。

1. 
   
2. /*      $OpenBSD: kern_fork.c,v 1.44 2001/10/14 14:39:03 art Exp $      */
   
3. /*      $NetBSD: kern_fork.c,v 1.29 1996/02/09 18:59:34 christos Exp $  */
   
4. 
   
5. /*
   
6. * Copyright (c) 1982, 1986, 1989, 1991, 1993
   
7. *      The Regents of the University of California.  All rights reserved.
   
8. * (c) UNIX System Laboratories, Inc.
   
9. * All or some portions of this file are derived from material licensed
   
10. * to the University of California by American Telephone and Telegraph
    
11. * Co. or Unix System Laboratories, Inc. and are reproduced herein with
    
12. * the permission of UNIX System Laboratories, Inc.
    
13. *
    
14. * Redistribution and use in source and binary forms, with or without
    
15. * modification, are permitted provided that the following conditions
    
16. * are met:
    
17. * 1. Redistributions of source code must retain the above copyright
    
18. *    notice, this list of conditions and the following disclaimer.
    
19. * 2. Redistributions in binary form must reproduce the above copyright
    
20. *    notice, this list of conditions and the following disclaimer in the
    
21. *    documentation and/or other materials provided with the distribution.
    
22. * 3. All advertising materials mentioning features or use of this software
    
23. *    must display the following acknowledgement:
    
24. *      This product includes software developed by the University of
    
25. *      California, Berkeley and its contributors.
    
26. * 4. Neither the name of the University nor the names of its contributors
    
27. *    may be used to endorse or promote products derived from this software
    
28. *    without specific prior written permission.
    
29. *
    
30. * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    
31. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    
32. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    
33. * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    
34. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    
35. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    
36. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    
37. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    
38. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    
39. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    
40. * SUCH DAMAGE.
    
41. *
    
42. *      @(#)kern_fork.c 8.6 (Berkeley) 4/8/94
    
43. */
    
44. 
    
45. #include <sys/param.h>
    
46. #include <sys/systm.h>
    
47. #include <sys/map.h>
    
48. #include <sys/filedesc.h>
    
49. #include <sys/kernel.h>
    
50. #include <sys/malloc.h>
    
51. #include <sys/mount.h>
    
52. #include <sys/proc.h>
    
53. #include <sys/resourcevar.h>
    
54. #include <sys/signalvar.h>
    
55. #include <sys/vnode.h>
    
56. #include <sys/file.h>
    
57. #include <sys/acct.h>
    
58. #include <sys/ktrace.h>
    
59. #include <sys/sched.h>
    
60. #include <dev/rndvar.h>
    
61. #include <sys/pool.h>
    
62. 
    
63. #include <sys/syscallargs.h>
    
64. 
    
65. #include <vm/vm.h>
    
66. #include <uvm/uvm_extern.h>
    
67. #include <uvm/uvm_map.h>
    
68. 
    
69. int     nprocs = 1;             /* process 0 */
    
70. int     randompid;              /* when set to 1, pid's go random */
    
71. pid_t   lastpid;
    
72. struct  forkstat forkstat;
    
73. 
    
74. 
    
75. /*ARGSUSED*/
    
76. int
    
77. sys_fork(p, v, retval)
    
78.         struct proc *p;
    
79.         void *v;
    
80.         register_t *retval;
    
81. {
    
82.         return (fork1(p, SIGCHLD, FORK_FORK, NULL, 0, retval));
    
83. }
    
84. 
    
85. /*ARGSUSED*/
    
86. int
    
87. sys_vfork(p, v, retval)
    
88.         struct proc *p;
    
89.         void *v;
    
90.         register_t *retval;
    
91. {
    
92.         return (fork1(p, SIGCHLD, FORK_VFORK|FORK_PPWAIT, NULL, 0, retval));
    
93. }
    
94. 
    
95. int
    
96. sys_rfork(p, v, retval)
    
97.         struct proc *p;
    
98.         void *v;
    
99.         register_t *retval;
    
100. {
     
101.         struct sys_rfork_args /* {
     
102.                 syscallarg(int) flags;
     
103.         } */ *uap = v;
     
104. 
     
105.         int rforkflags;
     
106.         int flags;
     
107. 
     
108.         flags = FORK_RFORK;
     
109.         rforkflags = SCARG(uap, flags);
     
110. 
     
111.         if ((rforkflags & RFPROC) == 0)
     
112.                 return (EINVAL);
     
113. 
     
114.         switch(rforkflags & (RFFDG|RFCFDG)) {
     
115.         case (RFFDG|RFCFDG):
     
116.                 return EINVAL;
     
117.         case RFCFDG:
     
118.                 flags |= FORK_CLEANFILES;
     
119.                 break;
     
120.         case RFFDG:
     
121.                 break;
     
122.         default:
     
123.                 flags |= FORK_SHAREFILES;
     
124.                 break;
     
125.         }
     
126. 
     
127.         if (rforkflags & RFNOWAIT)
     
128.                 flags |= FORK_NOZOMBIE;
     
129. 
     
130.         if (rforkflags & RFMEM)
     
131.                 flags |= FORK_VMNOSTACK;
     
132. 
     
133.         return (fork1(p, SIGCHLD, flags, NULL, 0, retval));
     
134. }
     
135. 
     
136. int
     
137. fork1(p1, exitsig, flags, stack, stacksize, retval)
     
138.         register struct proc *p1;
     
139.         int exitsig;
     
140.         int flags;
     
141.         void *stack;
     
142.         size_t stacksize;
     
143.         register_t *retval;
     
144. {
     
145.         struct proc *p2;
     
146.         uid_t uid;
     
147.         struct proc *newproc;
     
148.         struct vmspace *vm;
     
149.         int count;
     
150.         static int pidchecked = 0;
     
151.         vaddr_t uaddr;
     
152.         int s;
     
153.         extern void endtsleep __P((void *));
     
154.         extern void realitexpire __P((void *));
     
155. 
     
156. #ifndef RFORK_FDSHARE
     
157.         /* XXX - Too dangerous right now. */
     
158.         if (flags & FORK_SHAREFILES) {
     
159.                 return (EOPNOTSUPP);
     
160.         }
     
161. #endif
     
162. 
     
163.         /*
     
164.          * Although process entries are dynamically created, we still keep
     
165.          * a global limit on the maximum number we will create. We reserve
     
166.          * the last 5 processes to root. The variable nprocs is the current
     
167.          * number of processes, maxproc is the limit.
     
168.          */
     
169.         uid = p1->p_cred->p_ruid;
     
170.         if ((nprocs >= maxproc - 5 && uid != 0) || nprocs >= maxproc) {
     
171.                 tablefull("proc");
     
172.                 return (EAGAIN);
     
173.         }
     
174. 
     
175.         /*
     
176.          * Increment the count of procs running with this uid. Don't allow
     
177.          * a nonprivileged user to exceed their current limit.
     
178.          */
     
179.         count = chgproccnt(uid, 1);
     
180.         if (uid != 0 && count > p1->p_rlimit[RLIMIT_NPROC].rlim_cur) {
     
181.                 (void)chgproccnt(uid, -1);
     
182.                 return (EAGAIN);
     
183.         }
     
184. 
     
185.         /*
     
186.          * Allocate a pcb and kernel stack for the process
     
187.          */
     
188.         uaddr = uvm_km_valloc(kernel_map, USPACE);
     
189.         if (uaddr == 0)
     
190.                 return ENOMEM;
     
191. 
     
192.         /* Allocate new proc. */
     
193.         newproc = pool_get(&proc_pool, PR_WAITOK);
     
194. 
     
195.         lastpid++;
     
196.         if (randompid)
     
197.                 lastpid = PID_MAX;
     
198. retry:
     
199.         /*
     
200.          * If the process ID prototype has wrapped around,
     
201.          * restart somewhat above 0, as the low-numbered procs
     
202.          * tend to include daemons that don't exit.
     
203.          */
     
204.         if (lastpid >= PID_MAX) {
     
205.                 lastpid = arc4random() % PID_MAX;
     
206.                 pidchecked = 0;
     
207.         }
     
208.         if (lastpid >= pidchecked) {
     
209.                 int doingzomb = 0;
     
210. 
     
211.                 pidchecked = PID_MAX;
     
212.                 /*
     
213.                  * Scan the active and zombie procs to check whether this pid
     
214.                  * is in use.  Remember the lowest pid that's greater
     
215.                  * than lastpid, so we can avoid checking for a while.
     
216.                  */
     
217.                 p2 = LIST_FIRST(&allproc);
     
218. again:
     
219.                 for (; p2 != 0; p2 = LIST_NEXT(p2, p_list)) {
     
220.                         while (p2->p_pid == lastpid ||
     
221.                             p2->p_pgrp->pg_id == lastpid) {
     
222.                                 lastpid++;
     
223.                                 if (lastpid >= pidchecked)
     
224.                                         goto retry;
     
225.                         }
     
226.                         if (p2->p_pid > lastpid && pidchecked > p2->p_pid)
     
227.                                 pidchecked = p2->p_pid;
     
228.                         if (p2->p_pgrp->pg_id > lastpid &&
     
229.                             pidchecked > p2->p_pgrp->pg_id)
     
230.                                 pidchecked = p2->p_pgrp->pg_id;
     
231.                 }
     
232.                 if (!doingzomb) {
     
233.                         doingzomb = 1;
     
234.                         p2 = LIST_FIRST(&zombproc);
     
235.                         goto again;
     
236.                 }
     
237.         }
     
238. 
     
239.         nprocs++;
     
240.         p2 = newproc;
     
241.         p2->p_stat = SIDL;                      /* protect against others */
     
242.         p2->p_pid = lastpid;
     
243.         p2->p_exitsig = exitsig;
     
244.         LIST_INSERT_HEAD(&allproc, p2, p_list);
     
245.         p2->p_forw = p2->p_back = NULL;         /* shouldn't be necessary */
     
246.         LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash);
     
247. 
     
248.         /*
     
249.          * Make a proc table entry for the new process.
     
250.          * Start by zeroing the section of proc that is zero-initialized,
     
251.          * then copy the section that is copied directly from the parent.
     
252.          */
     
253.         bzero(&p2->p_startzero,
     
254.             (unsigned) ((caddr_t)&p2->p_endzero - (caddr_t)&p2->p_startzero));
     
255.         bcopy(&p1->p_startcopy, &p2->p_startcopy,
     
256.             (unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy));
     
257. 
     
258.         /*
     
259.          * Initialize the timeouts.
     
260.          */
     
261.         timeout_set(&p2->p_sleep_to, endtsleep, p2);
     
262.         timeout_set(&p2->p_realit_to, realitexpire, p2);
     
263. 
     
264.         /*
     
265.          * Duplicate sub-structures as needed.
     
266.          * Increase reference counts on shared objects.
     
267.          * The p_stats and p_sigacts substructs are set in vm_fork.
     
268.          */
     
269.         p2->p_flag = P_INMEM;
     
270.         p2->p_emul = p1->p_emul;
     
271.         if (p1->p_flag & P_PROFIL)
     
272.                 startprofclock(p2);
     
273.         p2->p_flag |= (p1->p_flag & (P_SUGID | P_SUGIDEXEC));
     
274.         MALLOC(p2->p_cred, struct pcred *, sizeof(struct pcred),
     
275.             M_SUBPROC, M_WAITOK);
     
276.         bcopy(p1->p_cred, p2->p_cred, sizeof(*p2->p_cred));
     
277.         p2->p_cred->p_refcnt = 1;
     
278.         crhold(p1->p_ucred);
     
279. 
     
280.         /* bump references to the text vnode (for procfs) */
     
281.         p2->p_textvp = p1->p_textvp;
     
282.         if (p2->p_textvp)
     
283.                 VREF(p2->p_textvp);
     
284. 
     
285.         if (flags & FORK_CLEANFILES)
     
286.                 p2->p_fd = fdinit(p1);
     
287.         else if (flags & FORK_SHAREFILES)
     
288.                 p2->p_fd = fdshare(p1);
     
289.         else
     
290.                 p2->p_fd = fdcopy(p1);
     
291. 
     
292.         /*
     
293.          * If p_limit is still copy-on-write, bump refcnt,
     
294.          * otherwise get a copy that won't be modified.
     
295.          * (If PL_SHAREMOD is clear, the structure is shared
     
296.          * copy-on-write.)
     
297.          */
     
298.         if (p1->p_limit->p_lflags & PL_SHAREMOD)
     
299.                 p2->p_limit = limcopy(p1->p_limit);
     
300.         else {
     
301.                 p2->p_limit = p1->p_limit;
     
302.                 p2->p_limit->p_refcnt++;
     
303.         }
     
304. 
     
305.         if (p1->p_session->s_ttyvp != NULL && p1->p_flag & P_CONTROLT)
     
306.                 p2->p_flag |= P_CONTROLT;
     
307.         if (flags & FORK_PPWAIT)
     
308.                 p2->p_flag |= P_PPWAIT;
     
309.         LIST_INSERT_AFTER(p1, p2, p_pglist);
     
310.         p2->p_pptr = p1;
     
311.         if (flags & FORK_NOZOMBIE)
     
312.                 p2->p_flag |= P_NOZOMBIE;
     
313.         LIST_INSERT_HEAD(&p1->p_children, p2, p_sibling);
     
314.         LIST_INIT(&p2->p_children);
     
315. 
     
316. #ifdef KTRACE
     
317.         /*
     
318.          * Copy traceflag and tracefile if enabled.
     
319.          * If not inherited, these were zeroed above.
     
320.          */
     
321.         if (p1->p_traceflag & KTRFAC_INHERIT) {
     
322.                 p2->p_traceflag = p1->p_traceflag;
     
323.                 if ((p2->p_tracep = p1->p_tracep) != NULL)
     
324.                         VREF(p2->p_tracep);
     
325.         }
     
326. #endif
     
327. 
     
328.         /*
     
329.          * set priority of child to be that of parent
     
330.          * XXX should move p_estcpu into the region of struct proc which gets
     
331.          * copied.
     
332.          */
     
333.         scheduler_fork_hook(p1, p2);
     
334. 
     
335.         /*
     
336.          * Create signal actions for the child process.
     
337.          */
     
338.         if (flags & FORK_SIGHAND)
     
339.                 sigactsshare(p1, p2);
     
340.         else
     
341.                 p2->p_sigacts = sigactsinit(p1);
     
342. 
     
343.         /*
     
344.          * This begins the section where we must prevent the parent
     
345.          * from being swapped.
     
346.          */
     
347.         PHOLD(p1);
     
348. 
     
349.         if (flags & FORK_VMNOSTACK) {
     
350.                 /* share as much address space as possible */
     
351.                 (void) uvm_map_inherit(&p1->p_vmspace->vm_map,
     
352.                     VM_MIN_ADDRESS, VM_MAXUSER_ADDRESS - MAXSSIZ,
     
353.                     VM_INHERIT_SHARE);
     
354.         }
     
355. 
     
356.         p2->p_addr = (struct user *)uaddr;
     
357. 
     
358.         /*
     
359.          * Finish creating the child process.  It will return through a
     
360.          * different path later.
     
361.          */
     
362.         uvm_fork(p1, p2, ((flags & FORK_SHAREVM) ? TRUE : FALSE), stack,
     
363.             stacksize);
     
364. 
     
365.         vm = p2->p_vmspace;
     
366. 
     
367.         if (flags & FORK_FORK) {
     
368.                 forkstat.cntfork++;
     
369.                 forkstat.sizfork += vm->vm_dsize + vm->vm_ssize;
     
370.         } else if (flags & FORK_VFORK) {
     
371.                 forkstat.cntvfork++;
     
372.                 forkstat.sizvfork += vm->vm_dsize + vm->vm_ssize;
     
373.         } else if (flags & FORK_RFORK) {
     
374.                 forkstat.cntrfork++;
     
375.                 forkstat.sizrfork += vm->vm_dsize + vm->vm_ssize;
     
376.         } else {
     
377.                 forkstat.cntkthread++;
     
378.                 forkstat.sizkthread += vm->vm_dsize + vm->vm_ssize;
     
379.         }
     
380. 
     
381.         /*
     
382.          * Make child runnable, set start time, and add to run queue.
     
383.          */
     
384.         s = splstatclock();
     
385.         p2->p_stats->p_start = time;
     
386.         p2->p_acflag = AFORK;
     
387.         p2->p_stat = SRUN;
     
388.         setrunqueue(p2);
     
389.         splx(s);
     
390. 
     
391.         /*
     
392.          * Now can be swapped.
     
393.          */
     
394.         PRELE(p1);
     
395. 
     
396.         uvmexp.forks++;
     
397.         if (flags & FORK_PPWAIT)
     
398.                 uvmexp.forks_ppwait++;
     
399.         if (flags & FORK_SHAREVM)
     
400.                 uvmexp.forks_sharevm++;
     
401. 
     
402.         /*
     
403.          * tell any interested parties about the new process
     
404.          */
     
405.         KNOTE(&p1->p_klist, NOTE_FORK | p2->p_pid);
     
406. 
     
407.         /*
     
408.          * Preserve synchronization semantics of vfork.  If waiting for
     
409.          * child to exec or exit, set P_PPWAIT on child, and sleep on our
     
410.          * proc (in case of exit).
     
411.          */
     
412.         if (flags & FORK_PPWAIT)
     
413.                 while (p2->p_flag & P_PPWAIT)
     
414.                         tsleep(p1, PWAIT, "ppwait", 0);
     
415. 
     
416.         /*
     
417.          * Return child pid to parent process,
     
418.          * marking us as parent via retval[1].
     
419.          */
     
420.         retval[0] = p2->p_pid;
     
421.         retval[1] = 0;
     
422.         return (0);
     
423. }
     

复制代码

yszll

看了. 好几遍. 的确精彩

guduzhe

oh!thank you!

lf_alex

原帖由 bashfulboy 于 2004-7-14 22:10 发表
我也来一下:
wujiajia 的理解有些错误,
printf("AAAAAAAA";//print 一次；   这里会print 2次
如果你将 printf("AAAAAA" 换成 printf("AAAAAA\n"   那么就是只打印一次了.
...

看完大伙儿的回复，我还是不是很清楚，printf()这条语句在子进程中难道不执行吗？这和标准缓存有关吗。如果子进程都是独立于父进程的，它理所当然应该执行printf()这条语句。
请回答！

tyc611

原帖由 lf_alex 于 2006-12-21 10:38 发表

看完大伙儿的回复，我还是不是很清楚，printf()这条语句在子进程中难道不执行吗？这和标准缓存有关吗。如果子进程都是独立于父进程的，它理所当然应该执行printf()这条语句。
请回答！

子进程执行点在fork()之后，所以之前的printf("fork"不会被子进程执行！
之所以有原贴的两次输出"fork"（而不是prinf()执行两次）是因为输出的字符串"fork"在输出缓冲区中没有刷新到屏幕，而子进程会继承父进程的所有数据（当然也包括缓冲区），所以在子进程中也有“fork”的输出。

liugnhm

好多牛人，受教了！

lonyce

我很少回帖的，今天破例一次，谢谢

hawk2012

1. 
   
2. int add_new_node(int *pid){
   
3. 
   
4.   if ((*pid = fork()) == -1)
   
5.     return(-2);
   
6.   return(0);
   
7. }
   
8. 
   
9. int main(int argc,  char *argv[]){
   
10.    int   i;             /* number of this process (starting with 1)   */
    
11.    int   childpid;      /* indicates process should spawn another     */
    
12.    int   nprocs = 7;        /* total number of processes in ring          */
    
13.    int   delay;
    
14.     for (i = 1; i < nprocs;  i++) {
    
15.      if(add_new_node(&childpid) < 0){
    
16.        perror("Could not add new node to ring");
    
17.        exit(EXIT_FAILURE); };
    
18.      if (childpid) break; };
    
19. 
    
20.    /* ring process code  */
    
21.    {
    
22.      char buff[BUFFSIZE];
    
23.      sprintf(buff,"I'm process %d with parent %d whose i = %i\n",
    
24.              getpid(), getppid(), i);
    
25.       exit(EXIT_SUCCESS);
    
26.    }
    
27.    /* end of process code */
    
28. }  /* end of main program here */
    
29. 
    

复制代码

请大家分析一下上面的进程是怎么产生并执行的？一共执行了多少次？

[ 本帖最后由 hawk2012 于 2007-1-15 15:57 编辑 ]