[V9,1/7] oslib-posix: add helpers for stack alloc and free

the allocated stack will be adjusted to the minimum supported stack size
by the OS and rounded up to be a multiple of the system pagesize.
Additionally an architecture dependent guard page is added to the stack
to catch stack overflows.

Signed-off-by: Peter Lieven <pl@kamp.de>
---
 include/sysemu/os-posix.h | 27 +++++++++++++++++++++++++++
 util/oslib-posix.c        | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+)

Am 27.09.2016 um 11:58 hat Peter Lieven geschrieben:
> the allocated stack will be adjusted to the minimum supported stack size
> by the OS and rounded up to be a multiple of the system pagesize.
> Additionally an architecture dependent guard page is added to the stack
> to catch stack overflows.
> 
> Signed-off-by: Peter Lieven <pl@kamp.de>
> ---
>  include/sysemu/os-posix.h | 27 +++++++++++++++++++++++++++
>  util/oslib-posix.c        | 42 ++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 69 insertions(+)
> 
> diff --git a/include/sysemu/os-posix.h b/include/sysemu/os-posix.h
> index 9c7dfdf..3cfedbc 100644
> --- a/include/sysemu/os-posix.h
> +++ b/include/sysemu/os-posix.h
> @@ -60,4 +60,31 @@ int qemu_utimens(const char *path, const qemu_timespec *times);
>  
>  bool is_daemonized(void);
>  
> +/**
> + * qemu_alloc_stack:
> + * @sz: pointer to a size_t holding the requested usable stack size
> + *
> + * Allocate memory that can be used as a stack, for instance for
> + * coroutines. If the memory cannot be allocated, this function
> + * will abort (like g_malloc()). This function also inserts an
> + * additional guard page to catch a potential stack overflow.
> + * Note that the memory required for the guard page and alignment
> + * and minimal stack size restrictions will increase the value of sz.
> + *
> + * The allocated stack must be freed with qemu_free_stack().
> + *
> + * Returns: pointer to (the lowest address of) the stack memory.
> + */
> +void *qemu_alloc_stack(size_t *sz);
> +
> +/**
> + * qemu_free_stack:
> + * @stack: stack to free
> + * @sz: size of stack in bytes
> + *
> + * Free a stack allocated via qemu_alloc_stack(). Note that sz must
> + * be exactly the adjusted stack size returned by qemu_alloc_stack.
> + */
> +void qemu_free_stack(void *stack, size_t sz);
> +
>  #endif
> diff --git a/util/oslib-posix.c b/util/oslib-posix.c
> index f2d4e9e..5745229 100644
> --- a/util/oslib-posix.c
> +++ b/util/oslib-posix.c
> @@ -499,3 +499,45 @@ pid_t qemu_fork(Error **errp)
>      }
>      return pid;
>  }
> +
> +void *qemu_alloc_stack(size_t *sz)
> +{
> +    void *ptr, *guardpage;
> +    size_t pagesz = getpagesize();
> +#ifdef _SC_THREAD_STACK_MIN
> +    /* avoid stacks smaller than _SC_THREAD_STACK_MIN */
> +    long min_stack_sz = sysconf(_SC_THREAD_STACK_MIN);
> +    *sz = MAX(MAX(min_stack_sz, 0), *sz);
> +#endif
> +    /* adjust stack size to a multiple of the page size */
> +    *sz = ROUND_UP(*sz, pagesz);
> +    /* allocate one extra page for the guard page */
> +    *sz += pagesz;
> +
> +    ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE,
> +               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
> +    if (ptr == MAP_FAILED) {
> +        abort();
> +    }
> +
> +#if defined(HOST_IA64)
> +    /* separate register stack */
> +    guardpage = ptr + (((sz - pagesz) / 2) & ~pagesz);

s/sz/*sz/

> +#elif defined(HOST_HPPA)
> +    /* stack grows up */
> +    guardpage = ptr + sz - pagesz;

Here too. I can fix both while applying the series.

> +#else
> +    /* stack grows down */
> +    guardpage = ptr;
> +#endif
> +    if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
> +        abort();
> +    }
> +
> +    return ptr;
> +}

Kevin

Am 27.09.2016 um 13:59 schrieb Kevin Wolf:
> Am 27.09.2016 um 11:58 hat Peter Lieven geschrieben:
>> the allocated stack will be adjusted to the minimum supported stack size
>> by the OS and rounded up to be a multiple of the system pagesize.
>> Additionally an architecture dependent guard page is added to the stack
>> to catch stack overflows.
>>
>> Signed-off-by: Peter Lieven <pl@kamp.de>
>> ---
>>   include/sysemu/os-posix.h | 27 +++++++++++++++++++++++++++
>>   util/oslib-posix.c        | 42 ++++++++++++++++++++++++++++++++++++++++++
>>   2 files changed, 69 insertions(+)
>>
>> diff --git a/include/sysemu/os-posix.h b/include/sysemu/os-posix.h
>> index 9c7dfdf..3cfedbc 100644
>> --- a/include/sysemu/os-posix.h
>> +++ b/include/sysemu/os-posix.h
>> @@ -60,4 +60,31 @@ int qemu_utimens(const char *path, const qemu_timespec *times);
>>   
>>   bool is_daemonized(void);
>>   
>> +/**
>> + * qemu_alloc_stack:
>> + * @sz: pointer to a size_t holding the requested usable stack size
>> + *
>> + * Allocate memory that can be used as a stack, for instance for
>> + * coroutines. If the memory cannot be allocated, this function
>> + * will abort (like g_malloc()). This function also inserts an
>> + * additional guard page to catch a potential stack overflow.
>> + * Note that the memory required for the guard page and alignment
>> + * and minimal stack size restrictions will increase the value of sz.
>> + *
>> + * The allocated stack must be freed with qemu_free_stack().
>> + *
>> + * Returns: pointer to (the lowest address of) the stack memory.
>> + */
>> +void *qemu_alloc_stack(size_t *sz);
>> +
>> +/**
>> + * qemu_free_stack:
>> + * @stack: stack to free
>> + * @sz: size of stack in bytes
>> + *
>> + * Free a stack allocated via qemu_alloc_stack(). Note that sz must
>> + * be exactly the adjusted stack size returned by qemu_alloc_stack.
>> + */
>> +void qemu_free_stack(void *stack, size_t sz);
>> +
>>   #endif
>> diff --git a/util/oslib-posix.c b/util/oslib-posix.c
>> index f2d4e9e..5745229 100644
>> --- a/util/oslib-posix.c
>> +++ b/util/oslib-posix.c
>> @@ -499,3 +499,45 @@ pid_t qemu_fork(Error **errp)
>>       }
>>       return pid;
>>   }
>> +
>> +void *qemu_alloc_stack(size_t *sz)
>> +{
>> +    void *ptr, *guardpage;
>> +    size_t pagesz = getpagesize();
>> +#ifdef _SC_THREAD_STACK_MIN
>> +    /* avoid stacks smaller than _SC_THREAD_STACK_MIN */
>> +    long min_stack_sz = sysconf(_SC_THREAD_STACK_MIN);
>> +    *sz = MAX(MAX(min_stack_sz, 0), *sz);
>> +#endif
>> +    /* adjust stack size to a multiple of the page size */
>> +    *sz = ROUND_UP(*sz, pagesz);
>> +    /* allocate one extra page for the guard page */
>> +    *sz += pagesz;
>> +
>> +    ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE,
>> +               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
>> +    if (ptr == MAP_FAILED) {
>> +        abort();
>> +    }
>> +
>> +#if defined(HOST_IA64)
>> +    /* separate register stack */
>> +    guardpage = ptr + (((sz - pagesz) / 2) & ~pagesz);
> s/sz/*sz/
>
>> +#elif defined(HOST_HPPA)
>> +    /* stack grows up */
>> +    guardpage = ptr + sz - pagesz;
> Here too. I can fix both while applying the series.

That would be nice, thank you.

Peter