babyos2（14）—— user stack, stack expand, load elf

最新推荐文章于 2021-04-30 08:04:50 发布
最新推荐文章于 2021-04-30 08:04:50 发布
阅读量478 收藏
点赞数
分类专栏： babyos2 babyos2 文章标签： babyos2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guzhou_diaoke/article/details/78765664
版权

到目前为止，babyos2用户态栈只分配并映射了一个页，所以当栈的内容超过这个界限时，就会PAGE_FAULT，并且无法处理导致进程halt。先简单验证下：

int main()
{
    uint32 cs = 0xffffffff;
    __asm__ volatile("movl %%cs, %%eax" : "=a" (cs));

    int i = 0;
    while (buffer[i] != '\0') {
        i++;
    }

    char num[9] = {0};
    int j = 0;
    while (cs != 0) {
        num[j++] = digits[cs % 16];
        cs /= 16;
    }

    while (j) {
        buffer[i++] = num[--j];
    }
    buffer[i++] = '\n';
    print(buffer);

    before_fork = (unsigned *) mmap(0, 4096, PROT_READ | PROT_WRITE, 0);
    for (unsigned int i = 0; i < 1024; i++) {
        before_fork[i] = i;
    }

    // fork
    int32 ret = fork();
    if (ret == 0) {
        // child
        buffer2[0] = 'I';
        buffer2[1] = 'C';
        buffer2[2] = ',';
        buffer2[3] = '\0';
        while (1) {
            for (int i = 0; i < 100000000; i++) ;
            print(buffer2);

            times2++;
            if (times2 == 10) {
                print(test2);
                for (unsigned int i = 100; i < 110; i++) {
                    before_fork[i] = i+1;
                }
                for (unsigned int i = 0; i < 16; i++) {
                    before_fork[i] = 100*i;
                    print_int(before_fork[i], 16, 0);
                }
            }
        }
    }
    else {
        // parent
        buffer[0] = 'I';
        buffer[1] = ',';
        buffer[2] = '\0';

        while (1) {
            for (int i = 0; i < 100000000; i++) ;
            print(buffer);

            times++;
            if (times == 15) {
                print(test);
                for (unsigned int i = 200; i < 210; i++) {
                    before_fork[i] = i;
                }
                for (unsigned int i = 0; i < 16; i++) {
                    print_int(before_fork[i], 16, 0);
                }

                // test stack
                unsigned ints[4000];
                for (unsigned i = 0; i < 4000; i++) {
                    ints[i] = i;
                }
                print_int(ints[400], 16, 0);
            }
        }
    }

    return 0;
}

目前依然没有任何用户态库，这个丑陋的测试函数还得用一阵子，将就下吧暂时……
增加的几行代码在 // test stack下面
因为4000个ints远远超过了4096字节，所以当调用函数写返回地址时会超过1个page，并且目前的page_fault无法处理这种情况：
这里写图片描述

1）sys_exec改为加载elf文件，并为栈分配单独的vma，带有VM_STACK标记:

io_clb_t clb_elf;
int32 sys_exec(trap_frame_t* frame)
{
    uint32 lba = frame->ebx;
    uint32 sector_num = frame->ecx;

    // 1. read init from hd
    clb_elf.flags = 0;
    clb_elf.read = 1;
    clb_elf.dev = 0;
    clb_elf.lba = lba;

    // 2. read elf from hard disk
    uint8* buffer = (uint8*) os()->get_mm()->alloc_pages(3); // 8 pages, 32K
    for (uint8* b = buffer; b < buffer + SECT_SIZE*sector_num; b += SECT_SIZE) {
        memset(clb_elf.buffer, 0, SECT_SIZE);
        os()->get_ide()->request(&clb_elf);
        memcpy(b, clb_elf.buffer, SECT_SIZE);

        clb_elf.flags = 0;
        clb_elf.lba++;
    }

    elf_hdr_t *elf = (elf_hdr_t *) (buffer);
    uint8 *base = (uint8 *) elf;

    // 3. check if it's a valid elf file
    if (elf->magic != ELF_MAGIC) {
        return -1;
    }

    pde_t* pg_dir = current->m_vmm.get_pg_dir();

    // 4. load program segments
    prog_hdr_t *ph = (prog_hdr_t *)(base + elf->phoff);
    prog_hdr_t *end_ph = ph + elf->phnum;
    for (; ph < end_ph; ph++) {
        if (ph->type != PT_LOAD || ph->filesz == 0) {
            continue;
        }
        void* vaddr = (void*) (ph->vaddr & PAGE_MASK);
        uint32 offset = ph->vaddr - (uint32)vaddr;
        uint32 len = PAGE_ALIGN(ph->filesz + ((uint32)vaddr & (PAGE_SIZE-1)));
        uint32 pagenum = len / PAGE_SIZE;
        uint32 order = 0, num = 1;
        while (num < pagenum) {
            num *= 2;
            order++;
        }

        current->m_vmm.do_mmap((uint32) vaddr, len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED);
        void* mem = os()->get_mm()->alloc_pages(order);
        os()->get_mm()->map_pages(pg_dir, vaddr, VA2PA(mem), len, PTE_W | PTE_U);
        memcpy(mem+offset, base+ph->off, ph->filesz);
        if (ph->memsz > ph->filesz) {
            memset(mem+offset+ph->filesz, 0, ph->memsz - ph->filesz);
        }
    }

    // 5. frame
    frame->cs = (SEG_UCODE << 3 | 0x3);
    frame->ds = (SEG_UDATA << 3 | 0x3);
    frame->es = (SEG_UDATA << 3 | 0x3);
    frame->ss = (SEG_UDATA << 3 | 0x3);
    frame->fs = (SEG_UDATA << 3 | 0x3);
    frame->gs = (SEG_UDATA << 3 | 0x3);

    // 6. stack, esp
    vm_area_t* vma = (vm_area_t *) os()->get_obj_pool(VMA_POOL)->alloc_from_pool();
    if (vma == NULL) {
        return -1;
    }
    vma->m_end   = USER_STACK_TOP;
    vma->m_start = USER_STACK_TOP - PAGE_SIZE;
    vma->m_page_prot = PROT_READ | PROT_WRITE;
    vma->m_flags = VM_STACK;
    vma->m_next = NULL;
    current->m_vmm.insert_vma(vma);

    void* stack = os()->get_mm()->alloc_pages(0);
    os()->get_mm()->map_pages(pg_dir, (void*) USER_STACK_TOP-PAGE_SIZE, VA2PA(stack), PAGE_SIZE, PTE_W | PTE_U);
    frame->esp = USER_STACK_TOP - PAGE_SIZE;

    // 7. eip
    void (*entry)(void) = (void(*)(void))(elf->entry);
    frame->eip = (uint32)entry;         // need get eip by load elf and get address

    return 0;
}

2）修改page_fault

/*
 * bit 0: 0 no page found, 1 protection fault
 * bit 1: 0 read, 1 write
 * bit 2: 0 kernel, 1 user
 */
uint32 vmm_t::do_page_fault(trap_frame_t* frame)
{
    uint32 addr = 0xffffffff;
    __asm__ volatile("movl %%cr2, %%eax" : "=a" (addr));

    vm_area_t* vma = find_vma(addr);

    /* not find the vma or out of range */
    if (vma == NULL || vma->m_start > addr) {
        uint32 expand_stk = 0;
        if (frame->err & 0x4) {
            if (vma != NULL && (vma->m_flags & VM_STACK) && addr + 32 >= frame->esp) {
                console()->kprintf(YELLOW, "expand stack\n");
                expand_stack(vma, addr);
                expand_stk = 1;
            }
            else {
                console()->kprintf(RED, "segment fault, addr: %x!\n", addr);
            }
        }

        if (!expand_stk) {
            return -1;
        }
    }

    /* find a vma and the addr in this vma */
    if (vma != NULL && vma->m_start <= addr) {
        if (frame->err & 0x1) {
            return do_protection_fault(vma, addr, (uint32) (frame->err & 2));
        }

        console()->kprintf(YELLOW, "handle no page, addr: %x\n", addr);

        /* no page found */
        void* mem = os()->get_mm()->alloc_pages(0);
        console()->kprintf(YELLOW, "addr: %x, map page: %x\n", addr, os()->get_mm()->va_2_pa(mem));

        addr = (addr & PAGE_MASK);
        os()->get_mm()->map_pages(m_pg_dir, (void*) addr, VA2PA(mem), PAGE_SIZE, PTE_W | PTE_U);
        console()->kprintf(GREEN, "alloc and map pages\n");
    }

    return 0;
}

uint32 vmm_t::expand_stack(vm_area_t* vma, uint32 addr)
{
    addr &= PAGE_MASK;
    uint32 grow = (vma->m_start - addr) >> PAGE_SHIFT;
    vma->m_start = addr;

    return 0;
}

当满足if (vma != NULL && (vma->m_flags & VM_STACK) && addr + 32 >= frame->esp)时，即找到了一个vma，但vma->m_start > addr，即addr比vma->m_start小时，如果此vma带有 VM_STACK标记，且addr + 32 >= frame->esp，我们认为是堆栈操作低于栈顶导致的，我们做栈扩展。

这里写图片描述

修改后可以发现可以正常运行了。

但这时依然存在问题：
用户态fork后，拷贝了父进程的vma，如果再执行exec想要执行新的代码，此时因为没有释放掉旧的vma，因为babyos2的mmap在map到已有的位置时会失败，所以加载新的elf过程中，mmap代码段、数据段等时会失败。

下一个进程就叫shell吧，一个简单的用户态shell是必不可少的，但在这之前先搞一个简单的用户态的lib吧，让init清爽些…，shell也得用这些必不可少的系统调用，库函数。

/*
 * guzhoudiaoke@126.com
 * 2017-12-10
 */

#ifndef _USERLIB_H_
#define _USERLIB_H_

#include "types.h"
#include "syscall.h"


#define PROT_NONE           0x0       /* page can not be accessed */
#define PROT_READ           0x1       /* page can be read */
#define PROT_WRITE          0x2       /* page can be written */
#define PROT_EXEC           0x4       /* page can be executed */


class userlib_t {
public:
    static int fork();
    static void print(const char *str);
    static void *mmap(uint32 addr, uint32 len, uint32 prot, uint32 flags);

    static void print_int(int32 n, int32 base, int32 sign);
};

#endif

/*
 * guzhoudiaoke@126.com
 * 2017-12-10
 */

#include "userlib.h"

static char digits[] = "0123456789abcdef";

int userlib_t::fork()
{
    int ret;
    __asm__ volatile("int $0x80" : "=a" (ret) : "a" (SYS_FORK));
    return ret;
}

void userlib_t::print(const char *str)
{
    __asm__ volatile("int $0x80" : : "b" (str), "a" (SYS_PRINT));
}

void *userlib_t::mmap(uint32 addr, uint32 len, uint32 prot, uint32 flags)
{
    uint32 ret = 0;
    __asm__ volatile("int $0x80" : "=a" (ret) : "a" (SYS_MMAP), "b" (addr), "c" (len), "d" (prot), "S" (flags));

    return (void*) ret;
}

char buffer_int[16] = {1};
char buffer_int_r[16] = {1};
void userlib_t::print_int(int32 n, int32 base, int32 sign)
{

    uint32 num = (uint32)n;
    if (sign && (sign = (n < 0))) {
        num = -n;
    }

    int i = 0;
    do {
        buffer_int[i++] = digits[num % base];
        num /= base;
    } while (num != 0);

    if (base == 16) {
        while (i < 8) {
            buffer_int[i++] = '0';
        }
        buffer_int[i++] = 'x';
        buffer_int[i++] = '0';
    }

    if (sign) {
        buffer_int[i++] = '-';
    }

    int j = 0;
    while (i-- > 0) {
        buffer_int_r[j++] = buffer_int[i];
    }

    buffer_int_r[j++] = ',';
    print(buffer_int_r);
}

修改后的init:

/*
 * guzhoudiaoke@126.com
 * 2017-11-4
 */

#include "userlib.h"

int main()
{
    uint32 cs = 0xffffffff;
    __asm__ volatile("movl %%cs, %%eax" : "=a" (cs));

    // print cs to show work in user mode
    userlib_t::print("This is printed by init, cs = ");
    userlib_t::print_int(cs, 16, 0);
    userlib_t::print("\n");

    // test mmap
    unsigned* before_fork = (unsigned *) userlib_t::mmap(0, 4096, PROT_READ | PROT_WRITE, 0);
    for (unsigned int i = 0; i < 1024; i++) {
        before_fork[i] = i;
    }

    // fork
    int32 ret = userlib_t::fork();
    if (ret == 0) {
        // child
        while (1) {
            for (int i = 0; i < 100000000; i++) ;
            userlib_t::print("IC,");
        }
    }
    else {
        // parent
        while (1) {
            for (int i = 0; i < 100000000; i++) ;
            userlib_t::print("I,");
        }
    }

    return 0;
}

清爽多了……

尝试子进程exec shell：

init.cc:

/*
 * guzhoudiaoke@126.com
 * 2017-11-4
 */

#include "userlib.h"

#define SHELL_LBA       544
#define SHELL_SECT_NUM  32

int main()
{
    uint32 cs = 0xffffffff;
    __asm__ volatile("movl %%cs, %%eax" : "=a" (cs));

    // print cs to show work in user mode
    userlib_t::print("This is printed by init, cs = ");
    userlib_t::print_int(cs, 16, 0);
    userlib_t::print("\n");

    // test mmap
    unsigned* before_fork = (unsigned *) userlib_t::mmap(0, 4096, PROT_READ | PROT_WRITE, 0);
    for (unsigned int i = 0; i < 1024; i++) {
        before_fork[i] = i;
    }

    // fork
    int32 ret = userlib_t::fork();
    if (ret == 0) {
        // child
        int ret = userlib_t::exec(SHELL_LBA, SHELL_SECT_NUM);
        if (ret != 0) {
            userlib_t::print("exec failed!!!\n");
            while (1) {
            }
        }
    }
    else {
        // parent
        while (1) {
            for (int i = 0; i < 100000000; i++) ;
            userlib_t::print("I,");
        }
    }

    return 0;
}

shell.cc:
/*
 * guzhoudiaoke@126.com
 * 2017-12-10
 */

#include "shell.h"
#include "userlib.h"

int main()
{
    userlib_t::print("This is printed by shell...\n");
    while (1) {
        for (int i = 0; i < 100000000; i++) ;
        userlib_t::print("S,");
    }

    return 0;
}

这里写图片描述

因为elf加载的时候，目前babyos2编译init, shell的时候代码段地址设为0x1000，所以init, shell的代码段加载地址是一样的，init fork出来的子进程拷贝了父进程的vma，已经拥有了0x1000~0x3000的一个vma，所以exec时要加载新的vma指定地址0x1000 do_mmap失败。
要解决这个问题，需要exec的时候先释放掉拷贝的父进程的映射的页，页表，vma。

io_clb_t clb_elf;
int32 sys_exec(trap_frame_t* frame)
{
    uint32 lba = frame->ebx;
    uint32 sector_num = frame->ecx;

    // 1. read init from hd
    clb_elf.flags = 0;
    clb_elf.read = 1;
    clb_elf.dev = 0;
    clb_elf.lba = lba;

    // 2. read elf from hard disk
    uint8* buffer = (uint8*) os()->get_mm()->alloc_pages(3); // 8 pages, 32K
    for (uint8* b = buffer; b < buffer + SECT_SIZE*sector_num; b += SECT_SIZE) {
        memset(clb_elf.buffer, 0, SECT_SIZE);
        os()->get_ide()->request(&clb_elf);
        memcpy(b, clb_elf.buffer, SECT_SIZE);

        clb_elf.flags = 0;
        clb_elf.lba++;
    }

    elf_hdr_t *elf = (elf_hdr_t *) (buffer);
    uint8 *base = (uint8 *) elf;

    // 3. check if it's a valid elf file
    if (elf->magic != ELF_MAGIC) {
        return -1;
    }

    pde_t* pg_dir = current->m_vmm.get_pg_dir();

    // flush old mmap
    current->m_vmm.release();

    // 4. load program segments
    prog_hdr_t *ph = (prog_hdr_t *)(base + elf->phoff);
    prog_hdr_t *end_ph = ph + elf->phnum;
    for (; ph < end_ph; ph++) {
        if (ph->type != PT_LOAD || ph->filesz == 0) {
            continue;
        }
        void* vaddr = (void*) (ph->vaddr & PAGE_MASK);
        uint32 offset = ph->vaddr - (uint32)vaddr;
        uint32 len = PAGE_ALIGN(ph->filesz + ((uint32)vaddr & (PAGE_SIZE-1)));
        uint32 pagenum = len / PAGE_SIZE;
        uint32 order = 0, num = 1;
        while (num < pagenum) {
            num *= 2;
            order++;
        }

        int32 ret = current->m_vmm.do_mmap((uint32) vaddr, len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED);
        if (ret < 0) {
            return -1;
        }
        void* mem = os()->get_mm()->alloc_pages(order);
        os()->get_mm()->map_pages(pg_dir, vaddr, VA2PA(mem), len, PTE_W | PTE_U);
        memcpy(mem+offset, base+ph->off, ph->filesz);
        if (ph->memsz > ph->filesz) {
            memset(mem+offset+ph->filesz, 0, ph->memsz - ph->filesz);
        }
    }

    // 5. frame
    frame->cs = (SEG_UCODE << 3 | 0x3);
    frame->ds = (SEG_UDATA << 3 | 0x3);
    frame->es = (SEG_UDATA << 3 | 0x3);
    frame->ss = (SEG_UDATA << 3 | 0x3);
    frame->fs = (SEG_UDATA << 3 | 0x3);
    frame->gs = (SEG_UDATA << 3 | 0x3);

    // 6. stack, esp
    vm_area_t* vma = (vm_area_t *) os()->get_obj_pool(VMA_POOL)->alloc_from_pool();
    if (vma == NULL) {
        return -1;
    }
    vma->m_end   = USER_STACK_TOP;
    vma->m_start = USER_STACK_TOP - PAGE_SIZE;
    vma->m_page_prot = PROT_READ | PROT_WRITE;
    vma->m_flags = VM_STACK;
    vma->m_next = NULL;
    if (current->m_vmm.insert_vma(vma) != 0) {
        return -1;
    }

    void* stack = os()->get_mm()->alloc_pages(0);
    os()->get_mm()->map_pages(pg_dir, (void*) USER_STACK_TOP-PAGE_SIZE, VA2PA(stack), PAGE_SIZE, PTE_W | PTE_U);
    frame->esp = USER_STACK_TOP-PAGE_SIZE;

    // 7. eip
    void (*entry)(void) = (void(*)(void))(elf->entry);
    frame->eip = (uint32)entry;         // need get eip by load elf and get address

    return 0;
}

void vmm_t::free_page_range(uint32 start, uint32 end)
{
    uint32 addr = start & PAGE_MASK;
    while (addr < end) {
        uint32 pa = os()->get_mm()->va_2_pa((void *) addr);
        if (pa != -1) {
            os()->get_mm()->free_pages((void *) (PA2VA(pa)), 0);
        }

        addr += PAGE_SIZE;
    }
}

void vmm_t::free_page_table()
{
    for (uint32 i = 0; i < KERNEL_BASE/(4*MB); i++) {
        pde_t *pde = &m_pg_dir[i];
        if (!(*pde & PTE_P)) {
            continue;
        }

        pte_t* table = (pte_t *) PA2VA((*pde) & PAGE_MASK);
        os()->get_mm()->free_pages(table, 0);
        *pde = 0;
    }
}

void vmm_t::release()
{
    // 1. pages
    vm_area_t* vma = m_mmap;
    while (vma != NULL) {
        console()->kprintf(YELLOW, "free page range: [%x, %x]\n", vma->m_start, vma->m_end);
        free_page_range(vma->m_start, vma->m_end);
        vma = vma->m_next;
    }

    // 2. page table
    free_page_table();

    // 3. vmas
    vma = m_mmap;
    while (vma != NULL) {
        vm_area_t* del = vma;
        vma = vma->m_next;

        console()->kprintf(YELLOW, "removing vma: [%x, %x]\n", del->m_start, del->m_end);
        os()->get_obj_pool(VMA_POOL)->free_object(del);
    }
    m_mmap = NULL;
}

加载新的elf之前调用current->m_vmm.release(); 释放旧的页，页表，vma。
这里写图片描述

shell进程启动起来之后一直打印S，经过释放旧的，加载新的，init fork出来的子进程成功开始执行shell进程的代码。

BSS段：
现在加载elf时忽略掉了filesz == 0的段，所以加载bss段，若有未初始化的全局变量，会出现PAGE_FAULT：

char buffer_int[16] = {0};
char buffer_int_r[16] = {0};
void userlib_t::print_int(int32 n, int32 base, int32 sign)
{

    uint32 num = (uint32)n;
    if (sign && (sign = (n < 0))) {
        num = -n;
    }

    int i = 0;
    do {
        buffer_int[i++] = digits[num % base];
        num /= base;
    } while (num != 0);

    if (base == 16) {
        while (i < 8) {
            buffer_int[i++] = '0';
        }
        buffer_int[i++] = 'x';
        buffer_int[i++] = '0';
    }

    if (sign) {
        buffer_int[i++] = '-';
    }

    int j = 0;
    while (i-- > 0) {
        buffer_int_r[j++] = buffer_int[i];
    }

    buffer_int_r[j++] = ',';
    print(buffer_int_r);
}

这里写图片描述

    // 5. load program segments
    prog_hdr_t *ph = (prog_hdr_t *)(base + elf->phoff);
    prog_hdr_t *end_ph = ph + elf->phnum;
    for (; ph < end_ph; ph++) {
        if (ph->type != PT_LOAD) {
            continue;
        }
        void* vaddr = (void*) (ph->vaddr & PAGE_MASK);
        uint32 offset = ph->vaddr - (uint32)vaddr;
        uint32 len = PAGE_ALIGN(ph->memsz + ((uint32)vaddr & (PAGE_SIZE-1)));
        uint32 pagenum = len / PAGE_SIZE;
        uint32 order = 0, num = 1;
        while (num < pagenum) {
            num *= 2;
            order++;
        }

        int32 ret = current->m_vmm.do_mmap((uint32) vaddr, len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED);
        if (ret < 0) {
            return -1;
        }
        void* mem = os()->get_mm()->alloc_pages(order);
        os()->get_mm()->map_pages(pg_dir, vaddr, VA2PA(mem), len, PTE_W | PTE_U);
        memcpy(mem+offset, base+ph->off, ph->filesz);
        if (ph->memsz > ph->filesz) {
            memset(mem+offset+ph->filesz, 0, ph->memsz - ph->filesz);
        }
    }

修改加载elf代码如上：
这里写图片描述

到这里babyos2已经能够做基本的fork和exec动作，处理基本的mmap和缺页。

后面需要做的：
1）一个简单的shell，能执行简单的命令，会对测试有帮助
2）现在进程无法退出，只能一直while (1)，需要一个简单的exit，wait_pid
3）sleep，wakeup目前还是可选的
4）brk也暂时不是必须的
5）目前BSS段是不能用的，所以全局变量初始化成0是有问题的。。。需要解决 [本blog已修改]
6）目前加载elf靠的是lba和扇区数，没有文件的概念，一个简单的文件系统是需要的
7）目前调度靠的是轮询，且时间片只有1，一个高级点的调度算法是需要的，但目前不着急
8）一个更丰富的user lib，可以用到啥增加啥
9）读取输入，是shell必须的
10）kmalloc, kfree 目前暂时不是必须的
11）用于IO的buffer，可以做文件系统时再做。

最近有点忙，进度可能要……

孤舟钓客
关注
专栏目录
ESP32-C3入门教程 ESP-IDF 5.x篇①——ESP-IDF V5.0.1编译报错：Failed to resolve component ‘jsmn‘.
小康师兄
03-26 868
ESP32-C3入门教程 问题篇⑱——ESP-IDF V5.0.1编译报错：Failed to resolve component 'jsmn'.
【编译、链接、装载九】静态链接
最新发布
junxuezheng的博客
06-21 864
详解静态链接、虚拟地址空间、重定位、重定位表、符号解析
babyos2（1）——boot
孤舟钓客
04-26 2487
要做一个能在裸机上跑的系统，一个简单的boot loader或者是支持grub之类的是必须的。目前并没有把babyos装到实体机上、支持多系统等的打算，所以还是自己写boot loader。 PC上电后，80x86 CPU自动进入实模式，并从0xFFFF0开始自动执行，这个地址是ROM-BIOS中的地址。BIOS会执行一些检测及初始化中断向量表等，之后它将启动设备第一个扇区512字节读入内存0x...
flutter 布局 Expanded Stack Positioned
dianchidu6913的博客
08-21 662
Expanded Stack Positioned 转载于:https://www.cnblogs.com/qqcc1388/p/11389746.html
babyos2（27） pipe
孤舟钓客
04-26 440
为babyos2实现pipe进程间通信方式。 一个pipe表现为两个文件描述符fd[2]，对应两个打开的文件，一个只读，一个只写。当通过fork创建子进程的时候，会拷贝父进程打开的文件，所以也持有这两个打开的文件。 使用的时候，一个关闭读端，一个关闭写端。即父子进程各自只剩下一个打开的文件，例如父进程关闭写端，子进程关闭读端： parent: fd[0] &lt;-&gt; file {...
babyos2（32）multi-processor，startup APs, mp schedule
孤舟钓客
04-26 1019
前面解析了MP config, 这次准备为babyos2实现启动其他processor。 解析config的时候可以看到，其中一个processor被指定为bootstrap processor(BSP)，其他的称为application processor(AP)。AP 的启动有固定的流程，在Intel MP spec中有描述。 为了简化cpu_t类，把一些代码挪到了新的类，在此不再描述。然...
babyos2（0）——从零开始
孤舟钓客
11-10 3316
起因 读硕士时曾尝试写一个玩具内核,取名babyos，不料剑走偏锋，玩起了在裸机上绘图，而忽视了操作系统学习中真正精华的部分，后来求职、答辩、毕业、工作，就放下了。然而心里一直记着这回事。 近两年对围棋比较有兴趣，本科毕设做过中国象棋AI，自然对Alpha Go很感兴趣。前一阵子Alpha Go Zero刷爆了各种圈，就想学点深度学习的东西，好自己写一个围棋AI玩，当然目标定的比较低，能下过我...
ARM 之九 Cortex-M/R 内核 Keil（ARMCC） 程序启动流程
热门推荐
技术干货
05-05 1万+
内核规范   ARM Cortex-M/R 内核的复位启动过程也被称为复位序列(Reset sequence)。ARM Cortex-M/R内核的复位启动过程与其他大部分CPU不同，也与之前的ARM架构（ARM920T、ARM7TDMI等）不相同。大部分CPU复位后都是从 0x00000000 处取得第一条指令开始运行的，然而在ARM Cortex-M/R内核中并不是这样的。其复位序列为： 从地...
《Linux Device Driver》——调试技术
sunr_的博客
09-07 566
内核中的调试支持 编译内核 1.获取内核源码，解压至/usr/src # tar xf linux-3.13.5.tar.xz -C /usr/src # ln -sv /usr/src/linux-3.13.5 /usr/src/linux 2.配置内核特性(选择一种方法就可以了) make config：遍历选择所要编译的内核特性 make allyesconfig：配置所有可编译的内核特性 make allnoconf
链接/装载/运行(4)-静态链接
知易行难
01-12 393
静态链接就是将多个目标文件合并为一个可执行文件。 实例文件： /* a.c */ extern int shared; extern void swap(int *a, int *b)； int main() { int a = 100; swap(&amp;amp;a, &amp;amp;shared); } /* b.c */ int shared = 1; void swap(int *a, int ...
babyos2（5）——分页
孤舟钓客
04-26 584
加载elf格式的内核完成后，babyos正式开始执行内核代码，首先要开启分页。 这张图表示了段页式内存管理的基本流程。要开启保护模式，一定会开启分段，而分页是可选的。但现代操作系统，分页也是最基本的功能。 如图所示，左半边展示了分段。进入保护模式之前，我们用lgdt指令加载了GDT，GDT名字叫全局描述符表，它是一张表。每一个表项是一个全局描述符： 它描述了一个段的基地址、限长及一些...
babyos2（31）multi-processor configuration
孤舟钓客
04-26 919
要为babyos2实现MP(multi-processor)，首先得解析MP configuration。找到mp configuration的一种方法是通过mp floating pointer. 1.mp floating pointer Intel MP Spcification 中对floating pointer 描述如下: The MP Floating Pointer Stru...
babyos2（41） network(7) -- udp, dns resolve
孤舟钓客
04-26 536
前面为babyos2实现了简单的raw socket及从用户态ping指定IP地址。而通常意义的ping不但可以ping某个具体的地址，还可以ping baidu.com这种域名。而从内核角度看，要发送IP包，必须知道目的IP地址。所以需要经过域名转换，将给定的域名转换成IP地址，这就是常说的DNS（Domain Name System）的主要功能。反映到用户态就算常用的gethostbyname...
babyos2（6）——IDT，interrupt，exception
孤舟钓客
04-26 694
babyos2内核开始执行后，会重新设置GDT到一个更安全的位置。同时，为了能处理中断和异常，需要设置IDT。 IDT也是一个表，叫中断描述符表。每个项表示一个中断描述符。 Task Gate，Intel是想用于任务调度的，在此先不描述。 中断门和陷阱门的区别在于通过中断门进入中断服务程序时CPU自动关中断，即将CPU的EFLAGS中IF位清0，防止中断嵌套。而通过陷阱门进入则IF标志位...
babyos2（3）—— console, kprintf
孤舟钓客
04-26 689
babyos2与babyos的另一个不同之处，babyos2采用的是C++，当然没有使用任何C++的库及new等，只是使用类方便代码组织，并且全局对象的构造函数是没有用的，因为没有一个运行时库来构造他们… 为了方便后面代码的一些调试及更有趣，实现一个简单的在屏幕上输出字符还是很有必要的。 1. class screen 主要功能是屏幕上绘制像素、绘制填充矩形，绘制ASCII字符。 #d...
babyos2（11）—— physical memory manage, buddy system
孤舟钓客
04-26 633
由于babyos2采用了类似于linux的获取current进程指针的方法，这要求process_t的内存按8K对齐，继续采用boot阶段m_start_mem递增的方式就很笨拙了，而要实现后续的vma,虚拟内存管理等功能，一个好用的物理页分配函数是必须的，所以实现了一个buddy system来管理物理内存。 #define MAX_ORDER 6 #define ...
babyOS开源框架
m0_38123630的博客
04-27 620
BabyOS适用于MCU项目，她是一套管理功能模块和外设驱动的框架。 对项目而言，缩短开发周期。项目开发时选择适用的功能模块及驱动。直接进入功能代码编写的阶段。 对工程师而言，减少重复工作。调试过的功能模块和驱动代码放入BabyOS中管理，以后项目可以直接使用，去掉重复调试的工作。 代码结构 BabyOS代码分为3部分： BabyOS仓库：功能模块和驱动 ,一般情况下用户不需要改动，可以将此仓库作为子模块。 BabyOS_Config：配置文件和设备注册文件 BabyOS_Hal：硬件抽象层,
BabyOS开源框架之四 -------------DS18B20
m0_38123630的博客
04-30 145
待完成
tensor.view和torch.transpose的区别、torch.stack和torch.cat的区别以及tensor.expand和tensor.repeat的区别
qq_42655006的博客
09-01 528
笔者最近阅读代码的时候发现，pytorch中有许多对于tensor的操作功能类似但是区别还是挺大的，查阅了官方文档后，决定记录一下 tensor.view、torch.transpose和tensor.expand 这三个函数都可以更改数tensor的形状： 1、tensor.view是按照元素的顺序直接整合成目标形状，例如: >>> m = tensor([[1,1,1],[2,2,2]]) >>> m.view(3,2) # 将m的形状由2×3变为3×2 tensor
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值