/* $OpenBSD: stack.c,v 1.4 2014/08/10 05:08:31 guenther Exp $ */
/* PUBLIC DOMAIN Feb 2012 <guenther@openbsd.org> */

/* Test the handling of the pthread_attr_t stack attributes */

#include <sys/types.h>
#include <sys/mman.h>
#include <stdint.h>
#include <limits.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "test.h"

#define LARGE_SIZE      (1024 * 1024)

/* thread main for plain location tests */
void *
tmain0(void *arg)
{
        int s;

        return (&s);
}

/* thread main for testing a large buffer on the stack */
void *
tmain1(void *arg)
{
        char buf[LARGE_SIZE];

        memset(buf, 0xd0, sizeof(buf));
        return (buf + LARGE_SIZE/2);
}

/*
 * struct and thread main for testing that a thread's stack is where
 * we put it
 */
struct st
{
        char *addr;
        size_t size;
};
void *
tmain2(void *arg)
{
        struct st *s = arg;

        ASSERT((char *)&s >= s->addr && (char *)&s - s->addr < s->size);
        return (NULL);
}

int
main(void)
{
        pthread_attr_t attr;
        pthread_t t;
        struct st thread_stack;
        void *addr, *addr2;
        size_t size, size2, pagesize;
        int err;

        pagesize = (size_t)sysconf(_SC_PAGESIZE);

        CHECKr(pthread_attr_init(&attr));

        /* verify that the initial values are what we expect */
        size = 1;
        CHECKr(pthread_attr_getguardsize(&attr, &size));
        ASSERT(size != 1);              /* must have changed */
        ASSERT(size != 0);              /* we default to having a guardpage */

        size = 1;
        CHECKr(pthread_attr_getstacksize(&attr, &size));
        ASSERT(size >= PTHREAD_STACK_MIN);

        addr = &addr;
        CHECKr(pthread_attr_getstackaddr(&attr, &addr));
        ASSERT(addr == NULL);           /* default must be NULL */

        addr2 = &addr;
        size2 = 1;
        CHECKr(pthread_attr_getstack(&attr, &addr2, &size2));
        ASSERT(addr2 == addr);          /* must match the other calls */
        ASSERT(size2 == size);

        /* verify that too small a size is rejected */
        err = pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN - 1);
        ASSERT(err == EINVAL);
        CHECKr(pthread_attr_getstacksize(&attr, &size2));
        ASSERT(size2 == size);


        /* create a thread with the default stack attr so we can test reuse */
        CHECKr(pthread_create(&t, NULL, &tmain0, NULL));
        sleep(1);
        CHECKr(pthread_join(t, &addr));

        /*
         * verify that the stack has *not* been freed: we expect it to be
         * cached for reuse.  This is unportable for the same reasons as
         * the mquery() test below.  :-/
         */
        *(int *)addr = 100;


        /* do the above again and make sure the stack got reused */
        CHECKr(pthread_create(&t, NULL, &tmain0, NULL));
        sleep(1);
        CHECKr(pthread_join(t, &addr2));
        ASSERT(addr == addr2);


        /*
         * increase the stacksize, then verify that the change sticks,
         * and that a large buffer fits on the resulting thread's stack
         */
        size2 += LARGE_SIZE;
        CHECKr(pthread_attr_setstacksize(&attr, size2));
        CHECKr(pthread_attr_getstacksize(&attr, &size));
        ASSERT(size == size2);

        CHECKr(pthread_create(&t, &attr, &tmain1, NULL));
        sleep(1);
        CHECKr(pthread_join(t, &addr));

        /* test whether the stack has been freed */
        /* XXX yow, this is grossly unportable, as it depends on the stack
         * not being cached, the thread being marked freeable before
         * pthread_join() calls the gc routine (thus the sleep), and this
         * being testable by mquery */
        addr = (void *)((uintptr_t)addr & ~(pagesize - 1));
        ASSERT(mquery(addr, pagesize, PROT_READ, MAP_FIXED|MAP_ANON, -1, 0)
            == addr);

        /* the attr wasn't modified by pthread_create, right? */
        size = 1;
        CHECKr(pthread_attr_getstacksize(&attr, &size));
        ASSERT(size == size2);


        /* allocate our own stack and verify the thread uses it */
        size = pagesize * 4;
        addr = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
            -1, 0);
        ASSERT(addr != MAP_FAILED);
        memset(addr, 0xd0, size);
        CHECKr(pthread_attr_setstack(&attr, addr, size));

        CHECKr(pthread_attr_getstacksize(&attr, &size2));
        ASSERT(size2 == size);
        CHECKr(pthread_attr_getstackaddr(&attr, &addr2));
        ASSERT(addr2 == addr);
        CHECKr(pthread_attr_getstack(&attr, &addr2, &size2));
        ASSERT(addr2 == addr);
        ASSERT(size2 == size);

        thread_stack.addr = addr;
        thread_stack.size = size;
        CHECKr(pthread_create(&t, &attr, &tmain2, &thread_stack));
        sleep(1);
        CHECKr(pthread_join(t, NULL));

        /* verify that the stack we allocated was *not* freed */
        memset(addr, 0xd0, size);

        return (0);
}