Два ядра процессора выполняют один и тот же инкремент над общей переменной, и одна правка исчезает без следа: компилятор развернул counter++ в загрузку, сложение и запись, потоки вклинились между шагами, и половина работы ушла в никуда. Из таких незаметных потерь вырастают плавающие сбои, которые воспроизводятся раз в неделю и не повторяются под отладчиком. Ядро живёт в этом мире постоянно: прерывания, мягкие прерывания, потоки ядра и системные вызовы дёргают одни и те же структуры одновременно, а язык C не даёт защиты по умолчанию.

На выручку приходят три семейства примитивов, спинлоки, мьютексы и семафоры, плюс атомарные операции для счётчиков и флагов. У каждого своя цена и жёсткие запреты, а ошибка в выборе обходится дороже самого примитива. Дальше разбирается устройство каждого механизма, приводятся примеры кода, реальные сообщения ядра о нарушениях и инструменты lockdep, ftrace и lock_stat, которые превращают поиск гонок в нормальную инженерию.

Цена общих данных и гонки, которых не видно в тесте

Сначала честный расчёт. Незанятый спинлок на современном x86 стоит десятки наносекунд, атомарный инкремент без конкурентов в единицы или десятки наносекунд. Перенос строки кэша с одного сокета на другой, когда два потока бьются за одну переменную, стоит сотни наносекунд за каждое перемещение, и на горячем объекте это съедает микросекунды в секунду. Сон и пробуждение через планировщик ещё дороже: порядка микросекунды уходит только на переход контекста, без учёта потерь в кэше и предсказателе переходов.

Отсюда первый вывод: цена защиты растёт не от примитива, а от конкуренции. Идеальный замок тот, который почти никогда не берут два потока одновременно. Поэтому в ядре дробят состояние: не один глобальный замок на таблицу, а по спинлоку на хэш-бакет, не общий счётчик, а переменные на каждое ядро через DEFINE_PER_CPU. Сюда же примыкает ложное разделение, когда две независимые, но горячие переменные лежат в одной строке кэша и заставляют ядра перебрасывать её туда-сюда; лечится выравниванием через ____cacheline_aligned или перестроением структуры.

Проверить гипотезу просто: запустите однопоточный тест, затем тот же код в восемь потоков на восьми ядрах. Если скорость не выросла совсем, вы упёрлись в один замок, и тюнинг планировщика не поможет.

| Механизм | Спать внутри секции | Из обработчика прерывания | Типичное применение |
|---|---|---|---|
| spinlock | нельзя | да, вариант irqsave обязателен | короткие секции, данные IRQ |
| mutex | можно | нельзя | процессный контекст, ioctl, драйверы |
| semaphore | можно | только up() | счётные лимиты ресурсов |

Таблица сжимает суть, однако детали у каждого механизма свои, и именно в них прячутся ошибки.

Спинлок и ожидание у двери без права уснуть

Спинлок устроен по самому простому принципу: не получил замок, крути раз за разом, пока не освободится. Тип spinlock_t в Linux служит обёрткой над raw_spinlock_t. Долгие годы x86 использовал билетные спинлоки, где каждый кандидат получает номер и ждёт честной очереди, а в ядре 4.2 их сменили очередные спинлоки qspinlock на алгоритме MCS: при конкуренции каждое ядро крутится на собственной строке кэша, и трафик между сокетами резко падает.

Базовый интерфейс: spin_lock, spin_unlock, spin_trylock, spin_lock_irqsave и парный spin_unlock_irqrestore. Вариант irqsave нужен ровно в одном случае: если тот же замок берётся в обработчике прерывания, который может воткнуться на то же ядро посреди критической секции. Без сохранения флагов и запрета прерываний выходит классический тупик: поток взял замок, прерывание пришло на тот же CPU, обработчик крутится на занятом замке, а отпустить его некому, потому что поток заморожен своим же обработчиком.

static DEFINE_SPINLOCK(queue_lock);
static LIST_HEAD(pending);

/* процессный контекст */
void submit(struct request *req)
{
    unsigned long flags;

    spin_lock_irqsave(&queue_lock, flags);
    list_add_tail(&req->list, &pending);
    spin_unlock_irqrestore(&queue_lock, flags);
}

/* обработчик прерывания, контекст уже атомарный */
static irqreturn_t hardirq_handler(int irq, void *dev)
{
    struct request *req;

    spin_lock(&queue_lock);
    req = list_first_entry_or_null(&pending, struct request, list);
    if (req)
        list_del(&req->list);
    spin_unlock(&queue_lock);
    return IRQ_HANDLED;
}

Внутри секции под спинлоком жить нельзя: спать запрещено, никаких kmalloc с GFP_KERNEL, никаких mutex_lock и copy_to_user. В mainline-ядре spin_lock ещё и запрещает вытеснение на текущем ядре, значит долгая секция портит латентность всей системе. Держите её короткой, в идеале десятки инструкций: достать из списка, пометить, положить в другой список, выйти. Оборонительный приём: в обработчике прерывания брать не spin_lock, а spin_trylock, а при неудаче откладывать работу в tasklet или workqueue; тупик становится невозможным по построению.

На однопроцессорной машине без CONFIG_PREEMPT спинлок почти вырождается и схлопывается в пару инструкций, зато на многопроцессорной собирается в честный замок. В ядрах PREEMPT_RT обычный spinlock превращается в спящий примитив на базе rt_mutex, а настоящие спинлоки остаются под именем raw_spinlock_t для самых низкоуровневых участков; правила использования при этом почти не меняются.

Мьютекс и семафор честная очередь вместо бесполезного кружения

Спинлок платит процессорным временем за всё ожидание. Если секция длинная или конфликт редкий, разумнее уснуть и отдать ядро другим задачам. Для этого есть struct mutex, появившийся в 2.6.16 как лёгкая замена семафорам с монопольным владением. Быстрый путь без конкуренции это одна атомарная операция, сопоставимая по цене со спинлоком, медленный путь уводит задачу в очередь ожидания через планировщик.

У мьютекса три неочевидных свойства. Первое, у него есть владелец, указатель на struct task_struct в поле owner, поэтому ядро ругается, если mutex_unlock зовут не из той задачи, которая брала замок. Второе, оптимистичное вращение: если владелец исполняется на другом ядре (за это отвечает очередь osq), новая задача сначала покрутится и только потом уснёт, благодаря чему частые короткие конфликты не доходят до сна. Третье, отладка: CONFIG_DEBUG_MUTEXES и lockdep ловят двойное освобождение, забытые замки и сон в атомарном контексте.

static DEFINE_MUTEX(cfg_mutex);

static long cfg_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{
    int rc;

    mutex_lock(&cfg_mutex);
    /* здесь можно спать: kmemdup, i2c-транзакции, работа с устройством */
    rc = apply_config(arg);
    mutex_unlock(&cfg_mutex);
    return rc;
}

Мьютекс живёт в процессном контексте: из обработчика прерывания или под спинлоком допустим только mutex_trylock, сам mutex_lock там запрещён. Внутри секции можно спать спокойно, и этим надо пользоваться, держа под мьютексом операции, которые ходят на железо или в память с ожиданием. Для интерактивных путей есть mutex_lock_interruptible(), для проверки состояния без захвата mutex_is_locked().

Семафор, struct semaphore, старше и проще: счётчик и очередь спящих. down() уменьшает счётчик, если тот ушёл в минус, уводит задачу спать; up() увеличивает его и будит одного ожидающего. Интерфейс включает down_interruptible(), возвращающую -ERESTARTSYS по сигналу, down_trylock() и down_timeout(). У семафора нет владельца, up() может позвать любой контекст, включая прерывание, и никакой отладчик не скажет, что вы освободили чужой замок; быстрый путь тяжелее мьютекса, поэтому для взаимного исключения он устарел. Зато он естественен там, где нужен счётчик ресурсов:

static DEFINE_SEMAPHORE(ports_free, 4);   /* максимум четыре одновременных запроса */

static int take_port(void)
{
    if (down_interruptible(&ports_free))
        return -ERESTARTSYS;    /* сигнал пришёл раньше ресурса */
    return 0;
}

static void put_port(void)
{
    up(&ports_free);            /* допустимо и из прерывания */
}

Шпаргалка: мьютекс для взаимного исключения в процессном контексте, семафор для лимита одновременных потребителей, completion (wait_for_completion и complete) для задачи, ждущей события в другом контексте.

Атомарные счётчики и операции без блокировок вообще

Самая дешёвая защита не замок, а его отсутствие. Тип atomic_t это обёртка над целым: atomic_read, atomic_set, atomic_inc, atomic_dec, atomic_add, atomic_sub, atomic_inc_return, atomic_dec_and_test, atomic_cmpxchg. На x86 каждая операция собирается в инструкцию с префиксом lock, удерживающую строку кэша в эксклюзивном состоянии, и заодно задаёт барьеры памяти, тогда как обычная запись не обещает порядка наблюдения. Дешевле всего атомика обходится без конкуренции, поэтому она идеальна для счётчиков ссылок, статистики и флагов.

static atomic_t users = ATOMIC_INIT(0);

static int open_user(void)
{
    atomic_inc(&users);
    return 0;
}

static void close_user(void)
{
    if (atomic_dec_and_test(&users))   /* сработает ровно у последнего */
        schedule_teardown();
}

Главное ограничение: атомика защищает одну переменную, а не инвариант из нескольких. Конструкция, где сначала читают atomic_read(&x), а потом зовут atomic_dec(&x), неатомарна: между чтением и декрементом другой поток израсходует последний ресурс. Для проверки с уменьшением есть atomic_dec_if_positive() и atomic_cmpxchg(), но честный ответ чаще иной: составное условие надо накрывать настоящим замком. С ядра 4.11 для ссылочных счётчиков рекомендуется refcount_t с интерфейсом refcount_inc и refcount_dec_and_test и защитой от переполнения, которое в atomic_t тихо портит число.

Когда один замок становится узким местом, состояние дробят дальше: percpu-счётчики разводят статистику по ядрам, percpu-refcount масштабирует счётчики ссылок, читающая сторона обходится без блокировок через RCU, где rcu_read_lock() и rcu_read_unlock() в большинстве конфигураций не стоят ничего. Отдельно стоят rwlock_t для случая, когда чтения многократно преобладают над записями, и seqlock для редко меняющихся данных вроде jiffies:

static DEFINE_SEQLOCK(stats_sl);
unsigned seq;

do {
    seq = read_seqbegin(&stats_sl);
    tx = dev->tx_packets;
    rx = dev->rx_packets;
} while (read_seqretry(&stats_sl, seq));

Сон в прерываниях и взаимоблокировки из практики

Большинство аварий сводятся к двум ошибкам: спать там, где нельзя, и брать замки в разном порядке.

Первая печатает себя сама. Достаточно позвать mutex_lock в tasklet или kmalloc(GFP_KERNEL) под спинлоком, и в логе появится BUG: sleeping function called from invalid context, а при попытке именно уснуть BUG: scheduling while atomic. Причина в preempt_count: ядро ведёт счётчик вложенных запретов, где нижние биты считает preempt_disable, выше идут softirq и hardirq, и пока итог не нулевой, контекст атомарный. С CONFIG_DEBUG_ATOMIC_SLEEP ловушка срабатывает на самой попытке сна, раньше перепланирования.

static void my_tasklet(unsigned long data)
{
    /* неверно: контекст атомарный, мьютекс здесь запрещён */
    mutex_lock(&cfg_mutex);
}

Вторая ошибка тоньше. Два потока, два замка, порядок в разных ветках противоположный, и оба замирают навсегда:

/* поток A */
mutex_lock(&lock_a);
mutex_lock(&lock_b);        /* ждёт B */

/* поток B */
mutex_lock(&lock_b);
mutex_lock(&lock_a);        /* ждёт A, никто не двинется */

Внешне это выглядит как потеря производительности, потом как hung task: ядро печатает INFO: task ... blocked for more than 120 seconds, порог настраивается через sysctl kernel.hung_task_timeout_secs. Классика из драйверов: замок A берут в ioctl, замок B в netlink-обработчике, пути никогда не пересекаются, пока кто-то не добавит третий маршрут вызова. Третья классика описана выше: замок, который берут и в процессе, и в прерывании, без spin_lock_irqsave; под нагрузкой это мгновенное замирание одного ядра, а диагноз лежит в /proc/interrupts, где видно, на каком CPU висит застрявший обработчик. Наконец, заведомо тупиковый вариант: рекурсивный spin_lock. Спинлок не реентерабелен, второй захват того же замка крутится вечно, и система останавливается без единого сообщения.

lockdep ftrace и lock_stat в руках инженера

Самый мощный инструмент живёт в конфигурации ядра. CONFIG_PROVE_LOCKING включает lockdep, который на лету строит граф порядка захвата замков и ругается при первом же опасном цикле с сообщением INFO: possible circular locking dependency detected, за которым идут имена задач, стеки и цепочка замков. Ловит он не только AB-BA тупики, но и нарушения правил прерываний: замок, берущийся и в прерывании, и в процессе без irqsave, помечается как irq-unsafe и даёт отчёт раньше первого зависания. Цена высока, замедление измеряется порядками, поэтому lockdep включают в тестовых конфигурациях и CI ядра, а не на нагруженных серверах.

Пригодятся и соседние опции: CONFIG_DEBUG_SPINLOCK, CONFIG_DEBUG_MUTEXES, CONFIG_DEBUG_ATOMIC_SLEEP, CONFIG_LOCK_STAT. С ними доступны /proc/lockdep, /proc/lockdep_chains и /proc/lockdep_stats для просмотра выученных классов замков, а /proc/lock_stat даёт статистику по реальной конкуренции:

class name                   con-bounces  contentions  waittime-total ...
------------------------------------------------------------------------
&dev->queue_lock:                   41           41          0.912 ...
&xmit_skb_lock:                      7            7          0.103 ...

Колонки con-bounces, contentions, waittime-total и holdtime-total прямо отвечают на вопросы, чей замок тормозит систему и сколько времени его держат. Управление простое: echo 1 > /proc/sys/kernel/lock_stat включает сбор, echo 0 > /proc/sys/kernel/lock_stat выключает.

ftrace закрывает вопрос, где именно крутится код:

cd /sys/kernel/debug/tracing
echo 'native_queued_spin_lock_slowpath' > set_ftrace_filter
echo function_graph > current_tracer
echo 1 > tracing_on
cat trace | head -n 40
echo 1 > events/lock/lock_acquire/enable
cat trace_pipe

Если native_queued_spin_lock_slowpath постоянно вверху, спинлок реально конкурирует; события lock_acquire и lock_release дают времена захвата, а с CONFIG_LOCK_STAT добавляются lock_contended и lock_acquired. Сверху всё накрывается perf: perf lock record -a -- sleep 10 собирает данные по всей системе, perf lock report --sort wait_total строит таблицу самых конфликтных замков, и отправной точкой становится конкретное имя класса, а не общее ощущение тормозов.

Практические правила выбора и дисциплина критических секций

Опыт сходится к нескольким правилам, которые экономят недели отладки:

  1. Для взаимного исключения в процессном контексте берите mutex: быстрый путь не хуже семафора, а владелец и отладка делают поведение предсказуемым.
  2. Спинлок выбирайте только для коротких секций без сна и для данных, к которым стучится прерывание; тогда обязательны irqsave-варианты или честное разделение замков на процессные и прерываний.
  3. Счётчики, флаги и статистику защищайте atomic_t, refcount_t и percpu-переменными; составные инварианты атомикой не накрываются.
  4. Лимит одновременных потребителей выражайте семафором, событие ждите через completion, а не через кустарные циклы со сном.
  5. Держите критические секции минимальными: за границу замка выносите всё, что ходит на железо, в сеть или в подсистему аллокации.
  6. Каждый новый путь вызова проверяйте на порядок замков: правило все берут A, потом B, фиксируется комментарием рядом с объявлением замков.
  7. Прогон нагрузки с включенным lockdep и последующий взгляд в /proc/lock_stat или perf lock стоят дешевле одной ночной аварии на проде.

Правила не догма, но в них зашита главная мысль: сначала понять контекст исполнения (процесс, softirq, hardirq), потом выбрать примитив и только затем оптимизировать. Обратный порядок, когда сначала по привычке берут spin_lock, а потом годами лечат мигания и зависания, встречается в рабочих системах регулярно.

Хорошая новость в том, что ядро давно помогает честно. Ловушки вроде might_sleep(), отладочные опции, lockdep и события ftrace дают объективную картину вместо догадок. Осталось привыкнуть спрашивать у системы не о том, почему медленно, а о том, кто держит замок и как долго, и почти любая история с синхронизацией сокращается до короткого скучного исправления. Скучный код в этой области и есть высшая похвала: замок, который никто никогда не видел в отчётах о конкуренции, работает ровно так, как задуман.