fork是否会阻塞吗?

flw

fork 应该会阻塞吧。
不过应该阻塞时间不会太长，否则系统性能可想而知。

wuqing

FreeBSD6.1 fork.S Alpha

1. #include <machine/asm.h>
   
2. __FBSDID("$FreeBSD: src/lib/libc/alpha/sys/fork.S,v 1.5 2003/08/16 18:59:08 marcel Exp $");
   
3. 
   
4. #include "SYS.h"
   
5. 
   
6. SYSCALL(fork)
   
7.         cmovne        a4, zero, v0                /* a4 (rv[1]) != 0, child */
   
8.         RET
   
9. END(__sys_fork)
   

复制代码

FreeBSD6.1 fork.S IA64

1. 
   
2. #include <machine/asm.h>
   
3. __FBSDID("$FreeBSD: src/lib/libc/ia64/sys/fork.S,v 1.6 2003/08/01 22:17:12 marcel Exp $");
   
4. 
   
5. #include "SYS.h"
   
6. 
   
7. SYSCALL(fork)
   
8.         cmp.ne        p7,p0=ret1,r0                /* ret1!=0 for child */
   
9.         ;;
   
10. (p7)        mov        ret0=r0
    
11.         br.ret.sptk.few rp
    
12. END(__sys_fork)
    

复制代码

wuqing

vfork.S Solaris i386

1. 
   
2. /*
   
3. * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
   
4. * Use is subject to license terms.
   
5. */
   
6. 
   
7. #pragma ident        "@(#)vfork.s        1.21        05/06/08 SMI"
   
8. 
   
9.         .file        "vfork.s"
   
10. 
    
11. #include <sys/asm_linkage.h>
    
12. 
    
13.         ANSI_PRAGMA_WEAK(vfork,function)
    
14. 
    
15. #include "SYS.h"
    
16. #include <assym.h>
    
17. 
    
18. / The child of vfork() will execute in the parent's address space,
    
19. / thereby changing the stack before the parent runs again.
    
20. / Therefore we have to be careful how we return from vfork().
    
21. / Pity the poor debugger developer who has to deal with this kludge.
    
22. /
    
23. / We block all blockable signals while performing the vfork() system call
    
24. / trap.  This enables us to set curthread->ul_vfork safely, so that we
    
25. / don't end up in a signal handler with curthread->ul_vfork set wrong.
    
26. 
    
27.         ENTRY(vfork)
    
28.         movl        0(%esp),%ecx                / save %eip in %ecx
    
29.         _prologue_
    
30.         leal        _sref_(0f),%eax                / arrange for RET to return here
    
31.         _epilogue_
    
32.         movl        %eax,0(%esp)
    
33.         ret
    
34. 
    
35. 0:
    
36.         pushl        $MASKSET1                / block signals
    
37.         pushl        $MASKSET0
    
38.         pushl        $SIG_SETMASK
    
39.         pushl        %ecx
    
40.         __SYSCALLINT(lwp_sigmask)
    
41.         addl        $16, %esp
    
42. 
    
43.         __SYSCALLINT(vfork)
    
44.         jae         2f
    
45. 
    
46.         / reconstruct stack before jumping to __cerror
    
47.         call        1f
    
48. 1:        movl        %ecx,0(%esp)
    
49.         pushl        %eax                / save the vfork() error number
    
50. 
    
51.         pushl        %gs:UL_SIGMASK+4        / reinstate signals
    
52.         pushl        %gs:UL_SIGMASK
    
53.         pushl        $SIG_SETMASK
    
54.         pushl        %ecx
    
55.         __SYSCALLINT(lwp_sigmask)
    
56.         addl        $16, %esp
    
57. 
    
58.         popl        %eax                / restore the vfork() error number
    
59.         jmp        __cerror
    
60. 
    
61. 2:
    
62.         / To determine if we are (still) a child of vfork(), the child
    
63.         / increments curthread->ul_vfork by one and the parent decrements
    
64.         / it by one.  If the result is zero, then we are not a child of
    
65.         / vfork(), else we are.  We do this to deal with the case of
    
66.         / a vfork() child calling vfork().
    
67.         /
    
68.         / %edx is zero if we are the parent, non-zero if we are the child.
    
69.         /
    
70.         cmpl        $0,%edx
    
71.         jne        3f
    
72.         movl        %gs:UL_VFORK, %edx
    
73.         cmpl        $0, %edx        / don't let it go negative
    
74.         je        4f
    
75.         subl        $1, %edx        / curthread->ul_vfork--;
    
76.         jmp        4f
    
77. 3:
    
78.         movl        $0,%eax                / zero the return value in the child
    
79.         movl        %gs:UL_VFORK, %edx
    
80.         addl        $1, %edx        / curthread->ul_vfork++;
    
81. 4:
    
82.         movl        %edx, %gs:UL_VFORK
    
83.         /
    
84.         / Clear the schedctl interface in both parent and child.
    
85.         / (The child might have modified the parent.)
    
86.         /
    
87.         xorl        %edx, %edx
    
88.         movl        %edx, %gs:UL_SCHEDCTL
    
89.         movl        %edx, %gs:UL_SCHEDCTL_CALLED
    
90.         pushl        %eax                / save the vfork() return value
    
91. 
    
92.         pushl        %gs:UL_SIGMASK+4        / reinstate signals
    
93.         pushl        %gs:UL_SIGMASK
    
94.         pushl        $SIG_SETMASK
    
95.         pushl        %ecx
    
96.         __SYSCALLINT(lwp_sigmask)
    
97.         addl        $16, %esp
    
98. 
    
99.         popl        %eax                / restore the vfork() return value
    
100.         jmp        *%ecx                / jump back to the caller
     
101.         SET_SIZE(vfork)
     

复制代码

wuqing

vfork.S  Solaris Sparc

1. 
   
2. /*
   
3. * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
   
4. * Use is subject to license terms.
   
5. */
   
6. 
   
7. .ident        "@(#)vfork.s        1.13        05/06/08 SMI"
   
8. 
   
9. /*
   
10. * C library -- vfork
    
11. * pid_t vfork(void);
    
12. */
    
13. 
    
14. /*
    
15. * From the syscall:
    
16. * %o1 == 0 in parent process, %o1 == 1 in child process.
    
17. * %o0 == pid of child in parent, %o0 == pid of parent in child.
    
18. *
    
19. * The child process gets a zero return value from vfork; the parent
    
20. * gets the pid of the child.
    
21. *
    
22. * We block all blockable signals while performing the vfork() system call
    
23. * trap.  This enables us to set curthread->ul_vfork safely, so that we
    
24. * don't end up in a signal handler with curthread->ul_vfork set wrong.
    
25. *
    
26. * Note that since the SPARC architecture maintains stack maintence
    
27. * information (return pc, sp, fp) in the register windows, both parent
    
28. * and child can execute in a common address space without conflict.
    
29. */
    
30. 
    
31.         .file        "vfork.s"
    
32. 
    
33. #include <sys/asm_linkage.h>
    
34. 
    
35.         ANSI_PRAGMA_WEAK(vfork,function)
    
36. 
    
37. #include "SYS.h"
    
38. #include <../assym.h>
    
39. 
    
40.         ENTRY(vfork)
    
41.         mov        SIG_SETMASK, %o0        ! block signals
    
42.         set        MASKSET0, %o1
    
43.         set        MASKSET1, %o2
    
44.         SYSTRAP_2RVALS(lwp_sigmask)
    
45. 
    
46.         SYSTRAP_2RVALS(vfork)
    
47.         bcc,a,pt %icc, 1f
    
48.         tst        %o1
    
49.         mov        %o0, %o3        ! save the vfork() error number
    
50. 
    
51.         mov        SIG_SETMASK, %o0        ! reinstate signals
    
52.         ld        [%g7 + UL_SIGMASK], %o1
    
53.         ld        [%g7 + UL_SIGMASK + 4], %o2
    
54.         SYSTRAP_2RVALS(lwp_sigmask)
    
55. 
    
56.         mov        %o3, %o0        ! restore the vfork() error number
    
57.         ba,a        __cerror
    
58. 1:
    
59.         /*
    
60.          * To determine if we are (still) a child of vfork(), the child
    
61.          * increments curthread->ul_vfork by one and the parent decrements
    
62.          * it by one.  If the result is zero, then we are not a child of
    
63.          * vfork(), else we are.  We do this to deal with the case of
    
64.          * a vfork() child calling vfork().
    
65.          */
    
66.         bnz,pt        %icc, 2f
    
67.         ld        [%g7 + UL_VFORK], %g1
    
68.         brnz,a,pt %g1, 3f        ! don't let it go negative
    
69.         sub        %g1, 1, %g1        ! curthread->ul_vfork--;
    
70.         ba,a        3f
    
71. 2:
    
72.         clr        %o0                ! child, return (0)
    
73.         add        %g1, 1, %g1        ! curthread->ul_vfork++;
    
74. 3:
    
75.         st        %g1, [%g7 + UL_VFORK]
    
76.         /*
    
77.          * Clear the schedctl interface in both parent and child.
    
78.          * (The child might have modified the parent.)
    
79.          */
    
80.         stn        %g0, [%g7 + UL_SCHEDCTL]
    
81.         stn        %g0, [%g7 + UL_SCHEDCTL_CALLED]
    
82.         mov        %o0, %o3        ! save the vfork() return value
    
83. 
    
84.         mov        SIG_SETMASK, %o0        ! reinstate signals
    
85.         ld        [%g7 + UL_SIGMASK], %o1
    
86.         ld        [%g7 + UL_SIGMASK + 4], %o2
    
87.         SYSTRAP_2RVALS(lwp_sigmask)
    
88. 
    
89.         retl
    
90.         mov        %o3, %o0        ! restore the vfork() return value
    
91.         SET_SIZE(vfork)
    

复制代码