WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 |   ...   | 7 | 8 ||

«; ...»

-- [ Страница 9 ] --

Таблица 19.3. Расположение данных в памяти для разных порядков следования байтов Адрес Обратный порядок Прямой порядок 0 00000000 1 00000000 2 00000100 3 00000011 Обратите внимание на то, что для аппаратной платформы с обратным порядком байтов самый старший байт записывается в самый минимальный адрес памяти.

И наконец, еще один пример — фрагмент кода, который позволяет определить порядок байтов для той аппаратной платформы, на которой он выполняется.

int х = 1;

if (*(char *)&х == 1) /* прямой порядок */ else /* обратный порядок */ Этот пример работает как в ядре, так и в пространстве пользователя.

400 Глава История терминов big-endian и little-endian Термины big-endian и little-endian заимствованы из сатирического романа Джонатана Свифта "Путешествие Гулливера", который был издан в 1726 году. В этом романс наиболее важной политической проблемой народа лилипутов была пробле ма, с какого конца следует разбивать яйцо: с тупого (big) или острого (little). Тех, кто предпочитал тупой конец называли "тупоконечниками" (big-endian), тех же, кто предпочитал острый конец, называли "остроконечниками" (little-endian).

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

Порядок байтов в ядре Для каждой аппаратной платформы, которая поддерживается ядром Linux, в файле < a s m / b y t e o r d e r. h > определена одна из двух констант BIG_ENDIAN или LITTLE_ENDIAN, в соответствии с используемым порядком байтов.

В этот заголовочный файл также включаются макросы из каталога i n c l u d e / l i n u x / b y t e o r d e r /, которые помогают конвертировать один порядок байтов в дру гой. Ниже показаны наиболее часто используемые макросы.

u23cpu_to_be32(u32);

/* преобразовать порядок байтов текущего процессора в порядок big-endian */ u32cpu_to_le32(u32);

/* преобразовать порядок байтов текущего процессора в порядок little-endian */ u32 be32_to_cpu(u32);

/* преобразовать порядок байтов big-endian в порядок байтов текущего процессора */ u32lе32_to_cpus(u32);

/* преобразовать порядок байтов little-endian в порядок байтов текущего процессора */ Эти макросы выполняют преобразование одного порядка байтов в другой. В слу чае когда порядки байтов, между которыми выполняется преобразование, одинако вы (например, если выполняется преобразование в обратный порядоку байтов и процессор тоже использует такой же порядок), то эти макросы не делают ничего. В противном случае возвращается преобразованное значение.

Таймер Никогда нельзя привязываться к какой-либо конкретной частоте генерации пре рывания системного таймера и, соответственно, к тому, сколько раз в секунду изме няется переменная j i f f i e s. Всегда необходимо использовать константу HZ, чтобы корректно определять интервалы времени. Это очень важно, потому что значение частоты системного таймера может отличаться не только для разных аппаратных платформ, но и для одной аппаратной платформы при использовании разных вер сий ядра.

Например, константа HZ для аппаратной платформы х86 сейчас равна 1000. Это значит, что прерывание таймера возникает 1000 раз в секунду, или каждую миллисе кунду. Однако до серии ядер 2.6 для аппаратной платформы х86 значение константы HZ было равно 100. Для разных аппаратных платформ эти значения отличаются: для аппаратной платформы alpha константа HZ равна 1024, а для платформы ARM — 100.

Переносимость Никогда нельзя сравнивать значение переменной j i f f i e s с числом, таким как 1000, и думать, что это всегда будет означать одно и то же. Для получения интерва лов времени необходимо всегда умножать или делить на константу HZ, как в следую щем примере.

HZ /* одна секунда */ (2*HZ) /* две секунды */ (HZ/2) /* полсекунды */ (HZ/100) /* 10 мс */ (2*Н2/100) /* 20 мс */ Константа HZ определена п файле. Об этом подробно рассказано в главе 10, "Таймеры и упрадление временем".

Размер страницы памяти При работе со страницами памяти никогда нельзя привязываться к конкретному размеру страницы. Программисты, которые разрабатывают для аппаратной плат формы х86, часто делают ошибку, считая, что размер страницы всегда равен 4 Кбай та. Хотя это справедливо для платформы х86, для других аппаратных платформ раз мер станицы может быть другим. Некоторые аппаратные платформы поддерживают несколько размеров страниц! В табл. 19.-1 приведен список размеров страниц памяти для всех поддерживаемых аппаратных платформ.

Таблица 19.4. Размеры страниц памяти для разных аппаратных платформ Значение PAGE_SHIFT Значение P A G E _ S I Z E Аппаратная платформа alpha 13 8 Кбайт arm 12, 14, 15 4 Кбайт, 16 Кбайт, 32 Кбайт cris 13 8 Кбайт h8300 12 4 Кбайт i386 12 4 Кбайт ia64 12, 13, 14, 16 4 Кбайт, 8 Кбайт, 32 Кбайт, 64 Кбайт m68k 12, 13 4 Кбайт, 8 Кбайт m86knommu 12 4 Кбайт mips 12 4 Кбайт mips64 12 4 Кбайт • parisc 12 4 Кбайт ррс 12 4 Кбайт ррс64 12 4 Кбайт S390 12 4 Кбайт sh 12 4 Кбайт spare 12,13 4 Кбайт, 8 Кбайт sparc64 13 8 Кбайт v850 12 4 Кбайт х86_64 12 4 Кбайт 402 Глава При работе со страницами памяти необходимо использовать константу PAGE_SIZE, которая содержит размер страницы памяти в байтах.

Значение макроса PAGE_SHIFT — это количество битов, на которое необходимо сдвинуть влево значение адреса, чтобы получить номер соответствующей страницы памяти. Например, для аппаратной платформы х86, для которой размер страницы равен 4 Кбайт, макрос PAGE_SIZE равен 4096, а макрос PAGE_SHIFT— 12. Эти значе ния содержатся в заголовочном файле.

Порядок выполнения операций процессором Вспомните из материала главы 9, "Средства синхронизации в ядре", что для раз личных аппаратных платформ процессоры в разной степени изменяют порядок вы полнения программных инструкций. Для некоторых процессоров порядок выполне ния операций строго соблюдается, запись данных в память и считывание данных из памяти выполняются в строго указанном в программе порядке. Другие процессоры имеют ослабленные требования к порядку выполнения операций считывания и за писи данных и могут изменять порядок выполнения этих операций с целью опти мизации.

Если код зависит от порядка выполнения операций чтения-записи данных, то не обходимо гарантировать, что даже процессор с самыми слабыми ограничениями на порядок выполнения чтения-записи будет выполнять эти операции в правильном по рядке. Это делается с помощью соответствующих барьеров, таких как rmb() и wmb().

Более подробная информация приведена в главе 9, "Средства синхронизации в ядре".

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

• Всегда необходимо учитывать, что код может выполняться на SMP-системе и использовать соответствующие блокировки.

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

• Всегда необходимо учитывать, что код может выполняться на системе с под держкой верхней памяти (непостоянно отображаемая память) и при необходи мости использовать функцию kmap ().

Переносимость Пару слов о переносимости Если говорить коротко, то написание переносимого, ясного и красивого кода подразумевает следующие два момента.

• Код необходимо разрабатывать с учетом самого общего сценария: следует предполагать, что все, что может случиться, обязательно случится, и принять на этот счет все возможные меры.

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

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

404 Глава Заплаты, разработка и сообщество О дно из самых больших преимуществ операционной системы Linux — это связанное с ней большое сообщество пользователей и разработчиков.

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

Сообщество Если говорить о том, где физически существует сообщество разработчиков ядра Linux, то можно сослаться на список рассылки разработчиков ядра Linux (Linux Kernel Mail List, или, сокращенно, LKML). Список разработчиков ядра Linux— это то место, где происходит большинство дискуссий, дебатов и флеймов вокруг ядра Linux. Здесь обсуждаются новые возможности, и большая часть кода отправляется в этот список рассылки перед тем, как этот код для чего-нибудь начинает использоваться. В списке рассылки насчитывается до 300 сообщений в день — количество не для слабонерв ных. Подписаться на этот список (или но крайней мере читать его обзор) рекомен дуется всем, кто серьезно занимается разработкой ядра. Даже только наблюдая за работой специалистов, можно узнать достаточно МНОГО.

Подписаться на данный список рассылки можно, отправив сообщение subscribe linux-kernel в виде обычного текста на адрес m a j o r d o m o @ v g e r. k e r n e l. o r g. Больше информа ции доступно по Интернет-адресу h t t p : / / v g e r. k e r n e l. o r g /, а список часто зада ваемых вопросов (FAQ) — по адресу h t t p : //www.tux.org/lkml/.

Много других WWW-сайтов и списков рассылки посвящены как ядру, так и вообще операционной системе Linux. Отличный ресурс для начинающих хакеров — h t t p : / / www.kernelnewbies.org/, сайт, который сможет удовлетворить желания всех, кто, стачивая зубы, грызет основы разработки ядра. Два других отличных источника ин формации — это сайт http://www.lwn.net/, Linux Weekly News, на котором есть большая колонка новостей ядра, и сайт h t t p : / / w w w. k e r n e l t r a f f i c. o r g, Kernel Traffic, который содержит сводку сообщений из списка рассылки разработчиков ядра Linux с. комментариями.

Стиль написания исходного кода Как и для любого большого программного проекта, для ядра Linux определен стиль написания исходного кода, который определяет форматирование и размеще ние кода. Это сделано не потому, что стиль написания, который принят для Linux, лучше других (хотя очень может быть), и не потому, что все программисты пишут неразборчиво (хотя тоже бывает), а потому, что одинаковость стиля является важным моментом для обеспечения производительности разработки. Часто говорят, что стиль написания исходного кода не важен, потому что он не влияет на скомпилирован ный объектный код. Однако для большого программного проекта, в котором задей ствовано большое количество разработчиков, такого как ядро, важна слаженность стиля. Слаженность включает в себя одинаковость восприятия, что ведет к упроще нию чтения, к избежанию путаницы и вселяет надежду на то, что и в будущем стиль останется одинаковым. К тому же, это приводит к увеличению количества разработ чиков, которые смогут нормально читать ваш код, и увеличивает количество кода, который вы сможете нормально читать. Для проектов с открытым исходным кодом чем больше будет глаз, тем лучше.

Пока стиль еще не выбран и широко не используется, не так важно, какой имен но стиль выбрать. К счастью, еще очень давно Линус представил на рассмотрение стиль, который необходимо использовать, и при написании большей части кода сей час стараются придерживаться именно этого стиля. Подробное описание стиля при ведено в файле D o c u m e n t a t i o n / C o d i n g S t y l e со свойственным Линусу юмором.

Отступы Для выравнивания текста и введения отступов используются символы табуляции.

Размер одного символа табуляции при отображении соответствует восьми позициям.

Это не означает, что для структурирования можно использовать восемь или четы ре символа "пробел" либо что-нибудь еще. Это означает, что каждый уровень отсту па равен одному символу табуляции от предыдущего и что при отображении длина символа табуляции равна восьми символам. По непонятным причинам, это правило почти всегда нарушается, несмотря на то что оно очень сильно влияет на читабель ность. Восьмисимвольная табуляция позволяет очень легко визуально различать от дельные блоки кода даже после нескольких часов работы.

Если табуляция в восемь символов кажется очень большой, то не нужно делать так много вложений кода. Почему ваши функции имеют пять уровней вложенности?

Необходимо исправлять код, а не отступы.

Фигурные скобки Как располагать фигурные скобки, это личное дело каждого, и практически нет никаких принципиальных причин, по которым одно соглашение было бы лучше дру гого, но какое-нибудь соглашение все-таки должно быть. Принятое соглашение при 406 Глава разработке ядра — это размещать открывающую скобку в первой строке, сразу за со ответствующим оператором. Закрывающая скобка помещается в первой позиции с новой строки, как в следующем примере.

if (fox) { dog();

cat();

} В случае, когда за закрывающей скобкой продолжается то же самое выражение, то продолжение выражения записывается в той же строке, что и закрывающая скоб ка, как показано ниже if (fox) { ant();

pig();

} else { dog();

cat();

} или следующим образом.

do { dog();

cat();

} while (fox);

Для функций это правило не действует, потому что внутри одной функции тело другой функции описывать нельзя.

unsigned long func(void) { /*.. */ } И наконец, для выражений, в которых фигурные скобки не обязательны, эти скобки можно опустить.

if (foo) bar();

Логика всего этого базируется на K&R.

Длинные строки При написании кода ядра необходимо стараться, насколько это возможно, чтобы длина строки была не больше 80 символов. Это позволяет строкам, при отображе нии на терминале размером 80x24 символа, вмещаться в одну строу терминала.

Брайан У. Керниган, Деннис М. Ритчи, Язык программирования С, 2-е изд. Пер. с англ. — М.: Издат.

дом "Вильяме", 2005.

Заплаты, разработка и сообщество Не существует стандартного правила, что делать, если длина строки кода обяза тельно должна быть больше 80 символов. Некоторые разработчики просто пишут длинные строки, возлагая ответственность за удобочитаемое отображение строк на программу текстового редактора. Другие разработчики разбивают такие строки на части и вручную вставляют символы конца строки в тех местах, которые кажутся им наиболее подходящими для этого, и отделяют продолжения разбитой строки от ее начала двумя символами табуляции.

Некоторые разработчики помещают параметры функции друг под другом, если параметры не помещаются в одной строке, как в следующем примере.

static void get_pirate_parrot(const char *name, unsigned long disposition, unsigned long feather_quality) Другие разработчики разбивают длинную строку на части, но не располагают па раметры функций друг под другом, а просто используют два символа табуляции для отделения продолжений длинной строки от ее начала, как показано ниже.

int find_pirate_flag_by_color(const char *color, const char *name, int len) Поскольку на этот счет нет определенного правила, выбор остается за разработ чиками, то есть за вами.

Имена В именах нельзя использовать символы разных регистров. Назвать переменную именем idx, или даже i — это очень хорошо, но при условии, что будет понятно на значение этой переменной. Слишком хитрые имена, такие как theLoopIndex, недо пустимы. Так называемая "венгерская запись" (Hungarian notation), когда тип пере менной кодируется в ее имени, В данном случае — признак плохого тона. Это С, а не Java и Unix, а не Windows.

Тем не менее, глобальные переменные и функции должны иметь наглядные име на. Если глобальной функции присвоить имя a t t y ( ), то это может привести к пу танице. Более подходящим будет имя g s t a c t i v e t t y ( ). Это все-таки Linux, а не BSD.

Функции Существует мнемоническое правило: функции не должны по объему кода пре вышать двух экранов текста и иметь больше десяти локальных переменных. Каждая функция должна выполнять одно действие, но делать это хорошо. Не вредно раз бить функцию на последовательность более мелких функций. Если возникает бес покойство по поводу накладных расходов за счет вызова функций, то можно исполь зовать подстановку тела — i n l i n e.

Комментарии Очень полезно использовать комментарии кода, но делать это нужно правильно.

Обычно необходимо описывать, что делает код и для чего это делается. То, как реа лизован алгоритм, описывать не нужно, это должно быть ясно из кода. Если так сде 408 Глава лать не получается, то, возможно, стоит пересмотреть то, что вы написали. Кроме того, комментарии не должны включать информацию о том, кто написал функцию, когда это было сделано, время модификации и др. Такую информацию логично раз мещать в самом начале файла исходного кода.

В ядре используются комментарии в стиле С, хотя компилятор gcc поддерживает также и комментарии в стиле C++. Обычно комментарии кода ядра должны быть по хожи на следующие (только на английском языке, конечно).

/* * get_ship_speed() - возвращает текущее значение скорости * пиратского корабля * Необходима для вычисления координат корабля.

* Может переходить в состояние ожидания, * нельзя вызывать при удерживаемой блокировке.

*/ Комментарии внутри функций встречаются редко, и их нужно использовать толь ко в специальных ситуациях, таких как документирование дефектов, или для важных замечаний. Важные замечания часто начинаются со строки "XXX: ", а информация о дефектах— со строки "FIXME: ", как в следующем примере.

/* * FIXME: Считается, что dog == cat.

* В будущем это может быть не так */ У ядра есть возможность автоматической генерации документации. Она основана на GNOME-doc, но немного модифицирована и называется Kernel-doc. Для создания документации в формате HTML необходимо выполнить следующую команду.

make htmldocs Для генерации документации в формате postscript команда должна быть следую щей.

make psdocs Документировать код можно путем введения комментариев в специальном фор мате.

/** * find_treasure - нахождение сокровищ, помеченных на карте крестом * @map - карта сокровищ * @time - момент времени, когда были зарыты сокровища * * Должна вызываться при удерживаемой блокировке pirate_ship_lock.

*/ void find_treasure (int dog, int cat) { /*.. */ } Для более подробной информации см. файл Documentation/kernel-doc-nano HOWTO.txt.

Заплаты, разработка и сообщество Использование директивы t y p e d e f Разработчики ядра не любят определять новые типы с помощью оператора typedef, и причины этого довольно трудно объяснить. Разумное объяснение может быть следующим.

• Определение нового типа через оператор t y p e d e f скрывает истинный вид структур данных.

• Поскольку новый тип получается скрытым, то код более подвержен таким не хорошим вещам, как передача структуры данных в функцию по значению, че рез стек.

• Использование оператора typedef — признак лени.

Чтобы избежать насмешек, лучше не использовать оператор typedef.

Конечно, существуют ситуации, в которых полезно использовать оператор t y p e d e f : сокрытие специфичных для аппаратной платформы деталей реализации или обеспечение совместимости при изменении типа. Нужно хорошо подумать, дей ствительно ли оператор t y p e d e f необходим или он используется только для того, чтобы уменьшить количество символов при наборе кода.

Использование того, что уже есть Не нужно изобретать паровоз. Ядро предоставляет функции работы со строками, подпрограммы для сжатия и декомпрессии данных и интерфейс работы со связан ными списками — их необходимо использовать.

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

Никаких директив i f d e f в исходном коде Использование директив препроцессора i f d e f в исходном коде категорически не рекомендуется. Никогда не следует делать чего-нибудь вроде следующего.

...

#ifdef config_foo foo();

#endif...

Вместо этого, если макрос CONFIG_FOO не определен, необходимо определять функцию fоо(), как ту, которая ничего не делает.

tifdef CONFIG_FOO static int foo(void) { /*.. */ } #else static inline int foo(void) { } #endif 410 Глава После этого можно вызывать функцию foo() без всяких условий. Пусть компи лятор поработает за вас.

Инициализация структур Структуры необходимо инициализировать, используя метки полей. Это позво ляет предотвратить некорректную инициализацию при изменении структур. Это также позволяет выполнять инициализацию не всех полей. К сожалению, в стан дарте С99 принят довольно "страшненький" формат меток полей, а в компиляторе gcc ранее использовавшийся формат меток полей в стиле GNU признан устаревшим.

Следовательно, для кода ядра необходимо использовать новый формат, согласно стандарту С99, каким бы ужасным он ни был.

struct foo rny_foo = {.а = INITIAL_A,.Ь = INITIAL_B, };

где а и b — это поля структуры s t r u c t foo, а параметры INITIAL_A и INITIAL_B — соответственно, их начальные значения. Если поле не указано при инициализации, то оно устанавливается в свое начальное значение, согласно стандарту ANSI С (ука зателям присваивается значение NULL, целочисленным полям — нулевое значение, а нолям с плавающей точкой— значение 0.0). Например, если структура s t r u c t foo также имеет поле i n t с, то это поле в предыдущем примере будет инициализирова но в значение 0.

Да, это ужасно. Но у нас нет другого выбора.

Исправление ранее написанного кода Если в ваши руки попал код, который даже близко не соответствует стилю напи сания кода ядра Linux, то все равно не стоит терять надежды. Немного упорства, и утилита i n d e n t поможет сделать все как надо. Программа i n d e n t — отличная утили та GNU, которая включена во многие поставки ОС Linux и предназначена для фор матирования исходного кода в соответствии с заданными правилами. Установки по умолчанию соответствуют стилю форматирования GNU, который выглядит не очень красиво. Для того чтобы утилита выполняла форматирование в соответствии со сти лем написания кода ядра Linux, необходимо использовать следующие параметры.

indent -kr -i8 -ts8 -sob -180 -ss -bs -psl <файл> Можно также использовать сценарий s c r i p t s / L i n d e n t, который вызывает ути литу i n d e n t с необходимыми параметрами.

Организация команды разработчиков Разработчики — это хакеры, которые занимаются развитием ядра Linux.

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

Заплаты, разработка м сообщество Для различных частей ядра выбираются ответственные разработчики (mainlainers), которые официально выполняют их поддержку. Ответственные разработчики — это один человек или группа людей, которые полностью отвечают за свою часть ядра.

Каждая подсистема ядра, например сетевая подсистема, также имеет связанного с ней ответственного. Разработчики, которые отвечают за определенный драйвер или подсистему, обычно перечислены в файле MAINTAINERS. Этот файл тоже находится в корневом каталоге дерева исходных кодов.

Среди ответственных разработчиков существует специальный человек, который отвечает за все ядро в целом (kernel maintainer). Исторически, Линус отвечает за разрабатываемую серию ядер (где наиболее интересно) и за первые выпуски ста бильной версии ядра. Вскоре после того как ядро становится стабильным, Линус пе редает бразды правления одному из ведущих разработчиков. Они продолжают под держку стабильной серии ядра, а Линус начинает работу над новой разрабатываемой серией. Таким образом, серии ядер 2.0, 2.4 и 2.6 все еще активно поддерживаются.

Несмотря на слухи, здесь нет никаких других, в том числе тайных, организаций.

Отправка сообщений об ошибках Если вы обнаружили ошибку, то наилучшим решением будет исправить ее, сгене рировать соответствующую заплату, оттестировать и отправить, как это будет расска зано в следующих разделах. Конечно, можно и просто сообщить об ошибке, чтобы кто-нибудь исправил ее для вас.

Наиболее важная часть сообщения об ошибке — это полное описание проблемы.

Необходимо описать симптомы, системные сообщения и декодированное сообще ние oops (если такое есть). Еще более важно, чтобы вы смогли пошагово описать, как устойчиво воспроизвести проблему, и кратко описать особенности вашего аппа ратного обеспечения.

Следующий этап — определение того, кому отправить сообщение об ошибке.

В файле MAINTAINERS приведен список людей, которые отвечают за каждый драй вер и подсистему. Эти люди должны получать все сообщения об ошибках, которые возникают в том коде, поддержку которого они выполняют. Если вы не смогли най ти необходимого разработчика, то отправьте вопрос в список рассылки разработчи ков ядра Linux по адресу l i n u x - k e r n e l @ v g e r. k e r n e l. o r g. Даже если вы нашли нужное ответственное лицо, то никогда не помешает отправить копию сообщения в список рассылки разработчиков.

Больше информации об этом приведено в файлах REPORTING-BUGS и Documentation/oops-tracing.txt.

Генерация заплат Все изменения исходного кода ядра Linux распространяются в виде заплат (patch).

Заплаты представляют собой результат вывода утилиты GNU d i f f ( 1 ) в формате, который может подаваться на вход программы p a t c h ( 1 ). Наиболее просто сгене рировать заплату можно в случае, когда имеется два дерева исходных кодов ядра:

одно — стандартное, а другое — с вашими изменениями. Обычная схема имен состоит в том, что каталог, в котором находится стандартное ядро, называется 1 i n u x - x. у. z (каталог, в который разворачивается архив дерева исходного кода в формате tar), a 412 Глава имя модифицированного ядра — l i n u x. Для генерации заплаты на основе двух ката логов с исходным кодом необходимо выполнить следующую команду из каталога, в котором находятся два рассмотренных дерева исходного кода.

diff -urN linux-x.y.z/linux/ > my-patch Обычно это делается где-нибудь в домашнем каталоге, а не в каталоге / u s r / s r c / linux, поэтому нет необходимости иметь права пользователя root. Флаг -u указыва ет, что необходимо использовать унифицированный формат вывода команды diff.

Без этого флага внешний вид заплаты получается неудобочитаемым. Флаг -r указы вает на необходимость рекурсивного анализа каталогов, а флаг -N указывает, что новые файлы, которые появились в измененном каталоге, должны быть включены в результат вывода команды diff. Если же необходимо получить только изменения одного файла, то можно выполнить следующую команду.

diff -u linux-x.y.z/some/file_linux/some/file > my-patch Обратите внимание на то, что вычислять изменения необходимо всегда, находясь в одном текущем каталоге, а именно в том, где находятся оба дерева исходного кода.

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

patch -p1 <../my-patch В этом примере имя файла, который содержит заплату, - my-patch, а находится он в родительском каталоге по отношению к каталогу, в котором хранится дерево исходного кода ядра. Флаг -p1 означает, что необходимо игнорировать (strip) имя первого каталога в путях всех файлов, в которые будут вноситься изменения. Это позволяет применить заплату независимо от того, какие имена каталогов кода ядра были на той машине, где создавалась заплата.

Полезная утилита d i f f s t a t позволяет сгенерировать гистограмму изменений, к которым приведет применение заплаты (удаление и добавление строк). Для того чтобы получить эту информацию для какой-либо заплаты, необходимо выполнить следующую команду.

diffstat -p1 my-patch Обычно полезно включить результат выполнения этой команды при отправле нии заплаты п список рассылки lkml. Так как программа p a t c h (1) игнорирует все строки до того момента, пока не будет обнаружен формат diff, то вначале заплаты можно включить короткое описание.

Представление заплат Заплата должна быть сгенерирована так, как описано в предыдущем разделе.

Если заплата касается определенного драйвера или подсистемы, то заплату нужно отправить соответствующему ответственному разработчику, одному из тех, которые перечислены в файле MAINTAINERS. Другой вариант — это отправить сообщение в список рассылки разработчиков ядра по адресу l i n u x - k e r n e l @ v g e r. k e r n e l. o r g.

Заплаты, разработка и сообщество Обычно тема (subject) письма, в котором содержится заплата, должна быть по хожа на следующую " [PATCH] короткое описание. ". В теле письма должны быть описаны основные технические детали изменений, которые вносятся заплатой, а также обоснования необходимости этих изменений. Описание должно быть макси мально конкретным. Также необходимо указать, на какую версию ядра рассчитана заплата.

Большинство разработчиков ядра будут просматривать заплату прямо в теле пись ма и при необходимости записывать все письмо в файл. Следовательно, лучше все го будет вставить заплату прямо в тело письма, в самом конце сообщения. Будьте внимательны, потому что некоторые злобные почтовые клиенты вводят в сообще ния дополнительное форматирование. Это испортит заплату и будет надоедать раз работчикам. Если ваш почтовый клиент делает такие вещи, то необходимо поискать возможность включения текста без изменений ("Insert Inline") или что-нибудь ана логичное. Нормально работает также присоединение (attachment) заплаты в виде обычного текста, без перекодировки.

Если заплата большая или содержит несколько принципиальных изменений, то лучше разбить ее на логические части. Например, если вы предложили новый API и изменили несколько драйверов с целью его использования, то эти изменения мож но разбить на две заплаты (новый API и изменения драйверов) и выслать их двумя письмами. Если в каком-либо случае необходимо вначале применить предыдущую за плату, то это необходимо специально указать.

После отправки наберитесь терпения и подождите ответа. Не нужно обижаться на негативный ответ — в конце концов это тоже ответ! Обдумайте проблему и вы шлите обновленную версию заплаты. Если ответа нет, то попытайтесь разобраться, что было сделано не так, и решить проблему. Спросите у ответственного разработ чика и в списке рассылки по поводу комментариев. Если повезет, то ваши изменения будут включены в новую версию ядра!

Заключение Наиболее важными качествами любого хакера являются желание и умение рабо тать — нужно искать себе проблемы и решать их. В этой книге приведено описание основных частей ядра, рассказано об интерфейсах, структурах данных, алгоритмах и принципах работы. Книга предоставляет вид ядра изнутри и делает это в практиче ской форме. Она предназначена для того, чтобы удовлетворить ваше любопытство и стать отправной точкой в разработке ядра.

Тем не менее, как уже было сказано, единственный способ начать разрабатывать ядро — это начать читать и писать исходный код. Операционная система Linux пре доставляет возможность работать в сообществе, которое не только позволяет это делать, но и активно побуждает к указанным действиям. Если есть желание действо вать — вперед!

414 Глава А Связанные списки С вязанный список — это структура хранения информации (контейнер), которая может содержать переменное количество элементов данных, часто называе мых узлами, и позволяет манипулировать этими данными. В отличие от статического массива, элементы связанного списка можно создавать динамически. Это дает воз можность создавать переменное количество элементов списка, причем указанное ко личество может быть неизвестно на этапе компиляции. Так как элементы связанных списков создаются в разные моменты времени, они не обязательно будут находиться в смежных областях оперативной памяти. Поэтому элементы списка должны быть связаны друг с другом таким образом, чтобы каждый элемент содержал указатель на следующий за ним элемент (next). Вставка или удаление элементов списка выполня ется простым измепением указателей на следующий элемент. Структура связанного списка показана на рис. А.1.

next next next NULL Рис. A.I. Однос&язный список В. некоторых связанных списках содержится указатель не только на следующий, но и на предыдущий элемент (prev). Эти списки называются двухсвязными (doubly link ed), потому что они связаны как вперед, так и назад. Связанные списки, аналогичные тем, что показаны на рис.А.1, называются односвязиыми (singly linked). Двухсвязный список показан на рис. А.2.

prev prev next prev next next NULL NULL Рис. А.2. Двухсвязный список Кольцевые связанные списки Последний элемент связанного списка не имеет следующего за ним элемента, и значение указателя n e x t последнего элемента обычно устанавливается равным спе циальному значению, обычно NULL, чтобы показать, что этот элемент списка явля ется последним. в определенных случаях последний элемент списка не указывает на специальное значение, а указывает на первый элемент этого же списка. Такой список называется кольцевым связанным списком (circular linked list), поскольку связи образуют топологию кольца. Кольцевые связанные списки могут быть как односвязными, так и двухсвязными. В двухсвязных кольцевых списках указатель p r e v первого элемента указывает на последний элемент списка. На рис. А.З и А.4 показаны соответственно односвязные и двухсвязные кольцевые списки.

next next next Рис. A3. Односвязный кольцевой список prev prev next prev next next Рис. А.4. Двухсвязный кольцевой список Стандартной реализацией связанных списков в ядре Linux является двухсвязный кольцевой список. Такие связанные списки обеспечивают наибольшую гибкость работы.

Перемещение по связанному списку Перемещение по связанному списку выполняется последовательно (линейно).

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

416 Приложение А Часто первый элемент списка представлен с помощью специального указателя, который называется головным элементом или головой (head), что дает возможность бы стро и легко обращаться к первому элементу. В некольцевом связанном списке по следний элемент отличается тем, что его указатель равен значению NULL. В кольце вом связанном списке последний элемент отличается тем, что указывает на головной элемент. Таким образом прохождение списка можно выполнить линейно, начиная с первого элемента и заканчивая последним. В двухсвязном списке прохождение мож но также выполнить и в противоположном направлении, начиная с последнего и за канчивая первым элементом. Конечно, если задан определенный элемент списка, то можно перейти по списку вперед и назад на заданное количество элементов. При этом нет необходимости проходить весь список.

Реализация связанных списков в ядре Linux В ядре Linux для прохождения по связанным спискам используется унифициро ванный подход. При прохождении связанного списка, если не важен порядок про хода, эту операцию не обязательно начинать с головного элемента, на самом деле вообще не важно, с какого элемента списка начинать прохождение! Важно только, чтобы при таком прохождении были пройдены все узлы. В большинстве случаев нет необходимости вводить концепции первого и последнего элементов. Если в кольце вом связанном списке содержится коллекция несортированных данных, то любой эле мент можно назвать головным. Для прохождения всего связанного списка необходи мо взять любой элемент и следовать за указателями, пока снова не вернемся к тому элементу, с которого начали обход списка. Это избавляет от необходимости вводить специальный головной элемент. Кроме того, упрощаются процедуры работы со свя занными списками. Каждая подпрограмма должна просто принимать указатель на один элемент — любой элемент списка. Разработчики ядра даже немножко гордятся такой остроумной реализацией.

Связанные списки в ядре, так же как и в любой сложной программе, встречаются часто. Например, в ядре связанный список используется для хранения списка задач (структура t a s k _ s t r u c t каждого процесса является элементом связанного списка).

Структура элемента списка Раньше в ядре было несколько реализаций связанных списков. Тем не менее в таких случаях необходима единая реализация с целью убрать разный код, который выполняет одинаковые действия. Во время разработки серии ядер 2.1 была пред ложена единая реализация связанных списков в ядре. Сегодня во всех подсистемах ядра используется официальная реализация. Для новых разработок необходимо ис пользовать только существующий интерфейс и не нужно изобретать велосипед.

Код работы со связанными списками определен в файле < l i n u x / l i s t. h >, a основная структура данных имеет очень простой вид.

struct list_head { struct list_head *next, *prev;

};

Обратите внимание на характерное имя структуры l i s t h e a d. Такое название выбрано, чтобы подчеркнуть, что списку не нужно головного элемента. Наоборот, Связанные списки обход списка можно начинать с любого элемента, и каждый элемент может быть головным. В связи с этим все элементы списка называются головными (list head).

Указатель next указывает на следующий элемент списка, а указатель prev— на пред ыдущий элемент списка. Если текущий элемент списка является последним, то его указатель next указывает на первый узел. Если же текущим элементом является пер вый, то его указатель prev указывает па последний узел списка. Благодаря элегант ной реализации связанных списков без концепции головного элемента, можно во обще не вводить понятия первого и последнего элементов.

Структура l i s t h e a d сама по себе бесполезна. Ее необходимо включать в другие структуры данных.

struct my_struct { struct list_head list;

unsigned long dog;

void *cat;

};

Перед использованием элементы связанных списков должны быть инициализиро ваны. Так как элементы связанных списков обычно создаются динамически (иначе, вероятно, не нужно использовать связанный список), то эти элементы, как правило, инициализируются во время выполнения.

struct my_struct *р;

/* выделить память для структуры my_struct.. */ p->dog = 0;

p->cat = NULL;

INIT_LIST_HEAD(&p->list);

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

struct my_struct mine = {.list = LIST_HEAD_INIT(mine.list),.dog = 0,.cat = NULL };

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

static LIST_HEAD(fox);

Эта команда позволяет статически создать связанный список с именем fox.

Нет необходимости явно выполнять какие-либо операции со служебными полями элементов связанного списка. Вместо этого необходимо просто включить структуру узла связанного списка в вашу структуру данных, чтобы можно было легко манипули ровать данными и выполнять прохождение по связанному списку.

418 Приложение А Работа со связанными списками Для работы со связанными списками ядро предоставляет семейство функций. Все они принимают указатели на одну или более структур l i s t head. Все функции вы полнены как функции с подстановкой тела (inline) на языке С, и их все можно найти в файле < l i n u x / l i s t. h >.

Интересно, что время выполнения всех этих функций масштабируется как О (1) Это значит, что они выполняются в течение постоянного интервала времени независи мо от количества элементов списка, для которого они вызываются. Например, время добавления элемента в связанный список из 3 и 3000 элементов будет одинаковым.

Это, возможно, и не вызывает удивления, но тем не менее, приятно.

Для добавления элемента в связанный список можно использовать следующую функцию.

list_add(struct list_head *new, struct list head *head) Эта функция добавляет узел new в заданный связанный список сразу после эле мента head. Поскольку связанный список является кольцевым и для него не суще ствует понятий первого и последнего узлов, в качестве параметра head можно использо вать указатель на любой элемент списка. Если в качестве рассмотренного параметра всегда передавать указатель на последний элемент, то эту функцию можно использо вать для организации стека.

Для добавления элемента в конец связанного списка служит следующая функция.

list_add_tail (struct list_head *new, struct list_head *head) Эта функция добавляет новый элемент new в связанный список сразу перед эле ментом, на который указывает параметр head. Поскольку связанный список являет ся кольцевым, то, как и в случае функции l i s t _ a d d (), в качестве параметра head можно передавать указатель на любой элемент списка. Эту функцию можно исполь зовать для реализации очереди, если передавать указатель на первый элемент.

Для удаления узла списка служит следующая функция.

list_del (struct list_head *entry) Эта функция позволяет удалить из списка элемент, на который указывает пара метр e n t r y. Обратите внимание, что эта функция не освобождает память, выде ленную под структуру данных, содержащую узел списка, на который указывает па раметр e n t r y. Данная функция просто удаляет узел из списка. После вызова этой функции обычно необходимо удалить структуру данных, в которой находится узел list_head.

Для удаления узла из списка и повторной инициализации этого узла служит сле дующая функция.

list_del_init(struct list head *entry) Вопросы сложности алгоритмов рассматриваются в приложении В.

Связанные списки Эта. функция аналогична функции l i s t _ d e l ( ), за исключением того, что она до полнительно инициализирует указанную структуру l i s t h e a d из тех соображений, что эта структура данных больше не нужна в качестве элемента текущего списка и ее повторно можно использовать.

Для перемещения узла из одного списка в другой предназначена следующая функ ция.

list_move(struct list_head *list, struct list_head *head) Эта функция удаляет элемент l i s t из одного связанного списка и добавляет его в другой связанный список после элемента head.

Для перемещения элемента из одного связанного списка в конец другого служит следующая функция.

list_move_tail (struct list_head *list, struct list_head *head) Эта функция выполняет то же самое, что и функция list_rnove (), но вставляет элемент перед элементом head.

Для проверки того, пуст ли список, служит функция.

list_empty (struct list_head *head) Эта функция возвращает ненулевое значение, если связанный список пуст, и ну левое значение в противном случае.

Для объединения двух не перекрывающихся связанных списков служит следую щая функция.

list_splice(struct list_head *list, struct list_head *head) Эта функция вставляет список, на который указывает параметр l i s t, в другой список после параметра head.

Для объединения двух не перекрывающихся списков и повторной инициализа ции старого головного элемента служит следующая функция.

list splice init(struct list head *list, struct list head *head) Эта функция аналогична функции l i s t s p l i c e ( ), за исключением того, что па раметр l i s t, представляющий список, из которого удаляются элементы, повторно инициализируется.

Как избежать двух лишних разыменований Если вам уже доступны указатели n e x t и p r e v, то можно сэкономить пару процессорных тактов (в частности, время выполнения операций разыменования указателей) путем вызова внутрен них функций работы со связанными списками. Все ранее рассмотренные функции в сущности не делают ничего, кроме получения указателей n e x t и p r e v и вызовов внутренних функций.

Внутренние функции имеют те же имена, что и их оболочки, но перед именем используется два символа подчеркивания. Вместо того чтобы вызвать функцию l i s t _ d e l ( l i s t ), можно вызвать функцию _ _ l i s t _ d e l ( p r e v, n e x t ). Это имеет смысл, только когда указанные ука затели уже известны. В противном случае просто получится некрасивый код. Для подробной информации об этих интерфейсах можно обратиться к файлу < l i n u x / l i s t. h >.

Приложение А Перемещение по связанным спискам Теперь мы уже знаем, как объявлять, инициализировать и работать со связан ными списками в ядре. Это все хорошо, но не имеет никакого смысла, если нет возможности работать С данными, которые хранятся в списках! Связанный спи сок — это просто контейнер, в котором хранятся важные данные. Необходимо иметь способ перемещения по списку и доступа к данным. К счастью, ядро предоставляет набор полезных интерфейсов для перемещения по связанным спискам и обращения к структурам данных, которые хранятся в этих списках.

Обратите внимание, что, в отличие от подпрограмм управления списками, опера ции перебора элементов списка из н узлов масштабируются как О (n).

Наиболее простой способ выполнять итерации по элементам связанного спи ска — это использовать макрос l i s t _ f o r _ e a c h (). Этот макрос принимает два па раметра— указатели на структуры list_head. Первый параметр указывает на теку щий элемент списка, а второй — на любой элемент списка, для которого необходимо обойти все узлы. На каждой итерации цикла первый параметр макроса указывает на текущий элемент списка, пока не будут пройдены все элементы, как в следующем примере.

struct list_head *р;

list_for_each(p, list) { /* р указывает на каждый элемент списка list */ } Это пока все еще бесполезно! Указатель на структуру узла списка — это не то, что нам нужно. Нам нужен указатель на структуру данных, в которой содержится струк тура узла. В показанном ранее примере структуры данных my_struct необходимо получить указатель на каждый экземпляр структуры my_struct, а не на их поля l i s t. Макрос l i s t e n t r y ( ) возвращает структуру данных, которая содержит соот ветствующий элемент list_head. Этот макрос принимает три параметра: указатель на текущий узел, тип структуры данных, в которую включен узел списка, и имя поля структуры данных, в которой хранится этот узел.

struct list_head *р;

struct my_struct *my;

list_for_each(p, mine->list) { my = list_entry(p, struct my_struct, list);

/* * указатель my указывает на все структуры данных, * в которые включено поле list */ } Макрос list_for_each () раскрывается в обычный цикл for. Предыдущий при мер раскрывается следующим образом, for (р = mine->list->next;

р != mine->list;

р = p->next) Кроме этого, макрос l i s t _ f o r _ e a c h ( ) также выполняет предварительную за грузку (prefetch) данных в память, если процессор поддерживает такую возможность, Связанные списки чтобы все данные следующих элементов списка гарантированно находились в памя ти. Когда нет необходимости выполнять предварительную загрузку, можно использо вать макрос l i s t _ f o r _ e a c h ( ), который работает в точности, как цикл for. Если нет гарантии, что список содержит очень мало элементов или пустой, то всегда не обходимо использовать версию с предварительной загрузкой. Никогда нельзя про граммировать цикл вручную, необходимо всегда использовать макрос.

Если необходимо выполнить прохождение по спискам в обратном порядке, то следует использовать макрос list_for_each_prev (), который использует для про хождения указатель prev, а не указатель next.

Обратите внимание, что при прохождении связанного списка ничто не мешает удалять элементы из этого списка. Обычно, чтобы предотвратить конкурентный до ступ, следует использовать блокировки. Макрос list_for_each_safe() использует временные переменные, чтобы сделать прохождение списка безопасным при одно временном удалении элементов.

struct list_head *p, *n;

struct my_struct *my;

list_for_each_safe (p, n, &mine->list) { my = list_entry (p, struct my_struct, list);

/* * указатель my указывает на каждый экземпляр * структуры my_struct в списке */ } Обратите внимание, что этот макрос защищен только от операций удаления узлов списка. Для защиты отдельных элементов списка от конкурентного доступа необхо димо использовать блокировки.

422 Приложение А Б Генератор случайных чисел ядра В ядре Linux реализован генератор случайных чисел, который теоретически мо жет генерировать истинно случайные числа. Генератор случайных чисел собира ет в пул энтропии шумы внешней среды, которые поступают из драйверов устройств.

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

Истинно случайные числа отличаются от псевдослучайных чисел, которые гене рируются библиотечными функциями языка С. Псевдослучайные числа создаются с помощью детерминированных функций. Хотя такие функции и могут генериро вать последовательности чисел, которые обладают некоторыми свойствами истин но случайных чисел, тем не менее такие числа только статистически случайны.

Псевдослучайные числа являются детерминированными, потому что если известно хотя бы одно число последовательности, то можно определить и все остальные.

Если известно так называемое порождающее число последовательности (seed), то обыч но по нему определяется и вся последовательность. Для приложений, которые тре буют истинно случайных чисел, как, например, криптография, псевдослучайные чис ла обычно не подходят.

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

Физический термин энтропия— это мера беспорядка и случайности в любой си стеме. Энтропия измеряется в единицах энергии на единицу температуры (Джоуль на градус Кельвина). Когда Клод Шеннон (Claude Shennon)1, создатель информаци онной теории, искал термин для представления случайности информации, великий Клод Шеннон (30 апреля 1916-24 февраля 2001) работал инженером в компании Bell Labs. В его наиболее известной работе Математическая теории связи, опубликованной в 1948 году, впервые были разработаны основы информационной теории и было введено понятие энтропии Шеннона.

Шеннон также любил кататься на одноколесном велосипеде.

математик Джон фон Нейман (John von Neumann)2 предложил ему использовать термин энтропия, потому что никто толком не понимает, что за этим понятием кро ется. Шеннон согласился, и сегодня это звучит как энтропия Шеннона. Некоторые ученые считают, что такое двойное название только вносит путаницу, и когда речь идет об информации, то используют термин неопределенность. Разработчики ядра, на оборот, считают, что "энтропия"- это "круто", и поддерживают использование дан ного термина.

При рассмотрении генераторов случайных чисел понятие энтропии Шеннона яв ляется очень важным. Эта характеристика измеряется в битах на символ. Высокое значение энтропии означает, что в последовательности символов мало полезной (точнее, предсказуемой) информации и много случайного "мусора". Ядро поддер живает пул энтропии, который пополняется данными, возникающими в результате недетерминированных событий, связанных с аппаратными устройствами. В идеале, этот пул содержит полностью случайные данные. Для того чтобы иметь представ ление о значении энтропии пула, ядро постоянно вычисляет меру неопределенно сти данных в пуле. По мере того как ядро добавляет данные в пул, оно оценивает меру случайности добавляемых данных. И наоборот, по мере того как данные из влекаются из пула, ядро уменьшает значение оценки энтропии. Соответствующая количественная характеристика называется оценкой энтропии. Если значение оценки энтропии становится равным нулю, то ядро может отказаться выполнять запрос по считыванию данных из пула.

Генератор случайных чисел ядра был предложен в версии 1.3.30 и находится в файле drivers/char/random.с.

Принцип работы и реализация Компьютеры— это предсказуемые устройства. Действительно, трудно найти слу чайное поведение в системе, поведение которой можно практически полностью программировать. Однако окружающая среда, где находится машина, полна различ ных шумов, которые недетерминированы и которые можно измерить. Источники таких шумов включают моменты времени, в которые возникают события, связанные с аппаратными устройствами, а также события, связанные с взаимодействием поль зователей и компьютера. Например, интервалы времени между нажатиями клавиш, перемещения мыши, интервалы времени между некоторыми типами прерываний и время выполнения запроса блочного ввода-вывода являются недетерминированны ми, и, кроме того, их не может измерить внешний злоумышленник. Случайная ин формация, которая получается из этих событий, записывается в пул энтропии. Пул растет и заполняется случайными и непредсказуемыми шумовыми данными. По мере добавления данных в пул вычисляется оценка энтропии, и итоговое значение запо минается. Это позволяет всегда иметь информацию о значении энтропии в пуле. На рис. Б.1 показана диаграмма прохождения потока энтропии в пул и из пула.

Джон фон Нейман (28 декабря 1903-8 февраля 1957) работал в Институте специальных исследо ваний в Принстоне (Institute for Advanced Study;

Princeton). Он внес большой вклад в математиче ские, экономические и компьютерные науки. Среди наиболее значительных его разработок- тео рия игр, фон-неймановские алгебры и фон-неймановская проблема узких мест.

424 Приложение Б Для доступа к пулу энтропии, как из пространства ядра, так и из пространства пользователя, ядро предоставляет набор интерфейсов. Когда выполняется обра щение к этим интерфейсам, ядро вначале вычисляет хеш-значение SHA данных из пула. Алгоритм SHA (Secure Hash Algorithm, алгоритм вычисления безопасного хеш значения) — это алгоритм вычисления дайджеста сообщения (профиля сообщения, message digest), который был разработан Агентством национальной безопасности (National Security Agency, NSA) и утвержден в качестве федерального стандарта США Национальным институтом стандартов и технологий (NIST) (федеральный стандарт по обработке информации, FIPS 186). Вычисление дайджеста сообщения выполняет ся с помощью специального алгоритма, который принимает сообщение переменно го размера (большое или маленькое) и выдает на выходе хеш-значение фиксирован ного размера (обычно размером 128 или 160 байт). Это фиксированное значение и представляет собой дайджест. Входное сообщение не может быть реконструировано по его хеш-значению. Более того, простое изменение входного сообщения (напри мер, изменение одного символа) приведет к радикальному изменению хеш-значения.

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

Поэтому если известно несколько значений из пула, то это не дает никакой информа ции о прошлых и будущих значениях. Ядро может использовать оценку энтропии и отказаться выполнить запрос на считывание данных из пула, если значение энтропии равно нулю. По мере того как из пула считываются данные, оценка энтропии умень шается. Это реакция на то, что о пуле становится известно больше информации.

Пространство пользователя -> <- Пространство ядра При нажатии клавиш 1111010000-> генерируются прерывания 10110001- Ядро использует значения интервалов времени между Приложения считывают информацию Пул энтропии успешными прерываниями из пула через специальные файлы для заполнения пула энтропии /dev/random и /dev/urandom с помощью функции add_keyboard_random ness() Рис. Б.1. Прохождение энтропии через пул энтропии ядра Когда значение оценки энтропии достигает нуля, то ядро все равно может воз вращать случайные числа. Однако в этом случае теоретически появляется возмож ность того, что злоумышленник сможет предугадать результат вывода. Для этого тре буются все результаты вывода из пула энтропии, а также чтобы злоумышленник смог Генератор случайных чисел ядра выполнить криптографический анализ алгоритма SHA. Так как алгоритм SHA счи тается безопасным, то это невозможно. Для высоконадежной криптографии оценка энтропии позволяет гарантировать устойчивость случайных чисел. Для большинства пользователей такая дополнительная гарантия не нужна.

Почему это реализовано в ядре?

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

Хотя такая система и может выполняться с правами пользователя root, тем не менее ядро явля ется значительно более безопасным местом для пула энтропии. И наконец, самому ядру также необходимы случайные числа. Получать информацию о случайных числах, которая необходима ядру, из пространства пользователя — это не практично. В связи с этим генератор случайных чисел работает в ядре.

Проблема с загрузкой системы Когда ядро загружается, оно выполняет последовательность действий, которые гарантированно можно предугадать. Следовательно, злоумышленник может предска зать состояние пула энтропии на этапе загрузки. Еще хуже то, что каждая загрузка очень похожа на все остальные и пул инициализируется при каждой загрузке в очень близкие значения. Это уменьшает точность оценки энтропии, потому что нет ника кого способа обеспечить, чтобы энтропия, которая добавляется на этапе загрузки, была менее предсказуема, чем энтропия, которая добавляется при такой же загрузке в другое время.

Для решения проблемы большинство Linux-систем сохраняет на диске содер жимое части пула энтропии между перегрузками системы. При старте системы со храненные данные считываются и записываются в пул энтропии. Загрузка предыду щего содержимого пула в текущий пул позволяет обойтись без увеличения оценки энтропии.

Таким образом, злоумышленник не может предугадать состояние пула энтропии, не зная одновременно предыдущего и текущего состояний системы.

Интерфейсы для ввода энтропии Ядро экспортирует следующее семейство интерфейсов, которые могут использо ваться драйверами и системами для ввода данных в пул энтропии.

void add_interrupt_randomness(int irq) void add_keyboard_randomness (unsigned char scancode) void add_mouse_randomness(u32 mouse_data) Приложение Б Функция add_interrupt_randomness () вызывается системой обработки преры ваний, когда приходит прерывание, обработчик которого зарегистрирован с флагом SA_SAMPLE_RANDOM. Параметр i r q — это номер прерывания. Генератор случайных чисел использует интервалы времени между прерываниями, как источник шума.

Следует помнить, что не все устройства для этого подходят. Если устройства гене рируют прерывания детерминированным образом (например, прерывания тайме ра) или на них может воздействовать внешний злоумышленник (например, сетевые устройства), то такие устройства нельзя использовать для ввода информации в пул.

Подходящее устройство — жесткий диск, который генерирует прерывания с непред сказуемой частотой.

Функция add_keyboard_randomness () использует скан-коды и интервалы вре мени между нажатиями клавиш для ввода энтропии в пул. Интересно, что эта функ ция достаточно интеллектуальна и игнорирует повторение символов при постоян ном нажатии клавиши, потому что повторяющиеся скан-коды и интервалы времени вносят мало энтропии.

Функция add_mouse_randoraness () использует позицию указателя мыши и интер валы времени между прерываниями для заполнения пула. Параметр mouse_data — это позиция указателя, которая возвращается аппаратным обеспечением.

Эти три функции добавляют передаваемые данные в пул энтропии, вычисляют оценку энтропии добавляемых данных и увеличивают оценку энтропии пула на вы численное значение.

Все эти экспортируемые интерфейсы используют внутреннюю функцию add_timer_randomness () для ввода данных в пул. Эта функция вычисляет интер валы времени между успешными событиями одного типа и добавляет эти значения в пул. Например, интервалы времени между успешными прерываниями жесткого дис ка достаточно случайны, особенно если измерять достаточно точно. Самые младшие биты — это обычно электрический шум. После того как эта функция вводит данные в пул, она вычисляет количественную характеристику того, насколько эти данные случайны. Это делается путем вычисления отклонения первого, второго и третье го порядка от предыдущего момента времени и изменения этих отклонений перво го, второго и третьего порядка. Наибольшее из этих отклонений, округленное до 12 бит, используется в качестве оценки энтропии.

Интерфейсы для вывода энтропии Для получения случайных чисел внутри ядра экспортируется один интерфейс.

void get_random_bytes(void *buf, int nbytes) Эта функция сохраняет nbytes случайных байтов в буфере памяти, на который указывает параметр buf. Функция возвращает данные, даже если оценка энтропии равна нулю. Для ядра это не так критично, как для пользовательских криптографи ческих программ. Случайные данные мало используются в ядре, в основном они нужны сетевой подсистеме для генерации стартового номера последовательности сегментов при соединении по протоколу TCP.

Код ядра может выполнить следующий код для получения случайных данных раз мером в одно машинное слово.

Генератор случайных чисел ядра unsigned long rand;

get_random_bytes(&rand, sizeof(rand));

Для программ, которые выполняются в пространстве пользователя, предоставля ется два символьных устройства: /dev/random и /dev/urandom. Первое устройство, /dev/random, используется, когда необходимы гарантированно случайные данные для криптографических приложений с высоким уровнем безопасности. Это устрой ство выдает только то количество битов данных, которое соответствует оценке эн тропии в ядре. Когда оценка энтропии становится равной нулю, операция чтения устройства /dev/random блокируется и не возвращает данные, пока значение эн тропии не станет существенно положительным. Устройство /dev/urandom не имеет последней возможности, а в остальном работает аналогично. Оба устройства возвра щают данные из одного и того же пула.

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

,...

i unsigned long get_random(void) ( unsigned long seed = 0;

int fd;

fd = open("/dev/urandom", O_RDONLY);

if (fd == -1) { perror("open");

return 0;

} if (read (fd, &seed, sizeof(seed)) < 0) { perror("read") ;

seed = 0;

} if (close(fd)) perror("close");

return seed;

} Можно также считать $bytes байтов в файл $file, используя программу del.

dd if=/dev/urandom of=$file count=l bs=$bytes 428 Приложение Б в Сложность алгоритмов В компьютерных и связанных с ними дисциплинах полезно выражать сложность, или масштабируемость, алгоритмов с помощью количественных значащих ха рактеристик (в отличие от менее наглядных характеристик, таких как быстрый или медленный). Существуют различные методы представления масштабируемости.

Один из наиболее часто используемых подходов — это исследование асимптотиче ского поведения алгоритмов. Асимптотическое поведение — это поведение алгоритма при достаточно больших значениях входных параметров или, другими словами, при стремлении входных параметров к бесконечности. Асимптотическое поведение пока зывает, как масштабируется алгоритм, когда его входные параметры принимают все большие и большие значения. Исследование масштабируемости алгоритмов, т.е. из учение свойств алгоритма при больших значениях входных параметров, позволяет смоделировать поведение алгоритма по отношению к тестовым задачам и лучше по нять особенности этого поведения.

Алгоритмы Алгоритм — это последовательность действий, возможно, с одним входом или более и, в конечном счете, с одним результатом или выходом. Например, подсчет количества людей в комнате представляет собой алгоритм, для которого люди, на ходящиеся в комнате, являются входными данными, а количество людей в комнате — выходными данными. Операции замещения страниц в ядре Linux или планирование выполнения процессов — это тоже примеры алгоритмов. Математически алгоритм аналогичен функции (или, по крайней мере, может быть смоделирован с помощью функции). Например, если мы обозначим алгоритм подсчета людей в комнате бук вой f, а количество людей, которых необходимо посчитать, буквой х, то функцию подсчета количества людей можно записать следующим образом.

y=f(х) В этом выражении буквой у обозначено время подсчета количества людей в ком нате.

Множество О Полезным обозначением асимптотического поведения функции является верхняя граница — функция, значения которой всегда больше значений изучаемой функции.

Говорят, что верхняя граница некоторой функции растет быстрее, чем рассматрива емая функция. Специальное обозначение "большого-О" используется для описания этого роста. Это записывается как f (х) О (g (х} ) и читается так: f принадлежит множеству "О-болыпого" от g. Формальное математическое определение имеет сле дующий вид.

Если f(x) принадлежит множеству большого O(g(х)), то Это означает, что время вычисления функции f ( x ) всегда меньше времени вы числения функции g (х), умноженного на некоторую константу, и это справедливо всегда, для всех значений х, больших некоторого начального значения х'.

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

Множество большого-тета Когда говорят об обозначении большого-О, то чаще всего имеют в виду то, что Дональд Кнут (Donald Knulh) описывал с помощью обозначения "большого-тета".

Обозначение "болыпого-О" соответствует верхней границе. Например, число 7 — это верхняя граница числа 6, кроме того, числа 9, 12 и 65— это тоже верхние границы числа 6. Когда рассматривают рост функции, то обычно наиболее интересна наимень шая верхняя граница или функция, которая моделирует как верхнюю, так и нижнюю границу'. Профессор Кнут описывает это с помощью обозначения большого-тета следующим образом.

Если f (х) принадлежит множеству большого-тета от g (x), то g(х) является одновременно и верхней и нижней границей f(х) Можно также сказать, что функция f (x) порядка функции g ( х ). Порядок, или множество "большого-тета" алгоритма, — один из наиболее важных математических инструментов изучения алгоритмов.

Следовательно, когда говорят об обозначении большого-О, то чаще всего имеют в виду наименьший возможный вариант "большого-О" — "болыное-тета". Об этом не нужно особо волноваться, если, конечно, нет желания доставить удовольствие про фессору Кнуту.

Если и н т е р е с н о, то н и ж н я я граница описывается с помощью о б о з н а ч е н и я большого-омега.

Определение аналогично определению множества большого-О, за исключением того, что значе ния функции g ( s ) должны быть меньше значений функции f (х) или равны им.

430 Приложение В Объединяем все вместе Вернемся снова к подсчету количества людей в комнате. Допустим, что можно считать по одному человеку за секунду. Следовательно, если в комнате находится человек, то подсчет займет 7 секунд. Очевидно, что если будет n человек, то подсчет всех займет n секунд. Поэтому можно сказать, что этот алгоритм масштабируется, как О(n). Что если задача будет состоять в том, чтобы станцевать перед всеми, кто находится в комнате? Поскольку, независимо от того, сколько человек будет в комна те, это займет одно и то же время, значит, этот алгоритм масштабируется, как O(1).

В табл. В.1 показаны другие часто встречающиеся характеристики сложности.

Таблица В.1. Значения масштабируемости алгоритмов во времени O(g(x)) Название 1 Постоянная (отличная масштабируемость) log(n) Логарифмическая n Линейная Квадратичная n Кубическая n n Показательная, или экспоненциальная (плохо) n! Факториал (очень плохо) Как масштабируется алгоритм представления всех людей в комнате друг другу?

Какая функция может промоделировать этот алгоритм? Для представления одного человека необходимо 30 секунд, сколько времени займет представление 10 человек друг другу? Что будет в случае 100 человек?

Опасность, связанная со сложностью алгоритмов Очевидно, что будет разумным избегать алгоритмов, которые масштабируются, как О ( n ! ) или О(2 n ). Более того, замена алгоритма, который масштабируется, как О(n), алгоритмом, который масштабируется, как O(1), — это обычно серьезное улуч шение. Тем не менее это не всегда так, и нельзя принимать решение вслепую, бази руясь только на описании "болыпого-О". Вспомните, что в определении множества О ( g ( х ) ) фигурирует константа, на которую умножается значение функции g(х).

Поэтому есть возможность, что алгоритм, который масштабируется, как O(1), будет выполняться в течение 3 часов. Следовательно, он будет выполняться всегда в те чение 3 часов, независимо от количества входных данных, но это может оказаться дольше, по сравнению с алгоритмом, который масштабируется, как О ( n ), при не большом количестве входных данных. При сравнении алгоритмов необходимо всег да принимать во внимание количество входных данных. Не стоит слепо оптимизи ровать для некоторого случайно выбранного варианта.

Сложность алгоритмов г Библиография и список литературы С писок литературы отсортирован и содержит некоторые из самых интересных и полезных книг, которые близки по теме, или дополняют материал данной книги.

Полезность этих книг проверена временем. Некоторые из них представляют со бой "священные писания" но соответствующим темам, в то время как другие просто кажутся автору интересными, глубокими или занимательными. Автор надеется, что читателю они тоже окажутся полезными.

Наилучшая ссылка на "дополнительное чтение", которая лучше всего дополняет материал данной книги — это исходный код ядра. Для работы с ОС Linux у нас есть неограниченный доступ к полному исходному коду ядра современной операционной системы. Не принимайте это как должное! Разберитесь с ним! Читайте код! Пишите код!

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

• Deitel H., Deitel P. and Choffnes D. Operating Systems. Prentice Hall, 2003.

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

• Tanenbaum Andrew. Operating Systems: Design and Implementation. Prentice Hall, 1997.

Хорошие начальные сведения об оснопах построения, принципах работы и ре ализации Unix-подобной операционной системы Minix.

• Tanenbaum Andrew. Modern Operating Systems. Prentice Hall, 2001. Детальный об зор стандартных проблем разработки операционных систем, а также обсужде ние многих концепций, которые используются в современных операционных системах, таких как Unix и Windows.

• Silberschatz A., Galvin P. and Gagne G. Operating System Concepts. John Wiley and Sons, 2001. Также известна, как "книга про динозавров", в связи с тем что на обложке нарисованы динозавры, которые не имеют никакого отношения к теме. Хорошее введение в основы построения операционных систем. Книга часто перерабатывается, но все издания должны быть хорошими.

Книги о ядрах Unix В этих книгах описываются принципы работы и особенности реализации ядер Unix. В первых пяти рассмотрены конкретные варианты Unix, в двух последних — общие моменты всех вариантов Unix.

• Bach Maurice. The Design of the Unix Operating System. Prentice Hall, 1986.

Обсуждение особенностей построения операционной системы Unix System V, Release 2.

• McKusick M., Bostic K., Karcls M. and Quarterman J. The Design and Implementation of the 4.4BSD Operating System. Addison-Wesley, 1996. Описание особенностей по строения и реализации операционной системы 4.4BSD от разработчиков этой системы.

• McKusick M. and Neville-Neil G. The Design and Implementation of the FreeBSD Operating System. Addison-Wesley, 2004. Основы построения операционной систе мы FreeBSD 5.

• Mauro J. and McDougall R. Solaris Internals: Core Kernel Architecture. Prentice Hall, 2000. Интересное обсуждение основных подсистем и алгоритмов работы ядра ОС Solaris.

• Cooper С. and Moore С. HP-UX Lli Internals. Prentice Hall, 2004. Обзор внутренне го устройства операционной системы HP-UX аппаратной платформы PA-RISC.

• Vahalia, Uresh. Unix Internals:The New Frontiers. Prentice Hall, 1995. Отличная кни га о возможностях современных Unix-подобных операционных систем, вклю чая управление потоками и вытеснением кода в режиме ядра.

• Schimmel Curt. UNIX Systems for Modern Architectures: Symmetric Multiprocessing and Caching for Kernel Programmers. Addison-Wesley, 1994. Прекрасная книга о пробле мах поддержки современных аппаратных платформ современными Unix-подоб ными операционными системами.

Книги о ядрах Linux В этих книгах, как и в текущей, рассказывается о ядрах Linux.

• Rubini A. and Corbet J. Linux Device Drivers. O'Reilly and Associates, 2001. Прекрасная книга о том, как писать драйверы устройств для ядер Linux серии 2.4.

434 Приложение Г • Bovet D. and Cesati M. Understanding the. Linux Kemel O'Reilly and Associates, 2002.

Обсуждение основных алгоритмов работы ядер Linux серии 2.4. Основное вни мание уделено основополагающим принципам функционирования ядра.

• Mosberger D. and Eranian S. IA-64 Linux Kernel: Design and Implementation. Prentice Hall, 2002. Отличная книга, посвященная аппаратной платформе Intel Itanium и ядру Linux серии 2.4 для этой аппаратной платформы.

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

• Kogan M. and Deitel H. The Design of OS/2. Addison-Wesley, 1996. Интересный об зор операционной системы OS/2 2.0.

• Solomon D. and Russinovich M. Inside Windows 2000. Microsoft Press, 2000.

Интересный взгляд на операционную систему, которая чрезвычайно отличает ся от Unix.

• Richter Jeff. Advanced Windows. Microsoft Press, 1997. Описание низкоуровневого и системного программирования под ОС Windows.

Книги по API Unix Детальное описание системы Unix и API этой операционной системы важно не только для того, чтобы писать мощные прикладные программы, но и для понимания того, что требуется от ядра.

• Stevens W. Richard. Advanced Programming in the UNIX Environment. Addison-Wesley, 1992. Отличное, если не самое полное, обсуждение интерфейса системных вы зовов Unix.

• Stevens W. Richard. UNIX Network Programming, Volume 1. Prentice Hall, 1998.

Классический учебник по API сокетов операционной системы Unix.

• Johnson M. and Troan E. Linux Application Development. Addison-Wesley, 1998.

Общий обзор операционной системы Linux и интерфейсов, которые специ фичны для этой операционной системы.

Другие работы Книги, которые не посвящены операционным системам, но имеют к ним прямое отношение.

• Knuth Donald. The Art of Computer Programming, Volume 1. Addison-Wesley, 1997.

Бесценный курс по фундаментальным алгоритмам и теории вычислительных систем, который включает лучшие и не самые лучшие алгоритмы управления памятью. (Имеется русский перевод: Кнут Дональд Эрвин. Искусство програм мирования. Том 1. Основные алгоритмы, 3-е издание. - М: "Вильяме", 2000.) Библиография и список литературы • Kernighan В. and Ritchie D. The С Programming Language. Prentice Hall, 1988.

Наилучшая книга по языку программирования С. (Имеется русский перевод:

Брайан Керниган, Деннис Ритчи. Язык программирования С— М: "Вильяме", 2005 г.) • Hofstadter Douglas. Godel, Escher, Bach: An Eternal Golden Braid. Basic Books, 1999.

Глубокий взгляд на человечество через исследование различных предметов, включая компьютерные науки.

Web-сайты Эти WWW-сайты предоставляют последние новости и другую информацию, свя занную с операционной системой Linux и ее ядром.

• Kernel Traffic. Отличный обзор сообщений в списке рассылки разработчи ков ядра Linux (lkml) за последнюю неделю (очень рекомендуется), h t t p : / / www.kerneltraffic.org/ • Linux Weekly News. Хороший сайт новостей о том, что произошло касательно ядра Linux за последнюю неделю, с прекрасными комментариями (очень реко мендуется), http://www.lwn.net/ • Kernel Newbies. Сайт "Kernel Newbies" — это проект сообщества разработчиков с целью предоставления информации и помощи начинающим хакерам, которые стремятся заниматься разработкой ядра. http://www. kernelnewbies -org/ • Kernel.org. Официальный архив исходных кодов ядра. Здесь также находятся до машние страницы многих разработчиков основных подсистем ядра с соответ ствующими заплатами http://www.kernel.org/ • KernelTrap. Сайт, посвященный всему, что связано с ядром операционной систе мы, с большим уклоном в сторону ядра Linux. На сайте много информации о новостях и обзорах из области разработки ядра Linux. Здесь также в большом количестве размещаются интервью с ведущими разработчиками ядра. h t t p : / / www.kerneltrap.org • OS News. Новости об операционных системах, а также статьи, интервью и обзо ры из этой же области. http://www.osnews.com/ • Сайт, посвященный этой книге. Новости, сообщения об ошибках и другая инфор мация, которая касается этой замечательной книги. h t t p : / / t e c h 9. n e t / r r a l / kernel_book/ 436 Приложение Г Предметный указатель А test_and_set_bit(), test_bit(), Application Programing Interface, API, отладка, тип atomic_t, E целочисленные, Exception, 99;

110 atomic_add(), atomic_add_negative(), G atomic_dec_and_test(), gec, 40 atomic_inc(), аннотация ветвлений, 41 atomic_inc_and_test(), встроенный ассемблер, 41 atomic_read(), функции с подстановкой тела, 40 atomic_set(), Granularity, 174 atomic_sub(), atomic_sub_and_test(), L Б Linux Kernel Mail List, lkml, 405 Бинарное дерево, базисное, P красно-черное, POSIX, 96 Блок, Блокировки S advisory, IBS dcache_lock, SHA, deadlock, SMP-привязка, deadly embrace, T dentry->d_lock, inode_lock, Task, lock contention, Translation lookaside buffer, TLB, mmlist_lock, V page_table_lock, sell-deadlock, Virtual memory area, voluntary, VMA, xtime_lock, A большая блокировка ядра (BKL), lock_kernel(), Адресное пространство unlock_kernel(), плоское, 311 захват, процесса, SI 1;

313 освобождение, сегментированное, взаимоблокировка, структура типа AВВА, address_space, 297;

в обработчиках нижних половин, address_space_operations, защита данных, Алгоритм, конфликт при захвате, 168;

Аппаратная платформа, навязываемые, Атомарные операции, необязательные, битовые, обязательные, change_bit(), порядок захвата, clear_bit(), преемптивность, set_bit(), применение, test_and_change_bit(), рекомендуемые, test_and_clear_bit(), рекурсивность, 185 в обработчиках нижних половин, самоблокировка, 172;

189 записи, секвентные, 199;

222 захват, read_seqbegin(), 199 захват на запись, read_seqretry(), 199 захват на чтение, write_seqlock(), 199 инициализация, 187;

write_sequnlock(), 199 использование,189;

захват на запись, 200 освобождение, проверка чтения, 200 отладка, 186;

семафоры, 184;

190 преемптивность, DECLARE_MUTEX(), 193 проверка, DECLARE_RWSEM(), 195 проверка состояние, down(), 192;

193 чтения, down_interruptible(), 193 структуры down_read(), 195 completion, down_write(), 195 rw_semaphore, init_MUTEX(), 193 semaphore, init_rwsem(), 195 тупиковая ситуация, sema_init(), 193 условные переменные, up(), 192 complete(), up_read{), 195 wait_for_completion(), up_write(), 195 Блочное устройство бинарные, 192 RAID, захват, 194 очередь запросов, захват на запись, 195 сегмент, захват на чтение, 195 структура инициализация, 193;

194 bio, инкремент, 192 bio_vec, использование, 196 buffer_head, 296;

мьютекс, 192 request, request_queue, освобождение, Буфер, особенности, осовобождение, 195 быстрого преобразования адреса (TLB), заголовок, проверка, кольцевой, реализация, сообщений ядра, счетчик, состояние, чтения-записи, состояние конфликта, В спин-блокировки, read_lock(), 188 Ввод-вывод read_unlock(), 188 страничный, spin_is_locked(), 186 Виртуальный ресурс spin_lock(), 184 память, 45;

spm_lockbh(), 187 процессор, spin_lock_init(), 186 Возможность использования, spin_lock_irq{), 186 CAP_SYS_TIME, spin_lock_irqsave(), 185 Время spin_try_lock(), 186 абсолютное (wall time), 207;

208;

spin_unlock(), 184 начало эпохи (epoch), spin_unlock_bh(), 187 операции spin_unlock_irq{), 186 gettimeofday(), spin_unlock_irqrestore(), 185 settimeofday(), write_lock(), 189 относительное, write_unlock(), 189 time_after(), 438 Предметный указатель time_after_eq(), И time_before(), Инсталляция time_before_eq(), модулей, 38;

работы системы (uptime), ядра, часовой пояс (time zone), Исключительная ситуация, 99;

Выравнивание, Истинно случайные числа, естественное, массивов, К нестандартных типов данных, Кен Томпсон, объединений, Кластер, переменных, Клод Шеннон, полей структур, Код ядра проблемы, дерево, структур, заплаты, Вытеснение, 66;

инсталляция, г конфигурация, make config, Генератор случайных чисел, 423 make defconfig, Головка, 295 make gconfig, Гранулярность, 174 make menuconfig, cource, 174 make oldconfig, fine, 174 make xconfig, уровень крупных структурных единиц, 174 переменные, уровень мелких структурных единиц, 174 файл.config, получение, д сборка, Дайджест сообщения, 425 параллельная, Демон Константа klogd, 377 BIG_ENDIAN, kupdated, 339 LITTLE_ENDIAN, pdflush, 297;

337;

339 BITTS_PER_LONG, diity_background_ratio, 338 HZ, dirty_expire_centisecs, 338 PAGE_SHIFT, dirty_rado, 338 PAGE_SIZE, dirty_writeback_centisecs, 338 Конфигурация laptop_mode, 338 CONFIG_PREEMPT, предотвращения зависания, 340 CONFIG_SMP, syslogd, 377 Кэш Деннис Ритчи, 23 буферный, Джон фон Нейман, 424 дисковый, Дональд Кнут, 430 страничный, 3 Л Задание, Линус Торвальдс, Задача, м Заплата генерация, Масштабируемость, 71;

представление, О(1),419;

применение, О(n),421;

утилиты алгоритмов, diff, Машинное слово, diffstat, Многозадачность patch, preemptive, Заполнение структур, вытесняющая, Предметный указатель кооперативная, 66 индекс, преемптивная, 66 использование, Множество отдообработчик, большого-О, 430 регистрация, болыного-тета, 430 тасклет, Модуль структура загружаемый, 343 softirq_action, depmod, 348 tasklet_struct, 141;

EXPORT_SYMROL(), 353 тасклет, 134;

139;

169;

EXPORT_SYMBOL_GPL(), 353 DECLARE _TASKLET(), insmod, 348 DECLARE_TASKLET_DISABLED(), Makefile, 346 tasklet_disable(), make modules_install, 347 tasklet_disable_nosync(), modprobe, 348 tasklet_enable(), MODULE_AUTHOR(), 345 tasklet_hi_scbedule(), module_exit(), 344 tasklet_init(), module_init(), 344 tasklet_kill(), tasklet_schedule(), 142;

MODULE_LICENSE(), 345;

обработчик, module_param(), планирование, 142;

module_param_array(), реализация, module_param_array_named(), создание, module_param_named(), module_param_string, О MODULE_PARM_DESC(), rmmod, 348 Область памяти, 311;

зависимости, 347 деревья, загрузка, 348 интервал адресов, операции, инсталляция, конфигурация, 349 close(), параметры, 351 nopage(), разработка, 343 open(), сборка, 345 populate{), экспорт символов, 353 права доступа, н списки, структура Наименьшая верхняя граница, 430 vm_area_struct, Неатомарные операции vm_operations_struct, битовые, 182 флаги, find_first_bit(), 183 защиты, Объект find_first_zero_bit(), sched_find_first_bit(), 75 kobject, Нижние половины, 132;

187 kobject_get(), bottom half, 134 kobject_init(), ]ocal_bh_disable(), 160 kobject_put(), local_bh_enable(), 160 kobject_set_name(}, softirq, 135;

136 декларация, запрещение, 160 захват, интерфейс ВН, 134;

148 : инициализация, отложенное прерывание, 134;

169;

188 освобождение, open_softirq(), 140 присвоение имени, raise_softirq(), 140 счетчик ссылок, выполнение, 137 Операционная система вытеснение, 137 Linux, Multics, генерация, Unix, демон ksoftirqd, 138;

440 Предметный указатель AT&T, 23 файла, 322;

BSD, 24 частное, особенности, 24 Очередь ожидания add_wait_queue(), многозадачная, DECLARE_WAIT_O_UEUE_HEAD(), определение, remove_wait_queue(), с виртуальной памятью, Отладка п BUG(), BUG_ON(),382 Память dump_stack(),382 MMU, Memory Management Unit, атомарные операции, 381 адрес, генерация ошибок, 382 верхняя исследование и тестирование, 385 отладка, конфигурационные параметры, 381 переносимость, магическая клавиша SysRq, 382 виртуальная, 234;

ограничение частоты событий, 387 выделение утилита ksymoops, 380 alloc_percpu(), функция kallsyms, 380 get_free_pages(), Отладчик alloc_page(), gdb,384 alloc_pages, kdb,385 alloc_percpu(), kgdb,385 DEFINE_PER_CPU(), Отложенное действие, 136 get_zeroed_page(), cancel_delayed_work(), 156 gfp_mask, 238;

create_workqueue(), 156 kmalloc(), DECLARE_WORK(), 154 kmap(), flush_scheduled_work{), 155 kmap_atomic(), flush_workqueue(), 156 page_address(), INIT_WORK{), 154 vmalloc(), queue_work{), 156 виртуально непрерывный участок, run_workqueue(), 152 временное отображение, schedule_delayed_work(), 155 высокоуровневое, schedule_work{), 155 контекст процесса, work_handler(), 154 модификаторы зоны, work queue, 149 модификаторы операций, демон keventd, 157 нижняя половина, использование, 154 низкоуровневое, ожидание завершения, 155 обработчик прерывания, очереди заданий, 134;

157 отображение верхней памяти, планирование, 155 постоянное отображение, рабочий поток, 150 связанная с процессором (per-CPU), реализация, 150 слябовый распределитель (slab layer, slab создание, 156 allocator), структура списки свободных ресурсов, cpu_workqueue_struct, 150 стек ядра, work_struct, 151 физически непрерывный участок, 238;

workqueue_struct, 150 240;

Отображение флаги типов, анонимное, 312;

325 дескриптор, выполняемого кода, 312 выделение, инициализированных переменных, 312 счетчик использования, области ввода-вывода, 319 удаление, отладка, 381 защита, совместно используемое, 318;

322 зоны, страницы памяти, заполненной нулями, Предметный указатель ZONE_DMA, 235 Параллелизм ZONE_HIGHMEM, 235 pseudo-concurrency, ZONE_NORMAL, 235 race condition, безопасность верхняя память (high memory), 234;

нижняя память (low memory), 236 при SMP-обработке, кэширование, 263 при прерываниях, область, 311 защита данных, освобождение истинный, конкурентный доступ, _free_pages(), критический участок, free_page(), многопоточность, free_pages(), многопроцессорность, free_percpu(), псевдопараллелизм, kfree(), симметричная многопроцессорность, 163;

kunmap(), kunmap_atomic(), 259 синхронизация, vftee(), состояние "гонок", прямой доступ (ПДП, DMA), связанная с процессором состояние конкуренции за ресурс, 42;

get_cpu_ptr(), 262 Переключение контекста, get_cpu_var(), 260 Переносимость, 43;

Планирование put_cpu_ptr(), put_cpu_var(), 260 передача управления, слябовый распределитель, 47 с динамическим управлением по приоритетам, kmem_cache_alloc(), kmem_cache_create(), 252 с управлением по приоритетам, kmem_cache_destroy{), 253 Планировщик, 0(1), 66;

71;

NUMA, дескриптор сляба, 250 балансировка нагрузки, кэш, 249 битовая маска приоритетов, отладка, 381 ввода-вывода, сляб (slab), 249 CFQ, стек deadline, проверка переполнения, 381 noop, процесса, 312 задержки обслуживания, ядра, 42;

256 лифтовый алгоритм, страница, 233 объединение, page_count(), 234 прогнозирующий, виртуальный адрес, 234 слияние, вытеснение, 234 сортировка, гигантская, 318 с лимитом по времени, данные буфера, 297 с отсутствием операций, измененная, 337 с полностью равноправными копирование при записи, 54 очередями, массив приоритетов, нулевая, размер, 402 активный, флаги, 234 истекший, страничный кэш, 235 очередь выполнения, 72;

структура реального времени, стратегия, kmem_cache_s, mm_struct, 313 SCHED_FIFO, page, 234;

299 SCHED_RR, slab, 250 структура vm_area_struct, 316;

319 prio_array, zone, 237 runqueue, физическая, 234 Подсистема, 442 Предметный указатель Порядок выполнения, 180 описание, барьер, 403 освобождение, барьеры, 180;

202 регистрация, реентерабельность, barrier(), совместно используемый, 113;

mb(), реализация обработки, read_barrier_depends(), управление, rmb(), cli(), smp_mb()( smp_rmb(), 204 disable_irq(), smp_wmb(), 204 disable_irq_nosync(), enable_irq(), wmb(), записи памяти, 203 in_interrupt(), компилятора, 204 in_irq(), чтения памяти, 202 irq_disabled(), переносимость, 403 local_irq_disable(), Порядок следования local_irq_enable(), be32_to_cpu(),401 local_irq_restore(), cpu_to_be32(),401 local_irq_save(), cpu_to_le32(),401 sti(), le32_to_cpus(),401 synchronize_irq(), big-endian, 399 запрещение, little-endian, 399 разрешение, байтов,399 флаг SA_INTERRUPT, 113;

определение, SA_SAMPLE_RANDOM, 113;

обратный, прямой,399 SA_SHIRQ, 113;

Поток, 45;

57;

315 Пространство задачи, пространства ядра, 59;

пользователя, kernel_thread(), ядра, 27;

Преемптивность, 164;

Процесс данные связанные с процессорами, запрещение, 200 I/O-bound, preempt_disable(), 201 ink, preerapt_enable{), 201 parent, переносимость, 403 processor-bound, счетчик preempt._count, 89;

160 runnable, Прерывание, 27;

109;

169;

427 timeslice, /proc/interrupts, 123 wake_up(), do_IRQ(), 122 адресное пространство, 51;

handler, 111 вытеснение, пространства пользователя, interrupt request line, interrupt service routine, 111 пространства ядра, IRQ, 110 готовый к выполнению, дескриптор, 46;

ret_from_intr(), верхняя половина, 111;

131 создание, контекст, 111;

119 удаление, линия запроса, 110 завершение, нижняя половина, 111;

132 идентификатор, обработчик, 111 иерархия, add_interrupt_randomness(), 122 квант времени, 66;

69;

контекст, 52;

free_irq(), корневой каталог, request_irq(), макрос current, RTC, не готовый к выполнению, shared, ограниченный скоростью ввода-вывода, быстрый, Предметный указатель ограниченный скоростью процессора, 67 list_del(), операции list_del_init(), wakc_up(), 232 list_cmpty(), определение, 45 list_cntry(), парамтер list_for_each(), nice, 68 fist_for_each_prev(), переназначение родительского процесса, 61 list_for_each_safe(), порожденный, 46 list_move(), приоритет, 68;

78 list_move_tail(), пространство имен (namespace), 291. iist_splice(), родительский, 46 list_splice_init(), создание, 53 перемещение, 416;

состояние, 5() структура элемента, Сегмент.

sel_current_stale(), bss, set_task_state(), данных, sleep, TASK_UNTERRUFTIBLE, 50;

81;

230 кода, 312..

TASK_RUNNING, 50;

70 Сектор, TASK_STOPPED, 51 размер, TASK_UNINTERRUPTIBLE, 51;

81;

230 Система, TASK_ZOMBIE, 51 Системный вызов, errno, ожидания, заблокированное, 81 errnosys_call_table, ожидания, 170 getpid(), структура int $0x80, ioctl(), 101;

task_struct, mmap(), thread_info, mmap2(),, текущий каталог. munmapO, трассировка, sys_ni_syscall(), флаг syscall, need_resched, 83;

syscall(), Псевдослучайные числа, Пул энтропии, 423 доступ из пространства пользователя, операции модификатор asmlinkage, номер, add_inlerrupl_randomness(), обработчик, add_keyboard_randomness(), передача параметров, add_mouse_randomness(), планировщика, get_random_bytes{), nice(), р sched_get_priority_max{), sched_get_priority_min(), 91;

Режим ноутбука, sched_getaffinity(), С sched_getcheduler(), sched_getparam(), Сборка schcd_getscheduler(), 91.

модулей, sched_rr_get_interval(), Связанный список, 320;

sched_setaffinity(), головной элемент, sched_setparam(), двухсвязный, sched_setscheduler(), инициализация, sched_yield(),91;

кольцевой, производительность, однослязный, процессорной привязки операции schcd_getaffinity(), list_for_each(), schcd_sctaffinity(), list_add(), реализация, list_add_tail(), 444 Предметный указатель регистрация,104 временная отметка (tick), файле entry.S, 98;

105 гранулярность, Сообщение декрементный счетчик, динамический, 208;

Oops, уровень вывода, 376 обработчик, Сообщество разработчиков, 32;

405 задержки, maintainers, 412 BogoMIPS, ответственные разработчики, 412 mdelay(), отправка сообщений об ошибках, 412 udelay(), список рассылки, 32;

405 короткие, Сосредоточенность во времени, 331 очередь ожидания, Состояние с помощью цикла, импульс (tick), паники, константа Средняя загруженность системы, Стиль написания исходного кода, 406 HZ, ifdef, 410 USER_HZ, операции indent, typedef, 410 add_timer(), длинные строки, 407 del_timer(), имена, 408 del_timer_sync(), инициализация структур, 411 init_timer(), комментарии, 408 mod_timer(), отступы, 406 schedule_timeout(), фигурные скобки, 406 переменная функции,408 jiffies, Страничный кэш, 331 jiffies_64, структура xtime, 219;

address_space, 332 jiffies, address_space_operations, 334 переносимость, Структура переполнение, прерывание, 207;

208;

attribute, 357;

программируемый интервальный (PIT), cdev, системный, 207;

kobj_type, обработчик прерывания, kobject, срабатывание, kref, структура kref_get(), kref_init(), 362 timer_list, kref_put(), 362 timespec, kset, 358 счетчик отметок времени (TSC), list_head, 417 частота импульсов (tick rate), 208;

часы реального времени, 117;

subsystem, ядра, 135;

Структурность, т Типы данных char, sl6, Таблица страниц, s32, PGD, s64, PMD, s8, РТЕ, ul6, глобальный каталог, u32, каталог среднего уровня, u64, управление, u8, уровни, Трассировки Таймер, вызовов функций, APIC, Предметный указатель put_super, У read_inode, Упреждающее чтение, remount_fs, Уровень блочного ввода-вывода, statfs, Уровень событий sync_fs, kobject_uevent(), umount_begin, kobjcct_uevcnt_atomic{), unlockfs, Устройство write_inode, блочное, write_super, символьное, write_super_lockfs, унифицированная модель представления, файл alo_fsync, Ф aio_read, Файл aio_write, System.map, 380 check_flags, Файловая система fasync, /ргос, 363 flush, sysfs, 352;

363 fsync, HAL, 365 get_unmapped_area, kobject_add(), 365 ioctl, kobject_del(),365 llseek, kobject_init(), 365 lock, 286;

kobject_register(), 365 mmap, kobject_unregister(), 365 open, sysfs_create_file(), 367 poll, sysfs_crcate_link(), 367 read, sysfs_remove_file(), 368 readdir, sysfs_remove_link(), 368 readv, атрибуты, 366 release, добавление файлов, 357;

366 sendfile, корневой каталог, 363 sendpage, операция show(), 367 write, операция store(), 367 writev, соглашения, 368 файловый индекс структура sysfs_ops, 366 create, файлы, 366 follow_link, блок, 294 getattr, виртуальная (VFS), 265 link, диспетчер логических томов (LVM), 273 listxattr, добавление и удаление объектов, lookup, 276;

каталог (directory), mkdir, метаданные (metadata), mknod, монтирование (mount), permission, флаги mnt_flags, 289 put_link, обобщенный интерфейс, 266 readlink, объектная ориентированность, 269 femovexattr, операции rename, суперблок rmdir, alloc_inode, 273 setattr, clear_inode, 274 setxattr, delete_inode, 273 symlink, destray_inode, truncate, dirty_inode, unlink, drop_inode, элемент каталога put_inode, d_compare, 446 Предметный указатель d_delete, 282 find_VMA_intersection(), d_hash, 282 find_vma_prev(), d_iput, 282 fork(),46;

54;

d_release, 282 madvice(), d_revalidate, 282 mmap(),319;

особенности Unix, 267 munmap(), пространство имен, 55 panic(), пространство имен (namespace), 267;

291 prepare_wrife(), путь (path), 268 printk(), 39;

системные вызовы, 266 readpage(), структура release_task(), schedule(),76;

87;

dentry, 279;

SetPageDirty(), dentry_operations, 270;

switch_mm(), file, switch_to(), file_operations, 270;

unhash_process(), file_struct, vfork(),54;

file_system_type, 270;

vma_link(), files_struct, wakeup_bdflush(), fs_struct, 270;

wb_kupdate(), inode, inode_operations, 270;

X namespace, 270;

super_block, 271 Хеш-таблица страниц, super_operations, 270;

vfsmount, 270;

288 Ц суперблок (superblock), 268;

269;

270 Цилиндр, управляющий блок (control block), э файловый индекс (inode), 268;

269;

кэш (icache), Энтропия, файл (file), 267;

269;

оценка, элемент каталога (dentry), 268;

269;

Шеннона, LRU, Я кэш(dcache), состояния, Ядро хеш-таблица, Linux, Функция версии, bread(), разрабатываемое, clone(),54;

стабильное, commit_writc(), схема присваивания имен, context_switch(), tainted, copy_from_user(), Unix, copy_mm(), дефекты, copy_process(), микроядро, copy_to_user(), модульное, dup_task_struct(), монолитное, 29;

early_printk(), особенности, exec(), отладка, exit(),46;

уровень событий, exit_mm(), экзоядро, flnd_vma(), Предметный указатель Научно-популярное издание Роберт Лав Разработка ядра Linux 2-е издание Литературный редактор Е.Д. Давидян Верстка Т.Н. Артемеико Художественный редактор СЛ. Чернокозинский Корректоры JI.A. Гордиенко, А.В. Луценко, О.В. Мишутина, В.В. Столяр Издательский дом "Вильяме" 101509, г. Москва, ул. Лесная, д. 43, стр. Подписано в печать 27.07.2006. Формат 70x100/16.

Гарнитура Times. Печать офсетная.

Усл. печ. л. 36,12. Уч.-изд. л. 28,86.

Тираж 3000 экз. Заказ № 2169.

Отпечатано по технологии CtP в ОАО "Печатный двор" им. А. М. Горького 197110, Санкт-Петербург, Чкаловский пр., 15.

Разработка ядра Linux ОБ АВТОРЕ Роберт Лав является активным Второе издание разработчиком программного обеспечения с открытым исходным кодом и использует операционную систему Linux Эта книга посвящена основным принципам функционирования и деталям с первых дней ее существования.

реализации ядра Linux. Материал представлен в форме удобной как для тех, Он активно работает кто занимается разработкой кода ядра, так и для программистов, как в сообществе разработчиков которые хотят лучше понять особенности работы операционных систем ядра Linux, так и в сообществе и, соответственно, разрабатывать более эффективные прикладные разработчиков графической программы. среды GNOME и сейчас занимает должность главного инженера В книге детально рассмотрены основные подсистемы и функции ядра Linux, по разработке ядра группы особенности их построения, реализации и соответствующие программные разработчиков Ximian Desktop интерфейсы. При этом ядро рассматривается с теоретической и прикладной корпорации Novell. Проекты точек зрения, что может привлечь читателей с различными интересами по разработке ядра, которыми и потребностями. занимался автор, включают планировщик выполнения Автор книги является разработчиком основных подсистем ядра Linux. процессов, преемптивное В этой книге он делится своим ценными опытом и знаниями по ядрам Linux ядро, уровень событий серии 2.6. Рассмотренные вопросы включают управление процессами, ядра, улучшение поддержки виртуальной памяти, улучшение планирование выполнения процессов, управление временем и таймеры поддержки многопроцессорного ядра, интерфейс системных вызовов, особенности адресации и управления оборудования. Роберт является памятью, страничный кэш, подсистему VFS, механизмы синхронизации, автором утилит schedutils проблемы переносимости и особенности отладки. В книге также рассмотрены и менеджера томов GNOME.

интересные новшества, которые появились в ядрах серии 2.6, такие Автор имеет степень бакалавра как планировщик O(1), преемптивное ядро, уровень блочного ввода-вывода по математике и вычислительной и планировщики ввода-вывода. технике университета штата Флорида.

Второе издание книги включает...

Обновление информации о большинстве подсистем и функций ядер Linux Вступительное слово Эндрю Мортона (Andrew Morton), серии 2. ответственного разработчика Новые детали о загружаемых модулях ядра ядер Linux серии 2.6.

Расширенное рассмотрение виртуальной памяти и особенностей выделения памяти в режиме ядра Дополнительные сведения по отладке кода ядра Опубликовано Примеры, касающиеся синхронизации выполнения кода ядра и работы с разрешения таймеров и при содействии корпорации Novell, Inc.

Полезные детали по работе с заплатами и вопросы взаимодействия с сообществом разработчиков КАТЕГОРИЯ:

Программирование для операционной системы Linux УРОВЕНЬ:

Для опытных разработчиков www.novellpress.com и программистов средней квалификации ISBN 5-8459-1085- Novell -зарегистрированнаяторговаямаркав США и других странах. Novell Press и Ximian - торговые марки корпорации Novell, Inc., зарегистрирован ные в США и других странах. Linux — зарегистри www.williamspublishing.com рованная торговая марка Линуса Торвальдса.

Pages:     | 1 |   ...   | 7 | 8 ||



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.