vfork(2) [osx man page]
VFORK(2) BSD System Calls Manual VFORK(2) NAME
vfork -- spawn new process in a virtual memory efficient way SYNOPSIS
#include <unistd.h> pid_t vfork(void); DESCRIPTION
Vfork() can be used to create new processes without fully copying the address space of the old process, which is horrendously inefficient in a paged environment. It is useful when the purpose of fork(2) would have been to create a new system context for an execve. Vfork() differs from fork in that the child borrows the parent's memory and thread of control until a call to execve(2) or an exit (either by a call to exit(2) or abnormally.) The parent process is suspended while the child is using its resources. Vfork() returns 0 in the child's context and (later) the pid of the child in the parent's context. Vfork() can normally be used just like fork. It does not work, however, to return while running in the childs context from the procedure that called 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 can't execve, since exit will flush and close standard I/O channels, and thereby mess up the parent processes standard I/O data structures. (Even with fork it is wrong to call exit since buffered data would then be flushed twice.) SEE ALSO
execve(2), fork(2), sigaction(2), wait(2) ERRORS
The vfork() system call will fail for any of the reasons described in the fork man page. In addition, it will fail if: [EINVAL] A system call other than _exit() or execve() (or libc functions that make no system calls other than those) is called fol- lowing calling a vfork() call. BUGS
This system call will be eliminated when proper system sharing mechanisms are implemented. Users should not depend on the memory sharing semantics of vfork as it will, in that case, be made synonymous to fork. To avoid a possible deadlock situation, processes that are children in the middle of a vfork() are never sent SIGTTOU or SIGTTIN signals; rather, output or ioctl(2) calls are allowed and input attempts result in an end-of-file indication. HISTORY
The vfork() function call appeared in 3.0BSD. 4th Berkeley Distribution June 4, 1993 4th Berkeley Distribution
Check Out this Related Man Page
vfork(2) System Calls vfork(2) NAME
vfork - spawn new process in a virtual memory efficient way SYNOPSIS
#include <unistd.h> pid_t vfork(void); DESCRIPTION
The vfork() function creates a new process without fully copying the address space of the old process. This function is useful in instances where the purpose of a fork(2) operation is to create a new system context for an execve() operation (see exec(2)). Unlike with the fork() function, the child process borrows the parent's memory and thread of control until a call to execve() or an exit (either abnormally or by a call to _exit() (see exit(2)). Any modification made during this time to any part of memory in the child process is reflected in the parent process on return from vfork(). The parent process is suspended while the child is using its resources. In a multithreaded application, vfork() borrows only the thread of control that called vfork() in the parent; that is, the child contains only one thread. The use of vfork() in multithreaded applications, however, is unsafe due to race conditons that can cause the child process to become deadlocked and consequently block both the child and parent process from execution indefinitely. The vfork() function can normally be used the same way as fork(). The procedure that called vfork(), however, should not return while run- ning in the child's context, since the eventual return from vfork() in the parent would be to a stack frame that no longer exists. The _exit() function should be used in favor of exit(3C) if unable to perform an execve() operation, since exit() will invoke all functions registered by atexit(3C) and will flush and close standard I/O channels, thereby corrupting the parent process's standard I/O data struc- tures. Care must be taken in the child process not to modify any global or local data that affects the behavior of the parent process on return from vfork(), unless such an effect is intentional. The vfork() function is deprecated. Its sole legitimate use as a prelude to an immediate call to a function from the exec family can be achieved safely by posix_spawn(3C) or posix_spawnp(3C). RETURN VALUES
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 process, no child process is created, and errno is set to indicate the error. ERRORS
The vfork() function will fail if: EAGAIN The system-imposed limit on the total number of processes under execution (either system-quality or by a single user) would be exceeded. This limit is determined when the system is generated. ENOMEM There is insufficient swap space for the new process. ATTRIBUTES
See attributes(5) for descriptions of the following attributes: +-----------------------------+-----------------------------+ | ATTRIBUTE TYPE | ATTRIBUTE VALUE | +-----------------------------+-----------------------------+ |Interface Stability |Obsolete | +-----------------------------+-----------------------------+ |MT-Level |Unsafe | +-----------------------------+-----------------------------+ SEE ALSO
exec(2), exit(2), fork(2), ioctl(2), atexit(3C), exit(3C), posix_spawn(3C), posix_spawnp(3C), signal.h(3HEAD), wait(3C), attributes(5), standards(5) NOTES
To avoid a possible deadlock situation, processes that are children in the middle of a vfork() are never sent SIGTTOU or SIGTTIN signals; rather, output or ioctls are allowed and input attempts result in an EOF indication. To forstall parent memory corruption due to race conditions with signal handling, vfork() treats signal handlers in the child process in the same manner as the exec(2) functions: signals set to be caught by the parent process are set to the default action (SIG_DFL) in the child process (see signal.h(3HEAD)). Any attempt to set a signal handler in the child before execve() to anything other than SIG_DFL or SIG_IGN is disallowed and results in setting the handler to SIG_DFL. On some systems, the implementation of vfork() causes the parent to inherit register values from the child. This can create problems for certain optimizing compilers if <unistd.h> is not included in the source calling vfork(). SunOS 5.10 8 Nov 2004 vfork(2)