setjmp и longjump для реализации потоков

Быстрый и грязный взлом Windows. Извините за грязное имя и грязный код.

    // mythreads.cpp : Defines the entry point for the console application.
//

#include <setjmp.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include "List.h"

#include <Windows.h>

struct thread_t 
{
  util::Node node;
  jmp_buf buf;
};

util::List thread_list;
thread_t* runningThread = NULL;

void schedule(void);

void thread_yield()
{
  if (setjmp(runningThread->buf) == 0)
  {
    thread_list.push_back(&runningThread->node);
    schedule();
  }
  else
  {
    /* EMPTY */
  }
}

void myThread1(void *args)
{
  printf("myThread1\n");
}

void startThread(void(*func)(void*), void *args)
{
  thread_t* newThread = (thread_t*)malloc(sizeof(thread_t));

  // Create new stack here! This part is Windows specific. Find the current stack
  // and copy the contents. One might do more stuff here, e.g. change the return address 
  // of this function to be a thread_exit function.
  NT_TIB* tib = (NT_TIB*)__readfsdword(0x18);
  uint8_t* stackBottom = (uint8_t*)tib->StackLimit;
  uint8_t* stackTop = (uint8_t*)tib->StackBase;

  size_t stack_size = stackTop - stackBottom;
  uint8_t *new_stack = (uint8_t*)malloc(stackTop - stackBottom);
  memcpy(new_stack, stackBottom, stack_size);

  _JUMP_BUFFER *jp_buf = (_JUMP_BUFFER*)newThread->buf;

  if (setjmp(newThread->buf) == 0)
  {
    // Modify necessary registers to point to new stack. I may have 
    // forgotten a bunch of registers here, you must do your own homework on
    // which registers to copy.
    size_t sp_offset = jp_buf->Esp - (unsigned long)stackBottom;
    jp_buf->Esp = (size_t)new_stack + sp_offset;
    size_t si_offset = jp_buf->Esi - (unsigned long)stackBottom;
    jp_buf->Esi = (size_t)new_stack + si_offset;
    size_t bp_offset = jp_buf->Ebp - (unsigned long)stackBottom;
    jp_buf->Ebp = (size_t)new_stack + bp_offset;
    thread_list.push_back(&newThread->node);
  }
  else
  {
    /* This is where the new thread will start to execute */
    func(args);
  }
}

void schedule(void)
{
  if (runningThread != NULL)
  {

  }

  if (thread_list.size() > 0)
  {
    thread_t* t = (thread_t*)thread_list.pop_front();
    runningThread = t;
    longjmp(t->buf, 1);
  }
}

void initThreading()
{
  thread_list.init();

  thread_t* mainThread = (thread_t*)malloc(sizeof(thread_t));

  if (setjmp(mainThread->buf) == 0)
  {
    thread_list.push_back(&mainThread->node);
    schedule();
  }
  else
  {
    /* This is where the main thread will start to execute again */
    printf("Main thread running!\n");
  }
}

int main()
{
  initThreading();

  startThread(myThread1, NULL);

  thread_yield();

  printf("Main thread exiting!\n");
}

Кроме того, Microsoft и setjmp/longjmp могут не совпадать. Если бы у меня поблизости была коробка Unix, я бы сделал это на ней.

И мне, вероятно, придется немного больше изучить копию стека, чтобы убедиться, что она работает правильно.

РЕДАКТИРОВАТЬ: Чтобы проверить, какие регистры изменять после изменения стека, можно обратиться к руководству по компилятору.

Код начинается в main() с настройки структуры потоков. Он делает это, рассматривая ваш основной поток (единственный поток на данный момент) как простой поток среди других. Итак, сохраните контекст для основного потока и поместите его в thread_list. Затем мы schedule() запускаем один поток. Это делается в initThreading(). Поскольку единственный запущенный поток — это основной поток, мы продолжим работу с функцией main().

Следующее, что делает функция main, это startThread с указателем на функцию в качестве параметра (и аргументом NULL, который должен быть отправлен в func). Что делает функция startThread(), так это то, что она выделяет память для стека для нового потока (каждому потоку нужен свой собственный стек). После выделения мы сохраняем контекст выполняющегося потока в новый буфер контекста потока (jmp_buf) и меняем указатели стека (и все другие регистры, которые должны быть изменены) так, чтобы они указывали на только что созданный стек. Затем мы добавляем этот новый поток в список ожидающих потоков. И тогда мы возвращаемся из функции. Мы по-прежнему в основной ветке.

В основном потоке мы делаем thread_yield(), который говорит: «Хорошо, я больше не хочу бегать, пусть бежит кто-нибудь другой!». Функция thread_yield сохраняет текущий контекст и помещает основной поток в конец списка thread_list. Затем мы планируем.

Schedule() берет следующий поток из thread_list и выполняет longjmp контекст, сохраненный в потоке buf (jmp_buf). В этом случае поток будет продолжать работать в предложении else setjmp, где мы сохранили контекст.

  else
    {
        /* This is where the new thread will start to execute */
        func(args);
      }

Он будет работать до тех пор, пока мы не выполним thread_yield, а затем проделаем то же самое, но вместо этого возьмем основной поток и выполним longjmp в его сохраненном буфере и так далее и тому подобное…

Если кто-то хочет проявить фантазию и хочет получить временные интервалы, можно реализовать некоторый сигнал тревоги, чтобы сохранить текущий контекст потока, а затем вызвать schedule().

Есть яснее?