Виртуальная и физическая память в ядре Linux • Щупаем средствами C

Есть подозрение, что в ядре память какая-то другая. Другие методы, другие важные факторы — много чего. Начнём в этом разбираться. И первым делом увидим своими глазами, что физическая память — не то же самое, что память виртуальная.

*https://www.youtube.com/watch?v=km0Q6NOJWUY
**https://300.ya.ru/v_2ajiLV4W
***https://blog.itempuniversity.com/virtual-and-physical-memory-in-the-linux-kernel-probing-with-c-tools/

Таймкоды

00:00:00 Введение в эксперименты с памятью

• Начало экспериментов с памятью в Linux.
• Использование команд для получения информации о ядре.
• Получение длинного списка параметров, большинство из которых непонятны.

00:00:30 Анализ информации о памяти

• Система определяет объём оперативной памяти — 8 ГБ.
• Использование другой команды для более понятного обзора памяти.
• Объяснение, почему использовано чуть меньше 8 ГБ памяти.

00:01:54 Особенности килобайта в Linux

• В ядре Linux килобайт равен 1024 байтам.
• Это объясняет, почему использовано меньше памяти, чем ожидалось.

00:02:33 Файловая система ядра

• Ядро Linux использует особую файловую систему для хранения настроек и статусов.
• Файл /proc/meminfo содержит информацию о памяти.

00:05:17 Виртуальная и физическая память

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

00:08:12 Роль драйверов и пейджинга

• Драйверы обеспечивают устройства физической памятью.
• Пейджинг — система управления связкой физической и виртуальной памяти.

00:11:17 Виртуальные и физические адреса

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

00:13:20 Создание драйвера для преобразования адресов

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

00:14:28 Введение в системные вызовы

• Обсуждение пожеланий к дизайну стрима.
• Объяснение важности системных вызовов для выделения памяти.
• Упоминание о флагах и их роли в управлении памятью.

00:15:32 Управление виртуальной памятью

• Система прагматично выделяет виртуальную память, учитывая её нехватку.
• Команда kmalloc требует непрерывности выделяемого участка памяти.
• Система управления памятью может потребоваться время для освобождения места.

00:17:15 Особенности выделения памяти в ядре

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

00:20:04 Работа с адресами памяти

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

00:25:17 Отладка утечек памяти

• Обсуждение методов отладки утечек памяти в сложных модулях.
• Использование логов и ручного труда для выявления утечек.
• Ограниченность инструментов для отладки в пространстве системы.

00:26:14 Получение физического адреса

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

00:28:21 Макросы и их применение

• Использование макроса для вывода физического адреса.
• Зависимость макроса от системы и оборудования.
• Проверка работы макроса в разных системах.

00:30:15 Создание виртуального адреса

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

00:31:33 Конвертация виртуальных и физических адресов

• Проверка совпадения виртуальных и физических адресов.
• Успешная конвертация адресов.

00:33:06 Эксперимент с переменными

• Создание переменной «стек дата» и указателя на неё.
• Попытка освобождения памяти на стыке приводит к ошибке.

00:34:40 Анализ ошибок

• Обсуждение возможных причин ошибок в системе.
• Перезагрузка системы для устранения проблем.

00:36:31 Проблемы с модулем «ведре»

• Модуль «ведре» не добавляется в ядро из-за возврата отрицательного числа.
• Повторные попытки запуска системы.

00:39:07 Ошибка конвертации адресов

• Попытка найти обратный адрес у переменной на стеке.
• Взаимно однозначное отображение работает только для области «лоу-мем».

00:40:15 Зоны памяти

• Объяснение зон памяти и их различий.
• Стек не входит в зону «лоу-мем», что объясняет ошибку конвертации.

00:43:48 Иерархия виртуальных адресов

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

00:45:11 Компромиссы в управлении памятью

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

00:46:44 Вложенная система адресации

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

00:47:40 Преобразование адресов

• Виртуальный адрес в двоичной системе счисления превращается в физический.
• Физический адрес содержит привязку к реальности.

00:48:34 Точность адресации

• Адресация не достигает точности до байта.
• Задача системы — довести до уровня страниц.

00:49:19 Работа процессоров со страницами

• Процессоры оперируют адресами страниц, а не байтов.
• Страницы можно освобождать, находить, перемещать и защищать.

00:50:18 Переход к работе со страницами

• Переход от битовой адресации к байтовой, а теперь — к страничной.
• Размер страницы обычно составляет 4 КБ, но может быть и 8 КБ.

00:51:18 Микроконтроллеры и адресация

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

00:52:16 Важность физической памяти

• Физическая память не всегда совпадает с виртуальной.
• Необходимо постоянно проверять соответствие физической и виртуальной памяти.

00:53:05 Ограничения железа

• Исследование памяти приводит к ограничениям реального процессора.
• Побитовые сдвиги помогают в понимании адресации.

00:53:58 Управление памятью внутри процессора

• Система управления памятью оперирует страницами, а не байтами.
• Необходимо уметь переключаться на работу со страницами.

00:54:57 Заключение

• Обсуждение продолжается, но на сегодня достаточно.
• Благодарность зрителям и прощание.

В этом видео

Начало: как система видит память
0:00
эксперименты с памятью в еды. [музыка] Начинаем с
0:06
вопроса м как мы можем посмотреть на то, что выводит
0:12
то, что система в принципе знает про ядро. А давайте вот командой, которую я
0:19
уже немножко анонсировала, запустим её, э, и посмотрим на выдачу. Вот она,
0:25
выдача. Выдача длиннющая такая, там всякие параметры. [музыка]
0:30
Вообще ни один из этих параметров нормальному человеку так с ходу непонятен. Ну какие-то что-то про
0:36
страницы, что-то про фри, ну в общем, что-то явно осмысленное, да. Хорошо. Это
0:43
то, что система предлагает нам знать про про память и, видимо, считает это
0:49
важным. А, ну вот если посмотреть сюда, да, то
0:54
очевидно она каким-то образом видит, что у меня там на этой машине 8 Гб оперативной памяти.
1:01
Больше больше тут угадать как-то ничего не представляется возможно. А, ну и ладно. А нам бы
1:09
хотелось на самом деле как-то попроще, да, то есть какой-то беглый обзор для начала, что такое память идриликс.
Команда free и разночтения в объёмах
1:17
А для этого нам пригодится ещё одна команда. И эта команда уже показывает
1:24
чуть более понятные вещи. Во всяком случае, мы видим, что всего памяти там чуть меньше 8 гигаб. Сейчас поясню,
1:33
почему чуть меньше. А использовано, прямо скажем, немного. Почти всё свободно. А и дальше начинаются какие-то
1:41
интересные слова. А тут сразу надо понять такую штуку, что
1:49
мы уже гарантированно запутались, а гарантированно запутались
1:55
от того, что, ну, ждём 8 Гб, а получили чуть меньше восьми. А это
2:03
неспроста. Это потому, что когда мы дошли до ядраликса, то наконец-то
2:09
система вспомнила, что такое килобайт. Лобайт наконец-то вернулся к
2:16
своему исходному православному состоянию в 1024 байта. Называется он теперь
Почему «меньше 8 ГБ» — это нормально
2:21
по-другому, но короче это такой дополнительный способ
2:27
называть всё неправильно и думать вверх ногами. А хорошо. А это приятный, милый нюанс,
2:37
который греет душу. Всё-таки 1.24 — это более круглое число, чем 1.000. Да. Вот
2:42
что ещё мы здесь можем увидеть? Мы здесь можем увидеть, давайте повторим вот эту команду, что не первый раз мы уже
2:49
сталкиваемся вот с этой системой про, да, с этим как бы каталогом прок. Что-то
2:58
там такое всякое разное, что-то явно служебное. А на самом деле это не то,
proc и виртуальная файловая система
3:04
чтобы файлы. Ээ, этот прук — это очень особая файловая
3:10
система, а, которая показывает, ээ, скажем так, э, показывает состояние
3:18
всякого системного, а, внутридерного, а, и настройки, и статусы, и чего только
3:26
не, ну, помните, да, что поскольку Linux довольно настойчив в идее, э что ядро
3:34
что это, э, что всё, что у нас есть — это файл, то, в общем,
3:41
неудивительно, что там внутри есть файловая система и даже две. Сегодня просто одну посмотрим, потом вторую.
3:48
в которой и настройки какие-то файлы, и логи, естественно, файлы, и
3:55
параметры этих самых параметры запуска могут быть файлы и там
4:00
какие-то переменные, константы, всё, что угодно выражается через файл. Ну, что удобно, да, потому что файлы — это то,
4:07
что можем читать и писать. Это мы в прошлый раз обсуждали. Вот. Э, и в
4:12
частности здесь вот в файле прокem инфо таком файле, да? Он не лежит физически
4:18
на диске. А хранится состояние нашей системы. Там есть памяти, там есть ещё
Зачем всё это — и как использовать
4:24
кое-какие приятные файлики. С ними лучше
4:30
знакомиться постепенно, потому что иначе так умереть можно. Вот. А, ну ладно.
4:35
Хорошо. Значит, зачем нам все эти упражнения в командной
4:41
стройке? А, ну, в принципе, самое главное, что надо понимать, что по какой-то причине,
4:47
а, система сообщает нам на системном уровне, вот в этом в Прокнфо довольно
4:54
много информации про память. И значит, можно предполагать,
5:00
что рано или поздно нам какая-то часть или вид этой информации может понадобиться. И неспроста, так и есть.
5:08
Первое, что нам понадобится, это понадобится вспомнить, что память — это
Физическая vs виртуальная память
5:15
что-то ещё и физическая. Значит, почему м почему
5:21
вдруг всплыла физическая? У нас что до этого не физическая была? Нет, до этого была не физическая. Вот все эти адреса,
5:26
все эти выделения и так далее, да? А опять же, мы привыкли
5:32
думать, что это какой-то распределённый поток, какая-то линейка,
5:39
э, памяти, которая, значит, волшебным образом забивается по очереди и м ну и
5:46
всё, и больше ничего там не происходит. На самом деле, э, это не та память, которая вот
5:52
в м в п в плашечках оперативной памяти или там на диске, э там что там на
6:00
диске? Ээ смотри какие диски, да? А это просто модель. То есть когда мы на
6:06
прикладном уровне работаем с памятью, мы на самом деле работаем с её некоторой
6:12
упрощённой схемой. И это нам ещё повезло, потому что, например, там программисты более таких,
6:21
как бы даже сказать-то, прикладных языков, типа там того же питона, да, они
6:27
про память вообще редко вспоминают. Мм, им не надо. Ээ и про поведение тоже. Ну,
Почему виртуальная память — только модель
6:33
ну, в общем, вы всё это знаете. Но поскольку мы идём назад по
6:40
эволюционной цепочке, немножко деградируем, да, то вот от этого счастья, когда нам не надо ни о чём
6:45
думать, мы потихоньку приближаемся ситуацию, когда думать надо вообще обо всём. А торопиться туда не надо, но
6:53
сегодня шажочек сделаю. Значит, виртуальная физическая память.
6:59
Э как они связаны? Ну, такая картинка, которую я нарисовала, она, конечно,
7:08
она задаёт некоторое направление понимания. Значит, задача системы сделать вид, что
7:18
виртуальная память, ну, для прикладной работы, да, — это что-то непрерывное, а памяти надо много.
7:26
Поэтому в роли вот этой непрограмной памяти могут выступать самые разные
Зачем ядру физическая память
7:33
физические объекты. То есть иногда по адресу лежит что-то, что реально в виде
7:39
вот электронных импульсов находится в плашечке Азу. Иногда оно же лежит на
7:46
диске одном, там, втором, третьем и так далее. Ну, есть ещё такие более экзотические варианты, но вот аз и диск
7:52

это прямо частое явление. А, а для нас, для, ну, для прикладного
7:58
программирования, это всё одно и то же. И на прикладном уровне, я так понимаю,
8:03
почти никогда не не встречается ситуация, когда тебе надо выяснить, вот вот это вот эта конкретная твоя память,
8:09
она где сейчас лежит? Аэ, в оперативном, э, или где-то там чуть
8:16
дальше. А, а вот когда мы начинаем играть с ядром, то это резко становится
8:22
важным. Основная причина в том, что,
8:27
мм, устройства, э, там, ну, всякие с тяжёлыми потоками данных, они не
8:34
очень-то пропускают свои данные через виртуальную память и сразу идут в физическую. То есть, э, задача драйверов
Статистика виртуальной и физической памяти
8:42
в том числе, мм, обеспечивать устройством эту физическую память. Ну и
8:48
понятно, что вы не Ну можно, конечно, кинофильм положить в
8:53
оперативку. Нет ничего не возможно для человека с интеллектом, но, наверное, смысл тут не в этом. Наверное,
8:59
распоряжаться надо разумно, а для этого надо вот как раз физическими адресами-то
9:05
оперировать. А давайте для начала посмотрим вот с помощью тех самых того
9:10
самого файла, псевдофайла мемфо. Посмотрим, что там у нас с виртуальной памятью.
9:17
Ну вот виртуальной памятью как-то прямо вот очень много. Сколько там, посчитайте
9:23
за меня, пожалуйста, должно быть где-то около 120 гигабт. Ну на глазок примерно так и
9:29
есть. То есть как бы всё пространство, которое есть на машине, объединено в одну кучу, названо виртуальной памятью.
9:36
Ну может там что-то куда-то вычтено на всякие служебные дела, не знаю. Ну примерно так. А реально оперативки у
9:44
нас, конечно, не так богато. Совсем не так богато. Ну даже
9:49
вот видно, да, что где-то два-три порядка что-то потеряли или сколько там порядков, неважно. А, хорошо.
9:58
А вот эти два числа нам как бы намекают,
Что такое пейджинг
10:03
что, э, система, вот она фиолетовенькая, да, э, чем-то занята постоянно.
10:11
жонглируя физическими адресами ради того, чтобы нам было удобно использовать
10:16
виртуальный. И это так и есть. А есть некоторая концепция, её по-разному
10:25
называют. В целом, м, пожалуй, ну, такое типовое, наверное,
10:31
название йджинг. А это как раз вот вся вся э
10:42
система управления э связкой физической виртуальной памяти, она
10:48
построена вокруг вот этой концепции пейджинга и частично реализует. Тут я немножко не хотела бы упираться в
10:54
термины, потому что термины немножко плавают. А, но к страницам мы очень
11:01
скоро доберёмся. Давайте пока м не задумываясь о том, что это за страницы
11:06
такие, это прямо очень важно, но это чуть-чуть позже, а и точно сегодня,
Связь между физическими и виртуальными адресами
11:11
потому что это прямо база база база. Э давайте пока научимся простой вещи. Вот
11:17
у нас есть виртуальный адрес, у нас есть физический адрес. А как между ними ходить? Вот у нас ээ как бы можем ли мы
11:26
из одного получить другое и наоборот. Значит, во-первых, надо понять, что они разные.
11:33
То есть вот сами числа, которые работают адресами, они не
11:38
совпадают. А вроде кажется очевидным, но такое лучше остановиться на этом на 30
11:44
секунд. Вот. А дальше, значит, в реальности, вот как бы в реальности
11:52
физического мира, конечно, существует только то, что живёт за физическими
11:58
адресами. А виртуалка это, ну, вот вот вся эта виртуальная адресация, она
Адреса существуют только в контексте процесса
12:03
существует только в пределах процесса. Ну там будем пока считать, что в пределах
12:10
процесса, в том числе вот для процессов ядра это тоже, значит, вот вот вот ты
12:15
процесс, вот твои виртуальные адреса.
12:20
А как бы это то, что ну такой немножечко немножечко ситуация, как с котом
12:27
Шдингера, да, если вы не в процессе, то адреса процесса для вас, ну, они не то,
12:32
что прямо совсем недоступны, но это м это перестаёт быть простой простым
12:40
материалом. А и при этом, как я уже сказала, есть вот Access устройства,
12:46
которые прямо фигачат на железку. А, похожи, похожи, но они разные.
12:51
Значит, давайте сначала позапускаем, ну, понапишем чего-нибудь, какой-нибудь
12:58
м маленький модулёчек, который даже работать не будет. Мы его не дозагрузим
Пример: модуль для перевода адресов
13:04
в память ядра, но что он будет делать? Он будет превращать физический адрес в виртуальный.
13:10
И на это мы всё будем радостно смотреть. Ну, давайте его сделаем, скажем,
13:18
виртуальный, физический, да? Ну, во-первых, у нас есть я напомню, что у нас есть template
13:27
шаблон, шаблон просто любого драйвера, да? А, и мы его сейчас
13:34
будем использовать. Значит, какие тут всё стандартно. Единственное, что я уже
13:41
заранее поставила, что return -2, это значит, что мы не собираемся загружать
13:46
наш модуль в ядро. М, он будет всегда выпадать с ошибкой. Значит, что мы хотим
13:53
сделать? Мы, э, хотим, а, во-первых, э, выделить память совсем
kmalloc и флаг GFP_KERNEL
14:00
чуть-чуть, буквально выделить, э, э, один
14:06
байт, э, с помощью команды calog, ну, kmalog, да, вот один байт. Даже вот
14:14
никакой сайзов не пишу. А, и мы его
14:19
выделяем в очень специальном режиме, про который важно понимать и про который я сейчас
14:26
расскажу. Так, написала. Сейчас сделаю паузу, чтобы прочитать, что пишется в чате.
14:33
Аа так, э, пока пишут только пожелание к
14:39
дизайну, мм, стрима. дизайн стрима ээ в ближайшее время не
14:45
поменяется. Возвращаемся. Значит, смотрите, вот первая же команда, которая которая важна. Команда означает примерно
14:53
следующее: а система — это всё ещё системные вызовы. Дай нам один байт и
14:59
давай его вот в таком режиме. Ну, в общем, мы часто видим, что вот так
15:04
выглядят какие-то флаги. И неудивительно, это тоже флаг. Значит, зачем он нам нужен? Почему нельзя
15:11
просто, как мы обычно делали в в прикладных программах, почему вот так нельзя
15:17
сделать? Почему система хочет ещё каких-то уточнений? Она вот чего хочет.
Почему система может отказать в памяти
15:22
Смотрите, значит, как бы у нас
15:27
реальной настоящей памяти гораздо меньше, чем виртуальной. Когда мы просим систему:
15:33
«Дай нам ещё виртуальной памяти», она действует довольно
15:39
прагматично. Она понимает, что память понадобится прямо сейчас. Мм, а её мало, её надо где-то
15:46
откопать. Более того, э команда камалок требует, ну, в данном случае это не
15:52
актуально, да, один байт, но она требует непрерывности вот этого куска памяти. То есть, чтобы он физически шёл
16:01
как бы ячеечки шли один за другим. Ну вот такая команда, да, есть есть и другая, есть и дискретная, но вот это
16:08
хочет непрерывности. И система управления памятью такая: «Ну
16:14
где же я возьму? Всё занято. Давай-ка я пройдусь, потому что у меня тут накопилось в хозяйстве, и почищу. Ты
16:21
пока подожди», — говорит она. Говорит она нашему, а, например, драйверу. Я тут
16:28
приберусь, а, порядок наведу, выброщу то, что не используется, что-то там ещё куда-нибудь рассую по углам. Там там
16:35
много всяких углов, поверьте. Мм, управление памятью штука развесистая. Короче, много возможностей выделить этот
Проверка ошибок при выделении
16:42
наш несчастный байт. А, погоди, погоди, нашла. Всё, вот, держи, возвращаю.
16:49
А это, конечно, маловероятно, что здесь не выйдет вернуть, но, вообще говоря,
16:56
поскольку мы в очень экстремальной ситуации, очень близко к м системам,
17:02
которые просто физически могут отказать, то у нас может случиться и
17:07
отказ. А, то есть здесь нам надо проверять
17:14
сейчас. То есть, если то, нам надо улепётывать отсюда со всех ног, но сейчас мы пока на этой строчке.
17:21
Смотрите, вот что важно знать про эту штуку. А, про этот флаг. Этот флаг
17:28
обработка его требует времени. То есть, э, если система чистит, ээ, как бы своё
17:34
состояние, да, там чистит пёрышки, наводит порядок, разгребает место и даёт
17:40
нам какой-то кусок, то вот на это операцию требуется время. Маленькое,
17:45
конечно, но мы сейчас вообще вот в ситуации маленького времени. И,
Возврат памяти в ядре
17:51
э, во-первых, это требуется время, а значит, а программа, которая запущена,
17:57
ну, там поток, да, она должна согласиться ждать. А тут сюрприз. Не всякая
18:05
программа, которая работает в ядре, не всякий поток, ну нет, нельзя говорить поток. В общем, не всякий код, который
18:12
запускается в ядре, а имеет право ждать. То есть не то, что там хочет, не хочет,
18:18
он даже иногда права не имеет. Это через восемь через восемь шагов от нас сейчас.
18:24
Но, э, просто вот одна из закладочек, одна из особенностей выделения памяти в ядре,
18:31
что не всякий не во всякой ситуации вы можете попросить физическую
18:39
память и дождаться её, потому что, например, есть ещё другой флаг.
18:47
А, и он означает, ну, там есть ещё парочка, но третий два основных. Он означает: «Не наводи никакой порядок,
18:54
потому что ждать я не согласен. Если у тебя ничего нет, ну, ты мне так и скажи: «Ничего нет».
Логика отображения адресов
19:00
А, но лучше бы, конечно, было. А лучше бы, конечно, ты мне всё
19:07
это отдала. Я вот такая специальная программа, которая ждать, которая ждать может. Дай мне, пожалуйста, этот
19:12
несчастный байт. А в том очень вероятном случае, когда система не справляется,
19:19
нам нужно возвращаться с ошибкой no
19:26
memory, хотя бы так. И вот вот эту строчку вот прямо её всегда я я честно скажу, я её иногда
19:34
писать забываю и потом потом мне очень страшно. Пока
19:40
ничего страшного не произошло, но вообще это опасная игрушка. Хорошо, мы добились своего байта. Что бы
19:47
нам такое теперь сделать? Смотрите, значит, поскольку он лежит
19:53
в памяти физической и одновременно а памяти
19:59
виртуальной, то у него есть два адреса: физический адрес, виртуальный адрес. Как бы нам эти адреса узнать? Ну, тут всё
20:08
достаточно просто. А, значит, во-первых, нам пригодятся вот
Получение физического адреса через virt_to_phys
20:14
эти два, эти две библиотеки. Честно говоря, я не знаю, почему
20:19
вроде бы такие симметричные функции разбросаны по двум библиотекам, но уж что есть, то есть. Значит, дальше мы
20:28
сначала создаём. А так вот что важно, забыла,
20:35
поскольку опять же мы в ядре и поэтому смотрим четыре глаза, чтобы вся
20:41
выделенная память возвращалась обратно в ядру. Значит, перед ритурном нам точно
20:47
нужно вернуть вернуть системе вернуть едру то, на что
20:54
указывает сейчас Майда. В этом месте она уже на что-то указывает. Но, впрочем, если тут нул будет, никто не умрёт. Это
21:01
не страшное действие. Вот. Если дата, если память не выделилась, мы
21:07
уже улетели с ошибкой. А если память выделилась, то её надо вернуть, иначе
21:12
она навсегда в ядре зависит. Ну, как навсегда, до перезагрузки. А, всего
21:18
10.000 вёлдер. И у нас совсем ядро зависнет, потому что мы всю память такими упражнениями выжрем. Ну, здесь,
21:24
конечно, не всю, это понятно. Ээ, сейчас речь о привычках. Мы вообще сегодня больше говорим о
Обратное преобразование через phys_to_virt
21:31
привычках. А, нет, не вне usersпеaceйса не вернёт ядро памяти себе. Оно, э-э,
21:38
оно этим не занято, потому что оно занято возвращением, э, памяти для
21:43
прикладных программ. Сапожник без сапог себя таким образом не обслуживает. Опять же, я могу
21:51
в каком-то месте в отдельных случаях ошибаться. Может быть, где-то уже
21:58
завелись какие-то закоулки, ядра, которые вот эту всю магию умеют. Но в
22:05
целом гораздо спокойнее для своих нервов считать, что м память надо возвращать
22:12
абсолютно явным образом еду. Иначе Иначе беда. Но какая именно беда, тот уж как
22:18
повезёт. Так хорошо. Мы за полчаса героическим усилием воли написали три
22:25
осмысленных строчки. Это неплохо, но хотелось бы большего. Значит, давайте
22:30
сначала аа получим А, ну, наверное, сначала лучше проверить, что мы успешно
22:36
вываливаемся. И сейчас я запущу тогда, чтобы у нас было, чтобы можно было
22:42
переключаться легко. А значит, здесь я
22:47
запущу меж — V, чтобы мониторить происходящее. Вот мы видим, ну, вроде
22:54
ничего пока такого не происходит, да. А, а здесь я ещё раз
Почему оно иногда не работает
23:01
ВП там, да, ВП. Вот так. Значит, здесь это можно запускать. Давайте
23:09
запустим. Так, вот он у нас откомпилился. Так, что он там? А какой
23:15
долив? Ээ, сейчас, секунду. А, извините, пожалуйста, я
23:20
неправильно назвала. Точнее, я не переименовала эти штуки. Аэ. функции
23:26
входа-выхода. И теперь он путает их. Значит, давайте вот так
23:32
сделаем. VPIT P exit не зря проверили, потому что
23:39
exit-то он уже есть в стадели. И Linux сошёл с ума, когда я попросила его сделать ещё одну. Так, так, так, так.
23:48
Ага. Вот. Отлично. Всё. Вот ровно то, что надо. Значит, он попытался, он скомпилил. Всё хорошо. Он попытался
23:55
вставить наш модуль, и у него, конечно, ничего не вышло. Ну, по понятной причине мы return
24:01
-2 возвращаем, да? А пока ничего не произошло. Так, давайте
24:08
продолжать. Продолжаем. А мы бы хотели на какой-нибудь адресочек-то всё-таки
24:15
взглянуть. Значит, сначала взглянем на
Пример: переменная в стеке ломает отображение
24:21
исходный мм ну на обычный адрес вот этой этот этот самый мой дата, да. Значит,
24:29
как всегда в логе пишем. Это это принтка с уровнем и с
24:34
уровнем info, если вдруг кто-то забыл. Значит, что надо надо написать? Значит,
24:39
а, first, не забываем перенос строчки, не и
24:47
потом у нас, ну, что нам нужно указать здесь адрес. Адрес My
24:53
data это уже адрес. Очень хорошо. А, ну, шанс хороший, что у нас всё будет
24:59
нормально. Давайте проверим. Так.
25:06
И вот, видите, мы получили заветную строчку firstс. И он даже какой-то не
25:12
нулевой, осмысленный. Ну, отлично. Редактируем дальше. Значит,
25:20
следующее действие. Мы хотим превратить этот виртуальный адрес в
25:26
логический адрес. Вижу вопрос. Интересно, как в сложных модулях отлаживают утечки.
25:33
Вгризм условно сомнительно, что модуль возможно подтянуть. Ну, конечно, нельзя. Влгагрин-то исполняется в в пространстве
Почему стек нельзя конвертировать обратно
25:40
системы. Мне тоже, на самом деле, очень интересно, как э отлаживают утечки.
25:46
Насколько я знаю, примерно никак. Ну вот обвешивают всё логами, думают головой.
25:53
То есть там не то, что прямо какой-то богатый ассортимент инструментов. Ну, естественно, есть
25:59
миллион всяких мониторингов. А, но это всё такие мониторинги из серии Давайте
26:06
мы напишем утилиту, которая смотрит в файловую систему Прок и и будет удобно нам выводить данные, которые систеро и
26:14
так поставляет. Ну, то есть э да, это немножечко
26:20
мм э очень ручной труд. Э ну что знаю.
26:25
Может быть, кто-то знает больше, тогда расскажите. Э, о’кей. Мм, мы сейчас пытаемся получить
Zone info и зона lowmem
26:33
физический адрес. Он у него есть особый тип,
26:39
ээ, что не должно нас удивлять, да? А, ну это ничего страшного. Это, в
26:45
общем, тоже адрес, просто он для него выделен особый тип. Всё хорошо. И
26:51
команда тоже не особенно затейливо называется. и не особенно
26:58
затейлива не особенно затейливая у неё сигнатура. А есть шанс, что теперь в
27:05
переменной AGR у нас есть физический адрес. Тут надо сделать глубокий вдох и
27:13
понять, что мы в этом месте заняли кусочек стека, да? Ну, где
27:21
у нас лежит переменная физата? Она в стеке лежит. Ну ладно, пусть пока лежит. Как
27:27
там дела со стеком? И можно ли вот так вот его разбазаривать? Это следующий немножечко вопрос. Э, спойлер:
27:35
Слава богу, это маленькая штучка, поэтому она ничего нам не убьёт. Она
27:41
точно меньше 8 Кб, и ядро не грохнется от того, что мы заведём одну малюсенькую
27:48
переменную. Вот если бы в этой малюсенькой переменной было 8
27:53
Кб, нам бы мало сейчас не показалось, но там их нет. А для справки в
27:59
пользовательской среде, в в пространстве пользователя у стека, ну, 8 Мб минимум,
Эксперименты с zoneinfo из /proc
28:06
возможно, бывает даже больше. Так, хорошо, пришёл момент посмотреть, э,
28:11
посмотреть влоги. Давайте в блоге запишем наш
28:16
адрес, то, что мы только что добыли. Так, а и он
28:24
для его вывода нужен отдельный макрос. Это не P, а это P. А, ну это это нужно,
28:32
потому что в разных системах, а, в на разном железе,
28:37
в разных операционках м физические адреса бывают разные. То есть это
28:43
макрос. И как любой макрос, он э в момент компиляции заменяется на то, что нужно,
28:51
но вот что конкретно нужно — это сильно зависит от системы. Слава богу, тут хотя
28:56
бы тут можно не думать и просто ставить вот это па не п, да, надо помнить. Так, и это у
29:04
нас будет вот так указатель. Обратите
29:10
внимание, что это указатель. А, проверяем, что это
29:16
работает. Делаем, смотрим сюда. Так, возможно, там что-то. А,
29:23
ошибка какая-то. Сейчас посмотрим. А, сейчас 11 стоит. И,
29:28
видимо, какая-то у меня печатка. А, ну да. Ээ, Фис у меня не Фис, извините.
Переход виртуального адреса к физическому — через железо
29:36
Фис. Так, да, да. Вот так лучше. Делаем ещё раз всё то же самое.
29:44
Компилим. О, смотрите, мы теперь имеем не только first, но и physical.
29:49
Обратите, кстати, внимание, что новый запуск, новый first, новый адрес. А также интересно посмотреть, что
29:57
они разные. Ээ первый адрес и физический адрес. А давайте сделаем вот что.
30:03
Давайте мы, а, чуть-чуть выровняем происходящее, просто чтобы видеть, что
30:09
они разные, не сильно напрягая глаза. А, но нам, очевидно, хочется сделать
30:18
комплементарное действие и создать ещё один, ещё одну
30:24
переменную в стейке, а именно указатель на э виртуальный
30:30
адрес, который мы получим из этого физического. Ну, кажется, что зачем нам
30:35
это делать, да, но очевидно, что мы получим то же самое. А, и сейчас действительно, да,
Виртуальный адрес как иерархия (аналог IP)
30:42
но когда речь заходит о ядре, то наши старые привычки надо
30:49
надо очень внимательно на них смотреть, потому что, вообще говоря, тут очень
30:54
легко получить совершенно другое. И я вам сейчас покажу, как получить совершенно другое.
31:01
М такое ощущение, что,
31:07
а, видите, как мы медленно двигаемся. Казалось бы, ну, ну, что тут,
31:12
господи, ну, адреса, ну, физические, ну, виртуальные, ну, ну, что здесь обсуждать? А обсуждать тут можно много
31:20
чего. А у меня вообще такое ощущение, что я сегодня подготовила ээ рассказы часов на
31:28
10, а думала, что на один. Но тем не менее, вернёмся к теме, да,
31:33
вот опять мы получили опять что-то виртуальный адрес из физического. М и
31:40
давайте посмотрим, как это выглядит. А и выглядит ли вообще как-то, мало ли вдруг что. Так. Это всё
31:47
нормально. Ага. Вот смотрим. Так. Неаккуратненько, но видно,
31:54
что это одно и то же. Давайте всё-таки я сделаю аккуратненько. Очень хочется прямо, чтобы совсем было красиво. А
PTE, PMD и другие уровни адресации
32:02
почему хочется? Сейчас увидите. Потому что красота с нами не
32:08
всегда. Так, ну что, как-то так,
32:14
да? Вот. А, и вот мы видим всё, что хотели. м совпадающие адреса. То есть,
32:22
смотрите, конвертация из физическая
32:28
из виртуального адреса физически нам удалась на пять с плюсом. А сходили
32:34
сюда, вернулись сюда, получили то же самое. И знаете, хорошо бы э не поверить
32:41
своим глазам и подумать, а гарантировано ли нам такое счастье каждый раз.
32:47
Внезапно оказывается, что не особенно. Смотрите, сейчас будет
32:54
как сказать, немножечко немножечко издевательства. Давайте сделаем вещь,
33:01
казалось бы, очень простую, казалось бы, привычную и тыся раз мы её делали.
33:07
Давайте мы не будем, а, выделять вот этот молок, а давайте мы прямо в лоб сделаем.
33:15
А так. Создадим а переменную кг data
33:22
дата, ну, скажем, не знаю, 17, а,
33:29
my data будет с указателем на эту
33:35
переменную. А, и ещё мы сделали ещё одну переменную. Ну, пока пока наш стек не
Адресация в таблицах и байтовый доступ
33:43
под угрозой. Пока вроде бы всё хорошо и мы его не убили. А всё остальное должно
33:48
работать. Давайте посмотрим, что как это всё
33:55
выглядит. Так, а отработал, не загрузился, всё хорошо. Опа, смотрите,
34:01
как здорово. То есть он вообще не смог, а ему стало совсем
34:08
плохо. А в тот момент А нет, здесь не то. Смотрите, вот здесь он не смог, а
34:14
там я просто напрасно освобождала память. Это он пытался освободить, у него не вышло. Жалеем человека. Э,
34:22
потому что я пытался освободить память на стеке. Давайте это тоже уберём, чтобы не было вот такого вот.
34:29
Это же кафри. У нас же работает только на камолок, да? А тут такие ужасы. Да ещё и с ядром. Хорошо,
34:37
что мы не умерли. Так. Ээ, ну что ты
34:43
там, чего ты там не можешь? Ты не можешь, потому
34:48
что, может быть, ты вообще теперь ничего не
Процессоры работают не с байтами, а со страницами
34:54
сможешь. Возможно, я убила систему, а может быть, нет. Давайте надеяться, что
35:05
нет. А, да. Ну-ка.
35:11
Ну, в общем, ему плохо. В общем, ему
35:17
плохо. И ему плохо неспроста. Так, а
35:26
что плохого мы сделали? Ээ, так прямо в луб я не вижу, что мы
35:33
там прямо особенно плохого сделали, но так или иначе он не он не смог вообще. Он прямо вот совсем не смог.
35:42
А-а, почему немножечко для меня
35:47
немножечко сейчас для меня загадка, если вы знаете, давайте. Но мы сейчас развлекались как-то прямо совсем
35:53
нехорошо. А давайте, э, чуть-чуть по-другому. Может быть, нам стоит даже
Размер страницы и страничная адресация
36:00
вот вот так сделать, а, и сделать вот так.
36:09
получится, не получится, не знаю. А мы
36:14
рискнём. А, ну да, мы
36:25
рискнём. А,
36:30
сори. Ну нет, ему не стало легче. Возможно, я что-то такое в нём убила,
36:37
видите, уже навсегда. И придётся сейчас перезагружаться. Ну ладно, хорошо, можно
36:43
перезагрузиться. [музыка] Угу. Так, пусть он там себе тихонечко
36:51
перезагружается. А модуль в ядро вообще не добавлялся. Я вижу комментарии, что не зависли модуль в ядре. Смотрите,
36:58
модуль в ядро не добавлялся, потому что он возвращает мину. Ну, то есть он всегда возвращает отрицательное число,
37:05
либо код ошибки, либо просто -2. Это как раз гарантия того, что модуль в ядро
Микроконтроллеры и отсутствие страниц
37:10
вообще не попал. А, ну, честно говоря, у меня такое бывает, когда я совсем теряю берега и
37:18
делаю что-то странное с кодом. Э конкретно на этой машине
37:24
бывает. Не знаю, возможно, это какая-то общая тема. Но сейчас, смотрите, сейчас же задача не в том, чтобы показать, что
37:31
всё круто. А показать, что бывает. Вот бывает в том числе
37:36
такое. А так сейчас я попытаюсь
37:42
завести. Ну это просто я новое на открыла новое окно, чтобы оно там не выскочило. Сейчас. Всё, он
37:50
заребутился. Теперь я коннектчусь с нему заново. Наверное, он уже опять поднялся. Он там быстренький
37:57
такой. А, та-та. Вот. Всё, поднялся. Хорошо. Давайте ещё раз
Подведение итогов: физическая память — это сложно
38:04
рискнём.
38:09
А, всё, очистили. Аа, сделаем VP
38:18
run. Ага, вот всё теперь хорошо. Теперь, видите, он туда не зашёл.
38:27
мину V. А зато всё написал. И теперь смотрите, что происходит. Хорошо видно,
38:35
что с первым адресом, ну, адрес и адрес, а второй физический адрес, ну, тоже
38:41
какой-то, а вот обратно не вышло. И вот это вот обратно не вышло. Это, ну,
38:48
такая в некотором смысле драгоценность, которую мы обнаружили, потому что вот
38:54
как бы всегда хочется обвинить себя в том, что мы сделали что-то неправильно, но мы
Ошибки мышления: что не гарантировано
39:00
действительно сделали кое-что неправильно, но не там, где
39:06
опасались. Кажется, что это какая-то ошибка конвертации. А на самом деле всё дело в том, что мы,
39:16
а, пытались найти обратный адрес, а
39:23
пытались найти обратный адрес у переменной, которые находится на стеке, не в этом самом, не, ну, не в
39:33
выделенной динамической памяти, а на стеке. Вот. Но дело в том, что это не
39:39
работает. Дело в том, что вот такое вот однозначное, взаимно однозначное отображение работает только для м так,
39:47
так называемой l low memм области
39:53
памяти, в которую стек не входит. Ну то есть для неё вот вот это действие, оно
39:58
просто неосмыслено, так скажем. А что за лум такой? Ну как всегда, название
Закрепление: не всё можно преобразовать обратно
40:05
историческое, как всегда. Так легко не найти этот лоумем в системе. Ну, не как всегда, это, конечно, перепере переебай
40:12
попу. Вот. Но кое-что понять можно. Значит, в нашем же том же самом Zone
40:18
infо есть блок normal. И почти всё, что
40:23
нынче называется Lowm, оно вот там, вот в этом блоке normal. Значит, э да, я же
40:30
не сказала, что у нас есть, ээ, zone info, а это интересный палик. Он,
40:36
видите, он тоже в проке, то есть он всё в той же виртуальной файловой системе,
40:41
которая на самом деле а не не физические файлы на диске, а,
40:48
мм, эта система обеспечивает доступ к разным, к разной информации
40:55
из модуля ядра, из самого ядра, из конфига. Ну, короче, вот вот там.
Выводы по сегодняшней теме
41:01
А, и вот файлик, псевдофайлик, не знаю, термина нет, ну, файлик, что делать,
41:07
который описывает ну, всякие там разные штуки, которые называются зонами э
41:13
памяти. А очень разные, очень зависит от компьютера. Вот у меня, например, везде
41:19
тут Node 1, но вообще-то в неско если процессоров несколько, у вас будет и другие цифры тут вот. А, Direct Memory
41:27
Access, как видите, DMA, то есть это вот прямо память прямого доступа, что-то тут
41:33
про неё интересное. А другие какие-то куски, а вот DMI 32, это, по-моему, тоже
41:40
РМЛ. А вот он сам нормал наш. И, короче говоря, э мкни здесь, так скажем,
41:48
аккуратно. Видите, вот есть какая-то ещё зона, и вот она уже не лоумер. То есть тут вот такого взаимнооднозначного
41:55
соответствия вы не очень-то получите его. Значит, что вообще сейчас произошло?
Страницы, битовые сдвиги и ограничения железа
42:02
А мы сейчас как бы стартовали с некоторой идеей, что
42:08
давайте следовать физическую память, потому что откуда-то нас не зашло
42:13
озарение. Мы узнали, что до этого жили в пространстве виртуальной памяти, да, говорили прозой. А
42:21
оказалось, что не всё так просто, что за одним и тем же адресом может стоять там чего-то ещё. Мы туда пошли и выяснили,
42:29
что наша возможность вернуться сильно зависит от того, откуда мы шли. То есть
42:34
есть ещё какой-то феномен. Ну, теперь мы знаем, что это
42:40
называется зона. Теперь мы знаем, что такие вот походы туда-обратно работают только для зоны, которая входит в
42:49
исторически сложившее название low memм. Но это вот некоторое знание добыто эмпирическим путём, потому что, конечно,
42:55
конечно про него можно прочитать, но пока со всей дуре лбом не уткнёшься, ты
43:01
вообще не поймёшь, что эта информация тебе зачем-то нужна. А вот она, пожалуйста, она нужна, потому что если
43:07
ты не там переменно в своём коде определил, то ты к этой переменной с физической памяти, ну там смысла,
43:13
правда, нет большого, но тем не менее даже в рамках эксперимента просто не вернёшься никак. Вот. А что это вообще
43:21
за путь такой отсюда-сюда? Это интересно, потому что этот путь, он он вообще не про кот, он
43:29
про железо. То есть вот этот фиолетовая точка, это на самом деле мм процессор и
Почему директория весит минимум 4 КБ
43:36
его поведение. Ну и ещё там немножечко а оперативной памяти. А
43:42
потому что, значит, как вообще устроен вот этот поход?
43:48
А дело в том, что виртуальный адрес — это штука, которая очень-очень очень
43:55
напоминает, а, скажем, адрес компьютера в сети. Ну, там, не знаю, в локальной вашей сети, да. А он тоже устроен
Анонс следующего занятия и завершение
44:04
иерархически. То есть вот вот эти вот пять прямоугольничков с трудно произносимыми названиями — это, грубо
44:10
говоря, большой адрес, адрес поменьше, адрес вообще маленький, жесть. Ну и там совсем крохотулечный, да. А, и в
44:19
виртуальном Англисе, ну, вот там буквально всё написано вот по очереди. Первые там девять, нет, первый там
44:25
мусор, э, как бы первые значимые 9 бит говорят, э, как бы адрес крупного блока
44:33
внутри физической памяти. Мм, следующий 9 бит, ну, если
44:39
они что-то говорят, P4D не часто что-то говорит, но, допустим, говорят адрес
44:44
блока поменьше, да? Ну, например, там, не знаю, страна, город, ээ, улица, дом,
44:53
ээ, квартира. Ну, вот такой такого примерно рода мм адрес. Только только
45:00
это всё стандартизировано. То есть в каждой стране некоторый набор городов, в каждом городе некоторый набор улиц,
45:06
везде улица Ленина, везде дом один. Ну, понятно. А
45:11
как бы что, почему? Почему так? Ну, смотрите. Нам же надо как-то вот это
45:17
взаимнозначное соответствие устраивать. Ээ, оно устроено исходя из возможностей
45:23
железа, исходя из возможностей мм процессора. Процессор он вообще ему есть
45:31
чем заняться. То есть, конечно, управление памятью — это важная для него задача, но она не единственная.
45:37
Поэтому придумано много всяких схем, которые как бы такого немножко м
45:46
компромисса между удобством для программирования и удобством реализации,
45:52
собственно, железа. Вот одна из этих схем. Так, ну тут на тут ээ ничего
45:59
особенного в этом коде сейчас мы не будем э делать. Вот
46:04
таблица вот вот эта вот она показывает вот то самое распределение
46:10
там этих самых побайтовы первые девять адресов — это а
46:17
высокоуровневый адрес вот и таблица так тоже называется потом ну видите по 4D
46:24
совпадает почти всегда м у меня на компьютерах точно совпадает возможно на ваших как-то иначе но вот есть ещё ну
46:32
Это, знаете, это считайте, как если вы там пишете там, не знаю, ээ, в
46:37
Екатеринбурге, да, вы можете указать Свердловская область, но это не улучшит вашу адресацию. А дальше, э, следующий
46:46
кусочек — это, э, ещё меньше, ещё меньше и ещё меньше. Э такие такая вложенная
46:54
система адресации. И они все стоят рядышком. Я прямо даже не поленюсь,
46:59
напишу что-нибудь, что-нибудь такое. Это совершенно, это не адрес, но
47:05
просто, чтобы Ой, господи, сейчас. Ну вот как-то так. Сколько тут
47:12
сейчас? 1 2 3 1 2 3 1 2 3 Всё, тут, значит, заканчивается, э, заканчивается
47:18
наш ПЖД. Ну, P4 тут такой же, значит,
47:25
01 всё. Да, это у нас будет, а, ну и так далее, да, давайте
47:32
ещё раз продублирую просто. Вот. Ну, то есть до этого там какие-то нули, что-то
47:37
такое. А не надо так делать. Мм, что ж ты вот
47:44
так? А, вот так выглядит адрес. Ну, тут как бы, конечно, в двоичной системе
47:50
счисления. А, виртуальный адрес, и он превращается
47:55
в физический, который уже ничего, никаких шифров себе не содержит. Ну, просто вот такой адресочек там. Там уже
48:02
какие-то цифры тоже нули, единички, но они уже привязаны к реальности, к
48:08
железу. Значит, это удобно, потому что получается как что у нас каждый адрес это на самом
48:16
деле, а это как бы адрес в большем смысле, чем
48:24
мы привыкли. То есть это ещё и привязка к физическому
48:30
адресу. А это классно. Это часто нужно.
48:37
Ну, опять же, вот из-за того, что мы оперируем устройствами, которые непосредственно пишут физическую память.
48:43
Вот. А из Но смотрите, получается, что
48:49
у нас как-то адреса вот с точностью до байта, да? То есть можно было бы
48:54
предположить, как мы привыкли предполагать, да, что вот эта цепочка доводит нас до байта. Так вот, она нас
49:01
до байта не доводит. А, ну как бы дово, подождите,
49:07
не совсем так, как бы не её задача довести нас до байта, вот так скажем. Её
49:12
задача довести нас до некоторого единицы, которая называется страница. Значит,
49:19
а процессоры, насколько я знаю, все процессоры сейчас, хотя опять же это
49:25
такая знание не факт, вдруг там что изобрели.
49:30
Они не оперируют адресами байтов, они оперируют
49:36
адресами некоторых кусочков, которые называется страница.
49:42
Они, эти кусочки могут освободить, найти, положить на диск,
49:48
поднять диск обратно в оперативку, защитить там. Ну, короче, вот все
49:53
действия, которые железка может предпринимать с памятью, это действие
50:01
кусочками. Не, ну на самом деле мы к этому привыкли. Мы же не ждём битовой
50:07
адресации. Мы используем как бы в быту так, да, байтовую адресацию. И здесь то
50:13
же самое. То есть только не байты, а как бы немножко следующий уровень обобщения.
50:18
Вот куски памяти идут страницами. Ну почему важно? Всё то же
50:25
самое, потому что нам нужна физическая память, потому что нам нужно э отдавать
50:30
её устройством. А мы, короче, прощаемся с ещё одной
50:37
привычкой, которая к нам пришла из прикладного программирования, а именно,
50:42
что память адресуется побайтово. Вроде жмёт, но я уже сказала,
50:48
что м мы один раз от этого уже отвыкли. Мы уже когда-то давно уже забыли все, но
50:54
мы узнали, что память адресуется Побайтово, а не Побитого. Уже такой
50:59
переход с нами уже случался. Вот, вот сейчас точно такой же, точно такой же переход. От битов мы переходим к
51:08
страницам. И размер страницы можно узнать, но, честно говоря, э я не слыхала, не знаю
51:17
вообще. Э то есть нет, я знаю, что, по-моему, в армах
51:23
размеры страницы отличаются, но вот как бы всё, что я за своими глазами видела, оно возвращает вот эти 496, то есть 4
51:30
кб. По-моему, в по-моему бывает ещё восемь, но у меня
51:37
под рукой точно нет такой системы. Вот. А и как бы что важно важно знать, что даже
51:46
это не гарантия, потому что нам тут в дверь стучатся микроконтроллеры, а и вот в
51:52
микроконтроллерах вообще нет страниц. Они как-то победили эту м ну не то, что
51:58
они победили, им нечего было побеждать, у них всего они они микро, у них всё маленькое, поэтому им не на не нужно
52:04
оперировать мм. Им вполне нормально оперировать э
52:10
байтами. Вот. И тут конечно можно поиграть, но у нас закончилось время. Я
52:16
хочу обратить внимание, что мы сейчас вот дошли в своих исследованиях памяти,
52:22
а до довольно важного места. То есть мы начали щупать, мы поняли, что халявы не
52:28
будет. То есть предыдущие знания вообще никак почти не пригодятся. Ну разве что там код похоже пишется, да. Вот что с
52:35
нами теперь физическая память, которая мм у ну она местами взаимно однозначно с
52:43
виртуальной, а местами в общем очень даже и нет. И что мы должны за этим следить постоянно, а уже неплохо, да?
52:52
Это мы там даже 1% ещё не не посмотрели на то, как память это устроена. Вот что в любой момент нас ждут какие-то
52:59
странные вещи, а, и всё надо проверять. А что не всякое, ну, вот вот с этим, с
53:06
виртуалкой понятно вот, э, что бывают какие-то полезные файлики в разделе
53:13
прок, и можно, в принципе, себе там куда-нибудь их стороночку записывать. Вот что мы наконец добрались до того
53:20
места, которое называется вот натурально железо. Прямо упёрлись в ограничения
53:26
железа в настоящий процессор. А даже если мы не очень рвёмся его исследовать, видите,
53:33
тут придётся вот ещё раз не пожалели, что ээ знаем про
53:40
ээ битовые сдвиги. Это приятно. Вот вспомнили,
53:46
что уже что-то такое видели, когда была адресация в сети. Ну не то, что мы
53:54
прямо глубоко её копнули, но общий принцип тот, как видите, точно такой же. и дошли до фундамента, от которого
54:02
дальше уже станет, ну, как бы побыстрее, наверное, пойдёт, а именно до понимания,
54:09
что, э, система управления памяти внутри процессора оперирует,
54:14
ну да, оперирует страницами, а не баййтами. И что нам тоже надо уметь
54:21
переключиться на работу со страницами. дальше начинается упражнения
54:27
поинтереснее, но это уже в следующий раз. По поводу любой директории, которая весит 4 КБ. Значит, вопрос, да, из-за
54:34
этого любая директория весит 4 Кб, размер страницы? А я думаю, что да, потому что любая мелочь, которая
54:41
выделена как попала, без особых мер для выделения
54:47
этой мелочи, вот любая штуковина весит минимум одну страницу. И как раз с этого
54:54
мы начнём через неделю. Очень там очень прямо интересно за этим всем наблюдать,
55:01
но на сегодня я думаю, что хватит. Всё, всем большое спасибо. Всем пока.
55:07
S