NAME

SYNOPSIS

DESCRIPTION

The
vfork()
function has the same effect as
fork(),
except that the behaviour is undefined if the process created by
vfork()
either modifies any data other than a variable of type
pid_t
used to store the return value from
vfork(),
or returns from the function in which
vfork()
was called, or calls any other function before successfully calling
_exit()
or one of the
exec
family of functions.

RETURN VALUE

Upon successful completion,
vfork()
returns 0 to the child process and returns the process ID of the child process
to the parent process. Otherwise, -1 is returned to the parent, no child
process is created, and errno is set to indicate the error.

ERRORS

The
vfork()
function will fail if:

[EAGAIN]

The system-wide limit on the total number of processes under execution would
be exceeded, or the system-imposed limit on the total number of processes
under execution by a single user would be exceeded.

[ENOMEM]

There is insufficient swap space for the new process.

EXAMPLES

None.

APPLICATION USAGE

The
vfork()
function differs from
fork()
only in that the child process can share code and data with the calling
process (parent process). This speeds cloning activity significantly at a
risk to the integrity of the parent process if
vfork()
is misused.

The use of
vfork()
for any purpose except as a prelude to an immediate call to a function from
the
exec
family, or to
_exit(),
is not advised.

The
vfork()
function can be used to create new processes without fully copying the address
space of the old process. If a forked process is simply going to call
exec,
the data space copied from the parent to the child by
fork()
is not used. This is particularly inefficient in a paged environment, making
vfork()
particularly useful. Depending upon the size of the parent's data space,
vfork()
can give a significant performance improvement over
fork().

The
vfork()
function can normally be used just like
fork().
It does not work, however, to return while running in the child's context from
the caller of
vfork()
since the eventual return from
vfork()
would then return to a no longer existent stack frame. Be careful, also, to
call
_exit()
rather than
exit()
if you cannot
exec,
since
exit()
flushes and closes standard I/O channels, thereby
damaging the parent process' standard I/O data structures. (Even with
fork(),
it is wrong to call
exit(),
since buffered data would then be flushed twice.)

If signal handlers are invoked in the child process after
vfork(),
they must follow the same rules as other code in the child process.