The Linux Programming Interface

* Chapter 2. Fundamental Concepts - The Linux kernel executable typically resides at the pathname /boot/vmlinuz, or something similar. The derivation of this filename is historical. On early UNIX implementations, the kernel was called unix. Later UNIX implementa- tions, which implemented virtual memory, renamed the kernel as vmunix . On Linux, the filename mirrors the system name, with the z replacing the final x to signify that the kernel is a compressed executable. ** The Core Operating System: The Kernel *** Tasks performed by the kernel - Process scheduling - Memory management - Provision of a file system - Creation and termination of processes - Access to devices - Networking - Provision of a system call application programming interface(API) *** Kernel mode and user mode - Modern processor architectures typically allow the CPU to operate in at least two different modes: user mode and kernel mode(sometimes also referred to as supervisor mode). Hardware instructions allow switching from one mode to the other. Correspondingly, areas of virtual memory can be marked as being part of user space or kernel space. When running in user mode, the CPU can access only memory that is marked as being in user space; attempts to access memory in kernel space result in a hardware exceptiono. When running in kernel mode, the CPU can access both user and kernel memory space. ** The Shell ** Users and Groups ** Single Directory Hierarchy, Directories, Links, and Files - For the root directory, the dot-dot entry is a link to the root directory itself(thus, /.. equates to /) *** Symbolic links - Like a normal link, a symbolic link provides an alternative name for a file. But whereas a normal link is a filename-plus-pointer entry in a directory list, a symbolic link is a specially marked file containing the name of another file. (In other words, a symbolic link has a filename-plus-pointer entry in a directory, and the file referred to by the pointer contains a string that names another file.) - Often hard link and soft link are used as alternative terms for normal and sym- bolic links. The reasons for having two different types of links are explained in Chapter 18. *** Current working directory - Each process has a current working directory(sometimes just refered to as the process's working directory or current directory). - A process inherits its current working directory from its parent process. A login shell has its initial current working directory set to the location named in the home directory field of the user’s password file entry. ** File I/O Model - The kernel translates the application’s I/O requests into appropriate file system or device-driver operations that perform I/O on the target file or device. - UNIX systems have no end-of-file character; the end of a file is detected by a read that returns no data. ** Programs ** Processes - From a kernel point of view, processes are the entities among which the kernel must share the various resources of the computer. *** Process memory layout - Text - Data - Heap - Stack *** Process creation and program execution - The child inherits copies of the parent’s data, stack, and heap segments, which it may then modify independently of the parent’s copies. (The pro- gram text, which is placed in memory marked as read-only, is shared by the two processes.) - The child process goes on either to execute a different set of functions in the same code as the parent, or, frequently, to use the execve() system call to load and execute an entirely new program. An execve() call destroys the existing text, data, stack, and heap segments, replacing them with new segments based on the code of the new program. *** Process ID and parent process ID *** Process termination and termination status *** Process user and group identifiers(credentials) - Real user ID and real group ID: These identify the user and group to which the process belongs. A new process inherits these IDs from its parent. A login shell gets its real user ID and real group ID from the corresponding fields in the system password file. - Effective user ID and effective group ID: These two IDs (in conjunction with the supplementary group IDs discussed in a moment) are used in determining the permissions that the process has when accessing protected resources such as files and interprocess communication objects. Typically, the process’s effective IDs have the same values as the corresponding real IDs. Changing the effective IDs is a mechanism that allows a process to assume the privileges of another user or group, as described in a moment. - Supplementary group IDs: These IDs identify additional groups to which a pro- cess belongs. A new process inherits its supplementary group IDs from its par- ent. A login shell gets its supplementary group IDs from the system group file. *** Privileged processes - Traditionally, on UNIX systems, a privileged process is one whose effective user ID is 0 (superuser). Such a process bypasses the permission restrictions normally applied by the kernel. By contrast, the term unprivileged (or nonprivileged) is applied to processes run by other users. Such processes have a nonzero effective user ID and must abide by the permission rules enforced by the kernel. - A process may be privileged because it was created by another privileged process—for example, by a login shell started by root (superuser). Another way a process may become privileged is via the set-user-ID mechanism, which allows a process to assume an effective user ID that is the same as the user ID of the program file that it is executing. *** Capabilities - Since kernel 2.2, Linux divides the privileges traditionally accorded to the super- user into a set of distinct units called capabilities. Each privileged operation is asso- ciated with a particular capability, and a process can perform an operation only if it has the corresponding capability. A traditional superuser process (effective user ID of 0) corresponds to a process with all capabilities enabled. *** The init process - The init process can’t be killed (not even by the superuser), and it terminates only when the system is shut down. The main task of init is to create and monitor a range of processes required by a running system. *** Daemon processes - It is long-lived. A daemon process is often started at system boot and remains in existence until the system is shut down. - It runs in the background, and has no controlling terminal from which it can read input or to which it can write output. *** Environment list - When a new process is created via fork(), it inherits a copy of its parent’s environment. Thus, the environment pro- vides a mechanism for a parent process to communicate information to a child pro- cess. When a process replaces the program that it is running using exec(), the new program either inherits the environment used by the old program or receives a new environment specified as part of the exec() call. - Environment variables are created with the export command in most shells (or the setenv command in the C shell) - C programs can access the environment using an external variable (char **environ), and various library functions allow a process to retrieve and modify values in its environment. *** Resource list - Using the setrlimit() system call, a process can establish upper limits on its consumption of various resources. - Each such resource limit has two associated values: a soft limit, which limits the amount of the resource that the process may consume; and a hard limit, which is a ceiling on the value to which the soft limit may be adjusted. - An unprivileged process may change its soft limit for a particular resource to any value in the range from zero up to the corresponding hard limit, but can only lower its hard limit. ** Memory Mappings - The mmap() system call creates a new memory mapping in the calling process’s virtual address space. - Memory mappings serve a variety of purposes, including initialization of a process’s text segment from the corresponding segment of an executable file, allocation of new (zero-filled) memory, file I/O (memory-mapped I/O), and interprocess communication (via a shared mapping). ** Static and Shared Libraries *** Static libraries *** Shared libraries - If a program is linked against a shared library, then, instead of copying object modules from the library into the executable, the linker just writes a record into the executable to indicate that at run time the executable needs to use that shared library. - When the executable is loaded into memory at run time, a program called the dynamic linker ensures that the shared libraries required by the executable are found and loaded into memory, and performs run-time linking to resolve the func- tion calls in the executable to the corresponding definitions in the shared libraries. ** Interprocess Communication and Synchronization - signals, which are used to indicate that an event has occurred. - pipes and FIFOs, which can be used to transfer data between processes. - sockets, which can be used to transfer data from one process to another, either on the same host computer or on different hosts connected by a network. - file locking, which allows a process to lock regions of a file in order to prevent other processes from reading or updating the file contents. - message queses, which are used to exchange messages(packets of data) between processes. - semaphores, which are used to synchronize the actions of processes. - shared memory, which allows two or more processes to share a piece of memory. When one process changes the contents of the shared memory, all of the other processes can immediately see the changes. ** Singals - Signals are often described as "software interrupts." - Signals are sent to a process by the kernel, by another process(with suitable permissions), or by the process itself. - A kernel may send a signal to a process when one of the following occurs: - the user typed the interrupt character (usually Control-C) on the keyboard; - one of the process's children has terminated; - a timer(alarm clock) set by the process has expired; or - the process attempted to access an invalid memory address. - In the interval between the time it is generated and the time it is delivered, a signal is said to be pending for a process. Normally, a pending signal is delivered as soon as the receiving process is next scheduled to run, or immediately if the pro- cess is already running. However, it is also possible to block a signal by adding it to the process’s signal mask. If a signal is generated while it is blocked, it remains pending until it is later unblocked (i.e., removed from the signal mask). ** Threads - One way of envisaging threads is as a set of processes that share the same virtual memory, as well as a range of other attributes. Each thread is executing the same program code and shares the same data area and heap. However, each thread has it own stack containing local variables and function call linkage information. ** Process Groups and Shell Job Controls - All major shells, except the Bourne shell, provide an interactive feature called job control, which allows the user to simultaneously execute and manipulate multiple commands or pipelines. In job-control shells, all of the processes in a pipeline are placed in a new process group or job. (In the simple case of a shell command line containing a single command, a new process group containing just a single process is created.) - Each process in a process group has the same integer process group identifier, which is the same as the process ID of one of the processes in the group, termed the process group leader. - The kernel allows for various actions, notably the delivery of signals, to be per- formed on all members of a process group. Job-control shells use this feature to allow the user to suspend or resume all of the processes in a pipeline, as described in the next section. ** Sessions, Controlling Terminals, and Controlling Processes - A session is a collection of process groups(jobs). All of the processes in a session have the same session identifier. A session leader is the process that created the session, and its process ID becomes the session ID. - Sessions are used mainly by job-control shells. All of the process groups cre- ated by a job-control shell belong to the same session as the shell, which is the session leader. ** Pseudoterminals - A pseudoterminal is a pair of connected virtual devices, known as the master and slave. This device pair provides an IPC channel allowing data to be transferred in both directions between the two devices. - Pseudoterminals are used in a variety of applications, most notably in the implementation of terminal windows provided under an X Window System login and in application providing network login services, such as telnet and ssh. ** Date and Time Two types of time are of interest to a process: - Real time is measured either from some standard point (calendar time) or from some fixed point, typically the start, in the life of a process (elapsed or wall clock time). On UNIX systems, calendar time is measured in seconds since midnight on the morning of January 1, 1970, Universal Coordinated Time (usually abbreviated UTC), and coordinated on the base point for timezones defined by the longitudinal line passing through Greenwich, England. This date, which is close to the birth of the UNIX system, is referred to as the Epoch. - Process time, also called CPU time, is the total amount of CPU time that a process has used since starting. CPU time is further divided into system CPU time, the time spent executing code in kernel mode (i.e., executing system calls and performing other kernel services on behalf of the process), and user CPU time, the time spent executing code in user mode (i.e., executing normal program code). ** Client-Server Architecture ** Realtime - The provision of realtime responsiveness, especially where short response times are demanded, requires support from the underlying operating system. Most operating systems don’t natively provide such support because the requirements of realtime responsiveness can conflict with the requirements of multiuser time- sharing operating systems. Traditional UNIX implementations are not realtime operating systems, although realtime variants have been devised. Realtime variants of Linux have also been created, and recent Linux kernels are moving toward full native support for realtime applications. - POSIX.1b defined a number of extensions to POSIX.1 for the support of real- time applications. These include asynchronous I/O, shared memory, memory- mapped files, memory locking, realtime clocks and timers, alternative scheduling policies, realtime signals, message queues, and semaphores. Even though they don’t strictly qualify as realtime, most UNIX implementations now support some or all of these extensions. ** The /proc File System - The /proc file system is a virtual file system that provides an interface to kernel data structures in a form that looks like files and directories on a file system. - The /proc file system is not specified by any standards, and the details that we describe the Linux-specific.

待用 公式模式开启中。可以在文本框中写latex公式，发表后会自动识别。

stat(),lstat(),fstat() 系统调用获取文件信息，大部分是从inode中提取的。

区别在与stat 与fstat 传给函数的pathname的形式不同，一个为const char*的字符串一个为文件描述符。在用于链接文件时会直接给出其符号链接的文件的信息，若要是想知道链接本身的信息，则需要用lstat函数。

ctrl + c 是把signal发给这个 foreground process group, 而不是单独某一个进程。 问题：foreground process group 至多只能有1个，那是否z至少一个foreground process group?