SSD Nodes Learn Hosting plans →
Руководства Matt ConnorАвтор: Matt Connor · Обновлено 2026-11-14

История развития ядра Linux: ключевые решения

Узнайте, как переход на лицензию GPL, внедрение git и модель LTS сформировали современное ядро Linux. Анализ архитектурных решений от версии 0.01 до 7.x для серверов.

Краткая история ядра Linux

История ядра Linux охватывает период от версии 0.01 в сентябре 1991 года до серии 7.x, которая загружается на современных серверах. Список релизов — наименее интересная часть этой истории. Небольшое количество принятых решений определило архитектуру системы, и каждое из них до сих пор влияет на машину, которую вы арендуете сегодня. Причины, по которым в 1991 году вообще потребовалось новое ядро, относятся к более длинной истории Unix, лицензирования AT&T и судебного процесса, который затормозил развитие BSD.

Даты и номера версий здесь взяты с сайта kernel.org и опубликованной им истории релизов. Текущее состояние на 13 ноября 2026 года: версия 7.0 вышла 12 апреля 2026 года, 7.1 — 14 июня 2026 года, 7.2 — в середине августа 2026 года, а 7.3 — 18 октября 2026 года. На kernel.org версия 7.4-rc2 указана как основная (mainline), а 7.3.4 — как текущий стабильный релиз. Поддержка ветки 7.2 завершилась с выходом версии 7.2.15 1 ноября 2026 года.

Почему выбор GPL в 1992 году до сих пор важен

Версия 0.01 была опубликована 17 сентября 1991 года под лицензией, которую Торвальдс написал самостоятельно. Она требовала распространения исходного кода и содержала строку, которая имела большее значение: «Вы не можете распространять это за плату, даже за расходы на "обработку"». В 1991 году программное обеспечение поставлялось на дискетах, а копирование и пересылка дискет стоили денег. Это условие делало коммерческий дистрибутив Linux невозможным.

Он изменил это. Переход на GNU General Public License (GPL) был анонсирован в примечаниях к выпуску 0.12 в январе 1992 года и вступил в силу 1 февраля 1992 года. Версия 0.95, вышедшая в марте 1992 года, стала первым релизом, опубликованным на этих условиях. Весь бизнес, построенный впоследствии на Linux, опирается на это изменение.

Ядро лицензировано исключительно под GPL версии 2 и никогда не переходило на версию 3. Торвальдс отказался от этого в 2007 году, в основном из-за правила против «тивоизации» (anti-tivoisation) в GPLv3, которое требует предоставления информации об установке для модифицированных версий кода, поставляемого с потребительским устройством, за исключением случаев, когда ни поставщик, ни третья сторона не могут установить модифицированный код (например, если код прошит в ROM). Он рассматривал заблокированное оборудование как личное дело производителя. В 2017 году разработчики ядра опубликовали Kernel Enforcement Statement, который всё же заимствует один элемент из GPLv3: тот, кто получает первое уведомление о нарушении от правообладателя и устраняет его в течение 30 дней, сохраняет свою лицензию навсегда, вместо того чтобы лишиться её при первом же нарушении.

Для сервера это влечет два последствия. Бинарный файл ядра, который вы загружаете, дает право на получение соответствующего исходного кода, поэтому никто не может передать вам ядро Linux, которое вы не можете изучить или пересобрать. Кроме того, уведомление об авторских правах на ядро гласит, что лицензия не распространяется на пользовательские программы, использующие службы ядра через стандартные системные вызовы, поэтому проприетарные базы данных и агенты мониторинга поставляются для Linux без каких-либо нарушений. Разрешительная лицензия создает противоположное давление, и эту разницу стоит понимать перед выбором платформы: см. Linux и FreeBSD как серверные платформы.

Почему монолитное ядро победило на практике

29 января 1992 года Эндрю Таненбаум опубликовал в группе новостей comp.os.minix сообщение под заголовком "LINUX is obsolete". Он выдвинул два утверждения. Монолитные ядра, в которых драйверы и файловые системы работают в одном привилегированном адресном пространстве, — это архитектура 1970-х годов, тогда как микроядра, где эти компоненты работают как обычные процессы, — это будущее. И Linux жестко привязан к Intel 386, поэтому он никогда не станет переносимым.

На утверждение о переносимости ответили самой переносимостью. Когда в марте 1995 года вышла версия 1.2, порты для DEC Alpha, MIPS, SPARC и семейства Motorola 68000 уже находились в разработке. Версия 2.0 в июне 1996 года стала первым стабильным релизом, поддерживающим 64-битную архитектуру Alpha наряду с 386, а к началу 1997 года к ним присоединился SPARC в качестве интегрированного порта.

На утверждение об архитектуре ответили компромиссом. Linux не стал микроядром. В нем появились загружаемые модули ядра: объектные файлы, которые можно вставить в работающее ядро и извлечь обратно, поэтому драйвер поставляется отдельно от бинарного файла ядра.

lsmod | head
modinfo virtio_net | head -5

lsmod выводит список того, что загружено в данный момент. modinfo выводит файл, из которого был загружен модуль, и параметры, которые он принимает. На виртуальном сервере большая часть путей к диску и сети реализована через модули, поэтому один образ ядра загружается на оборудовании, с которым он ранее не сталкивался. Ядро лишь сообщает о новом оборудовании, а демон в пространстве пользователя решает, какой модуль загрузить и как назвать устройство. Именно так управление устройствами перешло в систему инициализации, что отчасти объясняет, почему systemd стало сложно избежать.

Модули обеспечили такую гибкость без затрат, присущих архитектуре микроядра. Изоляция драйвера в отдельном процессе означает необходимость переключения контекста и передачи сообщений при каждом вызове, а в 1992 году эти затраты были значительными.

Затраты, которые сохранил Linux, — это то, что нужно учитывать при планировании: модуль работает с полными привилегиями ядра, поэтому неисправный модуль может вывести из строя всю машину, а не один процесс. Это становится проблемой при использовании модулей вне основного дерева исходного кода (out-of-tree). Драйвер от поставщика, который не входит в основную ветку, необходимо пересобирать для каждого нового ядра, что и делает DKMS во время обновления. Если такая сборка завершается неудачей, устройство просто пропадает после перезагрузки.

Почему внедрение SMP заняло пятнадцать лет

Linux 2.0 в июне 1996 года стал первым стабильным ядром с поддержкой симметричной многопроцессорности (SMP), что означает работу одного ядра на нескольких процессорах. Первая реализация использовала единственную блокировку — большую блокировку ядра (BKL), поэтому только один процессор мог выполнять код ядра в конкретный момент времени. Второй процессор помогал задачам, выполняющим вычисления в пространстве пользователя, но почти не ускорял работу с системными вызовами, так как они выстраивались в очередь за той же блокировкой.

На устранение этой блокировки ушло пятнадцать лет. Оставшиеся участки кода были переведены на мелкозернистую блокировку, в основном благодаря Арнду Бергманну, и BKL была удалена в версии 2.6.39, выпущенной 18 мая 2011 года. Планировщик развивался в том же медленном темпе: планировщик O(1) в 2.6.0, Completely Fair Scheduler (CFS) начиная с 2.6.23 в 2007 году и EEVDF, который заменил CFS в версии 6.6 в октябре 2023 года.

Благодаря этой работе конфигурация с 4 vCPU сегодня считается обычным делом. Это также указывает на ограничение, о котором стоит знать. На общем виртуальном сервере ваше ядро планирует ваши потоки, а гипервизор планирует ваше ядро. Запустите top и прочитайте поле %st. Steal time — это время процессора, которое ваше ядро было готово использовать, но хост отдал его другому гостю, поэтому никакая настройка внутри вашего ядра не поможет его вернуть.

Почему в серии 2.6 изменился порядок сборки ядра

До версии 2.6 номера версий шли парами. Четная вторая цифра означала стабильную серию (2.4), нечетная — экспериментальную (2.5). Версия 2.4 вышла 4 января 2001 года, а 2.6 — 17 декабря 2003 года, поэтому пользователям пришлось ждать следующую стабильную серию почти три года. Дистрибутивы не могли ждать, поэтому они использовали бэкпорты. Два разных поставщика, выпускавшие «2.4», поставляли ядра, которые различались тысячами патчей.

После 2.6 от этого разделения отказались. Сейчас в основной ветке (mainline) открывается окно слияния (merge window) примерно на две недели, принимаются новые изменения, затем выпускаются релиз-кандидаты до тех пор, пока разработка не затихает, и релиз выходит каждые 9–10 недель — этот цикл до сих пор документирован на kernel.org. Вторая часть модели появилась 4 марта 2005 года с первым релизом стабильной ветки (stable tree), которая представляла собой обновление с исправлениями для 2.6.11, поддерживаемое Грегом Кроа-Хартманом и Крисом Райтом. Стабильная ветка принимает только исправления и отклоняет новые функции.

Побочный эффект: номер версии перестал быть обещанием. Версии 3.0, 4.0, 5.0 и 7.0 не являются переписанными с нуля продуктами. Торвальдс увеличивает первую цифру, когда вторая становится достаточно большой, чтобы его это начало беспокоить, поэтому версия 7.0 последовала за 6.19 в апреле 2026 года. Для сервера важно то, какую ветку отслеживает ваш дистрибутив и получает ли эта ветка исправления.

Как разрыв с BitKeeper привел к созданию git в апреле 2005 года

Начиная с февраля 2002 года, разработка ядра велась в BitKeeper — проприетарной распределенной системе контроля версий от компании BitMover Ларри Маквоя, начиная с серии 2.5. Компания BitMover предоставила разработчикам ядра бесплатную лицензию с рядом условий: запрещалась работа над конкурирующими инструментами контроля версий и обратная разработка BitKeeper. Многим разработчикам не нравилось создавать свободное ядро с помощью инструмента, исходный код которого им запрещено изучать.

Ситуация изменилась в апреле 2005 года, после того как Эндрю Триджелл продемонстрировал программу, взаимодействующую с репозиториями BitKeeper. В BitMover назвали это обратной разработкой и отозвали бесплатную лицензию. Ядро осталось без системы контроля версий в середине цикла разработки.

Работа над git началась в апреле 2005 года. Торвальдс объявил о разрыве с BitKeeper 6 апреля. Уже 7 апреля git стал самодостаточным (self-hosting), что означает, что собственная история разработки git уже хранилась в самом git. Торвальдс объявил о первом успешном слиянии (merge) в git 17 апреля. В июне 2005 года git обеспечил выпуск версии 2.6.12. Вскоре после этого Торвальдс передал сопровождение проекта Джунио Хамано и вернулся к работе над ядром.

Архитектура системы стала прямым ответом на возникшую проблему: тысячи участников и сопровождающие, которые получают изменения друг от друга через сеть, которой никто не доверяет. Каждый объект именуется на основе хеша своего содержимого, поэтому изменение даже одного байта в старой истории меняет имя каждого последующего коммита. Именно поэтому клон репозитория является доказательством, а не просто заявлением. Каждый конвейер развертывания, каждый репозиторий конфигураций, хостинг кода, куда отправляют изменения большинство команд и git-сервер, который можно запустить самостоятельно — всё это выросло из лицензионного спора вокруг ядра.

Что обещает модель LTS, а чего она не обещает

Mainline — это не то, что вы используете в работе. Релиз mainline сменяется новым через 9–10 недель. Ветка stable получает исправления до выхода следующего релиза mainline, если только ветка не переведена в статус longterm. Ветки longterm, обычно обозначаемые как LTS, получают исправления годами, и именно на них опираются многие дистрибутивы.

Модель доказала свою эффективность на примере версии 2.6.32, выпущенной в декабре 2009 года. Она использовалась в RHEL 6, Debian 6, SUSE Linux Enterprise 11 SP1 и Ubuntu 10.04 LTS, а поддержка ветки продолжалась до марта 2016 года — более шести лет после её появления. Red Hat пошла еще дальше и самостоятельно сопровождала ядро на базе 2.6.32 через бэкпорты до тех пор, пока RHEL 6 не покинул фазу обслуживания в 2020 году; компания до сих пор продает отдельные исправления безопасности и критические патчи для RHEL 6 в рамках платной подписки Long-Life с ежегодным продлением до конца 2030 года. Воспроизведение этого десятилетнего цикла поддержки на бесплатной основе — главная причина, по которой существовал CentOS, а Rocky Linux и AlmaLinux пришли ему на смену.

Обещания относительно сроков менялись не раз. Сначала это были два года, затем для некоторых веток — шесть лет. В 2023 году мейнтейнеры stable сократили срок по умолчанию до двух лет, так как бэкпортирование в старые ветки требует много времени, а старые ветки почти не проходят реального тестирования. 25 февраля 2026 года Грег Кроа-Хартман (Greg Kroah-Hartman) снова опубликовал более долгосрочные прогнозы после обсуждения с компаниями, зависящими от этих веток, но новые ядра longterm обычно по-прежнему имеют прогнозируемый срок жизни в два года.

ГрафикLongterm kernels: years from release to projected end of life (kernel.org, October 2026)
Данные, на которых построен график
[
  {
    "kernel": "5.10",
    "released": "2020-12-13",
    "eol_projected": "Dec 2026",
    "maintained_for": 6.0
  },
  {
    "kernel": "5.15",
    "released": "2021-10-31",
    "eol_projected": "Dec 2026",
    "maintained_for": 5.1
  },
  {
    "kernel": "6.1",
    "released": "2022-12-11",
    "eol_projected": "Dec 2027",
    "maintained_for": 5.0
  },
  {
    "kernel": "6.6",
    "released": "2023-10-29",
    "eol_projected": "Dec 2027",
    "maintained_for": 4.2
  },
  {
    "kernel": "6.12",
    "released": "2024-11-17",
    "eol_projected": "Dec 2028",
    "maintained_for": 4.1
  },
  {
    "kernel": "6.18",
    "released": "2025-11-30",
    "eol_projected": "Dec 2028",
    "maintained_for": 3.1
  }
]

На сайте kernel.org по состоянию на октябрь 2026 года указано 6 веток longterm. Самая старая из них, 5.10, будет получать исправления в течение 6.0 лет, когда её поддержка завершится в Dec 2026. Самая новая, 6.18, согласно прогнозам, будет поддерживаться до Dec 2028, что составляет 3.1 лет исправлений.

Воспринимайте эти даты как прогнозы, а не как контракт. Прогнозы для 6.6 и 6.12 были сдвинуты в феврале 2026 года, а ветка, которой никто не пользуется, может быть закрыта раньше. Ваш дистрибутив обычно делает выбор за вас: Debian 13 поставляется с 6.12, а Ubuntu 26.04 LTS — с 7.0. Этот разрыв и есть практическая суть вопроса о выборе между LTS и промежуточным релизом на сервере, и именно это реально меняется «под капотом», когда вы обновляете Ubuntu 24.04 до 26.04.

Из этого вытекает одна ловушка. Команда uname -r в Ubuntu 24.04 выводит что-то вроде 6.8.0-51-generic. Это апстрим-база плюс собственные бэкпорты дистрибутива, поэтому число указывает лишь на то, откуда началась ветка, а не на то, какие именно исправления в ней есть. Сканеры, оценивающие ядро по строке версии, именно по этой причине выдают ложные срабатывания для дистрибутивных ядер.

О чем сейчас спорят в ядре

Актуальны два спора, и оба касаются того, кто должен выполнять работу.

Язык Rust стал частью инфраструктуры в версии 6.1 в декабре 2022 года. В версии 7.0 была снята пометка «экспериментальный», поэтому основными языками ядра теперь являются C, ассемблер и Rust. Сборка с использованием стабильного компилятора Rust поддерживалась еще в 6.1: его Makefile устанавливает RUSTC_BOOTSTRAP=1 для включения нестабильных функций в стабильных компиляторах. Спор идет о сопровождении. Мейнтейнер C, изменяющий интерфейс, может нарушить работу привязок Rust, которые он не читает, и спор заключается в том, чья это обязанность — исправлять их.

Второй спор касается вклада ИИ. Саша Левин предложил политику в июле 2025 года, после того как объем патчей, созданных с помощью машинных средств, достиг списков рассылки. Документ был зафиксирован 6 января 2026 года и теперь находится в собственной документации процесса ядра по адресу docs.kernel.org/process/coding-assistants.html. ИИ-агент не должен добавлять тег Signed-off-by, поскольку эта строка подтверждает сертификат разработчика (DCO), а подтвердить его может только человек. Текущая документация ядра больше не требует тега Assisted-by и вместо этого отсылает участников к руководству по контенту, созданному инструментами. От участников по-прежнему ожидается описание использования инструментов в сопроводительных письмах и журналах изменений. Сгенерированный код должен быть совместим с лицензией GPL-2.0-only. Человек, который отправляет патч, проверяет его и несет за него ответственность.

Давление, стоящее за этой политикой, связано со временем проверки. Генерация патча занимает секунды, а его проверка отнимает у мейнтейнера вторую половину дня. Тег не исправляет этот дисбаланс. Подтверждение человеком сохраняет происхождение: история продолжает фиксировать, кто подписался под каждым изменением, что является тем свойством, для защиты которого в 2004 году был введен DCO.

Что эта история означает для арендуемого вами сервера

  • Лицензия — это причина, по которой вы можете читать и пересобирать ядро, которое загружает ваш провайдер, и по которой на нем работает проприетарное ПО.
  • Монолитная архитектура — это причина, по которой одна ошибка в драйвере может привести к падению всей машины, и по которой модуль вне основного дерева исходного кода (out-of-tree) приходится пересобирать при каждом обновлении ядра.
  • Модель релизов — это причина, по которой номер версии дает мало информации, тогда как ветка и дата окончания ее поддержки (end-of-life) говорят почти обо всем.
  • Тип виртуализации определяет, что вам вообще позволено делать: в KVM вы загружаете собственное ядро и загружаете модули, тогда как при контейнерной виртуализации, использующей общее ядро хоста, uname -r показывает версию хоста, а разрешение на использование modprobe или изменение sysctl зависит от привилегий и конфигурации, предоставленных хостом.

FAQ

Почему ядро Linux до сих пор распространяется под лицензией GPLv2, а не GPLv3?

Линус Торвальдс отказался от перехода на GPLv3 в 2007 году, в основном из-за требования по борьбе с «тивоизацией» (anti-tivoisation). Это требование обязывает предоставлять инструкции по установке модифицированных версий кода для потребительских устройств, за исключением случаев, когда ни поставщик, ни третья сторона не могут установить измененный код (например, если он прошит в ROM). Торвальдс считает, что блокировка оборудования — это личное дело производителя. Кроме того, перелицензирование практически невозможно, так как авторские права на ядро принадлежат тысячам контрибьюторов, и не существует соглашения о передаче прав, на которое можно было бы опереться. Ядро распространяется строго под GPL-2.0-only, поэтому код, предлагаемый исключительно под GPLv3, не может быть включен в состав ядра.

Ядро Linux — это монолитное ядро или микроядро?

Монолитное, с поддержкой загружаемых модулей. Драйверы и файловые системы работают в адресном пространстве ядра, а команда lsmod позволяет увидеть те из них, что загружены в данный момент. Это дает преимущество в скорости, но увеличивает радиус поражения: неисправный модуль может вызвать kernel panic всей системы, тогда как в микроядре это привело бы лишь к завершению одного процесса. С 1992 года ситуация смягчилась благодаря файловым системам FUSE, работающим в пространстве пользователя, и программам eBPF, которые ядро проверяет перед выполнением.

В чем разница между mainline, stable и longterm ядрами?

Mainline — это основная ветка Торвальдса, новые версии которой выходят каждые 9–10 недель; именно здесь в первую очередь появляются новые функции. Ветка stable берет за основу релиз mainline и получает исправления ошибок до выхода следующего релиза mainline, если только эта ветка не переводится в статус longterm. Ветки longterm получают исправления в течение нескольких лет, и многие дистрибутивы строят свои ядра именно на их основе. На сайте kernel.org приведен список текущих веток longterm с указанием планируемой даты окончания поддержки для каждой из них.

Принимает ли ядро Linux код, написанный ИИ?

Да, в соответствии с политикой, принятой в январе 2026 года. Текущая документация ядра больше не требует наличия тега Assisted-by; от контрибьюторов ожидается разъяснение происхождения сгенерированного инструментами контента в сопроводительных письмах и журналах изменений. ИИ-агент не должен добавлять строку Signed-off-by, а сгенерированный код должен быть совместим с GPL-2.0-only. Человек, отправляющий патч, подписывает его (sign-off), что означает проверку кода и принятие ответственности за него в рамках Developer Certificate of Origin.

Какую версию ядра следует использовать на сервере?

Почти во всех случаях — ту, которую поддерживает ваш дистрибутив. Дистрибутивное ядро — это апстрим-ветка плюс бэкпортированные исправления и тестирование со стороны вендора; именно на него ориентируются образы вашего провайдера и условия технической поддержки. Собирайте более новое ядро из ветки mainline только в том случае, если вам нужен специфический драйвер или функция, и обязательно проверяйте дату окончания поддержки ветки, на которую вы переходите, прежде чем принимать решение.

Была ли эта статья полезной?