Process Segments

Process Segments

A process (executing program) has text, data and system data segments. A process's address space consists of the text and data segments. The system data segment is part of the process but is maintained by the system and is accessible by the process only via system calls.

Text/Instruction Segment

The text segment consists of program code. It is read-only and is initialized from the program executable file.

User Data Segment

Initialized data: strings initialized from the program executable.
Uninitialized data: global variables. These are set to 0 bits.
Malloc arena or heap: created by the process.
Stack: auto variables and function parameters, including argc, argv[ ], and env[ ]. It is created by the startup routine (crt*.o) and grows/shrinks with function calls/returns.

System Data Segment

This is the u or user area consisting of, among other things:

Open file descriptors. A file descriptor is an index into a per process table of open files descriptors. Most processes read from 0, write to 1 and write errors to 2. Each table element contains a pointer into the (system-wide) open file table and contains a ``close-on-exec'' flag.
Current directory and controlling terminal if any.
Accumulated usages and limits.
Real user id (UID): the owner of process. Each LOGNAME has a numeric UID.
Effective user id: permissions picked up from setuid or setgid files.
Real and effective GID: group IDs.
Size of text, data and stack.
Arguments to and return values from system calls (and often even the per process kernel stack) and the process control block (saved registers when the process is not running).
Signal handlers.

The system maintains a second data structure for each process, the proc structure, which technically is not part of the system data segment, and consists of info needed even if the process is not running. It includes:

Process ID, Process group ID, Session ID, PPID (Parent Process ID).
State (stopped, etc.), signal masks, memory management info, scheduling priority, and other miscellaneous data.

The system/kernel is actually implemented with several apparent processes. PID 1 is init which handles login and is the ancestor of most processes. PID 0 is the scheduler and PID 2 is the memory pager. Despite appearances PID 0 and PID 2 are usually the same process, the kernel, however, most modern kernels will have many separate threads of control running in it.

Some additional data maintained in the kernel includes:

Table of all processes (table of proc structures).
Table of users.
Accumulated limits.
(System-wide) open file table. There is one entry for each open( ) call so the same physical file can be appear several times in this table. The entry includes:

the file status flags (read/write/append),
the file offset (how far into file to do the next I/O), and
a pointer to the open file/device (see next).

Open files (``v-nodes''). This structure describes the open file:

type,

pointers to functions acting on the file,

i-node (owner, size, etc.), and

pointer to data blocks. The environment is nowhere here. It is created and passed between processes by exec*( ) and fork( ). It exists solely on the stack.

Note this is a guide only and the actual implementation can vary. For example, open file tables and file descriptor tables need not be implemented as arrays.

Last update: 2001 January 1