在内存中创建并使用新堆栈

Question

由于一些特殊原因（请不要问我为什么），对于某些函数，我想使用单独的堆栈。例如，假设我希望函数 malloc 使用不同的堆栈进行处理，我需要在调用它之前切换到新创建的堆栈，并返回到程序使用的原始堆栈完成后。所以算法会是这样的。

switch_to_new_stack
call malloc
swith back to the original stack

做到这一点最简单、最有效的方法是什么？有什么想法吗？

Answer 1

它可能不符合您对简单或高效的定义，但以下可能是实现此目的的一种方法：

#include <stdio.h>
#include <stdlib.h>

#include <ucontext.h>

/* utility functions */
static void getctx(ucontext_t* ucp)
{
    if (getcontext(ucp) == -1) {
        perror("getcontext");
        exit(EXIT_FAILURE);
    }
}

static void print_sp()
{
#if defined(__x86_64)
    unsigned long long x; asm ("mov %%rsp, %0" : "=m" (x));
    printf("sp: %p\n",(void*)x);
#elif defined(__i386)
    unsigned long x; asm ("mov %%esp, %0" : "=m" (x));
    printf("sp: %p\n",(void*)x);
#elif defined(__powerpc__) && defined(__PPC64__)
    unsigned long long x; asm ("addi %0, 1, 0" : "=r" (x));
    printf("sp: %p\n",(void*)x);
#elif defined(__powerpc__)
    unsigned long x; asm ("addi %0, 1, 0" : "=r" (x));
    printf("sp: %p\n",(void*)x);
#else
    printf("unknown architecture\n");
#endif
}


/* stack for 'my_alloc', size arbitrarily chosen */
static int malloc_stack[1024];
static ucontext_t malloc_context; /* context malloc will run in */
static ucontext_t current_context; /* context to return to */

static void my_malloc(size_t sz)
{
    printf("in my_malloc(%zu) ", sz);
    print_sp();
}

void call_my_malloc(size_t sz)
{
    /* prepare context for malloc */
    getctx(&malloc_context);
    malloc_context.uc_stack.ss_sp = malloc_stack;
    malloc_context.uc_stack.ss_size = sizeof(malloc_stack);
    malloc_context.uc_link = ¤t_context;
    makecontext(&malloc_context, (void(*)())my_malloc, 1, sz);

    if (swapcontext(¤t_context, &malloc_context) == -1) {
        perror("swapcontext");
        exit(EXIT_FAILURE);
    }
}

int main()
{
    printf("malloc_stack = %p\n", (void*)malloc_stack);
    printf("in main ");
    print_sp();
    call_my_malloc(42);
    printf("in main ");
    print_sp();
    return 0;
}

这应该适用于支持 makecontext(3) 的所有平台。引用手册页（我也从中获得了示例代码的灵感）：

ucp->uc_stack 的解释与 sigaltstack(2) 中一样，即该结构体包含要用作堆栈的内存区域的起始位置和长度，而与堆栈的增长方向无关。因此，用户程序没有必要担心这个方向。

PPC64 的输出示例：

$ gcc -o stack stack.c -Wall -Wextra -W -ggdb -std=gnu99 -pedantic -Werror -m64 && ./stack
malloc_stack = 0x10010fe0
in main sp: 0xfffffe44420
in my_malloc(42) sp: 0x10011e20
in main sp: 0xfffffe44420

Answer 2

GCC 支持拆分堆栈，其工作方式有点像您所描述的。

http://gcc.gnu.org/wiki/SplitStacks

项目的目标不同，但实施会按照你的要求去做。

拆分堆栈的目标是允许不连续的堆栈根据需要自动增长。这意味着您可以运行多个线程，每个线程都从一个小堆栈开始，并让堆栈根据程序的需要增长和收缩。这样，在编写多线程程序时就不再需要考虑堆栈要求。典型多线程程序的内存使用量可以显着减少，因为每个线程不需要最坏情况下的堆栈大小。在 32 位地址空间中运行数百万个线程（完整的 NPTL 线程或协同例程）成为可能。