Fork and clone

Use fork to create a sub-process.

Code:

1. # Include <unistd. h>
2. # Include <stdio. h>
4. Int main (INT argc, char ** argv)
5. {
6. Int A = 10;
7. Pid_t PID;
9. Printf ("before fork pid = % d/N", getpid ());
11. PID = fork ();
13. If (PID <0 ){
14. Printf ("fork failed! /N ");
15. Return-1;
16. }
18. If (pid = 0 ){
19. A ++;
20. Printf ("this is child process! Parent pid = % d, my pid = % d, pid = % d, A = % d/N ", getppid (), getpid (), PID, );
21. }
22. Else {
23. Printf ("this is parent process! My pid = % d, child pid = % d, A = % d/N ", getpid (), PID, );
24. }
26. Return 0;
28. }

Compile: [root @ localhost/] # gcc-O fork. c

Result:

[Root @ localhost/] #./fork
Before fork pid = 23703
This is child process! Parent pid = 23703, my pid = 23704, pid = 0, A = 11
This is parent process! My pid = 23703, child pid = 23704, A = 10
 

Next, clone the system call.

Code:

1. # Include <stdlib. h>
2. # Include <sched. h>
3. # Include <signal. h>
4. # Include <unistd. h>
5. # Include <malloc. h>
6. # Include <fcntl. h>
7. # Include <sys/types. h>
8. # Include <sys/STAT. h>
9. # Include <sys/Wait. H>
11. Char * prog_argv [4];
12. Int Foo;
13. Int FD;
15. # Define child_stack (1024*64)
17. Int thread_function (void * argument)
18. {
19. Printf ("Child: Child thread begin.../N ");
20. Fool = 2008;
21. Close (FD );
22. Execvp (prog_argv [0], prog_argv );
24. Printf ("Child: Child thread exit, this line won't print out./N ");
26. Return 0;
27. }
29. Int main ()
30. {
31. Char C;
32. Char * stack;
33. Pid_t PID;
35. Fool = 2007;
37. FD = open ("/etc/passwd", o_rdonly );
38. If (FD <0 ){
39. Perror ("open ");
40. Exit (-1 );
41. }
43. Printf ("parient: The variable Foo was: % d/N", foo );
44. If (read (FD, & C, 1) <1 ){
45. Perror ("parient: File Read error/N ");
46. Exit (1 );
47. }
48. Else
49. Printf ("parient: We cocould read from the file: % C/N", C );
51. Prog_argv [0] = "/bin/ls ";
52. Prog_argv [1] = "-1 ";
53. Prog_argv [2] = "/";
54. Prog_argv [3] = "null ";
56. Stack = (char *) malloc (child_stack );
57. If (stack = NULL ){
58. Perror ("malloc: cocould not allocate stack ");
59. Exit (2 );
60. }
62. Printf ("parent: creating child thread/N ");
64. PID = clone (thread_function, (void *) (stack + child_stack ),
65. Sigchld | clone_fs | clone_sighand | clone_vm, null );
66. If (pid =-1 ){
67. Perror ("clone ");
68. Exit (3 );
69. }
70. Printf ("parent: waiting for the finish of child thread: % d/N", pid );
71. PID = waitpid (PID, 0, 0 );
72. If (pid =-1 ){
73. Perror ("wait ");
74. Exit (4 );
75. }
77. Free (stack );
78. Printf ("parent: Child thread returned and stack free./N ");
80. Printf ("parent: The variable Foo now is % d/N", foo );
81. If (read (FD, & C, 1) <1 ){
82. Perror ("parent: File Read error/N ");
83. Exit (5 );
84. }
85. }
86. Else
87. Printf ("parent: We cocould read from file: % C/N", C );
88. Return 0;
89. }

Compile and execute:

[Root @ localhost/] # gcc-O Clone. C-lpthread
[Root @ localhost/] #./clone
Parient: The variable Foo was: 2007
Parient: We cocould read from the file: R
Parent: creating child thread
Parent: waiting for the finish of child thread: 24951
Child: Child thread begin...
Child: Child thread exit, this line won't print out.
Parent: Child thread returned and stack free.
Parent: The variable Foo now is 2008
Parent: We cocould read from file: O