▍ Навигация по частям

• Часть 1
• Часть 2
• Часть 3
• Часть 4
• Часть 5 < — вы здесь

Дисковый ввод/вывод

▍ Virtio

▍ Virtqueue

1. Драйвер записывает запрос чтения/записи в область дескриптора.
2. Драйвер добавляет индекс верхнего дескриптора в кольцевой буфер Avail Ring.
3. Драйвер уведомляет устройство о поступлении нового запроса.
4. Устройство считывает этот запрос из Avail Ring и обрабатывает его.
5. Устройство записывает в кольцевой буфер Used Ring индекс дескриптора и уведомляет драйвер о завершении.

▍ Активация устройств virtio

$ echo "Lorem ipsum dolor sit amet, consectetur adipiscing elit. In ut magna consequat, cursus velit aliquam, scelerisque odio. Ut lorem eros, feugiat quis bibendum vitae, malesuada ac orci. Praesent eget quam non nunc fringilla cursus imperdiet non tellus. Aenean dictum lobortis turpis, non interdum leo rhoncus sed. Cras in tellus auctor, faucibus tortor ut, maximus metus. Praesent placerat ut magna non tristique. Pellentesque at nunc quis dui tempor vulputate. Vestibulum vitae massa orci. Mauris et tellus quis risus sagittis placerat. Integer lorem leo, feugiat sed molestie non, viverra a tellus." > lorem.txt

run.sh

$QEMU -machine virt -bios default -nographic -serial mon:stdio --no-reboot \
    -d unimp,guest_errors,int,cpu_reset -D qemu.log \
    -drive id=drive0,file=lorem.txt,format=raw,if=none \            # new
    -device virtio-blk-device,drive=drive0,bus=virtio-mmio-bus.0 \  # new
    -kernel kernel.elf

• -drive id=drive0: определяет диск drive0, используя в качестве его образа lorem.txt. Этот образ представлен в формате raw, то есть содержимое файла рассматривается в качестве данных диска как есть.
• -device virtio-blk-device: добавляет устройство virtio-blk с диском drive0. bus=virtio-mmio-bus.0 отображает это устройство в шину virtio-mmio (virtio с отображением в память [Memory Mapped I/O]).

▍ Определение макросов и структур на C

kernel.h

#define SECTOR_SIZE       512
#define VIRTQ_ENTRY_NUM   16
#define VIRTIO_DEVICE_BLK 2
#define VIRTIO_BLK_PADDR  0x10001000
#define VIRTIO_REG_MAGIC         0x00
#define VIRTIO_REG_VERSION       0x04
#define VIRTIO_REG_DEVICE_ID     0x08
#define VIRTIO_REG_QUEUE_SEL     0x30
#define VIRTIO_REG_QUEUE_NUM_MAX 0x34
#define VIRTIO_REG_QUEUE_NUM     0x38
#define VIRTIO_REG_QUEUE_ALIGN   0x3c
#define VIRTIO_REG_QUEUE_PFN     0x40
#define VIRTIO_REG_QUEUE_READY   0x44
#define VIRTIO_REG_QUEUE_NOTIFY  0x50
#define VIRTIO_REG_DEVICE_STATUS 0x70
#define VIRTIO_REG_DEVICE_CONFIG 0x100
#define VIRTIO_STATUS_ACK       1
#define VIRTIO_STATUS_DRIVER    2
#define VIRTIO_STATUS_DRIVER_OK 4
#define VIRTIO_STATUS_FEAT_OK   8
#define VIRTQ_DESC_F_NEXT          1
#define VIRTQ_DESC_F_WRITE         2
#define VIRTQ_AVAIL_F_NO_INTERRUPT 1
#define VIRTIO_BLK_T_IN  0
#define VIRTIO_BLK_T_OUT 1

// Запись области дескрипторов virtqueue.
struct virtq_desc {
    uint64_t addr;
    uint32_t len;
    uint16_t flags;
    uint16_t next;
} __attribute__((packed));

// Avail Ring.
struct virtq_avail {
    uint16_t flags;
    uint16_t index;
    uint16_t ring[VIRTQ_ENTRY_NUM];
} __attribute__((packed));

// Запись Used Ring.
struct virtq_used_elem {
    uint32_t id;
    uint32_t len;
} __attribute__((packed));

// Used Ring.
struct virtq_used {
    uint16_t flags;
    uint16_t index;
    struct virtq_used_elem ring[VIRTQ_ENTRY_NUM];
} __attribute__((packed));

// Virtqueue.
struct virtio_virtq {
    struct virtq_desc descs[VIRTQ_ENTRY_NUM];
    struct virtq_avail avail;
    struct virtq_used used __attribute__((aligned(PAGE_SIZE)));
    int queue_index;
    volatile uint16_t *used_index;
    uint16_t last_used_index;
} __attribute__((packed));

// Запрос virtio-blk.
struct virtio_blk_req {
    uint32_t type;
    uint32_t reserved;
    uint64_t sector;
    uint8_t data[512];
    uint8_t status;
} __attribute__((packed));

Примечание

__attribute__((packed)) — это расширение, которое инструктирует компилятор упаковать членов структур без заполнения. В противном случае он может добавить скрытые заполняющие байты, и драйвер/устройство увидит другие значения.

kernel.c

uint32_t virtio_reg_read32(unsigned offset) {
    return *((volatile uint32_t *) (VIRTIO_BLK_PADDR + offset));
}

uint64_t virtio_reg_read64(unsigned offset) {
    return *((volatile uint64_t *) (VIRTIO_BLK_PADDR + offset));
}

void virtio_reg_write32(unsigned offset, uint32_t value) {
    *((volatile uint32_t *) (VIRTIO_BLK_PADDR + offset)) = value;
}

void virtio_reg_fetch_and_or32(unsigned offset, uint32_t value) {
    virtio_reg_write32(offset, virtio_reg_read32(offset) | value);
}

Предупреждение

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

▍ Отображение области MMIO

kernel.c

struct process *create_process(const void *image, size_t image_size) {
    /* код опущен */

    for (paddr_t paddr = (paddr_t) __kernel_base;
         paddr < (paddr_t) __free_ram_end; paddr += PAGE_SIZE)
        map_page(page_table, paddr, paddr, PAGE_R | PAGE_W | PAGE_X);

    map_page(page_table, VIRTIO_BLK_PADDR, VIRTIO_BLK_PADDR, PAGE_R | PAGE_W); // добавлено

▍ Инициализация устройства virtio

3.1.1 Требования к драйверу: инициализация устройства. При инициализации устройства драйвер должен выполнить следующее:

1. Сбросить устройство.
2. Установить бит состояния ACKNOWLEDGE, означающий, что гостевая ОС обнаружила устройство.
3. Установить бит состояния DRIVER, означающий, что гостевая ОС знает, как управлять устройством.
4. Считать биты функциональности устройства и записать на него те из них, которые связаны с понятными для ОС и драйвера функциями. На этом этапе драйвер может считывать (но не должен записывать) относящиеся к устройству поля конфигурации, чтобы предварительно проверить возможность его поддержки.
5. Установить бит состояния FEATURES_OK. После этого шага драйвер не должен принимать новые биты функциональности.
6. Повторно считать состояние устройства, проверяя, установлен ли по-прежнему бит FEATURES_OK: если нет, значит, устройство не поддерживает обозначенное подмножество функций, и использовать его не получится.
7. Выполнить настройку устройства, включая поиск virtqueues для него, настройку по шинам (опционально), считывание и, возможно, запись конфигурации virtio устройства, а также заполнение всех virtqueue.
8. Установить бит состояния DRIVER_OK. На этом этапе устройство «оживает».

kernel.c

struct virtio_virtq *blk_request_vq;
struct virtio_blk_req *blk_req;
paddr_t blk_req_paddr;
unsigned blk_capacity;

void virtio_blk_init(void) {
    if (virtio_reg_read32(VIRTIO_REG_MAGIC) != 0x74726976)
        PANIC("virtio: invalid magic value");
    if (virtio_reg_read32(VIRTIO_REG_VERSION) != 1)
        PANIC("virtio: invalid version");
    if (virtio_reg_read32(VIRTIO_REG_DEVICE_ID) != VIRTIO_DEVICE_BLK)
        PANIC("virtio: invalid device id");

    // 1. Сброс устройства.
    virtio_reg_write32(VIRTIO_REG_DEVICE_STATUS, 0);
    // 2. Установка бита состояния ACKNOWLEDGE: гостевая ОС обнаружила устройство.
    virtio_reg_fetch_and_or32(VIRTIO_REG_DEVICE_STATUS, VIRTIO_STATUS_ACK);
    // 3. Установка бита состояния DRIVER.
    virtio_reg_fetch_and_or32(VIRTIO_REG_DEVICE_STATUS, VIRTIO_STATUS_DRIVER);
    // 5. Установка бита состояния FEATURES_OK.
    virtio_reg_fetch_and_or32(VIRTIO_REG_DEVICE_STATUS, VIRTIO_STATUS_FEAT_OK);
    // 7. Настройка устройства, включая обнаружение virtqueues для него.
    blk_request_vq = virtq_init(0);
    // 8. Установка бита состояния DRIVER_OK.
    virtio_reg_write32(VIRTIO_REG_DEVICE_STATUS, VIRTIO_STATUS_DRIVER_OK);

    // Уточнение ёмкости диска.
    blk_capacity = virtio_reg_read64(VIRTIO_REG_DEVICE_CONFIG + 0) * SECTOR_SIZE;
    printf("virtio-blk: capacity is %d bytes\n", blk_capacity);

    // Аллокация области для хранения запросов к устройству.
    blk_req_paddr = alloc_pages(align_up(sizeof(*blk_req), PAGE_SIZE) / PAGE_SIZE);
    blk_req = (struct virtio_blk_req *) blk_req_paddr;
}

kernel.c

void kernel_main(void) {
    memset(__bss, 0, (size_t) __bss_end - (size_t) __bss);
    WRITE_CSR(stvec, (uint32_t) kernel_entry);

    virtio_blk_init(); // добавлено

▍ Инициализация virtqueue

Виртуальная очередь настраивается так:

1. Выберите очередь, записав её индекс в QueueSel (первая — это 0).
2. Проверьте, не используется ли эта очередь: считайте QueuePFN — должен вернуться нуль (0x0).
3. Узнайте максимальный размер очереди (количество элементов), считав QueueNumMax. Если вернётся нуль (0х0), очередь недоступна.
4. Аллоцируйте и обнулите страницы очередей в непрерывной области виртуальной памяти, выровняв Used Ring по оптимальной границе (обычно по размеру страницы). Драйвер должен выбирать такую очередь, размер которой меньше либо равен QueueNumMax.
5. Уведомите устройство о размере очереди, записав его в QueueNum.
6. Уведомите устройство об используемом выравнивании, записав его значение в байтах в QueueAlign.
7. Запишите физический номер первой страницы очереди в регистр QueuePFN.

kernel.c

struct virtio_virtq *virtq_init(unsigned index) {
    // Аллокация области под virtqueue.
    paddr_t virtq_paddr = alloc_pages(align_up(sizeof(struct virtio_virtq), PAGE_SIZE) / PAGE_SIZE);
    struct virtio_virtq *vq = (struct virtio_virtq *) virtq_paddr;
    vq->queue_index = index;
    vq->used_index = (volatile uint16_t *) &vq->used.index;
    // 1. Выбор очереди путём записи её индекса в QueueSel (первая — это 0).
    virtio_reg_write32(VIRTIO_REG_QUEUE_SEL, index);
    // 5. Уведомление устройства о размере очереди путём его записи в QueueNum.
    virtio_reg_write32(VIRTIO_REG_QUEUE_NUM, VIRTQ_ENTRY_NUM);
    // 6. Уведомление устройства об используемом выравнивании путём записи его значения в байтах в QueueAlign.
    virtio_reg_write32(VIRTIO_REG_QUEUE_ALIGN, 0);
    // 7. Запись физического номера первой страницы очереди в регистр QueuePFN.
    virtio_reg_write32(VIRTIO_REG_QUEUE_PFN, virtq_paddr);
    return vq;
}

Подсказка

В процессе инициализации драйверы проверяют возможности/функции устройства, выделяют ресурсы ОС (например, память) и устанавливают параметры. Не напоминает рукопожатие в сетевых протоколах?

▍ Отправка запросов ввода/вывода

kernel.c

// Уведомляем устройство о поступлении запроса. `desc_index` - это индекс его верхнего дескриптора.
void virtq_kick(struct virtio_virtq *vq, int desc_index) {
    vq->avail.ring[vq->avail.index % VIRTQ_ENTRY_NUM] = desc_index;
    vq->avail.index++;
    __sync_synchronize();
    virtio_reg_write32(VIRTIO_REG_QUEUE_NOTIFY, vq->queue_index);
    vq->last_used_index++;
}

// Определяем, обрабатывает ли в данный момент устройство какие-либо запросы.
bool virtq_is_busy(struct virtio_virtq *vq) {
    return vq->last_used_index != *vq->used_index;
}

// Считываем/записываем из/в устройство virtio-blk.
void read_write_disk(void *buf, unsigned sector, int is_write) {
    if (sector >= blk_capacity / SECTOR_SIZE) {
        printf("virtio: tried to read/write sector=%d, but capacity is %d\n",
              sector, blk_capacity / SECTOR_SIZE);
        return;
    }

    // Создаём запрос в соответствии со спецификацией virtio-blk.
    blk_req->sector = sector;
    blk_req->type = is_write ? VIRTIO_BLK_T_OUT : VIRTIO_BLK_T_IN;
    if (is_write)
        memcpy(blk_req->data, buf, SECTOR_SIZE);

    // Создаём дескрипторы virtqueue (в данном случае 3).
    struct virtio_virtq *vq = blk_request_vq;
    vq->descs[0].addr = blk_req_paddr;
    vq->descs[0].len = sizeof(uint32_t) * 2 + sizeof(uint64_t);
    vq->descs[0].flags = VIRTQ_DESC_F_NEXT;
    vq->descs[0].next = 1;

    vq->descs[1].addr = blk_req_paddr + offsetof(struct virtio_blk_req, data);
    vq->descs[1].len = SECTOR_SIZE;
    vq->descs[1].flags = VIRTQ_DESC_F_NEXT | (is_write ? 0 : VIRTQ_DESC_F_WRITE);
    vq->descs[1].next = 2;

    vq->descs[2].addr = blk_req_paddr + offsetof(struct virtio_blk_req, status);
    vq->descs[2].len = sizeof(uint8_t);
    vq->descs[2].flags = VIRTQ_DESC_F_WRITE;

    // Уведомляем устройство о новом запросе.
    virtq_kick(vq, 0);

    // Ожидаем, пока устройство завершит обработку.
    while (virtq_is_busy(vq))
        ;

    // virtio-blk: возвращение ненулевого значения указывает на ошибку.
    if (blk_req->status != 0) {
        printf("virtio: warn: failed to read/write sector=%d status=%d\n",
               sector, blk_req->status);
        return;
    }

    // При операциях чтения копируем данные в буфер.
    if (!is_write)
        memcpy(buf, blk_req->data, SECTOR_SIZE);
}

1. Создайте запрос в blk_req. Укажите номер секции, к которой нужен доступ, и тип запроса: чтение/запись.
2. Создайте цепочку дескрипторов, указывающих каждый на свою область blk_req (подробнее ниже).
3. Добавьте индекс верхнего дескриптора цепочки в Avail Ring.
4. Уведомите устройство о поступлении нового запроса.
5. Подождите, пока устройство закончит обработку (используя холостой цикл или опрос).
6. Проверьте полученный от устройства ответ.

struct virtio_blk_req {
    // Первый дескриптор: только чтение с устройства
    uint32_t type;
    uint32_t reserved;
    uint64_t sector;

    // Второй дескриптор: возможна запись устройством, если это операция чтения (VIRTQ_DESC_F_WRITE)
    uint8_t data[512];

    // Третий дескриптор: возможна запись устройством (VIRTQ_DESC_F_WRITE)
    uint8_t status;
} __attribute__((packed));

▍ Проверим

kernel.c

    virtio_blk_init();

    char buf[SECTOR_SIZE];
    read_write_disk(buf, 0, false /* чтение с диска */);
    printf("first sector: %s\n", buf);

    strcpy(buf, "hello from kernel!!!\n");
    read_write_disk(buf, 0, true /* запись на диск */);

$ ./run.sh

virtio-blk: capacity is 1024 bytes
first sector: Lorem ipsum dolor sit amet, consectetur adipiscing elit ...

$ head lorem.txt
hello from kernel!!!
amet, consectetur adipiscing elit ...

Подсказка

Вы могли подметить, что драйверы устройств — это лишь связующий элемент между ОС и устройствами. Они не управляют оборудованием напрямую. Драйверы взаимодействуют с другим программным обеспечением устройства (например, прошивкой). Именно сами устройства и их программное обеспечение, а не драйвер ОС, будут выполнять всю основную работу, такую как перемещение головок чтения/записи.

Файловая система

▍ Файловая система на базе tar

Подсказка

Сегодня tar используется как альтернатива ZIP, но изначально создавался в качестве своего рода файловой системы для хранения данных на магнитной ленте. То есть его можно использовать в роли файловой системы, чем мы и займёмся далее, хотя вы заметите, что для произвольного доступа он не годится. Кстати, вам наверняка будет интересно почитать о структуре файловой системы FAT.

▍ Создание образа диска (файла tar)

$ mkdir disk
$ vim disk/hello.txt
$ vim disk/meow.txt

run.sh

(cd disk && tar cf ../disk.tar --format=ustar ./*.txt)                          # добавлено

$QEMU -machine virt -bios default -nographic -serial mon:stdio --no-reboot \
    -d unimp,guest_errors,int,cpu_reset -D qemu.log \
    -drive id=drive0,file=disk.tar,format=raw,if=none \                         # изменено
    -device virtio-blk-device,drive=drive0,bus=virtio-mmio-bus.0 \
    -kernel kernel.elf

• cf: создание файла tar.
• --format=ustar: создание в формате ustar.

Подсказка

Скобки (...) обеспечивают создание внутренней оболочки, чтобы команда cd не влияла на другие части скрипта.

▍ Структура файлов tar

+----------------+
| заголовок tar |
+----------------+
|   данные       |
+----------------+
|   заголовок   |
+----------------+
|   данные       |
+----------------+
|      ...      |

▍ Чтение файловой системы

kernel.h

#define FILES_MAX      2
#define DISK_MAX_SIZE  align_up(sizeof(struct file) * FILES_MAX, SECTOR_SIZE)

struct tar_header {
    char name[100];
    char mode[8];
    char uid[8];
    char gid[8];
    char size[12];
    char mtime[12];
    char checksum[8];
    char type;
    char linkname[100];
    char magic[6];
    char version[2];
    char uname[32];
    char gname[32];
    char devmajor[8];
    char devminor[8];
    char prefix[155];
    char padding[12];
    char data[];      // Массив, указывающий на область данных после заголовка
                      // (изменчивый член массива)
} __attribute__((packed));

struct file {
    bool in_use;      // Указывает, используется ли эта запись файла
    char name[100];   // Имя файла
    char data[1024];  // Содержимое файла
    size_t size;      // Размер файла
};

kernel.c

struct file files[FILES_MAX];
uint8_t disk[DISK_MAX_SIZE];

int oct2int(char *oct, int len) {
    int dec = 0;
    for (int i = 0; i < len; i++) {
        if (oct[i] < '0' || oct[i] > '7')
            break;

        dec = dec * 8 + (oct[i] - '0');
    }
    return dec;
}

void fs_init(void) {
    for (unsigned sector = 0; sector < sizeof(disk) / SECTOR_SIZE; sector++)
        read_write_disk(&disk[sector * SECTOR_SIZE], sector, false);

    unsigned off = 0;
    for (int i = 0; i < FILES_MAX; i++) {
        struct tar_header *header = (struct tar_header *) &disk[off];
        if (header->name[0] == '\0')
            break;

        if (strcmp(header->magic, "ustar") != 0)
            PANIC("invalid tar header: magic=\"%s\"", header->magic);

        int filesz = oct2int(header->size, sizeof(header->size));
        struct file *file = &files[i];
        file->in_use = true;
        strcpy(file->name, header->name);
        memcpy(file->data, header->data, filesz);
        file->size = filesz;
        printf("file: %s, size=%d\n", file->name, file->size);

        off += align_up(sizeof(struct tar_header) + filesz, SECTOR_SIZE);
    }
}

kernel.c

void kernel_main(void) {
    memset(__bss, 0, (size_t) __bss_end - (size_t) __bss);
    WRITE_CSR(stvec, (uint32_t) kernel_entry);
    virtio_blk_init();
    fs_init();

    /* код опущен */
}

▍ Проверка чтения файлов

$ ./run.sh

virtio-blk: capacity is 2560 bytes
file: world.txt, size=0
file: hello.txt, size=22

▍ Запись на диск

kernel.c

void fs_flush(void) {
    // Копируем всё содержимое файла в буфер `disk`.
    memset(disk, 0, sizeof(disk));
    unsigned off = 0;
    for (int file_i = 0; file_i < FILES_MAX; file_i++) {
        struct file *file = &files[file_i];
        if (!file->in_use)
            continue;

        struct tar_header *header = (struct tar_header *) &disk[off];
        memset(header, 0, sizeof(*header));
        strcpy(header->name, file->name);
        strcpy(header->mode, "000644");
        strcpy(header->magic, "ustar");
        strcpy(header->version, "00");
        header->type = '0';

        // Превращаем размер файла в восьмеричную строку.
        int filesz = file->size;
        for (int i = sizeof(header->size); i > 0; i--) {
            header->size[i - 1] = (filesz % 8) + '0';
            filesz /= 8;
        }

        // Вычисляем контрольную сумму.
        int checksum = ' ' * sizeof(header->checksum);
        for (unsigned i = 0; i < sizeof(struct tar_header); i++)
            checksum += (unsigned char) disk[off + i];

        for (int i = 5; i >= 0; i--) {
            header->checksum[i] = (checksum % 8) + '0';
            checksum /= 8;
        }

        // Копируем данные файла.
        memcpy(header->data, file->data, file->size);
        off += align_up(sizeof(struct tar_header) + file->size, SECTOR_SIZE);
    }

    // Записываем содержимое буфера `disk` в virtio-blk.
    for (unsigned sector = 0; sector < sizeof(disk) / SECTOR_SIZE; sector++)
        read_write_disk(&disk[sector * SECTOR_SIZE], sector, true);

    printf("wrote %d bytes to disk\n", sizeof(disk));
}

▍ Проектирование системных вызовов для чтения/записи файлов

common.h

#define SYS_READFILE  4
#define SYS_WRITEFILE 5

user.c

int readfile(const char *filename, char *buf, int len) {
    return syscall(SYS_READFILE, (int) filename, (int) buf, len);
}

int writefile(const char *filename, const char *buf, int len) {
    return syscall(SYS_WRITEFILE, (int) filename, (int) buf, len);
}

user.h

int readfile(const char *filename, char *buf, int len);
int writefile(const char *filename, const char *buf, int len);

Подсказка

Рекомендую почитать о проектировании системных вызовов в типичных операционных системах и проанализировать, что мы опустили в своей. Например, почему системные вызовы read(2) и write(2) в Linux получают в качестве аргументов не имена файлов, а файловые дескрипторы?

▍ Реализация системных вызовов

kernel.c

struct file *fs_lookup(const char *filename) {
    for (int i = 0; i < FILES_MAX; i++) {
        struct file *file = &files[i];
        if (!strcmp(file->name, filename))
            return file;
    }

    return NULL;
}

void handle_syscall(struct trap_frame *f) {
    switch (f->a3) {
        /* код опущен */
        case SYS_READFILE:
        case SYS_WRITEFILE: {
            const char *filename = (const char *) f->a0;
            char *buf = (char *) f->a1;
            int len = f->a2;
            struct file *file = fs_lookup(filename);
            if (!file) {
                printf("file not found: %s\n", filename);
                f->a0 = -1;
                break;
            }

            if (len > (int) sizeof(file->data))
                len = file->size;

            if (f->a3 == SYS_WRITEFILE) {
                memcpy(file->data, buf, len);
                file->size = len;
                fs_flush();
            } else {
                memcpy(buf, file->data, len);
            }

            f->a0 = len;
            break;
        }
        default:
            PANIC("unexpected syscall a3=%x\n", f->a3);
    }
}

Предупреждение

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

▍ Команды для чтения/записи файлов

shell.c

        else if (strcmp(cmdline, "readfile") == 0) {
            char buf[128];
            int len = readfile("hello.txt", buf, sizeof(buf));
            buf[len] = '\0';
            printf("%s\n", buf);
        }
        else if (strcmp(cmdline, "writefile") == 0)
            writefile("hello.txt", "Hello from shell!\n", 19);

$ ./run.sh

> readfile
PANIC: kernel.c:561: unexpected trap scause=0000000d, stval=01000423, sepc=8020128a

$ llvm-objdump -d kernel.elf
...

80201282 <strcmp>:
80201282: 03 46 05 00   lbu     a2, 0(a0)
80201286: 15 c2         beqz    a2, 0x802012aa <.LBB3_4>
80201288: 05 05         addi    a0, a0, 1

8020128a <.LBB3_2>:
8020128a: 83 c6 05 00   lbu     a3, 0(a1) ← отказ страницы здесь (a1 содержит 2-й аргумент)
8020128e: 33 37 d0 00   snez    a4, a3
80201292: 93 77 f6 0f   andi    a5, a2, 255
80201296: bd 8e         xor     a3, a3, a5
80201298: 93 b6 16 00   seqz    a3, a3

QEMU 8.0.2 monitor - type 'help' for more information
(qemu) info mem
vaddr    paddr            size     attr
-------- ---------------- -------- -------
01000000 000000008026c000 00001000 rwxu-a-

(qemu) x /10c 0x1000423
01000423: 'h' 'e' 'l' 'l' 'o' '.' 't' 'x' 't' '\x00' 'r' 'e' 'a' 'd' 'f' 'i'
01000433: 'l' 'e' '\x00' 'h' 'e' 'l' 'l' 'o' '\x00' '%' 's' '\n' '\x00' 'e' 'x' 'i'
01000443: 't' '\x00' 'w' 'r' 'i' 't' 'e' 'f'

▍ Обращение к указателям пространства пользователя

Подсказка

Это защитная мера с целью исключить нежелательное обращение к областям памяти пространства пользователя. Так совпало, что процессоры Intel имеют аналогичную функцию под названием SMAP (Supervisor Mode Access Prevention, предотвращение доступа в режиме супервизора).

kernel.h

#define SSTATUS_SUM  (1 << 18)

kernel.c

__attribute__((naked)) void user_entry(void) {
    __asm__ __volatile__(
        "csrw sepc, %[sepc]\n"
        "csrw sstatus, %[sstatus]\n"
        "sret\n"
        :
        : [sepc] "r" (USER_BASE),
          [sstatus] "r" (SSTATUS_SPIE | SSTATUS_SUM) // updated
    );
}

Подсказка

Я просто сказал, что «причиной был бит SUM», но некоторые читатели спросят, как можно было узнать это самим? Честно говоря, нелегко. Даже если вы знаете, что происходит отказ страницы, определить его причину зачастую трудно. К сожалению, процессоры даже не предоставляют нам подробные коды ошибок. Мне же удалось определить источник проблемы, так как я знал о бите SUM.

• Внимательно прочтите спецификацию RISC-V. В ней говорится, что «когда бит SUM установлен, режим S-Mode имеет доступ к страницам режима U-Mode».
• Прочтите исходный код QEMU. Причина упомянутого выше отказа страницы находилась здесь. Однако этот путь может оказаться труднее, чем внимательное прочтение спецификации.
• Обратитесь к LLM. Я серьёзно. Эти инструменты уже становятся вашим лучшим напарником в программировании.

▍ Тестирование чтения/записи файлов

$ ./run.sh

> readfile
Can you see me? Ah, there you are! You've unlocked the achievement "Virtio Newbie!"

> writefile
wrote 2560 bytes to disk

$ mkdir tmp
$ cd tmp
$ tar xf ../disk.tar
$ ls -alh
total 4.0K
drwxr-xr-x  4 seiya staff 128 Jul 22 22:50 .
drwxr-xr-x 25 seiya staff 800 Jul 22 22:49 ..
-rw-r--r--  1 seiya staff  26 Jan  1  1970 hello.txt
-rw-r--r--  1 seiya staff   0 Jan  1  1970 meow.txt
$ cat hello.txt
Hello from shell!

▍ Подведём итоги

▍ Расширьте функциональность

• Полноценный аллокатор памяти с возможностью её освобождения.
• Обработку прерываний вместо использования холостого цикла при обработке дискового ввода/вывода.
• Полноценную файловую систему. Хорошим началом станет реализация ext2.
• Сетевые возможности (TCP/IP). Реализовать UDP/IP несложно (TCP уже потруднее). Устройство virtio-net очень похоже на virtio-blk!

▍ Почитайте реализации других ОС

▍ Обратная связь приветствуется!

Telegram-канал со скидками, розыгрышами призов и новостями IT ?