I was looking to find the difference between these four on Google and I expected there to be a huge amount of information on this, but there really wasn&#39;t any solid comparison between the four calls. 

I set about trying to compile a kind of basic at-a-glance look at the differences between these system calls and here&#39;s what I got. Is all this information correct/am I missing anything important ?

`Fork` : The fork call basically makes a duplicate of the current process, identical in almost every way (not everything is copied over, for example, resource limits in some implementations but the idea is to create as close a copy as possible).

The new process (child) gets a different process ID (PID) and has the PID of the old process (parent) as its parent PID (PPID). Because the two processes are now running exactly the same code, they can tell which is which by the return code of fork - the child gets 0, the parent gets the PID of the child. This is all, of course, assuming the fork call works - if not, no child is created and the parent gets an error code.

`Vfork` : The basic difference between vfork and fork is that when a new process is created with vfork(), the parent process is temporarily suspended, and the child process might borrow the parent&#39;s address space. This strange state of affairs continues until the child process either exits, or calls execve(), at which point the parent 
process continues. 

This means that the child process of a vfork() must be careful to avoid unexpectedly modifying variables of the parent process. In particular, the child process must not return from the function containing the vfork() call, and it must not call exit() (if it needs to exit, it should use _exit(); actually, this is also true for the child of a normal fork()). 

`Exec :` The exec call is a way to basically replace the entire current process with a new program. It loads the program into the current process space and runs it from the entry point. exec() replaces the current process with a the executable pointed by the function. Control never returns to the original program unless there is an exec() error.

`Clone :` Clone, as fork, creates a new process. Unlike fork, these calls allow the child process to share parts of its execution context with the calling process, such as the memory space, the table of file descriptors, and the table of signal handlers.

When the child process is created with clone, it executes the function application fn(arg). (This differs from fork, where execution continues in the child from the point of the original fork call.) The fn argument is a pointer to a function that is called by the child process at the beginning of its execution. The arg argument is passed to the fn function. 

When the fn(arg) function application returns, the child process terminates. The integer returned by fn is the exit code for the child process. The child process may also terminate explicitly by calling exit(2) or after receiving a fatal signal. 



Information gotten form : 

 - [https://stackoverflow.com/questions/1653340/exec-and-fork][1]
 - [http://www.allinterview.com/showanswers/59616.html][2]
 - [http://www.unixguide.net/unix/programming/1.1.2.shtml][3]
 - [http://linux.about.com/library/cmd/blcmdl2_clone.htm][4]


Thanks for taking the time to read this ! :)


  [1]: https://stackoverflow.com/questions/1653340/exec-and-fork
  [2]: http://www.allinterview.com/showanswers/59616.html
  [3]: http://www.unixguide.net/unix/programming/1.1.2.shtml
  [4]: http://linux.about.com/library/cmd/blcmdl2_clone.htm

The difference between fork(), vfork(), exec() and clone()

Suppose I have a process which spawns exactly one child process. Now when the parent process exits for whatever reason (normally or abnormally, by kill, ^C, assert failure or anything else) I want the child process to die. How to do that correctly?


----------
Some similar question on stackoverflow:

 * (asked earlier) [https://stackoverflow.com/questions/269494/how-can-i-cause-a-child-process-to-exit-when-the-parent-does][1]
 * (asked later) [https://stackoverflow.com/questions/395877/are-child-processes-created-with-fork-automatically-killed-when-the-parent-is-k][2]


  [1]: https://stackoverflow.com/questions/269494/how-can-i-cause-a-child-process-to-exit-when-the-parent-does
  [2]: https://stackoverflow.com/questions/395877/are-child-processes-created-with-fork-automatically-killed-when-the-parent-is-k
----------
Some similar question on stackoverflow for **Windows**:  

 * https://stackoverflow.com/questions/53208/how-do-i-automatically-destroy-child-processes-in-windows  
 * https://stackoverflow.com/questions/3342941/kill-child-process-when-parent-process-is-killed

How to make child process die after parent exits?

What are the differences between `fork` and `exec`?





Differences between fork and exec

Consider the following piece of code:

    #include &lt;stdio.h&gt;
    #include &lt;sys/types.h&gt;
    #include &lt;unistd.h&gt;

    int main(void)
    {
        int i;
        for(i = 0; i &lt; 2; i++)
        {
            fork();
            printf(&quot;.&quot;);
        }
        return 0;
    }


This program outputs 8 dots. How can that be possible? Should not there be 6 dots instead?

fork() branches more than expected?

I guess the question says it all.

I want to fork on Windows. What is the most similar operation and how do I use it.

What is the closest thing Windows has to fork()?

I have a bit of an issue with one of my projects. 

I have been trying to find a well documented example of using shared memory with `fork()` but to no success.

Basically the scenario is that when the user starts the program, I need to store two values in shared memory: **current_path** which is a _char*_ and a **file_name** which is also _char*_.

Depending on the command arguments, a new process is kicked off with `fork()` and that process needs to read and modify the **current_path** variable stored in shared memory while the **file_name** variable is read only.

Is there a good tutorial on shared memory with example code (if possible) that you can direct me to?


How to use shared memory with Linux in C

Can anyone explain the difference between a fork and a thread?

What is the difference between fork and thread?

In many programs and man pages of Linux, I have seen code using `fork()`. Why do we need to use `fork()` and what is its purpose?


What is the purpose of fork()?

OS: Linux, Language: pure C

I&#39;m moving forward in learning C programming in general, and C programming under UNIX in a special case.

I detected a strange (for me) behaviour of the `printf()` function after using a `fork()` call. 


**Code**

    #include &lt;stdio.h&gt;
    #include &lt;system.h&gt;

    int main()
    {
        int pid;
        printf( &quot;Hello, my pid is %d&quot;, getpid() );

        pid = fork();
        if( pid == 0 )
        {
                printf( &quot;\nI was forked! :D&quot; );
                sleep( 3 );
        }
        else
        {
                waitpid( pid, NULL, 0 );
                printf( &quot;\n%d was forked!&quot;, pid );
        }
        return 0;
    }


**Output**

    Hello, my pid is 1111
    I was forked! :DHello, my pid is 1111
    2222 was forked!

Why did the second &quot;Hello&quot; string occur in the child&#39;s output?

Yes, it is exactly what the parent printed when it started, with the parent&#39;s `pid`.

But! If we place a `\n` character at the end of each string we get the expected output:

    #include &lt;stdio.h&gt;
    #include &lt;system.h&gt;

    int main()
    {
        int pid;
        printf( &quot;Hello, my pid is %d\n&quot;, getpid() ); // SIC!!

        pid = fork();
        if( pid == 0 )
        {
                printf( &quot;I was forked! :D&quot; ); // removed the &#39;\n&#39;, no matter
                sleep( 3 );
        }
        else
        {
                waitpid( pid, NULL, 0 );
                printf( &quot;\n%d was forked!&quot;, pid );
        }
        return 0;
    }


**Output**:

    Hello, my pid is 1111
    I was forked! :D
    2222 was forked!

Why does it happen? Is it correct behaviour, or is it a bug?

printf anomaly after &quot;fork()&quot;

I have been trying to understand [`fork()`][2] behavior. This time in a `for-loop`. Observe the following code: 

    #include &lt;stdio.h&gt;
   
    void main()
    {
       int i;
    
       for (i=0;i&lt;3;i++)
       {
          fork();

          // This printf statement is for debugging purposes
          // getppid(): gets the parent process-id
          // getpid(): get child process-id

          printf(&quot;[%d] [%d] i=%d\n&quot;, getppid(), getpid(), i);
       }

       printf(&quot;[%d] [%d] hi\n&quot;, getppid(), getpid());
    }


*Here is the output:*

    [6909][6936] i=0
    [6909][6936] i=1
    [6936][6938] i=1
    [6909][6936] i=2
    [6909][6936] hi
    [6936][6938] i=2
    [6936][6938] hi
    [6938][6940] i=2
    [6938][6940] hi
    [1][6937] i=0
    [1][6939] i=2
    [1][6939] hi
    [1][6937] i=1
    [6937][6941] i=1
    [1][6937] i=2
    [1][6937] hi
    [6937][6941] i=2
    [6937][6941] hi
    [6937][6942] i=2
    [6937][6942] hi
    [1][6943] i=2
    [1][6943] hi

I am a very visual person, and so the only way for me to truly understand things is by diagramming. My instructor said there would be 8 *hi* statements. I wrote and ran the code, and indeed there were 8 *hi* statements. But I really didn’t understand it. So I drew the following diagram:

![enter image description here][1]

*Diagram updated to reflect comments :)*

Observations:
-------------

 1. Parent process (main) must iterate the loop 3 times. Then printf is called
 2. On each iteration of parent for-loop a fork() is called
 3. After each fork() call, i is incremented, and so every child starts a for-loop from i before it is incremented
 4. At the end of each for-loop, &quot;hi&quot; is printed

Here are my questions:
------------------------

 - *Is my diagram correct?*
 - **Why are there *two* instances of `i=0` in the output?** 
 - What value of `i` is carried over to each child after the fork()? If the same value of `i` is carried over, then when does the &quot;forking&quot; stop? 
 - Is it always the case that `2^n - 1` would be a way to count the number of children that are forked? So, here `n=3`, which means `2^3 - 1 = 8 - 1 = 7` children, which is correct?


  [1]: http://i.stack.imgur.com/x7JPT.png
  [2]: http://en.wikipedia.org/wiki/Fork_(system_call)

Visually what happens to fork() in a For Loop

I have used threading before in my applications and know its concepts well, but recently in my operating system lecture I came across fork(). Which is something similar to threading.

I google searched difference between them and I came to know that:

 1. Fork is nothing but a new process that looks exactly like the old or the parent process but still it is a different process with different process ID and having  it’s own memory.
 2. Threads are light-weight process which have less overhead

But, there are still some questions in my mind.

 1. When should you prefer fork() over threading and vice-verse?
 2. If I want to call an external application as a child, then should I use fork() or threads to do it?
 3. While doing google search I found people saying it is bad thing to call a fork() inside a thread. why do people want to call a fork() inside a thread when they do similar things?
 4. Is it True that fork() cannot take advantage of multiprocessor system because parent and child process don&#39;t run simultaneously?


Forking vs Threading

I tried installing Intel MPI Benchmark on my computer and I got this error:

    fork: retry: Resource temporarily unavailable

Then I received this error again when I ran `ls` and `top` command.

What is causing this error?

Configuration of my machine:

    Dell precision T7500
    Scientific Linux release 6.2 (Carbon)


fork: retry: Resource temporarily unavailable

I&#39;m hoping someone could shed some light on how to make the parent wait for _ALL_ child processes to finish before continuing after the fork. I have cleanup code which I want to run but the child processes need to have returned before this can happen.

    for (int id=0; id&lt;n; id++) {
      if (fork()==0) {
        // Child
        exit(0);      
      } else {
        // Parent
        ...
      }
      ...
    }

How to make parent wait for all child processes to finish?

Why does this program print “forked!” 4 times?

    #include &lt;stdio.h&gt;
    #include &lt;unistd.h&gt;

    int main(void) {

      fork() &amp;&amp; (fork() || fork());

      printf(&quot;forked!\n&quot;);
      return 0;
    }

Why does this program print &quot;forked!&quot; 4 times?

What is the difference between `system` and `exec` family commands?  Especially I want to know which one of them creates child process to work?

Difference between &quot;system&quot; and &quot;exec&quot; in Linux?

A Zombie is created when a parent process does not use the wait system call after a child dies to read its exit status, and an orphan is child process that is reclaimed by init when the original parent process terminates before the child. 

In terms of memory management and the process table how are these processes handled differently, specifically in UNIX? 

What is an example or extreme case when the creation of zombies or orphans can be detrimental to the greater application or system?

Zombie process vs Orphan process

How can I have PHP 5.2 (running as apache mod_php) send a complete HTTP response to the client, and then keep executing operations for one more minute? 

**The long story:**

I have a PHP script that has to execute a few long database requests and send e-mail, which takes 45 to 60 seconds to run. This script is called by an application that I have no control over. I need the application to report any error messages received from the PHP script (mostly invalid parameter errors). 

The application has a timeout delay shorter than 45 seconds (I do not know the exact value) and therefore registers every execution of the PHP script as an error. Therefore, I need PHP to send the complete HTTP response to the client as fast as possible (ideally, as soon as the input parameters have been validated), and then run the database and e-mail processing. 

I&#39;m running mod_php, so `pcntl_fork` is not available. I could work my way around this by saving the data to be processed to the database and run the actual process from `cron`, but I&#39;m looking for a shorter solution.


Continue PHP execution after sending HTTP response

In fork child, if we modify a global variable, it will not get changed in the main program.

Is there a way to change a global variable in child fork?

    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;
    #include &lt;unistd.h&gt;
    
    int glob_var;
    
    main (int ac, char **av)
    {
      int pid;
    
      glob_var = 1;
    
      if ((pid = fork()) == 0) {
        /* child */
        glob_var = 5;
      }
      else {
        /* Error */
        perror (&quot;fork&quot;);
        exit (1);
      }
    
      int status;
      while (wait(&amp;status) != pid) {
      }
       printf(&quot;%d\n&quot;,glob_var); // this will display 1 and not 5.
    }

How to share memory between processes created by fork()?

I&#39;ve been trying to figure out how the fork-exec mechanism is used inside Linux.  Everything was going on according to the plan until some web pages started to confuse me.

It is said that a child process should strictly use `_exit()` instead of a simple `exit()` or a normal return from `main()`. 

As I know, Linux shell fork-execs every one of the external commands; assuming what I said above is true, the conclusion is that none of these external commands nor any other execution happening inside the Linux shell can do normal return!

Wikipedia &amp; some other webpages claim we&#39;ve got to use `_exit()` just to prevent a child process causing deletion of parent&#39;s temporary files while a probable double flushing of stdio buffers may happen. though I understand the former, I have no clues how a double flushing of buffers could be harmful to a Linux system.

I&#39;ve spent my whole day on this...
Thanks for any clarification.

What is the difference between using _exit() &amp; exit() in a conventional Linux fork-exec?

After few explorations, In my understanding, it is related to contribution.

Fork means to make a copy of the repository (the one being forked) into my own github account.
If I want to fork the official jQuery repository, then I would go to https://github.com/jquery/jquery and hit the &quot;Fork&quot; button and GitHub will copy the repository (jquery) to my account (http://github.com/sanjaykhadka). Then a copied version of that repository will be available to me at http://github.com/sanjaykhadka/jquery

Now I can make whatever the changes I wish to make to my repository and then send a pull request to the original repository (jQuery&#39;s repository), asking the jQuery team to merge my changes into their original repository.

Did I understand it properly, or does it mean something more or something else?

What does it mean to fork on GitHub?

I&#39;ve found myself twice in this situation: I install a gem on my system and start using it from my Rails project. Eventually I need to make some changes to that gem. How should I proceed?

Ideally I&#39;d like to check out the source code of that gem somewhere, like ~/third_party/gems, work on it and have my Rails project use that instead. Is that possible?

In all the cases the gems were at github so I would probably for it at github, clone it, make my chances and maintain my own branch. I suppose then I would install that branch directly with gem install on my server. Does that make sense?

Forking a gem for a Rails project

I&#39;m writing a bash script, which does several things.

In the beginning it starts several monitor scripts, each of them runs some other tools.

At the end of my main script, I would like to kill all things that were spawned from my shell.

So, it might looks like this:

    #!/bin/bash
    
    some_monitor1.sh &amp;
    some_monitor2.sh &amp;
    some_monitor3.sh &amp;
    
    do_some_work
    ...
    
    kill_subprocesses

The thing is that most of these monitors spawn their own subprocesses, so doing (for example): `killall some_monitor1.sh` will not always help.

Any other way to handle this situation?

How to kill all subprocesses of shell?

I have a simple program:

    int main()
    {
        std::cout &lt;&lt; &quot; Hello World&quot;;
        fork();
    }

After the program executes my output is: `Hello World Hello World`. Why does this happen instead of a single `Hello world`? I&#39;m guessing that the child process is rerun behind the scenes and the output buffer is shared between the processes or something along those lines, but is that the case or is something else happening?

fork() and output

Is it possible to do  a &quot;C like&quot; fork in java, using an new independent jvm process ?

How?



Java - C-Like Fork?

I would like to make a section of my code more efficient. I&#39;m thinking of making it fork off into multiple processes and have them execute 50/100 times at once, instead of just once. 

For example (pseudo):

    for line in file;
    do 
    foo;
    foo2;
    foo3;
    done

I would like this for loop to run multiple times. I know this can be done with forking. Would it look something like this?

    while(x &lt;= 50)
    parent(child pid)
    {
       fork child()
    }
    child
    {
       do 
       foo; foo2; foo3; 
       done
       return child_pid()
    }

Or am I thinking about this the wrong way?

Thanks!


Forking / Multi-Threaded Processes | Bash

I&#39;ve got a long running, daemonized Python process that uses subprocess to spawn new child processes when certain events occur. The long running process is started by a user with super user privileges. I need the child processes it spawns to run as a different user (e.g., &quot;nobody&quot;) while retaining the super user privileges for the parent process.

I&#39;m currently using

    su -m nobody -c &lt;program to execute as a child&gt;

but this seems heavyweight and doesn&#39;t die very cleanly.

Is there a way to accomplish this programmatically instead of using su? I&#39;m looking at the  os.set*uid methods, but the doc in the Python std lib is quite sparse in that area. 

Run child processes as different user from a long running Python process

all:
here is my server memory info with &#39;free -m&#39;

                  total       used       free     shared    buffers     cached
     Mem:         64433       49259      15174          0          3         31
     -/+ buffers/cache:      49224      15209
     Swap:         8197        184       8012

my redis-server has used 46G memory, there is almost 15G memory left free

As my knowledge,fork is copy on write, it should not failed when there has 15G free memory,which is enough to malloc necessary kernel structures .

besides, when redis-server used 42G memory, bgsave is ok and fork is ok too.

Is there any vm parameter I can tune to make fork return success ?


redis bgsave failed because fork Cannot allocate memory

If I run the classical bash forkbomb:

    :(){ :&amp;:&amp;};:

my system _hangs_ after a few seconds.

I tried to write a forkbomb in C, here is the code:

	#include &lt;unistd.h&gt;

	int main( )
	{
		while(1) {
			fork();
		}
		return 0;
	}

When I run it the system gets less responsive, but I can kill that process (even after minutes) just pressing `^C`.

---

The above code is different from the original bash forkbomb I posted: it&#39;s something more like:

	:( )
	{
		while true
		do
			:
		done
	}

(I didn&#39;t test it; don&#39;t know if it&#39;d _hang_ the system).

So I also tried to implement the original version; here the code:

	#include &lt;unistd.h&gt;

	inline void colon( const char *path )
	{
		pid_t pid = fork( );
		if( pid == 0 ) {
			execl( path, path, 0 );
		}
	}

	int main( int argc, char **argv )
	{
		colon( argv[0] );
		colon( argv[0] );
		return 0;
	}

But still nothing: I can run it and then easily kill it. It&#39;s not _hanging_ my system.

---

Why?

What&#39;s so special about bash forkbombs? Is it because bash uses a lot more memory/CPU? Because bash processes call a lot more system calls (eg, to access filesystem) than mine?

Why C-forkbombs don&#39;t work like bash ones?

Consider this code snippet:

    pid_t cpid = fork();

    if (cpid == -1) {
        perror(&quot;fork&quot;);
        exit(EXIT_FAILURE);
    }

    if (cpid == 0) { // in child
        execvp(argv[1], argv + 1);
        perror(&quot;execvp&quot;);
        _exit(EXIT_FAILURE);
    }

    // in parent

How shall I exit the child process if execvp returns? Shall I use exit() or _exit()?


how to exit a child process - _exit() vs. exit

Consider this simple code:

     int myvar = 0;
     int main() {
         if (fork()&gt;0) {
           myvar++;
         } else {
           // father do nothing
         }
     }

When child increments myvar, is the value shared with the father (like pthread)?


After forking, are global variables shared?

Take the following example:

    int main(void)
    {
         pid_t  pid;
    
         pid = fork();
         if (pid == 0) 
              ChildProcess();
         else 
              ParentProcess();
    }

So correct me if I am wrong, once fork() executes a child process is created. Now going by this [answer][1] fork() returns twice. That is once for the parent process and once for the child process. 

Which means that two separate processes come into existence DURING the fork call and not after it ending. 

Now I don&#39;t get it how it understands how to return 0 for the child process and the correct PID for the parent process. 

This where it gets really confusing. This [answer][2] states that fork() works by copying the context information of the process and manually setting the return value to 0. 

First am I right in saying that the return to any function is placed in a single register? **Since in a single processor environment a process can call only one subroutine that returns only one value (correct me if I am wrong here).** 

**Let&#39;s say I call a function foo() inside a routine and that function returns a value, that value will be stored in a register say BAR. Each time a function wants to return a value it will use a particular processor register.** So if I am able to manually change the return value in the process block I am able to change the value returned to the function right?

***So am I correct in thinking that is how fork() works?***


  [1]: https://stackoverflow.com/a/2562743/5826291
  [2]: https://stackoverflow.com/a/23819945/5826291

All Fork Solutions on Gang of Coders

Total of 31 Fork Solutions