为什么我的sbrk系统调用无法实现？

Question

I try to write a very simple os to better understand the basic principles. And I need to implement user-space malloc. So at first I want to implement and test it on my linux-machine.

At first I have implemented the sbrk() function by the following way

void* sbrk( int increment ) {
    return ( void* )syscall(__NR_brk, increment );
}

But this code does not work. Instead, when I use sbrk given by os, this works fine.

I have tryed to use another implementation of the sbrk()

static void *sbrk(signed increment)  
{  
    size_t newbrk;  
    static size_t oldbrk = 0;  
    static size_t curbrk = 0;  

    if (oldbrk == 0)  
        curbrk = oldbrk = brk(0);  

    if (increment == 0)  
        return (void *) curbrk;  

    newbrk = curbrk + increment;  

    if (brk(newbrk) == curbrk)  
        return (void *) -1;  

    oldbrk = curbrk;  
    curbrk = newbrk;  

    return (void *) oldbrk;  
}  

sbrk invoked from this function

static Header *morecore(unsigned nu)  
{  
    char *cp;  
    Header *up;  

    if (nu < NALLOC)  
        nu = NALLOC;  

    cp = sbrk(nu * sizeof(Header));  
    if (cp == (char *) -1)  
        return NULL;  

    up = (Header *) cp;  
    up->s.size = nu;  // ***Segmentation fault
    free((void *)(up + 1));  

    return freep;  
}  

This code also does not work, on the line (***) I get segmentation fault. Where is a problem ?

Thanks All. I have solved my problem using new implementation of the sbrk. The given code works fine.

void* __sbrk__(intptr_t increment)
 {
     void *new, *old = (void *)syscall(__NR_brk, 0);

     new = (void *)syscall(__NR_brk, ((uintptr_t)old) + increment);

     return (((uintptr_t)new) == (((uintptr_t)old) + increment)) ? old :
         (void *)-1;
 }

Answer 1

The first sbrk should probably have a long increment . And you forgot to handle errors (and set errno )

The second sbrk function does not change the address space (as sbrk does). You could use mmap to change it (but using mmap instead of sbrk won't update the kernel's view of data segment end as sbrk does). You could use cat /proc/1234/maps to query the address space of process of pid 1234). or even read (eg with fopen & fgets ) the /proc/self/maps from inside your program.

BTW, sbrk is obsolete (most malloc implementations use mmap ), and by definition every system call (listed in syscalls(2) ) is executed by the kernel (for sbrk the kernel maintains the "data segment" limit!). So you cannot avoid the kernel, and I don't even understand why you want to emulate any system call. Almost by definition, you cannot emulate syscalls since they are the only way to interact with the kernel from a user application. From the user application, every syscall is an atomic elementary operation (done by a single SYSENTER machine instruction with appropriate contents in machine registers).

You could use strace(1) to understand the actual syscalls done by your running program.

BTW, the GNU libc is a free software . You could look into its source code. musl-libc is a simpler libc and its code is more readable.

At last compile with gcc -Wall -Wextra -g and use the gdb debugger (you can even query the registers, if you wanted to). Perhaps read the x86/64-ABI specification and the Linux Assembly HowTo .