(itstool) path: textobject/literallayout
+----------------+ wait +----------------+
| parent process |--------------------------------->| parent process |--->
+----------------+ +----------------+
| ^
| fork |
V |
+----------------+ execve +----------------+ wait +----------------+
| child process |------->| child process |------->| zombie process |
+----------------+ +----------------+ +----------------+
Context English Portuguese (Brazil) State
Process Management
Gerenciamento de processos
4.4BSD supports a multitasking environment. Each task or thread of execution is termed a <emphasis>process</emphasis>. The <emphasis>context</emphasis> of a 4.4BSD process consists of user-level state, including the contents of its address space and the run-time environment, and kernel-level state, which includes scheduling parameters, resource controls, and identification information. The context includes everything used by the kernel in providing services for the process. Users can create processes, control the processes' execution, and receive notification when the processes' execution status changes. Every process is assigned a unique value, termed a <emphasis>process identifier</emphasis> (PID). This value is used by the kernel to identify a process when reporting status changes to a user, and by a user when referencing a process in a system call.
The kernel creates a process by duplicating the context of another process. The new process is termed a <emphasis>child process</emphasis> of the original <emphasis>parent process</emphasis> The context duplicated in process creation includes both the user-level execution state of the process and the process's system state managed by the kernel. Important components of the kernel state are described in Chapter 4.
Process lifecycle
Ciclo de vida do processo
external ref='fig1' md5='__failed__'
+----------------+ wait +----------------+
| parent process |---------------------------------&gt;| parent process |---&gt;
+----------------+ +----------------+
| ^
| fork |
V |
+----------------+ execve +----------------+ wait +----------------+
| child process |-------&gt;| child process |-------&gt;| zombie process |
+----------------+ +----------------+ +----------------+
<imageobject> <imagedata fileref="fig1"/> </imageobject> <textobject> <_:literallayout-1/> </textobject> <textobject> <phrase>Process-management system calls</phrase> </textobject>
The process lifecycle is depicted in <xref linkend="fig-process-lifecycle"/>. A process may create a new process that is a copy of the original by using the <emphasis>fork</emphasis> system call. The <emphasis>fork</emphasis> call returns twice: once in the parent process, where the return value is the process identifier of the child, and once in the child process, where the return value is 0. The parent-child relationship induces a hierarchical structure on the set of processes in the system. The new process shares all its parent's resources, such as file descriptors, signal-handling status, and memory layout.
Although there are occasions when the new process is intended to be a copy of the parent, the loading and execution of a different program is a more useful and typical action. A process can overlay itself with the memory image of another program, passing to the newly created image a set of parameters, using the system call <emphasis>execve</emphasis>. One parameter is the name of a file whose contents are in a format recognized by the system -- either a binary-executable file or a file that causes the execution of a specified interpreter program to process its contents.
A process may terminate by executing an <emphasis>exit</emphasis> system call, sending 8 bits of exit status to its parent. If a process wants to communicate more than a single byte of information with its parent, it must either set up an interprocess-communication channel using pipes or sockets, or use an intermediate file. Interprocess communication is discussed extensively in Chapter 11.
A process can suspend execution until any of its child processes terminate using the <emphasis>wait</emphasis> system call, which returns the PID and exit status of the terminated child process. A parent process can arrange to be notified by a signal when a child process exits or terminates abnormally. Using the <emphasis>wait4</emphasis> system call, the parent can retrieve information about the event that caused termination of the child process and about resources consumed by the process during its lifetime. If a process is orphaned because its parent exits before it is finished, then the kernel arranges for the child's exit status to be passed back to a special system process <emphasis>init</emphasis>: see Sections 3.1 and 14.6).



New source string

FreeBSD Doc / books_design-44bsdPortuguese (Brazil)

New source string 9 months ago
Browse all component changes


English Portuguese (Brazil)
No related strings found in the glossary.

Source information

Source string comment
(itstool) path: textobject/literallayout
No labels currently set.
Source string location
Source string age
9 months ago
Translation file
books/pt_BR/design-44bsd.po, string 142