Обзор 17 модулей — путь от userspace до железа
В этом уроке — карта курса. Понять заранее, куда вы движетесь, важно: каждая новая тема опирается на предыдущие, и без видения общей картины материал кажется обрывочным.
Курс построен от userspace вниз к железу. Сначала разбираемся, что видит программа: процессы, потоки, память, файлы. Потом спускаемся в ядро: syscalls, планировщик, виртуальная память. В конце — наблюдаемость и capstone, где вы сами пишете мини-инструменты. Это естественный путь обучения: от привычного «процесс python» до «контекстное переключение через interrupt и trap-инструкцию».
Карта курса — 17 модулей
Прежде чем погружаться в каждый модуль, посмотрим на курс целиком:
Это roadmap. Каждый блок — модуль из 4-5 уроков. Между модулями есть зависимости (например, M03 потоки требует M02 процессы), но в целом курс идёт линейно.
Нарратив: от userspace вниз к железу
Главная идея структуры: мы начинаем с того, что видит обычный программист, и постепенно опускаемся в детали. Это противоположно тому, как часто преподают «Операционные системы» в университете — там сначала железо, регистры, traps, а потом уже процессы. Такой подход теоретически правильный, но психологически тяжёлый: пока вы не понимаете «зачем», все эти trap’ы и регистры выглядят как абстрактная муть.
Каждая последующая тема использует предыдущие. Когда мы дойдём до «как работает планировщик» — вы уже знаете, что такое процесс и поток. Когда обсудим «виртуальная память» — вы знаете, что такое процесс и какое у него address space. Когда дойдём до «syscalls глубоко» — вы уже много раз использовали strace в предыдущих уроках, и теперь поймёте, как это работает изнутри.
Модули 01-04: процессная модель
Первый блок курса — про процессы и потоки. Это самые «человеческие» абстракции: программист видит процесс в ps, может убить его через kill, может запустить новый через subprocess.Popen(). Нужно понять, что процесс — не просто «запущенная программа», а сложная структура внутри ядра.
Модуль 01 — Что такое ОС. Базовые понятия: зачем нужна ОС, что такое kernel и userspace, что такое syscall, как устроены ring 0/3. Завершаем разбором архитектур: monolithic kernel (Linux), microkernel (L4), hybrid (Windows NT, macOS XNU).
Модуль 02 — Процессы. Что внутри процесса: PID, PPID, UID, address space, fd-таблица. Как создаётся процесс через fork() (копия родителя) и превращается в новую программу через exec(). Lifecycle: created -> ready -> running -> blocked -> zombie -> terminated. Практические тулзы: ps, pgrep, kill, /proc/[pid].
Модуль 03 — Потоки. Чем поток отличается от процесса — они делят address space. Threading models (1:1 в Linux через NPTL, M:N в Go). Синхронизация: race conditions, mutex, semaphore, atomic. Типичные грабли: deadlock, livelock, false sharing.
Модуль 04 — Планировщик. Зачем нужен планировщик, разница preemptive vs cooperative. Алгоритмы: round-robin, priority, multilevel feedback queue, CFS (концептуально). Приоритеты в Linux: nice, ionice, chrt. Real-time классы: SCHED_FIFO, SCHED_RR, SCHED_DEADLINE.
После этого блока вы понимаете, что значит «у нас 200 процессов в системе, 30% CPU usage, load 5.0» — и можете обоснованно решить, нужен ли вам тред или процесс для конкретной задачи.
Модули 05-06: память
Дальше — память. Это самая мистическая тема для Junior: free пишет, что свободно 200 MB из 8 GB, а сервер работает; RSS процесса 1 GB, но программа писала только 100 MB; иногда OOM убивает процесс, иногда — нет; swap есть, но не используется.
Модуль 05 — Memory Management. Иерархия памяти: регистры -> L1/L2/L3 cache -> RAM -> swap -> диск. Latency на каждом уровне. Виртуальная память: что это, зачем нужна (изоляция процессов, illusion бесконечной памяти). Pages, page tables, MMU, TLB. Swap и overcommit: почему Linux разрешает выделять больше памяти, чем есть. OOM killer: как выбирает жертву. NUMA: что это и когда важно.
Модуль 06 — Memory Allocation. Stack vs heap: где живут переменные, направление роста, что такое stack overflow. Как работает malloc/free: brk, mmap, аллокаторы (glibc ptmalloc, jemalloc). Утечки vs фрагментация: разные проблемы, разные тулзы (valgrind, ASan). Shared memory между процессами.
После этого блока вы понимаете, что означает каждая колонка free -h, разницу RSS vs VSZ, можете дебажить утечки и понимаете, почему сервер «работает» при «отсутствии свободной памяти».
Модули 07-09: коммуникация и файлы
Третий блок — про то, как процессы взаимодействуют между собой и с диском.
Модуль 07 — IPC. Inter-process communication: как один процесс отправляет данные другому. Pipes (anonymous и named/FIFO). Signals: kill, SIGTERM/SIGKILL, handlers, async-signal-safety. Unix domain sockets: чем отличаются от TCP, performance. Shared memory и message queues: когда нужно.
Модуль 08 — Filesystems. Что такое файловая система. VFS — виртуальный слой над разными ФС. Inodes: что хранится, как файл живёт без имени. Hard links vs symlinks. Mount, /etc/fstab. Сравнение ФС: ext4 vs xfs vs btrfs vs zfs — когда какую выбирать.
Модуль 09 — File I/O. Системные вызовы для работы с файлами: open, read, write, close. Буферизация: user buffer (Python’s open()), kernel page cache, O_DIRECT. fsync и durability: как гарантировать, что данные на диске. mmap: память как файл, файл как память.
После этого блока вы понимаете, что происходит при with open(...) as f: f.write(data) — какие syscalls, как идёт буферизация, когда данные физически на диске, почему fsync важен в БД.
Модули 10-13: безопасность и низкий уровень
Модуль 10 — Permissions. Users, groups, UID, GID, /etc/passwd, NSS. Права rwx, chmod, setuid, sticky bit. root, sudo, sudoers. Linux capabilities (CAP_NET_RAW и др.) и namespaces — основа Docker.
Модуль 11 — Syscalls. Глубокое погружение: что физически происходит при syscall (trap, переход в kernel mode, обратно). strace в деталях: фильтры, чтение output, диагностика. Syscall table, x86_64 ABI, register conventions (rax, rdi, rsi). vDSO: быстрые syscalls без trap (gettimeofday).
Модуль 12 — Devices. Block vs char devices, /dev/sda1 vs /dev/tty. udev: динамическое создание /dev. Драйверы и kernel modules: lsmod, modprobe. Debugging hardware: dmesg, lsblk, lspci, lsusb.
Модуль 13 — Boot/Init. Что происходит при загрузке: BIOS/UEFI -> MBR/GPT -> bootloader (GRUB) -> kernel -> init/systemd. systemd в деталях: units, targets, journalctl, systemctl. Troubleshooting: single mode, rescue, chroot.
После этого блока вы понимаете, как работает Docker (это namespaces + cgroups + capabilities), как ваша программа дёргает ядро (syscalls под капотом), как ядро видит ваш диск (драйвер + udev + VFS), и что происходит после нажатия Power.
Namespaces и cgroups: как всё изученное здесь лежит в основе DockerМодули 14-15: тулинг и capstone
Модуль 14 — Observability. Тулинг для диагностики реальных проблем. top, htop — основы. vmstat, iostat — что показывают, как читать. /proc и /sys как интерфейсы к kernel state. perf для профилирования и flame graphs. eBPF: что такое, обзор bcc/bpftrace.
Модуль 15 — Capstone. Финальный проект. Пишем мини-инструменты:
- Свой
psна Python из/proc/[pid]/. - Простейшая shell на Python с fork/exec и pipes.
- Resource monitor с alerts на CPU/mem/disk-io.
Capstone закрепляет все темы курса в практическом коде. Вы видите, как теория ложится на реальные тулзы, которыми вы пользуетесь каждый день.
Что вы умеете в конце
После прохождения всего курса:
Это уровень mid-инженера на собеседовании. На реальной работе вы становитесь «человек, который разбирается в Linux». DevOps подходит к вам с вопросами, потому что вы понимаете и backend, и систему.
Зависимости между модулями
Не все модули равнозависимы. Вот как они связаны:
Если хотите ускоренно пройти курс: M01 -> M02 -> M05 -> M11 -> M14 даст вам core. Остальное — по потребности. Но мы рекомендуем последовательно, потому что каждый модуль интересен сам по себе.
Реальный пример прогресса
Чтобы прогресс был ощутим, в начале курса напишите на бумаге ответ на простой вопрос: «Что происходит, когда я запускаю python script.py?»
В начале курса ответ типичного Junior: «Python запускается, читает скрипт, выполняет код». Это ОК на старте.
К концу M02 (процессы) вы дополните: «Shell делает fork(), потом execve(‘/usr/bin/python’, [‘python’, ‘script.py’]). Создаётся новый процесс с PID, который наследует fd-таблицу shell. Process state cycles между ready и running».
К концу M11 (syscalls) добавите: «execve вызывает syscall номер 59 в x86_64. Процессор переключается в ring 0 через инструкцию syscall. Ядро освобождает старый address space, загружает ELF-бинарь python через mmap, переходит в _start точку входа».
После M05 (memory): «Address space процесса — 128 TB виртуального, физически выделяется по требованию через page faults. Bilbliotek (.so) mmap’нуты shared между процессами Python».
После M14 (observability): «strace -fc python script.py покажет, какие syscalls и сколько раз. perf stat — циклы CPU. /proc/[pid]/status — состояние».
Это эволюция Junior. Вы вернётесь к этому вопросу в финальном модуле — и удивитесь, насколько детальный ответ сможете дать.
Попробуй сам
Ответьте сейчас (письменно, на бумаге или в текстовом файле) на 5 вопросов. Не подглядывайте в гугл — запишите свои текущие представления.
1. Что такое процесс? Чем отличается от программы?
2. Что такое виртуальная память? Зачем она нужна?
3. Что такое system call? Какие вы знаете?
4. Чем поток отличается от процесса?
5. Что показывает команда `top` в первой строке (load average)?Сохраните ответы. В конце курса вы вернётесь к этому файлу и увидите, насколько изменился ваш способ думать про систему.