Terms

Moving a CPU from running one process to running another: the kernel saves the outgoing process’s state, picks the next one, sets its time slice, and returns to user mode. Fast enough that every program appears to run at once.

Linux abstraction layers kernel time-slice

A shell variable marked for inheritance by child processes, using export. It does not write anything to disk and is not permanent — permanence comes from a startup file setting it again each time a shell starts.

The shell and the command line shell-variable path

The small integer a process uses to refer to an open stream. Every process starts with three: 0 for standard input, 1 for standard output, 2 for standard error. Redirection is the shell repointing them before the program runs.

Streams, redirection, and pipes standard-streams

The core of the operating system: it loads at startup, schedules the CPU, manages memory, drives hardware, and services the system calls processes make. It owns memory that no user process may touch, which is why a misbehaving program can crash itself without taking down the machine.

Linux abstraction layers system-call user-space

Hardware in modern CPUs that lets the kernel give each process a private, contiguous-looking virtual address space regardless of how the physical memory is actually arranged.

Linux abstraction layers kernel virtual-memory

The environment variable listing, in order, the directories the shell searches for the program a command names. Position matters: a directory early in the list can shadow a system command with something else of the same name.

The shell and the command line environment-variable

A connection joining one process’s standard output to the next one’s standard input, with nothing touching the disk. Pipes are what make many small single-purpose tools add up to work none of them was written for.

Streams, redirection, and pipes file-descriptor standard-streams

A filesystem with nothing on a disk behind it — the kernel presenting its own state through the file interface so that ordinary tools work on it. /proc and /sys are the two you meet first, which is why cat works on kernel state.

The Linux filesystem hierarchy kernel

A permission bit making a program run as its owner rather than as the user who launched it. It is how an ordinary user can change their own password in a file they cannot write, and it is why an unexpected setuid binary is worth investigating.

File permissions and links umask

A named value belonging to one shell, set with NAME=value and gone when that shell exits. It becomes an environment variable — visible to child processes — only when exported.

The shell and the command line environment-variable

The three streams every process starts with: standard input, standard output, and standard error. Results go to output and diagnostics to error, which is what lets you pipe a command’s results somewhere without also piping its complaints there.

Streams, redirection, and pipes file-descriptor pipe

A small file whose contents are a path to something else. Its own permission bits are meaningless — access is decided by the target — and because it stores a path rather than a reference to the data, deleting the target leaves the link pointing at nothing.

File permissions and links

A request from a user process asking the kernel to do something only the kernel can. Opening, reading, and writing files are all system calls, and so are fork() and exec() — which is how every process other than the first one comes to exist.

Linux abstraction layers kernel user-space

The window of CPU time the kernel gives a process before considering whether to run something else. Rotating between processes this way is multitasking, and it runs fast enough that a sequence of turns reads as simultaneity.

Linux abstraction layers context-switch

The mask of permission bits removed from newly created files and directories. It subtracts from 666 for files and 777 for directories, so a new file never gets execute permission no matter what you set — a deliberate safety property.

File permissions and links setuid

The memory the kernel allocates to user processes, and everything running in it. The boundary between it and kernel space is the reason a crashing program takes only itself down.

Linux abstraction layers kernel system-call

An address space that looks private and contiguous to a process regardless of how the underlying physical memory is arranged. The MMU is the hardware that makes it possible.

Linux abstraction layers memory-management-unit