如何使用 pthread 实现动态增长堆栈？

Question

从APUE，我了解了栈的guardsize和stackaddr 。 如果rsp指针将低于stackaddr ，则rsp进入guard stack area ，并发出信号通知程序。

我想知道是否可以使用此功能实现动态增长（动态增长）堆栈。 你能告诉我怎么做吗？

Answer 1

堆栈可以“动态”增长

1. 设置备用信号堆栈。
2. 使用SA_ONSTACK为SIGSEGV设置信号处理程序以使用备用堆栈。
3. 当程序用完堆栈时，会发出SIGSEGV信号。
4. 信号处理程序可以使用带有RLIMIT_STACK的getrlimit/setrlimit来更改堆栈大小。

man signal-safety中没有明确提到getrlimit和setrlimit ，但我不明白为什么它们会成为信号处理程序中的问题。

这是一个示例测试程序。 是有注释的。 使用-d调用以从信号处理程序中动态增加堆栈大小：

// stacktest.c -- test dynamically growing stack

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <assert.h>
#include <setjmp.h>

#include <sys/time.h>
#include <sys/resource.h>

volatile int opt_t = 0;
volatile int opt_d = 0;
volatile int opt_i = 0;

void *top;                              // initial top of stack

// signal handler
volatile int may_grow = 1;              // grow stack within signal handler
volatile int err1 = 0;                  // error on get
volatile int err2 = 0;                  // error on set
volatile int hitno;                     // number of signals

jmp_buf jbuf;

// alternate signal stack
unsigned char altstk[64 * 4096] __attribute__((aligned(4096)));

// xprtstr -- print string in signal handler
void
xprtstr(const char *str)
{
    size_t len = strlen(str);

    write(1,str,len);
}

// xprtstr -- print number in signal handler
void
xprtnum(unsigned long val,const char *sym)
{
    static const char *hex = "0123456789ABCDEF";

    xprtstr(" ");
    xprtstr(sym);
    xprtstr("=");

    char buf[100];
    char *bp = &buf[50];

    *bp-- = 0;

    for (int idx = 0;  idx < 16;  ++idx, --bp) {
        *bp = hex[val & 0x0F];
        val >>= 4;
    }

    ++bp;
    xprtstr(bp);
}

// sigfault -- SIGSEGV handler
void
sigfault(int signo,siginfo_t *info,void *vp)
{

    ++hitno;

    xprtstr("ISR hit");
    xprtnum(signo,"signo");
    xprtnum(hitno,"hitno");
    xprtstr("\n");

    struct rlimit rlim;

    do {
        if (opt_t) {
            xprtstr("ISR test\n");
            siglongjmp(jbuf,1);
            break;
        }

        // dynamically grow the stack
        if (may_grow) {
            xprtstr("ISR grow\n");
            may_grow = 0;

            err1 = getrlimit(RLIMIT_STACK,&rlim);
            xprtnum(rlim.rlim_cur,"rlim_cur");
            xprtnum(rlim.rlim_cur / 1024,"rlim_cur");
            xprtstr("\n");

            rlim.rlim_cur += 8 * 1024 * 1024;
            err2 = setrlimit(RLIMIT_STACK,&rlim);

            getrlimit(RLIMIT_STACK,&rlim);
            xprtnum(rlim.rlim_cur,"rlim_cur");
            xprtnum(rlim.rlim_cur / 1024,"rlim_cur");
            xprtstr("\n");
            break;
        }

        // stop the program
        xprtstr("ISR stop\n");
        siglongjmp(jbuf,2);
    } while (0);
}

// loop -- recursive function to overflow stack
void
loop(unsigned char *old)
{
    // get some space on the stack
    unsigned char cur[4096];

    // get current stack frame address
    void *frame = __builtin_frame_address(0);

    // get amount of space used on stack
    size_t dif = top - frame;

    // show where we are
    printf("loop: top=%p frame=%p dif=%8.8zX/%zu may_grow=%d\n",
        top,frame,dif,dif / 1024,may_grow);

    // keep consuming more stack
    // NOTE: we don't actually use cur/old but ensure that the compiler won't
    // optimize it away
    loop(cur);
}

#define SHOWFLAGS(_msk) \
    if (flags & (_msk)) \
        printf(" " #_msk)

void
showsa(const struct sigaction *sa,const char *who)
{
    int flags = sa->sa_flags;

    // show the signal flags
    printf("showflags: %s flags=%8.8X",who,flags);
    SHOWFLAGS(SA_NOCLDSTOP);
    SHOWFLAGS(SA_NOCLDWAIT);
    SHOWFLAGS(SA_NODEFER);
    SHOWFLAGS(SA_ONSTACK);
    SHOWFLAGS(SA_RESETHAND);
    SHOWFLAGS(SA_RESTART);
    SHOWFLAGS(SA_SIGINFO);

    // show the signal mask
    for (int signo = 1;  signo < 32;  ++signo) {
        if (sigismember(&sa->sa_mask,signo))
            printf(" S%d",signo);
    }

    printf("\n");
}

// setup_signal -- set up signal handler
void
setup_signal(int signo)
{
    struct sigaction sa;
    assert(sigaction(signo,NULL,&sa) == 0);

    sa.sa_sigaction = sigfault;
    showsa(&sa,"BEF");

    sa.sa_flags |= SA_SIGINFO;
    sa.sa_flags |= SA_ONSTACK;
    sa.sa_flags &= ~SA_RESETHAND;

    assert(sigaction(signo,&sa,NULL) == 0);

    assert(sigaction(signo,NULL,&sa) == 0);
    showsa(&sa,"AFT");
}

// setup_altstack -- set up alternate signal stack
void
setup_altstack(void)
{
    stack_t ss;

    sigaltstack(NULL,&ss);
    printf("setup_altstack: ss_sp=%p ss_flags=%8.8X ss_size=%zu\n",
        ss.ss_sp,ss.ss_flags,ss.ss_size);

    void *sp = altstk;
    sp += 16 * 4096;
    printf("altstk=%p sp=%p\n",altstk,sp);

    ss.ss_sp = sp;
    ss.ss_size = sizeof(altstk) / 2;
    ss.ss_flags = SS_ONSTACK;
    assert(sigaltstack(&ss,NULL) == 0);

    sigaltstack(NULL,&ss);
    printf("setup_altstack: ss_sp=%p ss_flags=%8.8X ss_size=%zu\n",
        ss.ss_sp,ss.ss_flags,ss.ss_size);

    if (ss.ss_sp != sp) {
        printf("setup_altstack: failed\n");
        exit(99);
    }
}

#define SHOWOPT(_opt,_reason) \
    if (_opt) \
        printf(#_opt " -- " _reason)

int
main(int argc,char **argv)
{

    setlinebuf(stdout);

    --argc;
    ++argv;

    for (;  argc > 0;  --argc, ++argv) {
        char *cp = *argv;
        if (*cp != '-')
            break;

        cp += 2;
        switch (cp[-1]) {
        case 'd':
            opt_d = ! opt_d;
            break;

        case 'i':
            opt_i = ! opt_i;
            break;

        case 't':
            opt_t = ! opt_t;
            break;
        }
    }

    // show the options
    SHOWOPT(opt_d,"dynamically grow stack within signal handler");
    SHOWOPT(opt_i,"grow stack initially");
    SHOWOPT(opt_t,"test sigsetjmp/siglongjmp");

    // set up alternate signal stack and signal handler
    if (opt_d || opt_t) {
        setup_altstack();
        setup_signal(SIGSEGV);
    }

    // test our sigsetjmp/siglongjmp
    if (opt_t) {
        for (int try = 1;  try <= 2;  ++try) {
            if (! sigsetjmp(jbuf,1)) {
                printf("main: ptr try=%d\n",try);
                unsigned int *ptr = NULL;
                *ptr = 23;
            }
            else
                printf("main: resume try=%d\n",try);
        }
        opt_t = 0;
    }

    // set up large stack outside of signal handler
    if (opt_i) {
        struct rlimit rlim;

        getrlimit(RLIMIT_STACK,&rlim);
        printf("rlim_cur=%lu/%lu\n",rlim.rlim_cur,rlim.rlim_cur / 1024);

        rlim.rlim_cur = 32 * 1024 * 1024;
        setrlimit(RLIMIT_STACK,&rlim);

        getrlimit(RLIMIT_STACK,&rlim);
        printf("rlim_cur=%lu/%lu\n",rlim.rlim_cur,rlim.rlim_cur / 1024);
    }

    printf("main: loop\n");

    // dynamically grow the stack
    may_grow = opt_d;

    // top of stack
    top = __builtin_frame_address(0);

    if (! sigsetjmp(jbuf,1))
        loop(NULL);
    else
        printf("main: stop\n");

    return 0;
}

---

更新：

这描述了如何使“the”堆栈动态增长（非常有趣），但我认为问题是关于线程堆栈而不是初始线程堆栈。 或者至少包括那些堆栈。 我不认为这个答案解决了他们。 – 约翰博林格

虽然这个问题被标记为pthreads ，但我不确定 OP 是否真的在谈论子线程这样做。

我不确定这是否可以用于子线程（通过pthread_create创建）。 至少不是通过使用默认的pthread_create调用。

如果没有特殊的pthread_attr_t值， pthread_create的默认值为malloc个堆栈 [默认大小]。 使用属性，调用者可以设置更大的堆栈大小。 和/或调用者 [通常] 会显式malloc并传递地址（连同大小）。

AFAICT，从阅读glibc源代码来看，如果用户提供堆栈指针， pthread_create将不会设置保护区。 设置警戒区[如果有的话]是调用者的责任。

但是，无论哪种情况，如果堆栈溢出（带有保护区），都会生成一个信号（ SIGSEGV ？）。

但是，那个时候能做什么？？？

调用用户的start_routine的 [pthread internal] function、 start_routine本身以及启动例程调用的任何函数，已经有指向“旧”堆栈上的东西的指针[我们必须假设这一点]。

因此，不能移动每线程堆栈（即没有realloc ）。

[可能] 执行此操作的唯一方法是调用者提供显式堆栈指针 [和大小]。 如前所述，调用者必须设置防护页（我假设是通过mprotect ）。

虽然userfaultfd等。 阿尔。 可能可用/更可取，我将假设调用者必须使用显式mmap调用（与使用堆malloc/realloc相比）。

主线程的堆栈 [通常] 从虚拟 memory 空间的顶部向下增长。 它可以增长，直到所有物理 memory 用完并且分页磁盘已满。

但是，对于每线程（子线程）堆栈，调用者必须在创建线程之前决定每线程堆栈的最大大小。 更多内容请见下文。

它可以设置一个较小初始大小的堆栈（通过mmap ）。 创建线程后，基址/顶层堆栈地址必须保持不变。

编辑：以下内容由以下附加想法修改。

如果发生故障，信号处理程序可以尝试扩展堆栈。 可能有几种方法可以做到这一点。 我最好的猜测是：

1. 如果下面的重新映射没有像realloc那样复制现有数据，它可能必须复制/保存现有堆栈数据 [某处;-)]。
2. 暂时撤消任何保护页。
3. 在相同地址取消映射/重新映射堆栈，但大小更大（通过mremap和/或mmap使用MREMAP_FIXED/MAP_FIXED ）。
4. 如有必要，将堆栈数据复制回“新”堆栈。
5. 设置新的保护页。
6. 从信号处理程序返回 [并希望；-)]。

正如我所说，子线程堆栈不能像主线程堆栈那样“无限”增长（通过setrlimit ）。

下面示例中的大小/地址不是“按比例”...

考虑以小尺寸开始的两个线程（例如 tA 和 tB）：

1. tA 的堆栈位于 xxxx1000，大小为 1000
2. tB 的堆栈位于 xxxx2000，大小为 1000

如果 tB 访问了它的保护页并出错，会发生什么？ 它没有空间向下扩展它的堆栈而不与 tA 的堆栈顶部发生碰撞。

因此，我们必须map 具有足够空间的堆栈才能增长到“最大”，我们必须事先知道这一点。

我们需要“隔开”堆栈地址，以便它们有增长的空间[即使并非所有页面最初都被映射]。

假设“最大”大小为 10000。可行的映射是：

1. tA 的堆栈位于 xxxx1000，大小为 1000
2. tB 的堆栈位于 xxx11000，大小为 1000

现在，如果 tB 命中它的保护页，它可以将其堆栈扩展到最大值 10000

额外的想法...

我们可能首先需要map整个最大区域。 否则，其他不相关的mmap调用可能会在建议的扩展区域中抢占空间。 来自堆管理器的mmap ，共享 memory 映射，甚至是在设置其他线程时完成的mmap调用。

因此，我们不需要使用mremap来增加区域的大小。 相反，我们应该在我们当前未使用的区域上使用带有MADV_DONTNEED的madvise 。

如果我们这样做，我们就不需要信号处理程序或保护页面来调用它来扩展区域。 只做MADV_DONTNEED将保持资源使用率低（呃）。

线程 function 可以（在稍微弹出堆栈之后）使用MADV_DONTNEED释放“弹出”区域。

其他MADV_*选项可能更好。

以上所有这些都让我觉得很疯狂！ 唯一的用途是一个[巨大的]多线程应用程序，它正在执行深度递归功能。

但是，如果是这种情况，最好将递归函数转换为不使用基于实际程序堆栈的递归的函数。 相反，function 将结构数组作为软件控制的[伪]“堆栈”进行管理。 每个结构在程序堆栈框架中都具有函数/自动 scope 的所有变量。

这个数组的大小可以用realloc控制。 或者，我们可以使用“slab”分配方案将“堆栈”实现为这些结构的链表。 使用 slab 方案，所有线程可以共享同一个 slab 分配器。 这样做的好处是所需的 memory 的数量比每个线程都有自己的/私有的 slab 分配器要小。

所以，IMO，不要在真正的每线程程序堆栈上这样做！

好的，这就是我想出的。 我没有为它编写代码或测试它。 这是我想留给读者的练习；-)