type
status
date
slug
summary
tags
category
icon
password
Right now, Linux is the most flexible and powerful operating system that has ever been created, running everything from the tiniest cell phones and embedded devices to more than 90 percent fo the world’s top 500 supercomputers. No other operating system has ever been able to scale so well and meet the challenges of all of these different hardware types and environments.
The Linux system interface is definable as the application binary interface and application programming interface provided by the triplet of the Linux kernel, the GNU C library (glibc), and the GNU C Compiler (gcc).
Recommended command to compile a source file:
System programming is the practice of writing system software. System software lives at a low level, interfacing directly with the kernel and core system libraries. Your shell and your text editor, your compiler and your debugger, your core utilities and system daemons are all system software. But so are the network server, the web server, and the database. These components are entirely system software, primarily if not exclusively interfacing with the kernel and the C library. Other software (such as high-level GUI aplications) lives at a higher level, delving into the low level only on occasion.

1. APIs and ABIs

At the system level, there are two separate sets of definitions and descriptions that impact protability. One is the application programming interface (API), and the other is the application binary interface (ABI). Both define and describe the interfaces between different pieces of computer software.

1.1 APIs

An API defines the interfaces by which one piece of software communicates with another at the source level. It provides abstraction by providing a standard set of interfaces——usually functions——that one piece of software (typically, although not necessarily, a higher-level piece) can invoke from another piece of software (usually a lower-level piece).
It is common to call an API a “contract”. This is not correct, at least in the legal sense of the term, as an API is not a two-way agreement. The API user (generally, the higher-level software) has zero input into the API and its implementation. It may use the API as-is, or not use it at all: take it or leave it! The API acts only to ensure that if both pieces of software follow the API, they are source compatible; that is, that the user of the API will successfully compile against the implementation of the API.

1.2 ABIs

Whereas an API defines a source interface, an ABI defines the binary interface between two or more pieces of software on a particular architecture. It defines how an application interacts with itself, how an application interacts with the kernel, and how an application interacts with libraries. Whereas an API ensures source compatibility, an ABI ensures binary compatibility, guaranteeing that a piece of object code will function on any system with the same ABI, without requiring recompilation.
ABIs are concerned with issues such as calling conventions, byte ordering, register use, system call invocation, linking, library behavior, and the binary object format.The calling convention, for example, defines how functions are invoked, how arguments are passed to functions, which registers are preserved and which are mangled, and how the caller retrieves the return value.
 
Linux aims toward POSIX and SUS compliance.

2. Concepts of Linux Programming

2.1 Files and the Filesystem

The file is the most basic and fundamental abstraction in Linux. Linux follows the everything-is-a-file philosophy. Consequently, much interaction occurs via reading of and writing to files, even when the object in question is not what you would consider a normal file.
In order to be accessed, a file must first be opened. Files can be opened for reading, writing, or both. An open file is referenced via a unique descriptor, a mapping from the metadata associated with the open file back to the specific file itself. Inside the Linux kernel, this descriptor is handled by an integer called the file descriptor, abbreviated fd. File descriptors are shared with user space, and are used directly by user programs to access files. A large part of Linux system programming consists of opening, manipulating, closing, and otherwise using file descriptors.

Regular files

Directories and links

Although directories are treated like normal files, the kernel does not allow them to be opened and manipulated like regular files. Instead, they must be manipulated using a special set of system calls. These system calls allow for the adding and removing of links, which are the only two sensible operations anyhow. If user space were allowed to manipulate directories without the kernel’s mediation, it would be too easy for a single simple error to corrupt the filesystem.

Hard links

Symbolic links

Special files

Special files are kernel objects that are represented as files. Over the years, Unix systems have supported a handful of different special files. Linux supports four: block device files, character device files, named pipes, and Unix domain sockets. Special files are a way to let certain abstarctions fit into the filesystem, continuing the everything-is-a-file paradigm. Linux provides a system call to create a special file.

Filesystems and namespaces

2.2 Processes

Threads

Process hierarchy

2.3 Users and Groups

2.4 Permissions

2.5 Signals

2.6 Interprocess Communication

 
 

📎 参考文章

 
💡
有关Notion安装或者使用上的问题，欢迎您在底部评论区留言，一起交流~
 
相关文章
模板使用说明
Example-1
Linux系统编程(1)——文件I/O
高性能网络编程(9)——The C10K problem
高性能网络编程(8)——I/O 多路复用之 epoll
高性能网络编程(7)——I/O 多路复用之 poll
Linux系统编程(1)——文件I/O高性能网络编程(9)——The C10K problem