UNIX for Dummies Questions & Answers

hi everyone,
have this little piece of code in order to help you understand my question

Code:

#include<stdio.h>
#include<unistd.h>

int main()
{
	int i, pid;
	pid = fork();

	if(pid<0)
	{
		fprintf(stderr, "fork failed\n");
		_exit(1);
	}
	if(pid==0)
	{
		printf("in Child\n");
		_exit(0);
	}
	printf("in parent\n");
}

/** my question is: according to the definition of fork, it creates an
exact copy of original process. what is the original process here?
is it the whole code i.e. the program where this code is written
i named it as one.c, so is one.c the original process? orrrr
when i do pid = fork(), thats the original process created in one.c?
also does the child process exists only in the if loops if child
succeeds?
about fork() function, how does it generates a number? is it like
generating a random number? i just can't figure out, whats my parent process here and whats my child process here, i m confused with the two.
if fork is created when i do pid = fork(), isn't that the
parent process created? and in order to create a child process
am i not supposed to do pid = fork() again!? and what do the parent and child process share in common and what are their differences. i m aware that fork is done for synchronization but m having trouble with the basic */
appreciate your comments.

code tags added for readability --oombera

Since your code is running, it is already a process. Think about this program:

int main()
{
exit(0);
}

This is perfectly valid program. Note that it did not need to fork. But the shell had to fork to run it.

When you execute a line of code like:

pid=fork();

A complete copy of the process springs into existence. Both copies store something in pid. And then both copies continue with the next statement.

But they store a different value in pid. That's how the programmer can make parent and child do something different.

The child will store 0 in pid.

The parent will store the pid of the child in pid.

fork() is a system call. This is, it asks the kernel to do something. The kernel must pick a pid for the child. The algorithm is a little complex, but you don't need to know the gory details at this point. But you can be sure that it is not exactly random and it will pick a pid not currently in use.

hi there,
for instance you had it like this

int main()
{int pid = fork();
exit(0);
}

so the above code is parent process? lets assume that the fork succeeds.
u said, a complete copy of the process springs into existence. does
that mean that the code
int main() { int pid = fork(); exit(0); } will be regenerated ? if
so, then this will be always recurring or recrusive. this child process
will keep generating different child processes! n this will never
come to an end? will it!?

then u said "both copies store somethin in pid". we just did
fork once, why are u saying both copies? i dont' quite get that!

then u said
The child will store 0 in pid.

The parent will store the pid of the child in pid.

but the code that i had has got just one pid! hence the call
pid = fork() would store the pid of child. and child would store
0 in pid, but wouldn't the child have the same code as parent since
the child process is a copy of a process, so the child would store
another childs pid! when would the child store 0 in pid!

what i m tryin to say is if an exact copy of the process is created,
how would that come to an end, since the child will do fork as well
as it has the same code involved as in its parents!

i know i m not right, but i don't quite get this here. i may sound
stupid but i am probably missing something.
Perderabo, can you give me more insight on that!
Thanks

Let's take:

int main()
{int pid = fork();
exit(0);
}

as an example. Let's say that it is compiled and is sitting on disk as a file called forktest.

And let's say that forktest starts to run. This means that it must have a pid, let's say that it is pid 25021.

Well, pid 25021 will quickly invoke fork(). This means that the kernel must create a second process. The second process will be the child of process 25021. Let's say that the second process gets a pid of 25079. So now we have two processes: 25021 which is the original and 25079 which is the child.

Now both processes can run. If the system has two cpu's, they can literally run at the same time. But neither process restarts from the beginning. They both continue from where process 25021 was.

Both processes seem to be returning from fork. And both must store a value in pid. Now they do not share a common variable called pid. Each process has a private copy. The variable called pid in process 25021 gets a value of 25079. The variable called pid in process 25079 gets a zero.

Next both processes continue with the next statement. So both processes now exit.

The end.

Now the situation that you are worrying about can occur. And it is a nightmare. But it requires a bug like:

while(1) fork();

Here both processes are in an infinite loop. So both will fork again resulting in 4 processes. Then all 4 processes will fork again. Then all 8 processes will fork again. And so it goes until fork fails. So please don't do that.

thanks perderabo
i got it