- PVSM.RU - https://www.pvsm.ru -
В этой статье разработаем драйвер сетевой карты Intel I210 под Linux.
Разрабатывать данный драйвер я решил в учебных целях, чтобы чуть глубже погрузиться в сетевой стек ядра Linux. Так что если будут замечания, то пишите в комментариях.
В качестве подопытного сетевого устройства я выбрал гигабитный сетевой контроллер Intel I210 с интерфейсом PCI Express (PCIe). Выбор пал именно на Intel I210 по причине его доступности и открытой документации [1].
Рассмотрим архитектуру Intel I210, разберём теорию по MAC, PHY, DMA и PCI. Поймём как устроен механизм обнаружения PCI устройства в Linux, доступ к аппаратным регистрам через MMIO. После этого перейдём к передаче и приёму Ethernet пакетов. Рассмотрим sk_buff, DMA API ядра Linux, TX/RX дескрипторы и очереди. Разберём аппаратные прерывания, MSI/MSI‑X, интеграцию NAPI с обработкой пакетов.
6. Передача и приём данных [37]
8. Вывод [52]
В ядре Linux уже есть драйвер igb, поддерживающий Intel I210. Его код можно найти в исходниках Linux [53]. Повторюсь, что моя цель всё‑таки больше учебная, хочется написать базовый функционал драйвера, разобраться во взаимодействии сетевого контроллера с ядром Linux, а не полностью повторить имеющийся драйвер от Intel.
Параметры системы на которой я буду запускать драйвер:
~ > cat /etc/os-release
PRETTY_NAME="Ubuntu 24.04 LTS"
NAME="Ubuntu"
VERSION_ID="24.04"
VERSION="24.04 LTS (Noble Numbat)"
~ > uname -r
7.0.0-34-generic
~ > gcc --version
gcc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0
Если кратко, то MAC(Medium Access Control) обрабатывает Ethernet фреймы, а PHY(Physical Layer Transceiver) отвечает за передачу и приём сигналов на физическом уровне Ethernet.
MAC(Medium Access Control) — подуровень канального уровня, который отвечает за управление доступом к физической среде передачи данных и доставку Ethernet кадров узлу назначения в соответствии с его MAC адресом без гарантий доставки данных. PHY(Physical layer) — самый нижний уровень модели OSI, его главная задача — перевод цифровых данных в аналоговые сигналы среды передачи, и наоборот.
Аппаратный MAC реализует часть функций канального уровня Ethernet. Драйвер Linux обеспечивает взаимодействие аппаратуры с сетевым стеком, то есть драйвер настраивает контроллер, организует передачу и приём пакетов, управляет очередями и обрабатывает события от устройства.
MAC и PHY могут быть реализованы в отдельных микросхемах или интегрированы в один контроллер. Для обмена данными между отдельными MAC и PHY используются цифровые интерфейсы, например MII, RMII, GMII, RGMII или SGMII. Конкретный интерфейс зависит от архитектуры устройства и требуемой скорости. В Intel I210 MAC и PHY/PCS взаимодействуют через внутренний интерфейс GMII/MII. Для гигабитного режима используется GMII.

Сетевая модель IEEE 802.3 Источник [55] PCS(Physical Coding Sublayer) — подуровень физического кодирования данных, преобразующего поступающие от уровня MAC байты в символы логического кода, например 4B/5B или 64B/66B. PMA(Physical Media Attachment) — подуровень, который соединяет интерфейс, зависящий от физической среды (MDI), с подуровнем физического кодирования (PCS). PMD(Physical Medium Dependent) — которые обеспечивают формирование сигналов в соответствии с методом физического кодирования.
DMA(Direct Memory Access) — это механизм, позволяющий устройству читать данные из оперативной памяти и записывать их туда без того, чтобы CPU вручную копировал каждый байт между устройством и памятью.
В Intel I210 DMA организован через очереди передачи TX(Transmit) и приёма RX(Receive). Каждая очередь использует кольцо дескрипторов — массив дескрипторов, доступный контроллеру через DMA. Дескриптор содержит DMA адрес, длину и управляющие поля. При TX контроллер читает из памяти дескрипторы и буферы отправляемых пакетов. При RX контроллер записывает полученные данные в буферы, заранее подготовленные драйвером.
PCI(Peripheral Component Interconnect) — это периферийный интерфейс через который сетевуха Intel I210 будет взаимодействовать с системой. Intel I210 поддерживает PCIe 2.1 с одной линией передачи (x1). PCI состоит из линий передачи данных, каждая линия использует отдельные дифференциальные пары для передачи и приёма, поэтому обмен может идти одновременно в обоих направлениях.
При инициализации PCI устройства, ядро Linux обнаруживает контроллер, читает его идентификаторы и выделенные ресурсы. Драйвер получает доступ к регистрам через MMIO (Memory‑Mapped I/O — ввод‑вывод с отображением на память).
Общая схема передачи и приёма данных для Intel I210 на уровнях L1 и L2 описана в документации в этих разделах: 1.8.1 Transmit Data Flow и 1.8.2 Receive Data Flow
А вообще, в данном разделе хотел бы описать передачу пакета из простарнства пользователя до сетевой карты, чтобы сложилось общее представление какой путь проходит сетевой пакет прежде чем попадёт на уровень драйвера устройства.
Рассмотрим передачу данных через UDP‑сокет с помощью sendto(). В примере ниже предполагается, что сокет предварительно связан с адресом назначения через connect(), поэтому адрес в sendto() не передаётся:
sendto(sockfd, buf, len, flags, NULL, 0);
После вызова sendto() управление переходит из пространства пользователя в ядро. Данные копируются из пользовательского буфера в память ядра и передаются обработчику соответствующего протокола.
В зависимости от типа сокета ядро вызывает соответствующую функцию обработки:
udp_sendmsg() — для UDP
tcp_sendmsg() — для TCP
В обоих случаях данные из пользовательского буфера копируются в память ядра и представляются с помощью struct sk_buff, которая используется сетевым стеком для хранения данных пакета и связанных с ним метаданных. При этом конкретный способ подготовки sk_buff зависит от протокола.
Для UDP формируется UDP‑заголовок, содержащий порты отправителя и получателя, длину и контрольную сумму. Как правило, одна отправка UDP‑сообщения соответствует одной UDP‑дейтаграмме. Подготовленный пакет передаётся на IP‑уровень.
Для TCP обработка сложнее: данные помещаются в очередь отправки сокета, после чего TCP определяет момент передачи, формирует сегменты и добавляет необходимые заголовки. TCP может объединять данные нескольких вызовов send() или разбивать поток на несколько сегментов, поэтому нельзя считать, что один вызов send() обязательно соответствует одному sk_buff.
На сетевом уровне ядро формирует IP заголовок и определяет маршрут передачи пакета.
Для TCP одним из этапов передачи является вызов ip_queue_xmit(). Эта функция выполняет поиск маршрута и подготавливает пакет к передаче на IP‑уровень, включая формирование IP‑заголовка. Далее пакет проходит через функции IP‑уровня, в том числе ip_output().
Для UDP используется другой путь отправки: udp_sendmsg() подготавливает UDP‑дейтаграмму и передаёт её в IP‑уровень через UDP/IP‑функции отправки. Поэтому ip_queue_xmit() не следует считать общей функцией для TCP и UDP.
На выходе IP‑уровня пакет проходит через соответствующие хуки Netfilter. Например, могут применяться правила фильтрации или NAT. Конкретное расположение хуков зависит от этапа обработки: для локально сформированного пакета важны, в частности, LOCAL_OUT и POST_ROUTING.
После определения маршрута необходимо подготовить Ethernet кадр.
Ядро определяет MAC адрес следующего узла через таблицу соседей (neighbour table). Если адрес неизвестен, для IPv4 может потребоваться ARP‑запрос.
Затем формируется Ethernet заголовок с MAC адресами отправителя и получателя.
После этого пакет передаётся функции dev_queue_xmit(), которая запускает его передачу через выбранный сетевой интерфейс.
Внутри dev_queue_xmit() пакет проходит через механизм управления трафиком (Traffic Control, TC), включая egress обработку и соответствующую очередь qdisc.
На этапе передачи (egress) пакет может ожидать в очереди, например, если сетевой интерфейс временно не готов принять новые данные от вышележащего уровня. Когда приходит время передачи, ядро вызывает метод ndo_start_xmit() из структуры net_device_ops.
В нашем драйвере этот метод будет связан с функцией i210_xmit():
static const struct net_device_ops i210_netdev_ops = {
.ndo_open = i210_open,
.ndo_stop = i210_close,
.ndo_start_xmit = i210_xmit,
};
В i210_xmit() передаётся указатель на структуру sk_buff, содержащую данные пакета и необходимые метаданные.
Драйвер подготавливает TX дескриптор, отображает буфер с данными в DMA адресное пространство и помещает дескриптор в TX кольцевой буфер. Сетевая карта получает информацию о новых дескрипторах и самостоятельно считывает данные из оперативной памяти с помощью DMA.
Чуть далее на практике разберём работу i210_xmit().
Сетевой стек Linux отвечает за подготовку и маршрутизацию пакета, а драйвера за передачу данных в сеть.
Нужно разобраться как Linux обнаруживает PCI устройства, идентифицирует их и предоставляет драйверу доступ к аппаратным ресурсам.
Каждое PCI устройство имеет адрес, состоящий из четырёх частей: домена, шины, устройства и функции.
Если выполнить lspci -nn, то для Intel I210 можно увидеть примерно такой вывод:
02:00.0 Ethernet controller [0200]: Intel Corporation I210 Gigabit Network Connection [8086:1533] (rev 03)
02:00.0 — адрес устройства, оно находится на шине 02, устройство номер 00 и функция 0. 8086 — Vendor ID, 16 битный идентификатор производителя Intel. 1533 — Device ID, 16 битный идентификатор конкретного устройства. [0200] — Class Code в сокращённом представлении lspci: класс 02 обозначает сетевой контроллер, а подкласс 00 это Ethernet контроллер. rev 03 — идентификатор аппаратной ревизии устройства.
Vendor ID и Device ID используются для идентификации устройства, а Class Code позволяет определить его функциональную категорию, например, два Ethernet устройства могут иметь одинаковый Class Code, но разные Vendor ID и Device ID.
Одна шина может содержать до 32 устройств, а каждое устройство может иметь до восьми функций с номерами от 0 до 7.
PCI функция представляет собой отдельный логический интерфейс устройства с собственным конфигурационным пространством и идентификаторами. Одно физическое PCI устройство может включать несколько функций, каждая из которых предоставляет определённый набор возможностей и может обслуживаться отдельным драйвером. Например, одна PCI карта может содержать сетевой контроллер и UART контроллер, для которых будут использоваться разные драйверы.
Каждое PCI устройство имеет конфигурационное пространство, в котором хранятся его идентификаторы, сведения о возможностях и параметры ресурсов. В начале расположены стандартные поля, включая Vendor ID, Device ID, Class Code и BAR(0×10-0×24).
При запуске системы, Linux исследует доступные PCI шины и обнаруживает подключённые устройства. Для проверки адресов выполняются операции чтения конфигурационного пространства.
Когда устройство обнаружено, ядро получает его Vendor ID, Device ID, Class Code и другие параметры. Оно также определяет требуемые устройству ресурсы. На этапе начальной настройки BAR регистры(подробнее в даташите 9.3.11 Base Address Registers) используются для определения типа и размера ресурсов, после чего адресные диапазоны распределяются с учётом возможностей платформы.
После обнаружения ядро создаёт объекты PCI устройств и сохраняет сведения об их идентификаторах и ресурсах. Затем подсистема PCI сопоставляет обнаруженные устройства с таблицами идентификаторов зарегистрированных драйверов. Если драйвер подходит, ядро вызывает его функцию probe(). К моменту вызова probe() подсистема PCI уже обнаружила устройство и знает описание PCI ресурсов этого устройства.
PCI драйвер не ищет устройство на PCI шине самостоятельно. Он получает от ядра описание уже обнаруженной PCI функции и подготавливает её к работе.
Для регистрации PCI драйвера мы будем записывать Vendor ID и Device ID в struct pci_device_id. В ней перечисляются идентификаторы, по которым ядро может сопоставить обнаруженное устройство с драйвером.
Когда драйвер регистрируется в ядре, подсистема PCI сопоставляет его таблицу с уже обнаруженными устройствами. Если находится подходящее совпадение, ядро вызывает probe().
BAR(Base Address Register) — это регистр конфигурационного пространства PCI, с помощью которого устройство описывает предоставляемый системе ресурс, например, область памяти, доступную через MMIO(Memory‑Mapped I/O). BAR не содержит сами регистры управления и не является указателем на них. Он описывает ресурс, который подсистема PCI распределяет в адресном пространстве системы. BAR — регистр конфигурационного пространства, описывающий ресурс устройства. MMIO область — адресный диапазон, через который CPU может обращаться к регистрам устройства. Отображение MMIO — получение драйвером подходящего адреса в виртуальном адресном пространстве ядра, через который выполняется доступ к регистрам.
Для лучшего понимания, вот такой примерный алгоритм будет у нас при работе с ресурсами PCI устройства:
Включить PCI устройство с помощью pci_enable_device().
Запросить необходимые PCI ресурсы через pci_request_selected_regions().
Отобразить область MMIO с помощью pci_iomap().
Будем использовать readl() и writel() для доступа к памяти устройства, а для доступа к конфигурационному пространству будем использовать pci_read_config_word()
После настройки кольцевых TX и RX очередей необходимо организовать механизм, с помощью которого процессор будет узнавать о событиях сетевого контроллера. Например, о поступлении новых пакетов или завершении передачи.
Для этого сетевые контроллеры могут использовать аппаратные прерывания. Однако обработка каждого пакета непосредственно в обработчике прерывания негативно сказывается на производительности при большом трафике. В Linux для решения этой проблемы используется NAPI (New API).
Рассмотрим три подхода: обработку через прерывания, polling и гибридный механизм NAPI.
В классической interrupt‑driven модели сетевая карта генерирует аппаратное прерывание при поступлении пакета или другом событии. Процессор приостанавливает выполнение текущего кода и вызывает зарегистрированный обработчик прерывания (ISR).
В Linux обработка пакета не обязательно выполнялась целиком непосредственно в IRQ контексте. Обработчик обычно подтверждал/определял причину прерывания и передавал дальнейшую работу отложенному механизму, например, bottom half, tasklet или сетевой softirq. Однако при традиционной схеме уведомление о поступлении каждого пакета могло приводить к отдельному аппаратному прерыванию, а значит, к большому количеству входов в обработчик.
При высокой скорости поступления пакетов процессор тратит значительное время на обслуживание прерываний и переключение контекстов. Даже если фактическая обработка выполняется позже в softirq, большое количество IRQ создаёт дополнительную нагрузку. В результате часть ресурсов CPU расходуется не на обработку полезных данных, а на обслуживание самих уведомлений.
Возникает задача уменьшить количество аппаратных прерываний и при этом не заставлять процессор постоянно опрашивать устройство.
NAPI (New API) — механизм Linux для обработки сетевых пакетов, который сочетает аппаратные прерывания с polling. Прерывание сообщает процессору о появлении работы, после чего драйвер временно маскирует соответствующий источник прерываний и планирует NAPI. Дальнейшая обработка выполняется опросом RX кольца, обычно сразу для нескольких готовых дескрипторов.
Ключевая идея NAPI — не вызывать полноценную обработку сетевого пакета для каждого аппаратного прерывания. Одно прерывание запускает цикл обработки, в рамках которого драйвер может забрать несколько пакетов за один проход. Это уменьшает частоту IRQ при высокой нагрузке.
Упрощённо последовательность выглядит примерно так:
Сетевая карта записывает принятый пакет в RX DMA буфер и обновляет статус дескриптора.
Контроллер генерирует прерывание.
Обработчик прерывания определяет причину события, маскирует соответствующий источник прерываний и планирует NAPI.
Ядро вызывает NAPI callback драйвера.
Драйвер проверяет RX дескрипторы и обрабатывает готовые пакеты. За один проход разрешено обработать не более budget(будем его задавать далее) пакетов.
Если за проход обработано меньше budget пакетов, драйвер завершает NAPI и снова разрешает прерывания.
Если достигнут budget, обработка продолжается следующим проходом polling без повторного включения прерываний.
Т.е. при небольшой нагрузке интерфейс быстро реагирует на прерывания, а при высокой нагрузке NAPI позволяет обработать сразу несколько пакетов за один проход, уменьшая количество аппаратных прерываний.
Важно, что NAPI не означает постоянный бесконечный опрос RX кольца. Опрос запускается после прерывания и продолжается, пока есть работа или пока не исчерпан выделенный бюджет.
В классической модели каждый принятый пакет мог вызывать отдельное аппаратное прерывание. Обработчик прерывания выполнял минимальную работу и, как правило, передавал обработку пакета в отложенный контекст, например, в сетевой softirq. При большом потоке пакетов CPU получал множество отдельных уведомлений, даже если обработка самих пакетов уже выполнялась вне hard IRQ.
NAPI меняет именно модель уведомления и последующего получения пакетов:
До NAPI: поступление пакета обычно приводило к аппаратному прерыванию; обработчик подтверждал событие и инициировал отложенную обработку. При интенсивном трафике число прерываний могло быть очень большим.
С NAPI: первое прерывание запускает polling и маскирует соответствующий источник IRQ. Драйвер последовательно проверяет RX дескрипторы и обрабатывает несколько готовых пакетов за один проход. Пока NAPI запланирован, новые пакеты обычно обнаруживаются polling‑ом, а не отдельными прерываниями на каждый пакет.
Когда очередь опустела: драйвер завершает NAPI и снова разрешает прерывания. Следующее поступление пакетов снова может вызвать IRQ и запустить новый цикл.
Обработка в NAPI выполняется в контексте сетевого softirq (обычно NET_RX_SOFTIRQ), а не внутри hard IRQ handler. Это позволяет ограничивать объём работы за один проход с помощью budget и возвращать управление планировщику, если очередь остаётся загруженной. При этом NAPI не отменяет аппаратные прерывания полностью — они используются для перехода от ожидания к polling.
Таким образом, главное отличие NAPI — это пакетная обработка и временное подавление повторных прерываний на время опроса очереди, а не просто перенос обработки из обработчика прерывания в softirq.
Ещё один подход — это постоянный опрос RX кольца (polling). В этом случае процессор циклически проверяет статусы дескрипторов и обрабатывает появившиеся пакеты, не ожидая аппаратного прерывания.
Преимущество такого подхода — минимальная задержка между появлением пакета в памяти и началом его обработки. Процессору не требуется ждать прерывание и переключаться в обработчик.
Недостаток — процессорное ядро постоянно занято проверкой очереди, даже когда новых пакетов нет. Это приводит к повышенной загрузке CPU и энергопотреблению. Поэтому такой вариант имеет смысл, когда важна минимальная задержка и можно выделить отдельное процессорное ядро под обработку сетевого трафика.
Нужно различать обычный polling внутри драйвера, механизм NAPI и busy polling Linux. В Linux существуют механизмы busy polling, позволяющие приложению или сетевому стеку инициировать опрос NAPI для уменьшения задержки. Отдельный вариант — это пользовательские сетевые фреймворки, например DPDK, где приложение может самостоятельно опрашивать RX очереди, обходя обычный путь обработки пакетов через сетевой стек Linux.
В нашем драйвере будет использоваться NAPI совместно с MSI. При выделении вектора вызывается pci_alloc_irq_vectors() с флагом PCI_IRQ_MSI и минимальным/максимальным количеством векторов, равным одному. То есть в текущей реализации используется один MSI‑вектор, а не MSI‑X.
После регистрации обработчика через request_irq() и включения NAPI контроллер может генерировать прерывания при событиях RX/TX очереди. Обработчик i210_interrupt() не должен выполнять полноценную обработку пакетов. Его задача — определить причину прерывания, временно замаскировать соответствующий источник и запланировать NAPI через napi_schedule().
Далее ядро вызывает функцию i210_clean(). В ней выполняется обработка RX дескрипторов через i210_clean_rx() и очистка завершённых TX дескрипторов через i210_clean_tx(). Для RX используется budget, ограничивающий количество пакетов за один проход.
Когда RX пакетов для обработки больше нет и work_done меньше budget, драйвер завершает NAPI с помощью napi_complete_done() и снова разрешает прерывания очереди через регистр EIMS. Если же budget исчерпан, NAPI остаётся запланированным, и ядро продолжает polling.
Аппаратное прерывание используется как сигнал о появлении работы, а непосредственная обработка RX/TX дескрипторов выполняется в NAPI callback. Это позволяет избежать обработки каждого пакета в контексте аппаратного прерывания и уменьшить нагрузку на CPU при интенсивном сетевом трафике.
В текущем варианте RX и TX обслуживаются одним NAPI callback, но это не означает, что завершение TX автоматически вызовет NAPI. Нужно проверить, что источник прерывания TX действительно разрешён и отображён на используемый вектор, либо что очистка TX гарантированно запускается другим событием. В противном случае завершённые TX дескрипторы могут оставаться неочищенными, а очередь передачи не возобновляться после остановки.
Напишим probe() с регистрацией pci драйвера, отобразим область MIMO, прочитаем MAC адрес из сетевой карточки и выполним регистрацию сетевого интерфейса через net_device. Реализуем приём и передачу данных.
Для работы с PCI подсистемой Linux нужно описать в драйвере структуру struct pci_driver [59]. У меня она выглядит вот так:
static struct pci_driver i210_driver = {
.name = DRV_NAME,
.id_table = i210_pci_tbl,
.probe = i210_probe,
.remove = i210_remove,
.shutdown = i210_shutdown,
};
Подробно описывать каждое поле сейчас не буду, остановлюсь только на .id_tabel, это поле содержит указатель на таблицу PCI устройств, поддерживаемые нашим драйвером. Драйвер пишем для одного конкретного устройства с PCI ID 8086:1533, поэтому struct pci_device_id у меня выглядит так(Vendor ID и Device ID берём из даташита):
static const struct pci_device_id i210_pci_tbl[] = {
{
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x1533),
},
{ 0, }
};
MODULE_DEVICE_TABLE(pci, i210_pci_tbl);
Когда драйвер регистрируется в ядре, PCI подсистема сопоставляет его таблицу с уже обнаруженными устройствами. Если подходящее устройство найдено, ядро вызывает нашу i210_probe(). Для регистрации драйвера в подсистеме PCI используем pci_register_driver() с указателем на экземпляр struct pci_driver. Функция i210_init будет выполняться при загрузке модуля, а при выгрузке моделя будет выполняться функция i210_exit.
static int __init i210_init(void)
{
pr_info(DRV_NAME ": init()n");
return pci_register_driver(&i210_driver);
}
static void __exit i210_exit(void)
{
pr_info(DRV_NAME ": exit()n");
pci_unregister_driver(&i210_driver);
}
module_init(i210_init);
module_exit(i210_exit);
В функции probe нам нужно будет выполнить подготовку ресурсов устройства и зарегистрировать сетевой интерфейс. Настройку передачи и приёма будем выполнять позже при открытии интерфейса.
Для доступа к регистрам Intel I210 используем MMIO, выбираем BAR и включаем устройство. После включения резервируем нужный PCI ресурс при помощи pci_request_selected_regions(). Выполнять резервирование необходимо, чтобы область ресурсов не использовалась одновременно несколькими драйверами.
//Выбираем BAR содержащие ресурсы памяти
bars = pci_select_bars(pdev, IORESOURCE_MEM);
if (!bars)
return -ENODEV;
//Включаем устройство
err = pci_enable_device_mem(pdev);
if (err)
return err;
//Резервируем в экслюзивное владение память, запрошенную из BAR
err = pci_request_selected_regions(pdev, bars, DRV_NAME);
if (err)
goto err_disable_device;
Для работы с DMA нужно выполнить:
pci_set_master(pdev);
Это разрешает устройству выступать инициатором транзакций PCI и обращаться к оперативной памяти через DMA.
Память запросили, теперь можно её отобразить на пространство памяти, доступное драйверу. Вот такая сигнатура у функции pci_iomap: void __iomem pci_iomap(struct pci_dev dev, int bar, unsigned long maxlen). Второй аргумент 0 это номер BAR, а последний аргумент 0 означает, что мы отображаем весь ресурс.
//Снаружи probe() объвил структуру через которую буду выполнять доступ к памяти PCI устройства
struct i210_hw {
void __iomem *hw_addr; //Адрес области MMIO в виртуальном адресном пространстве
void __iomem *flash_address;
};
adapter->hw.hw_addr = pci_iomap(pdev, 0, 0);
if (!adapter->hw.hw_addr) {
err = -EIO;
goto err_free_netdev;
}
Вот так будет выглядеть чтение регистра STATUS(смещение 0×8, Table 8–6. Register Summary):
u32 status;
status = readl(adapter->hw.hw_addr + 0x8);
pr_info(DRV_NAME ": STATUS = 0x%08xn", status);
Чтение MMIO и чтение PCI Configuration Space(Table 9–2. PCIe Configuration Registers Map) отличаются. Для PCI Configuration Space предусмотрены отдельные функции, например pci_read_config_word().
Это пример чтения Vendor ID и Device ID из PCI Configuration Space:
pci_read_config_word(pdev, 0x00, &vendor_id);
pci_read_config_word(pdev, 0x02, &device_id);
pr_info(DRV_NAME ": PCI Vendor ID = 0x%04xn", vendor_id);
pr_info(DRV_NAME ": PCI Device ID = 0x%04xn", device_id);
Пример чтения MAC адреса из iNVM — Integrated Non‑Volatile Memory (iNVM), описание регистров из раздела Flash‑Security Registers таблицы 8–6. Register Summary. Релизация вычитывания одного слова:
static int i210_read_nvm_word(struct i210_adapter *adapter,
u16 offset, u16 *data)
{
u32 value;
int timeout = 1000;
/* Сигнализируем о начале чтения NVM */
value = EERD_START | ((u32)offset << EERD_ADDR_SHIFT);
writel(value, adapter->hw.hw_addr + I210_EERD);
do {
value = readl(adapter->hw.hw_addr + I210_EERD);
if (value & EERD_DONE) {
*data = (u16)(value >> EERD_DATA_SHIFT);
return 0;
}
udelay(1);
} while (--timeout);
pr_err(DRV_NAME ": NVM read timeout, offset=0x%04xn", offset);
return -ETIMEDOUT;
}
Функция i210_read_nvm_word принимает смещение(offset — это адрес слова в NVM) и указатель, куда нужно записать результат.
Первые три слова NVM содержат шесть байтов MAC адреса(3.4.2 iNVM Structures):
u16 nvm_word[3];
u8 mac[6];
for (i = 0; i < 3; i++) {
err = i210_read_nvm_word(adapter, i, &nvm_word[i]);
if (err)
return err;
pr_info(DRV_NAME ": NVM word[0x%02x] = 0x%04xn", i, nvm_word[i]);
}
mac[0] = nvm_word[0] & 0xff;
mac[1] = nvm_word[0] >> 8;
mac[2] = nvm_word[1] & 0xff;
mac[3] = nvm_word[1] >> 8;
mac[4] = nvm_word[2] & 0xff;
mac[5] = nvm_word[2] >> 8;
/* Установили MAC адрес для устройства из net_device */
eth_hw_addr_set(netdev, mac);
pr_info(DRV_NAME ": MAC address %pMn", netdev->dev_addr);
PCI драйвер обеспечивает взаимодействие с шиной и аппаратными ресурсами устройства, но для подключения сетевого контроллера к сетевому стеку Linux нужна структура net_device:
struct net_device *netdev;
netdev = alloc_etherdev(sizeof(struct i210_adapter));
if (!netdev) {
err = -ENOMEM;
goto err_release_regions;
}
alloc_etherdev() выделяет структуру net_device и дополнительную приватную область памяти, размер которой задаётся аргументом функции. Драйвер использует эту область для хранения собственных данных, например структуры адаптера. Сама net_device содержит параметры сетевого интерфейса и ссылки на его операции; связь с PCI устройством и отображёнными регистрами драйвер организует в своих структурах.
После настройки netdev нужно сохранить:
pci_set_drvdata(pdev, netdev);
Настройка операций сетевого интерфейса:
static const struct net_device_ops i210_netdev_ops = {
.ndo_open = i210_open,
.ndo_stop = i210_close,
.ndo_start_xmit = i210_xmit,
};
i210_open — открытие сетевого интерфейса, например команда ip link set eth0 up i210_close — остановка сетевого интерфейса, например команда ip link set eth0 down i210_xmit — передача данных
После настройки операций сетевого интерфейса и NAPI вызывается:
err = register_netdev(netdev);
if (err)
goto err_napi;
register_netdev() регистрирует сетевой интерфейс в ядре. После успешной регистрации он становится виден в юзерспейсе.
Более подробно по регистру CTRL можно посмотреть в документации — 8.2.1 Device Control Register - CTRL
Для доступа к регистрам PHY используется регистр MAC MDIC. Драйвер записывает команду чтения или записи, затем ожидает завершения операции и проверяет наличие ошибки.
Сброс и базовую настройку будем выполнять в i210_open() внутри i210_reset_hw(). Перед настройкой контроллера необходимо выполниться сброс, чтобы вывести устройство из режима сна или энергосбережения, для этого будем использовать регистр CTRL.
Читаем текущее значение CTRL, затем устанавливается бит RST:
ctrl = readl(hw + I210_CTRL);
ctrl |= I210_CTRL_RST;
writel(ctrl, hw + I210_CTRL);
После установки RST бита контроллер выполняет программный сброс. Согласно документации Intel I210, драйвер должен подождать не менее 3 мс, прежде чем обращаться к регистрам устройства после сброса(Раздел 4.3.1 Software Reset (RST)). Затем необходимо убедиться, что завершился сброс и автоматическая загрузка конфигурации из NVM.
msleep(3);
status = readl(hw + I210_STATUS);
if (!(status & I210_STATUS_PF_RST_DONE)) //Проверка завершён ли сброс
return -ETIMEDOUT;
eec = readl(hw + I210_EEC);
if (!(eec & I210_EEC_AUTO_RD)) //Проверка завершено ли чтение NVM
return -EIO;
Перед включением приёма пакетов необходимо настроить MAC фильтр, чтобы контроллер мог отбрасывать пакеты, не предназначенные этому устройству.
Выполняем запись MAC адреса в RAL0 и RAH0 внутри функции i210_set_mac_address:
writel(ral, hw + I210_RAL0);
writel(rah | I210_RAH_AV, hw + I210_RAH0);
RAL0 содержит первые четыре байта адреса, а RAH0 оставшиеся два байта и бит AV, который указываюет, что запись адреса действительна.
Вся инициализация PHY вынесена в отдельную функцию i210_init_phy
Сначала устанавливается бит SLU в регистре CTRL, чтобы MAC уровень не игнорировал сигнлаы линка от PHY.
ctrl = readl(adapter->hw.hw_addr + I210_CTRL);
ctrl |= I210_CTRL_SLU;
writel(ctrl, adapter->hw.hw_addr + I210_CTRL);
После чего драйвер читает управляющий регистр PHY через функцию i210_read_phy_reg и сбрасывает биты POWER DOWN и ISOLATE внутри функции i210_phy_power_up, если они установлены.
ctrl &= ~BIT(11); /* POWER DOWN */
ctrl &= ~BIT(10); /* ISOLATE */
Функция i210_phy_start_autoneg устанавливает увтосогласование скорости, устройства в сети сами будут согласовывать скорость обмена данными.
Перед настройкой буферов RX и TX для лучшего понимания можно почитать про кольцевые очереди — https://stackoverflow.com/questions/36625892/descriptor‑concept‑in‑nic [60]
Перед тем как выделять ресурсы под TX буферы, нужно выполнить настройку передачи, это выполняется внутри функции i210_configure_tx_buffer:
writel(I210_TXPBSIZE_DEFAULT, hw + I210_TXPBS);
writel(I210_DTXMXPKTSZ_DEFAULT, hw + I210_DTXMXPKTSZ);
Регистр TXPBSIZE — 8.3.2 TX Packet Buffer Size — TXPBSIZE Регистр DTXMXPKTSZ — 8.12.9 DMA TX Maximum Packet Size
TXPBSIZE — распределение памяти для хранения передаваемых пакетов, я присваиваю туда значение 0x04000014 — это значение по умолчанию, не стал эксперементировать, оставил как в документации. На выходе получаем, что размер Txpb0size равен 20KB, а размер os2Bmcpbsize 4KB — буфер передачи данных от операционной системы
DTXMXPKTSZ задаёт максимальный размер передаваемого пакета. Значение 0x98 (152) соответствует 152 единицам по 64 байта, то есть 9728 байтам. Однако одной этой настройки недостаточно, чтобы говорить о полноценной поддержке Jumbo Frames всем драйвером. В текущей реализации RX буферы имеют размер 2048 байт, обработка пакетов, распределённых между несколькими RX дескрипторами, не реализована, а MTU интерфейса отдельно не настраивается. Поэтому в текущем варианте поддержку Jumbo Frames считать реализованной нельзя.
Внутри функции i210_setup_tx_resources выделяется память под TX кольцо из 64 дескрипторов с помощью функции dma_alloc_coherent. Также выделяется массив buffer_info для хранения программной информации о передаваемых пакетах.
Массив buffer_info содержит информацию о каждом передаваемом пакете: указатель на sk_buff, DMA адрес буфера и его длину. Массив buffer_info используется только драйвером, а кольцо дескрипторов будет доступно аппаратуре.
По аналогии с TX, в функции i210_setup_rx_resources задаём количество дескрипторов и вычисляем размер кольца:
rx_ring->count = I210_RX_DESC_COUNT;
rx_ring->size = rx_ring->count * sizeof(struct i210_rx_desc);
Далее выделяется массив buffer_info и память для самого кольца дескрипторов через dma_alloc_coherent():
rx_ring->buffer_info = kcalloc(
rx_ring->count,
sizeof(*rx_ring->buffer_info),
GFP_KERNEL
);
rx_ring->desc = dma_alloc_coherent(
&pdev->dev,
rx_ring->size,
&rx_ring->dma,
GFP_KERNEL
);
После этого последовательно выделяем 64 сетевых буфера по 2048 байта:
skb = netdev_alloc_skb(adapter->netdev, I210_RX_BUFFER_SIZE);
После выделения памяти каждый буфер отображается для DMA:
dma = dma_map_single(
&pdev->dev,
skb->data,
I210_RX_BUFFER_SIZE,
DMA_FROM_DEVICE
);
После выделения памяти для RX буфров вызывается функцияi210_configure_rx_ring в которой необходимо сообщить контроллеру, где находится RX кольцо и сколько дескрипторов в нём доступно. Для этого используются регистры: RDBAL — младшие 32 бита DMA адреса RX кольца RDBAH — старшие 32 бита DMA адреса RDLEN — размер кольца в байтах RDH — индекс головного дескриптора RDT — индекс последнего доступного дескриптора RXDCTL — управление RX очередью
Сначала записываем адрес и размер кольца:
writel(lower_32_bits(rx_ring->dma), hw + I210_RDBAL(0));
writel(upper_32_bits(rx_ring->dma), hw + I210_RDBAH(0));
writel(rx_ring->size, hw + I210_RDLEN(0));
Настраивается регистр SRRCTL — 8.10.2 Split and Replication Receive Control — SRRCTL:
writel(0, hw + I210_SRRCTL(0));
Затем устанавливаем начальные значения индексов. Поскольку перед этим драйвер подготовил все дескрипторы RX кольца, в RDT нужно передать индекс последнего подготовленного дескриптора:
writel(0, hw + I210_RDH(0));
writel(rx_ring->count - 1, hw + I210_RDT(0));
RDH указывает на текущую позицию, с которой контроллер начинает обработку RX кольца, а RDT задаёт границу дескрипторов, доступных контроллеру. Если записать в RDT ноль, когда подготовлено всё кольцо, контроллеру не будут доступны все подготовленные дескрипторы.
Используем нулевое значение SRRCTL, это означает, что размер RX буфера определяется полем RCTL.BSIZE, при стандартном значении RCTL.BSIZE это соответствует буферу размером 2048 байт.
После этого можно перейти к настройке MAC, для этого будем использовать функцию i210_configure_tx и i210_configure_rx.
В первой настраивается регистр TCTL— 8.12.1 Transmit Control Register — TCTL (0×0400; R/W:
tctl = readl(hw + I210_TCTL);
tctl &= ~I210_TCTL_CT_MASK;
/*
Pad Short Packets (PSP)
Retransmit on late collision (RTLC)
*/
tctl |= I210_TCTL_PSP;
tctl |= I210_TCTL_RTLC;
tctl |= I210_TCTL_CT;
/*
TX disabled yet
*/
tctl &= ~I210_TCTL_EN;
writel(tctl, hw + I210_TCTL);
Здесь включаются PSP и RTLC, а также устанавливается параметр CT, но саму передачу пока не включаем.
После настройки MAC вызывается функцию i210_enable_tx, которая устанавливает бит EN в TCTL
tctl = readl(hw + I210_TCTL);
tctl |= I210_TCTL_EN;
writel(tctl, hw + I210_TCTL);
Для настройки приёма используем регистр RCTL — 8.10.1 Receive Control Register — RCTL (0×0100; R/W):
rctl = readl(hw + I210_RCTL);
/*
Enable receiver
*/
rctl |= I210_RCTL_EN;
/*
Accept broadcast packets
*/
rctl |= I210_RCTL_BAM;
/*
Strip Ethernet CRC
*/
rctl |= I210_RCTL_SECRC;
writel(rctl, hw + I210_RCTL);
Устанавливается бит EN, разрешающий приём пакетов, BAM для приёма широковещательных кадров и SECRC для удаления CRC из принятых кадров.
Для обработки событий контроллера будем использовать MSI (Message Signaled Interrupts).
Сначала отключаем прерывания в функции i210_disable_interrupts, чтобы во время настройки не возникало неожиданных вызовов обработчика:
void __iomem *hw = adapter->hw.hw_addr;
writel(0xffffffff, hw + I210_EIMC);
writel(0xffffffff, hw + I210_IMC);
/*
Clear pending causes
*/
readl(hw + I210_EICR);
readl(hw + I210_ICR);
Затем выделяем вектор прерывания в функции i210_alloc_irq:
err = i210_alloc_irq(adapter);
if (err)
goto err_free_tx;
Внутри i210_alloc_irq используется `pci_alloc_irq_vectors:
ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
В нашем случае запрашивается один MSI‑вектор. После его выделения получаем номер IRQ с помощью pci_irq_vector().
Важно различать MSI и MSI‑X. MSI использует механизм передачи сообщений для генерации прерываний и в нашей реализации выделяется один вектор. MSI‑X предоставляет более гибкую таблицу векторов и позволяет распределять разные очереди и события по нескольким прерываниям. В текущем драйвере MSI‑X не используется.
Далее регистрируем обработчик прерывания:
err = i210_request_irq(adapter);
if (err)
goto err_free_tx;
В качестве обработчика используется i210_interrupt(). При возникновении прерывания он проверяет причину события, маскирует прерывания и планирует выполнение NAPI:
napi_schedule(&adapter->napi);
Таким образом, непосредственно обработкой принятых пакетов занимается не обработчик аппаратного прерывания, а функция NAPI.
При реализации важно использовать согласованный набор регистров и причин прерывания. В I210 существуют обычные регистры маскирования/причин IMS/IMC/ICR и расширенные EIMS/EIMC/EICR. Если источник разрешается через EIMS, обработчик должен проверять соответствующую причину через EICR; нельзя без проверки смешивать эти регистры с обычными IMS/IMC/ICR.
NAPI контекст был создан ранее, при регистрации сетевого интерфейса в probe(), с помощью netif_napi_add().
Теперь необходимо разрешить его работу:
napi_enable(&adapter->napi);
После этого вызывается i210_configure_interrupts(), которая настраивает маршрутизацию и разрешает прерывания RX/TX очереди.
Через регистр IVAR настраивается привязка прерывания к очереди, а через EIMS разрешается соответствующий источник:
ivar = 0;
ivar |= 0 << I210_IVAR_RX0_SHIFT;
ivar |= I210_IVAR_RX0_VALID;
writel(ivar, hw + I210_IVAR);
writel(I210_EICR_RXTXQ0, hw + I210_EIMS);
В результате контроллер сможет уведомлять процессор о событиях, связанных с обработкой очереди.
При поступлении прерывания вызывается i210_interrupt(), который передаёт обработку пакетов механизму NAPI.
Последний этап i210_open() — это проверка состояния физического соединения.
После запуска автосогласования в i210_init_phy() необходимо убедиться, что PHY установил соединение с другим сетевым устройством. Для этого используется функция i210_phy_wait_link():
err = i210_phy_wait_link(adapter, 5000);
if (err) {
if (err == -ENOLINK) {
pr_info(DRV_NAME ": no PHY linkn");
} else {
pr_err(DRV_NAME ": PHY link check failed: %dn", err);
}
goto err_free_rx;
}
Функция периодически читает регистр состояния PHY и проверяет бит LINK_STATUS. В текущей реализации интервал между проверками составляет 100 мс, а максимальное время ожидания 5 секунд.
Особенность текущей реализации: если за это время линк не поднялся, i210_open() переходит к обработке ошибки и не открывает интерфейс. Для обычного сетевого драйвера Linux это не самый типичный вариант. Обычно отсутствие кабеля не должно мешать открытию интерфейса: драйвер завершает ndo_open() успешно, оставляет carrier выключенным и сообщает о появлении/потере линка отдельно, по изменению состояния PHY. Это можно улучшить в дальнейшей версии драйвера.
После успешного установления соединения вызывается:
netif_carrier_on(netdev);
netif_start_queue(netdev);
netif_carrier_on() — сообщает сетевому стеку, что физическое соединение установлено. netif_start_queue() — разрешает передачу пакетов через сетевой интерфейс.
Если собрать все рассмотренные операции в одну последовательность, получим следующий алгоритм:
Программный сброс Intel I210.
Запись MAC адреса в аппаратные регистры RAL0 и RAH0.
Инициализация PHY и запуск автосогласования.
Настройка TX буферов.
Выделение памяти под TX и RX кольца дескрипторов.
Выделение и отображение RX буферов для DMA.
Настройка аппаратных регистров TX и RX очередей.
Настройка MAC для передачи и приёма пакетов.
Включение TX и RX.
Выделение MSI вектора и регистрация обработчика прерывания.
Включение NAPI и настройка источников прерываний.
Ожидание установления физического соединения.
Включение сетевой очереди.
За передачу пакетов отвечает функция i210_xmit. При приёме сетевая карта записывет данные в подготовленные драйвером RX буферы, а драйвер обрабатывает их в контексте NAPI.
Когда сетевой стек Linux передаёт пакеты данных, он вызывает i210_xmit(). В качестве аргумента функция получает struct sk_buff структуру, содержащую сетевой пакет и метаданные, необходимые сетевому стеку и драйверу.
Сначала драйвер проверяет, остались ли свободные дескрипторы:
if (i210_tx_ring_full(tx_ring)) {
netif_stop_queue(netdev);
return NETDEV_TX_BUSY;
}
В кольце используется два индекса: next_to_use — индекс следующего дескриптора, который драйвер может заполнить новым пакетом. next_to_clean — индекс следующего дескриптора, который ожидает проверки и освобождения после завершения передачи.
Функция i210_tx_ring_full вычисляет следующий индекс после next_to_use и сравнивает его с next_to_clean. Если индексы совпадают, кольцо считается заполненным.
bool i210_tx_ring_full(struct i210_tx_ring *tx_ring)
{
u16 next;
next = tx_ring->next_to_use + 1;
if (next == tx_ring->count)
next = 0;
return next == tx_ring->next_to_clean;
}
Один дескриптор специально остаётся незанятым. Поэтому драйвер может отличить полностью заполненное кольцо от пустого.
Если свободных дескрипторов нет, драйвер останавливает сетевую очередь с помощью функции netif_stop_queue. Это сообщает сетевому стеку, что пока не нужно передавать драйверу новые пакеты. После освобождения дескрипторов очередь будет запущена повторно.
Если свободный дескриптор найден, драйвер получает его индекс и соответствующие структуры:
i = tx_ring->next_to_use;
tx_desc = &tx_ring->desc[i];
tx_buffer = &tx_ring->buffer_info[i];
Здесь tx_desc указывает на аппаратный дескриптор, а tx_buffer — на программную структуру, в которой драйвер хранит информацию о передаваемом пакете.
Далее отобразим данных пакета в DMA адресное пространство:
dma = dma_map_single(&adapter->pdev->dev, skb->data, skb->len, DMA_TO_DEVICE);
if (dma_mapping_error(&adapter->pdev->dev, dma)) {
dev_kfree_skb_any(skb);
return NETDEV_TX_OK;
}
dma_map_single() подготавливает непрерывную область памяти с данными пакета для доступа со стороны сетевого адаптера. В результате функция возвращает DMA адрес, который можно передать устройству.
Важно: dma_map_single() подходит для линейной части skb. Поскольку текущая реализация отображает только skb->data длиной skb->len, она не обрабатывает корректно нелинейные sk_buff, у которых часть данных находится во фрагментах (skb_shared_info/frags). Для учебной реализации можно предварительно линеаризовать пакет с помощью skb_linearize() и проверить результат, а более полноценный вариант — реализовать scatter‑gather передачу с dma_map_sg().
В качестве направления передачи используется DMA_TO_DEVICE так как в данном случае сетевая карта должна прочитать данные из оперативной памяти компьютера и отправить их в Ethernet‑сеть.
Полученный DMA адрес и указатель на исходный skb сохраняются в buffer_info:
tx_buffer->skb = skb;
tx_buffer->dma = dma;
tx_buffer->len = skb->len;
Эта информация необходима драйверу после завершения передачи. Когда адаптер обработает дескриптор, драйвер должен будет снять DMA mapping и освободить соответствующий skb.
После подготовки DMA буфера драйвер заполняет аппаратный дескриптор:
tx_desc->buffer_addr = cpu_to_le64(dma);
cmd = skb->len;
cmd |= I210_TXD_DTYP_ADV << I210_TXD_DTYP_SHIFT;
cmd |= (I210_TXD_CMD_EOP | I210_TXD_CMD_IFCS | I210_TXD_CMD_RS | I210_TXD_CMD_DEXT) << I210_TXD_CMD_SHIFT;
tx_desc->cmd_type_len = cpu_to_le32(cmd);
tx_desc->olinfo_status = cpu_to_le32((u32)skb->len << I210_TXD_PAYLEN_SHIFT);
В дескриптор записывается DMA адрес буфера с данными пакета, его длина и набор управляющих флагов.
В данном случае используется формат Advanced Transmit Data Descriptor. На это указывает установка поля DTYP_ADV и бита DEXT.
Используемые флаги: EOP — Указывает, что данный дескриптор содержит последний фрагмент Ethernet‑пакета. IFCS — Предписывает сетевой карте добавить Ethernet FCS (Frame Check Sequence). RS — Запрашивает запись статуса завершения обработки дескриптора. DEXT — Указывает на использование расширенного формата дескриптора.
Отдельно заполняется поле PAYLEN в olinfo_status. Оно содержит длину передаваемых данных и используется аппаратурой при обработке TX дескриптора.
При этом важно различать длину пакета, передаваемую в cmd_type_len, и поле PAYLEN в olinfo_status: это разные поля дескриптора, хотя в данном случае в оба записывается skb->len.
После заполнения всех полей вызывается:
dma_wmb();
Этот барьер гарантирует, что записи CPU в дескриптор будут видны устройству до того, как драйвер сообщит ему о появлении нового задания.
Затем обновляется программный индекс:
i++;
if (i == tx_ring->count)
i = 0;
tx_ring->next_to_use = i;
И наконец, драйвер записывает новое значение в регистр TDT:
writel(i, adapter->hw.hw_addr + I210_TDT(0));
TDT (Transmit Descriptor Tail) указывает на границу дескрипторов, переданных драйвером в распоряжение аппаратуры. После обновления этого регистра Intel I210 получает возможность прочитать подготовленный дескриптор из оперативной памяти через DMA и начать передачу пакета.
Таким образом, i210_xmit() не ожидает фактического завершения отправки пакета. Функция только подготавливает DMA буфер, заполняет дескриптор и уведомляет сетевую карту. Завершение передачи обрабатывается отдельно.
После передачи пакета сетевая карта обновляет статус соответствующего TX дескриптора. В частности, при использовании флага RS устройство устанавливает бит DD (Descriptor Done), который указывает драйверу на завершение обработки дескриптора.
Проверка завершения передачи выполняется функцией i210_clean_tx():
while (tx_ring->next_to_clean != tx_ring->next_to_use) {
u16 i = tx_ring->next_to_clean;
struct i210_tx_desc *tx_desc = &tx_ring->desc[i];
struct i210_tx_buffer *tx_buffer = &tx_ring->buffer_info[i];
u32 status;
status = le32_to_cpu(READ_ONCE(tx_desc->olinfo_status));
if (!(status & I210_TXD_STAT_DD))
break;
Драйвер последовательно проверяет дескрипторы, начиная с next_to_clean. Если бит DD ещё не установлен, значит, аппаратная передача соответствующего пакета не завершена, поэтому дальнейшая очистка пока невозможна.
Когда дескриптор обработан, драйвер освобождает связанные с ним ресурсы:
if (tx_buffer->skb) {
dma_unmap_single(&pdev->dev, tx_buffer->dma, tx_buffer->len, DMA_TO_DEVICE);
dev_kfree_skb_any(tx_buffer->skb);
tx_buffer->skb = NULL;
tx_buffer->dma = 0;
tx_buffer->len = 0;
}
Сначала снимается DMA mapping, после чего освобождается skb. Это необходимо, поскольку после завершения передачи сетевая карта больше не должна обращаться к соответствующему буферу.
Затем очищается сам дескриптор:
tx_desc->buffer_addr = 0;
tx_desc->cmd_type_len = 0;
tx_desc->olinfo_status = 0;
Индекс next_to_clean перемещается к следующему дескриптору. Таким образом, освобождённая запись снова становится доступной для использования.
В конце функции проверяется, была ли ранее остановлена сетевая очередь из‑за заполнения TX кольца:
if (cleaned && netif_queue_stopped(netdev) &&
!i210_tx_ring_full(tx_ring)) {
netif_wake_queue(netdev);
}
Если хотя бы один дескриптор освобождён и в кольце снова появилось место, вызывается netif_wake_queue(). После этого сетевой стек Linux может продолжить передавать пакеты драйверу.
В отличие от передачи, приём пакетов начинается не с вызова драйвером функции из сетевого стека. Драйвер заранее подготавливает RX кольцо и передаёт сетевой карте DMA адреса буферов, в которые можно записывать входящие данные.
Эта работа выполняется ещё при открытии интерфейса, в функциях i210_setup_rx_resources() и i210_configure_rx_ring().
Для каждого RX дескриптора выделяется отдельный sk_buff, а его DMA адрес записывается в поле buffer_addr. После этого драйвер обновляет RDT, сообщая сетевой карте, какие дескрипторы можно использовать.
Когда на порт поступает Ethernet‑кадр, I210 принимает его, выполняет аппаратную обработку и записывает данные в один из подготовленных буферов. После завершения записи устройство обновляет статус соответствующего дескриптора.
Обработка полученных пакетов выполняется в рамках NAPI. Основная функция i210_clean() вызывает i210_clean_rx() для обработки RX дескрипторов:
work_done = i210_clean_rx(adapter, budget);
i210_clean_tx(adapter);
budget определяет максимальное количество RX пакетов, которое разрешено обработать за один проход NAPI. Очистка TX дескрипторов не учитывается в этом лимите.
В начале i210_clean_rx() драйвер получает индекс следующего дескриптора для обработки:
i = rx_ring->next_to_clean;
rx_desc = &rx_ring->desc[i];
rx_buffer = &rx_ring->buffer_info[i];
Затем проверяется бит DD:
status = READ_ONCE(rx_desc->status);
if (!(status & I210_RXD_STAT_DD))
break;
dma_rmb();
Если DD не установлен, значит, устройство ещё не завершило обработку данного дескриптора и новых данных для драйвера нет.
Если же DD установлен, драйвер может прочитать остальные поля дескриптора. Для этого используется dma_rmb(), который гарантирует корректный порядок чтения данных, записанных устройством через DMA.
Далее извлекается длина принятого пакета:
length = le16_to_cpu(READ_ONCE(rx_desc->length));
После этого драйвер проверяет наличие skb, связанного с дескриптором, и флаг EOP:
skb = rx_buffer->skb;
if (!skb) {
pr_err(DRV_NAME ": RX desc[%u] has no skbn", i);
break;
}
if (!(status & I210_RXD_STAT_EOP)) {
pr_err(DRV_NAME ": RX desc[%u] is not EOPn", i);
…
}
EOP (End of Packet) указывает, что данный дескриптор содержит конец Ethernet‑пакета. В текущей реализации драйвер предполагает, что каждый пакет помещается в один RX буфер и обрабатывается одним дескриптором. Поддержка пакетов, распределённых между несколькими дескрипторами, пока не реализована.
Это ограничение важно не только для Jumbo Frames. Если драйвер встретит дескриптор без EOP, текущая ветка с break прекращает обработку, не собирая пакет и не возвращая этот дескриптор в кольцо. В таком состоянии RX обработка может остановиться на этой позиции. Для корректной реализации необходимо либо собирать пакет из нескольких дескрипторов, либо корректно отбрасывать весь такой пакет и возвращать использованные дескрипторы в работу.
Если дескриптор содержит полный пакет, драйвер снимает DMA mapping:
dma_unmap_single(&pdev->dev, rx_buffer->dma, I210_RX_BUFFER_SIZE, DMA_FROM_DEVICE);
rx_buffer->skb = NULL;
rx_buffer->dma = 0;
После этого буфер снова принадлежит CPU, и драйвер может передать содержащиеся в нём данные сетевому стеку.
Сначала обновляется длина skb:
skb_put(skb, length);
Затем определяется протокол верхнего уровня Ethernet‑кадра:
skb->protocol = eth_type_trans(skb, adapter->netdev);
eth_type_trans() анализирует Ethernet‑заголовок, определяет протокол (например, IPv4 или IPv6), удаляет Ethernet‑заголовок из начала области данных skb и подготавливает пакет для дальнейшей обработки сетевым стеком.
Наконец, пакет передаётся в Linux Network Stack:
netif_receive_skb(skb);
На этом этапе ответственность за дальнейшую обработку пакета переходит от драйвера к сетевому стеку ядра.
После передачи принятого пакета сетевому стеку освободившийся RX дескриптор необходимо подготовить для следующего входящего пакета.
Для этого вызывается i210_alloc_rx_buffer():
if (i210_alloc_rx_buffer(adapter, i)) {
pr_err(DRV_NAME ": RX refill failed for desc[%u]n", i);
break;
}
dma_wmb();
writel(i, hw + I210_RDT(0));
Функция выделяет новый sk_buff, отображает его в DMA адресное пространство и записывает полученный DMA адрес в RX дескриптор:
rx_buffer->skb = skb;
rx_buffer->dma = dma;
rx_ring->desc[i].buffer_addr = cpu_to_le64(dma);
rx_ring->desc[i].length = 0;
rx_ring->desc[i].status = 0;
rx_ring->desc[i].errors = 0;
После подготовки дескриптора вызывается dma_wmb(), чтобы гарантировать видимость изменений для сетевой карты. Затем обновляется RDT, возвращая дескриптор в распоряжение аппаратуры.
После этого индекс next_to_clean перемещается на следующую позицию, а счётчик work_done увеличивается.
Таким образом, RX кольцо работает циклически: устройство записывает принятые пакеты в подготовленные буферы, драйвер обрабатывает их и передаёт сетевому стеку, после чего выделяет новые буферы и возвращает дескрипторы устройству.
В драйвере используется общий NAPI callback — i210_clean(). Он вызывается ядром для обработки событий, связанных с сетевыми очередями:
static int i210_clean(struct napi_struct *napi, int budget)
{
struct i210_adapter *adapter = container_of(napi, struct i210_adapter, napi);
int work_done;
work_done = i210_clean_rx(adapter, budget);
i210_clean_tx(adapter);
if (work_done < budget) {
if (napi_complete_done(napi, work_done)) {
writel(I210_EICR_RXTXQ0,
adapter->hw.hw_addr + I210_EIMS);
readl(adapter->hw.hw_addr + I210_EIMS);
}
}
return work_done;
}
Сначала выполняется обработка входящих пакетов. Затем вызывается i210_clean_tx(), которая освобождает завершённые TX дескрипторы.
Если количество обработанных RX пакетов оказалось меньше budget, NAPI завершает текущий цикл через napi_complete_done(). Если завершение прошло успешно, драйвер снова разрешает прерывания очереди записью в EIMS. Последующее чтение EIMS используется для завершения/синхронизации MMIO‑записи. Чтение EIMS до записи не включает прерывания, а чтение EICR имеет побочный эффект очистки причин прерывания, поэтому его не следует без необходимости использовать в этом месте.
Таким образом, NAPI позволяет не обрабатывать каждый входящий пакет непосредственно в контексте аппаратного прерывания. Вместо этого обработчик прерывания планирует NAPI, а дальнейшая обработка пакетов выполняется в контексте polling.
Для сборки используется Makefile, расположенный в корневой директории проекта:
make clean
make all
В результате компиляции создаётся модуль ядра i210_driver.ko
Перед загрузкой драйвера необходимо отвязать сетевое устройство от стандартного драйвера igb, который подгрузился к Intel I210 после страта системы:
sudo sh -c 'echo 0000:02:00.0 > /sys/bus/pci/drivers/igb/unbind'
Загрузим собранный модуль:
sudo insmod ./i210_driver.ko
Проверим, какой драйвер теперь обслуживает PCI устройство:
lspci -k -s 02:00.0
В выводе должна быть строка:
Kernel driver in use: i210
Также проверим появление сетевого интерфейса:
ip link show
В моей конфигурации драйвер регистрирует интерфейс под именем eth0
Для просмотра сообщений драйвера и ядра удобно использовать:
sudo dmesg -w
Для проверки работы драйвера использовались два компьютера, соединённые через Ethernet:
PC1 (Host) — компьютер со стандартным сетевым драйвером Linux
PC2 (I210) — компьютер с установленным разрабатываемым драйвером Intel I210
Для тестирования была настроена следующая адресация:
|
Компьютер |
Сетевой интерфейс |
IPv4-адрес |
|---|---|---|
|
PC1 (Host) |
|
|
|
PC2 (I210) |
|
|
Сначала настроим сетевые интерфейсы
На PC1:
sudo ip addr add 10.123.45.2/24 dev enp0s31f6
На PC2:
sudo ip link set eth0 up
sudo ip addr add 10.123.45.1/24 dev eth0
Для анализа проходящих Ethernet‑кадров на PC1 запустим tcpdump:
sudo tcpdump -ni enp0s31f6 -e -vv 'arp or icmp'
Теперь с PC2 отправим ICMP Echo Request:
ping -I eth0 -c 10 10.123.45.2
Перед отправкой первого ICMP‑пакета Linux должен определить MAC адрес получателя. Для этого используется протокол ARP.
В захвате tcpdump можно увидеть следующую последовательность:
PC2 отправляет широковещательный ARP Request с запросом MAC адреса узла 10.123.45.2.
PC1 отвечает ARP Reply, сообщая свой MAC адрес.
PC2 отправляет ICMP Echo Request.
PC1 принимает запрос и отправляет ICMP Echo Reply.
Пример захваченных кадров:
c4:62:37:03:18:ad > ff:ff:ff:ff:ff:ff,
ethertype ARP (0x0806):
Request who-has 10.123.45.2 tell 10.123.45.1
e4:b9:7a:56:48:46 > c4:62:37:03:18:ad,
ethertype ARP (0x0806):
Reply 10.123.45.2 is-at e4:b9:7a:56:48:46
c4:62:37:03:18:ad > e4:b9:7a:56:48:46,
ethertype IPv4 (0x0800):
10.123.45.1 > 10.123.45.2: ICMP echo request
e4:b9:7a:56:48:46 > c4:62:37:03:18:ad,
ethertype IPv4 (0x0800):
10.123.45.2 > 10.123.45.1: ICMP echo reply
Таким образом, удалось проверить не только передачу и приём Ethernet кадров, но и взаимодействие драйвера с сетевым стеком Linux: ARP‑запросы и ответы, а также обработку ICMP пакетов.
Следующим этапом будет проверка производительности драйвера. Для этого использовалась утилита iperf3
На PC1 запускаем сервер:
iperf3 -s
На PC2 запускаем клиент, который будет передавать данные в течение 10 секунд:
iperf3 -c 10.123.45.2 -t 10
Результат тестирования на PC2:
Connecting to host 10.123.45.2, port 5201
[ ID] Interval Transfer Bitrate Retr
[ 5] 0.00-1.00 sec 113 MBytes 949 Mbits/sec 1
[ 5] 1.00-2.00 sec 112 MBytes 942 Mbits/sec 0
[ 5] 2.00-3.00 sec 112 MBytes 938 Mbits/sec 0
[ 5] 3.00-4.00 sec 112 MBytes 941 Mbits/sec 0
[ 5] 4.00-5.00 sec 112 MBytes 943 Mbits/sec 0
[ 5] 5.00-6.00 sec 112 MBytes 941 Mbits/sec 0
[ 6] 6.00-7.00 sec 113 MBytes 947 Mbits/sec 0
[ 7] 7.00-8.00 sec 112 MBytes 941 Mbits/sec 0
[ 8] 8.00-9.00 sec 112 MBytes 941 Mbits/sec 0
[ 9] 9.00-10.00 sec 112 MBytes 939 Mbits/sec 0
[ ID] Interval Transfer Bitrate
[ 5] 0.00-10.00 sec 1.10 GBytes 943 Mbits/sec sender
[ 5] 0.00-10.00 sec 1.10 GBytes 941 Mbits/sec receiver
В результате тестирования была получена пропускная способность около 941 Mbit/s на стороне получателя, вообщем, почти гигабит удалось прогнать через сетевуху и драйвер.
Проведённые тесты подтвердили работоспособность основных механизмов драйвера: инициализацию сетевого интерфейса, передачу и приём Ethernet кадров, обработку ARP и ICMP, а также передачу TCP трафика через стандартный сетевой стек Linux.
Тесты и трафика прикладываю в Readme в репозитории драйвера — https://github.com/k0v4back/Linux‑Kernel‑Ethernet‑driver‑Intel‑i210 [61]
В этой статье мы рассмотрели архитектуру сетевого контроллера Intel I210 и основные механизмы, необходимые для разработки Linux драйвера: взаимодействие с PCIe, доступ к регистрам через MMIO, работу MAC и PHY, использование DMA и кольцевых буферов.
Исходный код проекта доступен на GitHub [61]
Автор: kosolapov_vadim
Источник [62]
Сайт-источник PVSM.RU: https://www.pvsm.ru
Путь до страницы источника: https://www.pvsm.ru/network/462525
Ссылки в тексте:
[1] документации: https://www.intel.com/content/www/us/en/content-details/333016/intel-ethernet-controller-i210-datasheet.html
[2] Вот такую сетевух будем прогать: https://media.gekko-computer.de/images/Shop1600px/50022210_7.jpg
[3] 1. Теория по MAC, PHY, DMA и PCIe: #1-%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D1%8F-%D0%BF%D0%BE-mac-phy-dma-%D0%B8-pcie
[4] 1.1. Путь сетевого пакета от приложения до сетевой карты: #11-%D0%BF%D1%83%D1%82%D1%8C-%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B3%D0%BE-%D0%BF%D0%B0%D0%BA%D0%B5%D1%82%D0%B0-%D0%BE%D1%82-%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B4%D0%BE-%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B9-%D0%BA%D0%B0%D1%80%D1%82%D1%8B
[5] 2. Немного про Vendor ID, Device ID, BAR: #2-%D0%BD%D0%B5%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE-%D0%BF%D1%80%D0%BE-vendor-id-device-id-bar
[6] 2.1. Адрес PCI устройства и его идентификаторы: #21-%D0%B0%D0%B4%D1%80%D0%B5%D1%81-pci-%D1%83%D1%81%D1%82%D1%80%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0-%D0%B8-%D0%B5%D0%B3%D0%BE-%D0%B8%D0%B4%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80%D1%8B
[7] 2.2. Что такое PCI функция?: #22-%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-pci-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F
[8] 2.3. Конфигурационное пространство PCI: #23-%D0%BA%D0%BE%D0%BD%D1%84%D0%B8%D0%B3%D1%83%D1%80%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%BE%D0%B5-%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%BE-pci
[9] 2.4. Обнаружение PCI устройств в Linux: #24-%D0%BE%D0%B1%D0%BD%D0%B0%D1%80%D1%83%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-pci-%D1%83%D1%81%D1%82%D1%80%D0%BE%D0%B9%D1%81%D1%82%D0%B2-%D0%B2-linux
[10] 2.5. Связывание PCI устройств с драйверами: #25-%D1%81%D0%B2%D1%8F%D0%B7%D1%8B%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-pci-%D1%83%D1%81%D1%82%D1%80%D0%BE%D0%B9%D1%81%D1%82%D0%B2-%D1%81-%D0%B4%D1%80%D0%B0%D0%B9%D0%B2%D0%B5%D1%80%D0%B0%D0%BC%D0%B8
[11] 2.6. BAR и MMIO: #26-bar-%D0%B8-mmio
[12] 3. Обработка прерываний и механизм NAPI: #3-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0-%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%B0%D0%BD%D0%B8%D0%B9-%D0%B8-%D0%BC%D0%B5%D1%85%D0%B0%D0%BD%D0%B8%D0%B7%D0%BC-napi
[13] 3.1. Классическая обработка через аппаратные прерывания: #31-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0-%D1%87%D0%B5%D1%80%D0%B5%D0%B7-%D0%B0%D0%BF%D0%BF%D0%B0%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%B5-%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F
[14] 3.2. NAPI: гибридный подход: #32-napi-%D0%B3%D0%B8%D0%B1%D1%80%D0%B8%D0%B4%D0%BD%D1%8B%D0%B9-%D0%BF%D0%BE%D0%B4%D1%85%D0%BE%D0%B4
[15] 3.2.1. Чем NAPI отличается от модели до его появления: #321-%D1%87%D0%B5%D0%BC-napi-%D0%BE%D1%82%D0%BB%D0%B8%D1%87%D0%B0%D0%B5%D1%82%D1%81%D1%8F-%D0%BE%D1%82-%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D0%B8-%D0%B4%D0%BE-%D0%B5%D0%B3%D0%BE-%D0%BF%D0%BE%D1%8F%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F
[16] 3.3. Polling и Busy Polling: #33-polling-%D0%B8-busy-polling
[17] 3.4. Что используется в нашем драйвере: #34-%D1%87%D1%82%D0%BE-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D0%B5%D1%82%D1%81%D1%8F-%D0%B2-%D0%BD%D0%B0%D1%88%D0%B5%D0%BC-%D0%B4%D1%80%D0%B0%D0%B9%D0%B2%D0%B5%D1%80%D0%B5
[18] 4. От теории к практике: #4-%D0%BE%D1%82-%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D0%B8-%D0%BA-%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D0%BA%D0%B5
[19] 4.1. Регистрация в подсистеме PCI: #41-%D1%80%D0%B5%D0%B3%D0%B8%D1%81%D1%82%D1%80%D0%B0%D1%86%D0%B8%D1%8F-%D0%B2-%D0%BF%D0%BE%D0%B4%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B5-pci
[20] 4.2. Инициализация устройства в probe(): #42-%D0%B8%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D1%83%D1%81%D1%82%D1%80%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0-%D0%B2-probe
[21] 4.3. Отображение области MMIO: #43-%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BE%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D0%B8-mmio
[22] 4.4. Регистрация сетевого интерфейса: #44-%D1%80%D0%B5%D0%B3%D0%B8%D1%81%D1%82%D1%80%D0%B0%D1%86%D0%B8%D1%8F-%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B3%D0%BE-%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%D0%B0
[23] 4.5. Операции сетевого интерфейса: #45-%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8-%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B3%D0%BE-%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%D0%B0
[24] 5. Выполнение i210_open(): #5-%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5-i210_open
[25] 5.1. Сброс Intel I210: #51-%D1%81%D0%B1%D1%80%D0%BE%D1%81-intel-i210
[26] 5.2. Инициализация MAC фильтра: #52-%D0%B8%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-mac-%D1%84%D0%B8%D0%BB%D1%8C%D1%82%D1%80%D0%B0
[27] 5.3. Инициализация PHY: #53-%D0%B8%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-phy
[28] 5.4. Автосогласование скорости: #54-%D0%B0%D0%B2%D1%82%D0%BE%D1%81%D0%BE%D0%B3%D0%BB%D0%B0%D1%81%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D1%81%D0%BA%D0%BE%D1%80%D0%BE%D1%81%D1%82%D0%B8
[29] 5.5. Настройка TX буферов: #55-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-tx-%D0%B1%D1%83%D1%84%D0%B5%D1%80%D0%BE%D0%B2
[30] 5.6. Выделение памяти TX буферов: #56-%D0%B2%D1%8B%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8-tx-%D0%B1%D1%83%D1%84%D0%B5%D1%80%D0%BE%D0%B2
[31] 5.7. Выделение памяти RX буферов: #57-%D0%B2%D1%8B%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8-rx-%D0%B1%D1%83%D1%84%D0%B5%D1%80%D0%BE%D0%B2
[32] 5.8. Настройка RX буферов: #58-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-rx-%D0%B1%D1%83%D1%84%D0%B5%D1%80%D0%BE%D0%B2
[33] 5.9. Настройка MAC для передачи и приёма: #59-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-mac-%D0%B4%D0%BB%D1%8F-%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B8-%D0%B8-%D0%BF%D1%80%D0%B8%D1%91%D0%BC%D0%B0
[34] 5.10. Настройка прерываний MSI: #510-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%B0%D0%BD%D0%B8%D0%B9-msi
[35] 5.11. Включение NAPI и настройка источников прерываний: #511-%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5-napi-%D0%B8-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-%D0%B8%D1%81%D1%82%D0%BE%D1%87%D0%BD%D0%B8%D0%BA%D0%BE%D0%B2-%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%B0%D0%BD%D0%B8%D0%B9
[36] 5.12. Проверка физического соединения и запуск сетевой очереди: #512-%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B0-%D1%84%D0%B8%D0%B7%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B3%D0%BE-%D1%81%D0%BE%D0%B5%D0%B4%D0%B8%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8-%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA-%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B9-%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8
[37] 6. Передача и приём данных: #6-%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B0-%D0%B8-%D0%BF%D1%80%D0%B8%D1%91%D0%BC-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85
[38] 6.1. Передача данных: i210_xmit(): #61-%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B0-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-i210_xmit
[39] 6.1.1. Проверка доступности TX кольца: #611-%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B0-%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%BD%D0%BE%D1%81%D1%82%D0%B8-tx-%D0%BA%D0%BE%D0%BB%D1%8C%D1%86%D0%B0
[40] 6.1.2. Подготовка DMA буфера: #612-%D0%BF%D0%BE%D0%B4%D0%B3%D0%BE%D1%82%D0%BE%D0%B2%D0%BA%D0%B0-dma-%D0%B1%D1%83%D1%84%D0%B5%D1%80%D0%B0
[41] 6.1.3. Заполнение TX дескриптора: #613-%D0%B7%D0%B0%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5-tx-%D0%B4%D0%B5%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%80%D0%B0
[42] 6.1.4. Передача дескриптора сетевой карте: #614-%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B0-%D0%B4%D0%B5%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%80%D0%B0-%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B9-%D0%BA%D0%B0%D1%80%D1%82%D0%B5
[43] 6.2. Очистка TX кольца: i210_clean_tx(): #62-%D0%BE%D1%87%D0%B8%D1%81%D1%82%D0%BA%D0%B0-tx-%D0%BA%D0%BE%D0%BB%D1%8C%D1%86%D0%B0-i210_clean_tx
[44] 6.3. Приём пакетов: RX descriptor ring: #63-%D0%BF%D1%80%D0%B8%D1%91%D0%BC-%D0%BF%D0%B0%D0%BA%D0%B5%D1%82%D0%BE%D0%B2-rx-descriptor-ring
[45] 6.4. Обработка RX пакетов: i210_clean_rx(): #64-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0-rx-%D0%BF%D0%B0%D0%BA%D0%B5%D1%82%D0%BE%D0%B2-i210_clean_rx
[46] 6.4.1. Повторное заполнение RX дескриптора: #641-%D0%BF%D0%BE%D0%B2%D1%82%D0%BE%D1%80%D0%BD%D0%BE%D0%B5-%D0%B7%D0%B0%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5-rx-%D0%B4%D0%B5%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%80%D0%B0
[47] 6.5. Как RX и TX объединены в NAPI: #65-%D0%BA%D0%B0%D0%BA-rx-%D0%B8-tx-%D0%BE%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D0%B5%D0%BD%D1%8B-%D0%B2-napi
[48] 7. Компиляция и запуск некоторых тестов: #7-%D0%BA%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%86%D0%B8%D1%8F-%D0%B8-%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA-%D0%BD%D0%B5%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D1%85-%D1%82%D0%B5%D1%81%D1%82%D0%BE%D0%B2
[49] 7.1. Компиляция и загрузка драйвера: #71-%D0%BA%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%86%D0%B8%D1%8F-%D0%B8-%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BA%D0%B0-%D0%B4%D1%80%D0%B0%D0%B9%D0%B2%D0%B5%D1%80%D0%B0
[50] 7.2. Проверка передачи и приёма пакетов: #72-%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B0-%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B8-%D0%B8-%D0%BF%D1%80%D0%B8%D1%91%D0%BC%D0%B0-%D0%BF%D0%B0%D0%BA%D0%B5%D1%82%D0%BE%D0%B2
[51] 7.3. Измерение пропускной способности: #73-%D0%B8%D0%B7%D0%BC%D0%B5%D1%80%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF%D1%80%D0%BE%D0%BF%D1%83%D1%81%D0%BA%D0%BD%D0%BE%D0%B9-%D1%81%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D0%BD%D0%BE%D1%81%D1%82%D0%B8
[52] 8. Вывод: #8-%D0%B2%D1%8B%D0%B2%D0%BE%D0%B4
[53] исходниках Linux: https://elixir.bootlin.com/linux/latest/source/drivers/net/ethernet/intel/igb
[54] Упрощённая схема Ethernet устройства: https://www.researchgate.net/publication/228819175_The_performance_potential_of_an_integrated_network_interface
[55] Источник: https://www.chipestimate.com/The-Benefits-of-a-Multi-Protocol-PMA/Silicon-Creations/Technical-Article/2024/05/21
[56] Структурная схема взаимодействия с контроллером DMA: https://www.geeksforgeeks.org/computer-organization-architecture/direct-memory-access-dma-controller-in-computer-architecture/
[57] Кольцевой буфер дескрипторов: https://tungdam.medium.com/linux-network-ring-buffers-cea7ead0b8e8
[58] Примерный путь сетевых пакетов в Linux: https://networks.cs.northwestern.edu/CS497-s24/papers/sigcomm21-kernel.pdf
[59] struct pci_driver: https://elixir.bootlin.com/linux/v7.0.10/source/include/linux/pci.h#L1013
[60] https://stackoverflow.com/questions/36625892/descriptor‑concept‑in‑nic: https://stackoverflow.com/questions/36625892/descriptor-concept-in-nic
[61] https://github.com/k0v4back/Linux‑Kernel‑Ethernet‑driver‑Intel‑i210: https://github.com/k0v4back/Linux-Kernel-Ethernet-driver-Intel-i210
[62] Источник: https://habr.com/ru/articles/1109528/?utm_source=habrahabr&utm_medium=rss&utm_campaign=1109528
Нажмите здесь для печати.