// ...

#define UPPER_BOUND 500000000
#define QUANTUM_SEC 0
#define QUANTUM_MICRO_SEC 500000

// stores the context of the thread_function context
static ucontext_t thread_context;
// stores the context of the scheduler_function context
static ucontext_t scheduler_context;

int thread_finished;
int i;

static void signal_handler_function(int sig_nr, siginfo_t* info, void *context) {
    // saves the thread context
    thread_context = *((ucontext_t*)context);

    // swaps back to scheduler context
    setcontext(&scheduler_context);
}

// This function simulates a thread function. It consists of two simple for-loops and prints, whether every loop finished successfully.
void thread_function(void) {

    // 1st count
    for (i = 0; i < UPPER_BOUND; ++i);

    if (i == UPPER_BOUND) {
        printf("\n[Thread Function]\t1st counting worked fine...");
    } else {
        printf("\n[Thread Function]\tError: 1st counting didn't finished (%d)...", i);
    }

    // 2nd count
    for (i = 0; i < UPPER_BOUND; ++i);

    if (i == UPPER_BOUND) {
        printf("\n[Thread Function]\t2nd counting worked fine...");
    } else {
        printf("\n[Thread Function]\tError: 2nd counting didn't finished (%d)...", i);
    }

    thread_finished = 1;
}

// The context will swap into this function after a signal was raised. The while-loop ends, when thread_finished == 1.
// thread_finished is set to 1 at the end of the thread_function.
void scheduler_function() {
    // thread_finished is a global variable, which is set to 1, if the thread function is finished
    while(thread_finished != 1) {
        swapcontext(&scheduler_context, &thread_context);
        printf("\n[Scheduler Function]\tSwap back is done...");
    }
}

// main initializes all needed stuff (timer, signal handler) and starts the scheduler_function.
int main(int argc, char **argv) {
    thread_finished = 0;

    char thread_stack[65536];

    // initializing scheduler context
    getcontext(&scheduler_context);

    // initializing thread context
    getcontext(&thread_context);
    thread_context.uc_stack.ss_sp = thread_stack;
    thread_context.uc_stack.ss_size = sizeof(thread_stack);
    thread_context.uc_link = &scheduler_context;

    // initialize alternate stack for signal handling
    char * alternate_stack = (char*)malloc(65536);

    stack_t new_signal_stack;
    new_signal_stack.ss_sp = alternate_stack;
    new_signal_stack.ss_size = 65536;
    new_signal_stack.ss_flags = 0;
    sigaltstack(&new_signal_stack, NULL);

    // sets the signal handler for swapping to the scheduler context
    struct sigaction scheduling_interuption_handler;
    scheduling_interuption_handler.sa_sigaction = signal_handler_function;
    scheduling_interuption_handler.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
    sigemptyset(&scheduling_interuption_handler.sa_mask);
    sigaction(SIGPROF, &scheduling_interuption_handler, NULL)

    // sets the timer which sends SIGPROF periodically
    struct itimerval timeslice;
    timeslice.it_value.tv_sec = QUANTUM_SEC;
    timeslice.it_value.tv_usec = QUANTUM_MICRO_SEC;
    timeslice.it_interval = timeslice.it_value;

    setitimer(ITIMER_PROF, &timeslice, NULL);

    // sets the thread function
    makecontext(&thread_context, thread_function, 0);

    // this function handles the swapping part
    scheduler_function();
}