用户态线程库——C语言实现

  1 #pragma once
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include <unistd.h>
  5 #include <string.h>
  6 #include <signal.h>
  7 #include <assert.h>
  8 #include <time.h>
  9 
 10 #define JMP(r)    asm volatile  11                 (   "pushl %3\n\t"  12                     "popfd\n\t"  13                     "movl %2, %%ebp\n\t"  14                     "movl %0, %%esp\n\t"  15                     "jmp *%1\n\t"  16                     :  17                     : "m"(r._esp),"m"(r._eip),"m"(r._ebp),"m"(r._eflags)  18                     :  19                 )
 20 
 21 #define SAVE()                  asm volatile  22                             (   "movl %%eax, %0\n\t"  23                                 "movl %%ecx, %1\n\t"  24                                 "movl %%edx, %2\n\t"  25                                 "movl %%ebx, %3\n\t"  26                                    "movl %%esp, %4\n\t"  27                                 "movl %%ebp, %5\n\t"  28                                 "movl %%esi, %6\n\t"  29                                 "movl %%edi, %7\n\t"  30                                 "pushfd\n\t"  31                                 "movl (%%esp), %%eax\n\t"  32                                 "movl %%eax, %8\n\t"  33                                 "popfd\n\t"  34                                 : "=m"(_eax),"=m"(_ecx),"=m"(_edx),"=m"(_ebx)  35                                 ,"=m"(_esp),"=m"(_ebp)  36                                 , "=m"(_esi),"=m"(_edi),"=m"(_eflags)  37                                 :  38                                 : "%eax"  39                             )
 40 
 41 #define RESTORE(r)          asm volatile  42                             (   "movl %0, %%eax\n\t"  43                                 "movl %1, %%ecx\n\t"  44                                 "movl %1, %%edx\n\t"  45                                 "movl %3, %%ebx\n\t"  46                                 "movl %4, %%esi\n\t"  47                                 "movl %5, %%edi\n\t"  48                                 :  49                                 :"m"(r._eax),"m"(r._ecx),"m"(r._edx),"m"(r._ebx)  50                                 , "m"(r._esi),"m"(r._edi)  51                             )
 52 
 53 typedef void Func(int);
 54 
 55 /* __timer struct is the real Timer struct we use
 56  * id is unique to each timer
 57  * intersec is the inteval seconds to each signal forwarding the this Timer
 58  * sigactor is the handler for this Timer
 59  * next is a internal member used for linked list
 60  */
 61 struct __timer
 62 {
 63     void *next;
 64     unsigned int sec;
 65     unsigned int intersec;
 66     int id;
 67     Func *sigactor;
 68 };
 69 
 70 /* struct alarm is ugly for the compatibility with early struct.
 71  * I should have used unnamed member instead of __inner.
 72  */
 73 typedef struct alarm *Timer;
 74 struct alarm
 75 {
 76     union{
 77         struct
 78         {
 79             Timer next;
 80             unsigned int sec;
 81         };
 82         struct __timer __inner;
 83     }; 
 84 };
 85 
 86 typedef struct list *Header;
 87 
 88 struct list
 89 {
 90     Timer head;
 91 };
 92 
 93 typedef struct __thread_table_regs Regs;
 94 struct __thread_table_regs
 95 {
 96     int _edi;
 97     int _esi;
 98     int _ebp;
 99     int _esp;
100     int _ebx;
101     int _edx;
102     int _ecx;
103     int _eax;
104     int _eip;
105     int _eflags;
106 };
107 
108 typedef struct __ez_thread Thread_t;
109 struct __ez_thread
110 {
111     Regs regs;
112     int tid;
113     sigset_t sigmask;
114     unsigned int priority;
115     int tick;
116     int state;
117     int errno;
118     unsigned int stacktop;
119     unsigned int stacksize;
120     void *stack;
121     void *retval;
122     volatile int __reenter;
123 };
124 
125 typedef struct __pnode pNode;
126 struct __pnode
127 {
128     pNode *next;
129     pNode *prev;
130     Thread_t *data;
131 };
132 
133 typedef struct __loopcursor Cursor;
134 struct __loopcursor
135 {
136     int total;
137     pNode *current;
138 };
139 typedef struct __stack *Stack_t;
140 struct __stack
141 {
142     int __pad[4096];
143 };
144 
145 void switch_to(int);
146 
147 extern Header hdr_ptr;
148 extern Cursor live;
149 extern Cursor dead;
150 extern Thread_t pmain;

  1 /* MIT License
  2 
  3 Copyright (c) 2017 Yuandong-Chen
  4 
  5 Permission is hereby granted, free of charge, to any person obtaining a copy
  6 of this software and associated documentation files (the "Software"), to deal
  7 in the Software without restriction, including without limitation the rights
  8 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 copies of the Software, and to permit persons to whom the Software is
 10 furnished to do so, subject to the following conditions:
 11 
 12 The above copyright notice and this permission notice shall be included in all
 13 copies or substantial portions of the Software.
 14 
 15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 21 SOFTWARE. */
 22 
 23 #include "thread.h"
 24 /************************* Alarm facility *************************/
 25 
 26 struct list linkedlist;
 27 Header hdr_ptr = &linkedlist;
 28 
 29 
 30 Timer mallocTimer(int id, Func *actor,unsigned int sec, unsigned int interval)
 31 {
 32     Timer ret = (Timer)malloc(sizeof(struct alarm));
 33     assert(ret);
 34     ret->__inner.id = id;
 35     ret->__inner.sigactor = actor;
 36     ret->__inner.intersec = interval;
 37     ret->sec = sec;
 38     return ret;
 39 }
 40 
 41 /* find Timer in linked list which id is id.
 42  * return: return NULL if not found, -1 if it‘s header link, 
 43  * otherwise prev which is the previous Timer member to this Timer
 44  */
 45 
 46 Timer findTimerPrev(Header h, int id)
 47 {
 48     assert(h);
 49     if(h->head == NULL)
 50         return NULL;
 51 
 52     Timer t = h->head;
 53     Timer prev = NULL;
 54 
 55     while(t)
 56     {
 57         if(t->__inner.id == id){
 58             if(prev == NULL)
 59                 return (Timer)-1;
 60             else
 61                 return prev;
 62         }
 63         prev = t;
 64         t = t->next;
 65     }
 66 
 67     return NULL;
 68 }
 69 
 70 /* delete Timer in linked list.
 71  * return: nothing, we ensure this t is deleted in the linked list.
 72  */
 73 
 74 void delTimer(Header h, Timer t)
 75 {
 76     assert(h);
 77     assert(t);
 78     Timer prevtodel = findTimerPrev(h, t->__inner.id);
 79     unsigned int base = 0;
 80 
 81     if(prevtodel)
 82     {
 83         if(prevtodel == (Timer)-1){
 84 
 85             unsigned int res = (h->head)->sec;
 86             if(res != 0)
 87             {
 88                 base = res;
 89             }
 90             else
 91             {
 92                 kill(getpid(),SIGALRM);
 93                 return;
 94             }
 95             h->head = (h->head)->next;
 96             Timer tmp = (h->head);
 97 
 98             while(tmp){
 99                 tmp->sec += base;
100                 tmp = tmp->next;
101             }
102             return;
103         }
104         else
105         {
106             
107             base = (prevtodel->next)->sec;
108             prevtodel->next = (prevtodel->next)->next;
109             Timer tmp = (prevtodel->next);
110             
111             while(tmp){
112                 tmp->sec += base;
113                 tmp = tmp->next;
114             }
115             return;
116         }
117     }
118 
119     return;
120 }
121 
122 /* append Timer in appropriate place in linked list.
123  * the appropriate place means all timers in linked list are arranged 
124  * according their next alarm seconds.
125  * The algorithm we use here is that the real left alarm seconds for this Timer 
126  * is the sum of all the sec member in Timer in linked list prev to this Timer
127  * plus its sec member. For example, we add 3 Timers to the linked list,
128  * whose sec are 4, 3, 2 respectively. Then the linked list looks like:
129  * 2 (real sec = 2) --> 1 (real sec = 2+1 = 3) --> 1 (real sec = 2+1+1 = 4)
130  * The advantage is obviously, we dont need to remember how many seconds passed.
131  * We always fetch the header to respond the alarm signal and set next alarm sec 
132  * as the next timer in the linked list. (The real situation is a little bit more 
133  * complex, for example if upcoming timers‘ sec equals 0, we need to call their
134  * handler right away all together in a certain sequence. If its intersec is not 
135  * zero, we need to append it to the linked list again as quick as possible)
136  * note: delTimer also address this problem. If we delete any Timer, we need to 
137  * recalculate the secs after this timer in the linked list.(simply to add sec to 
138  * the next timer and delete this timer node)
139  * return: only 0 if success, otherwise the hole process failed.
140  */
141 
142 int appendTimer(Header h, Timer t)
143 {
144     assert(h);
145     assert(t);
146     delTimer(h, t);
147 
148     if(h->head == NULL)
149     {
150         h->head = t;
151         return 0;
152     }
153 
154     Timer tmp = h->head;
155     Timer prev = NULL;
156     unsigned int prevbase = 0;
157     unsigned int base = 0;
158 
159     while(tmp)
160     {
161         prevbase = base;
162         base += tmp->sec;
163         if(t->sec < base){
164             break;
165         }
166         else{
167             prev = tmp;
168             tmp = tmp->next;
169         }
170             
171     }
172 
173     if(prev == NULL)
174     {
175         (h->head)->sec -= t->sec;
176         t->next = h->head;
177         h->head = t;
178         return 0;
179     }
180 
181     if(tmp == NULL)
182         t->sec -=base;
183     else
184         t->sec -=prevbase;
185 
186     prev->next = t;
187     t->next = tmp;
188     if(tmp)
189         tmp->sec -= t->sec;
190 
191     return 0;
192 }
193 
194 /* pop header timer in linked list.
195  * return: its hander
196  */
197 
198 Func* popTimer(Header h)
199 {
200     assert(h);
201     if(h->head == NULL)
202         return (Func *)-1;
203     Func *ret = (h->head)->__inner.sigactor;
204     Timer todel = h->head;
205     h->head = (h->head)->next;
206     // if its intersec greater than 0, we append it right away to the linked list
207     if(todel->__inner.intersec > 0)
208     {
209         todel->sec = todel->__inner.intersec;
210         appendTimer(h, todel);
211     }
212     return ret;
213 }
214 
215 void printList(Header h)
216 {
217     assert(h);
218     if(h->head == NULL)
219         return;
220 
221     Timer tmp = h->head;
222 
223     while(tmp)
224     {
225         printf("timer[%d] = %u saved %u\n", tmp->__inner.id, tmp->sec, tmp->__inner.intersec);
226         tmp = tmp->next;
227     }
228 }
229 
230 /* it‘s the real signal handler responding to every SIGALRM.
231  */
232 void sig_alarm_internal(int signo)
233 { 
234     void funcWrapper(int signo, Func *func);
235 
236     if(hdr_ptr->head == NULL)
237         return;
238 
239     Func *recv;
240     if((recv = popTimer(hdr_ptr)) == (Func *)-1){
241         funcWrapper(SIGALRM, recv);
242     }  
243     else
244     {
245         // signal ourself if next timer‘s sec = 0
246         if(hdr_ptr->head){
247             ((hdr_ptr->head)->sec > 0?alarm((hdr_ptr->head)->sec):kill(getpid(), SIGALRM));
248         }
249         funcWrapper(SIGALRM, recv);
250     }
251 }
252 
253 /* Alarm function simulates native alarm function.
254  * what if SIGALRM arrives when process is running in Alarm?
255  * we just block the signal since there is no slow function in Alarm,
256  * sig_alarm_internal will for sure address the signal very soon.
257  */
258 
259 unsigned int Alarm(Header h, Timer mtimer)
260 {
261     sigset_t mask;
262     sigset_t old;
263     sigemptyset(&mask);
264     sigaddset(&mask, SIGALRM);
265     sigprocmask(SIG_BLOCK, &mask, &old);
266     
267     unsigned int res = 0;
268     Timer t;
269 
270     if((t = findTimerPrev(h, mtimer->__inner.id)) == NULL)
271         goto LL;
272 
273     t = h->head;
274     while(t)
275     {
276         res += t->sec; // it‘s not precise, we should use alarm(0) for the first sec.
277                        // However, its simple enough to implement. 
278         if(t->__inner.id == mtimer->__inner.id)
279             break;
280 
281         t = t->next;
282     }
283 LL:
284     if(mtimer->sec == 0)
285     {
286         delTimer(h, mtimer);
287         sigprocmask(SIG_SETMASK, &old, NULL);
288         return res;
289     }
290      
291     appendTimer(h, mtimer);
292     if(mtimer->__inner.id == (h->head)->__inner.id)
293         ((h->head)->sec > 0?alarm((h->head)->sec):kill(getpid(), SIGALRM));
294     sigprocmask(SIG_SETMASK, &old, NULL);
295     return res;
296 }
297 
298 void initTimer()
299 {
300     struct sigaction act;
301     act.sa_handler = sig_alarm_internal;
302     act.sa_flags = SA_RESTART|SA_NODEFER;
303     sigemptyset(&act.sa_mask);
304     sigaction(SIGALRM, &act, NULL);
305 }
306 
307 void funcWrapper(int signo, Func *func)
308 {
309     sigset_t mask;
310     sigset_t old;
311     sigemptyset(&mask);
312     sigaddset(&mask, SIGALRM);
313     sigprocmask(SIG_UNBLOCK, &mask, &old);
314     func(signo);
315     sigprocmask(SIG_SETMASK, &old, NULL);
316 }
317 
318 /************************* Thread facility *************************/
319 
320 
321 Cursor live;
322 Cursor dead;
323 Thread_t pmain;
324 
325 void initCursor(Cursor *cur)
326 {
327     cur->total = 0;
328     cur->current = NULL;
329 }
330 
331 Thread_t *findThread(Cursor *cur, int tid)
332 {
333     sigset_t mask,old;
334     sigemptyset(&mask);
335     sigaddset(&mask, SIGALRM);
336     sigprocmask(SIG_BLOCK, &mask, &old);
337     int counter = cur->total;
338     if(counter == 0){
339         sigprocmask(SIG_SETMASK, &old, NULL);
340         return NULL;
341     }
342         
343 
344     int i;
345     pNode *tmp = cur->current;
346     for (int i = 0; i < counter; ++i)
347     {
348         if((tmp->data)->tid == tid){
349             sigprocmask(SIG_SETMASK, &old, NULL);
350             return tmp->data;
351         }
352         tmp = tmp->next;
353     }
354     sigprocmask(SIG_SETMASK, &old, NULL);
355     return NULL;
356 }
357 
358 int appendThread(Cursor *cur, Thread_t *pth)
359 {
360     sigset_t mask,old;
361     sigemptyset(&mask);
362     sigaddset(&mask, SIGALRM);
363     sigprocmask(SIG_BLOCK, &mask, &old);
364     if(cur->total == 0)
365     {
366         //note this never freed for simple implementation
367         cur->current = (pNode *)malloc(sizeof(pNode));
368         assert(cur->current);
369         (cur->current)->data = pth;
370         (cur->current)->prev = cur->current;
371         (cur->current)->next = cur->current;
372         cur->total++;
373         sigprocmask(SIG_SETMASK, &old, NULL);
374         return 0;
375     }
376     else
377     {
378         #define MAXTHREADS 5
379         if(cur->total > MAXTHREADS)
380         {
381             assert((cur->total == MAXTHREADS));
382             sigprocmask(SIG_SETMASK, &old, NULL);
383             return -1;
384         }
385         //freed at threadJoin for simple implementation
386         pNode *tmp = malloc(sizeof(pNode));
387         assert(tmp);
388         tmp->data = pth;
389         tmp->prev = cur->current;
390         tmp->next = (cur->current)->next;
391         ((cur->current)->next)->prev = tmp;
392         (cur->current)->next = tmp;
393         cur->total++;
394         sigprocmask(SIG_SETMASK, &old, NULL);
395         return 0;
396     }
397 }
398 
399 pNode *deleteThread(Cursor *cur, int tid)
400 {
401     sigset_t mask,old;
402     sigemptyset(&mask);
403     sigaddset(&mask, SIGALRM);
404     sigprocmask(SIG_BLOCK, &mask, &old);
405 
406     int counter = cur->total;
407     int i;
408     pNode *tmp = cur->current;
409     for (int i = 0; i < counter; ++i)
410     {
411         if((tmp->data)->tid == tid){
412             (tmp->prev)->next = tmp->next;
413             (tmp->next)->prev = tmp->prev;
414             if(tmp == cur->current)
415             {
416                 cur->current = cur->current->next;
417             }  
418             //free(tmp);
419             cur->total--;
420             assert(cur->total);
421             sigprocmask(SIG_SETMASK, &old, NULL);
422             return tmp;
423         }
424         tmp = tmp->next;
425     }
426     sigprocmask(SIG_SETMASK, &old, NULL);
427     return NULL;
428 }
429 
430 void printThread(Thread_t *pth)
431 {
432     printf("pth tid: %d\n", pth->tid);
433     printf("pth stack top: %x\n", pth->stacktop);
434     printf("pth stack size: %u\n", pth->stacksize);
435     printf("pth state: %d\n", pth->state);
436     printf("pth errno: %d\n", pth->errno);
437     printf("pth retval: %p\n", pth->retval);
438     printf("pth sigmask: %u\n", pth->sigmask);
439     printf("pth priority: %d\n", pth->priority);
440     printf("pth tick: %d\n", pth->tick);
441     printf("EFLAGS: %x\t", pth->regs._eflags);
442     printf("EIP: %x\t", pth->regs._eip);
443     printf("EAX: %x\t", pth->regs._eax);
444     printf("ECX: %x\n", pth->regs._ecx);
445     printf("EDX: %x\t", pth->regs._edx);
446     printf("EBX: %x\t", pth->regs._ebx);
447     printf("ESP: %x\t", pth->regs._esp);
448     printf("EBP: %x\n", pth->regs._ebp);
449     printf("ESI: %x\t", pth->regs._esi);
450     printf("EDI: %x\n", pth->regs._edi);
451 
452 }
453 
454 void printLoop(Cursor *cur)
455 {
456     int count = 0;
457     pNode *tmp = cur->current;
458     assert(tmp);
459     do{
460         printThread(tmp->data);
461         tmp = tmp->next;
462         count ++; 
463     }while(tmp != cur->current);
464     printf("real total: %d\n", count);
465     printf("total record:%d\n", cur->total);
466     assert(count == cur->total);
467 }
468 
469 int fetchTID()
470 {
471     static int tid;
472     return ++tid;
473 }
474 
475 void real_entry(Thread_t *pth, void *(*start_rtn)(void *), void* args)
476 {
477     //printf("in real entry: %p\n", start_rtn);
478     
479     pth->retval = (*start_rtn)(args);
480     //deleteThread(&live, pth->tid);
481     /* some clean job here */
482     //free(pth->stack);
483     //pth->stack = NULL;
484     //pth->stacktop = 0;
485     //pth->stacksize = 0;
486     #define DETACHED 1
487     deleteThread(&live, pth->tid);
488     appendThread(&dead, pth);
489 
490     if(pth->state == DETACHED)
491         threadJoin(pth, NULL);
492 
493     switch_to(-1);
494 }
495 
496 int threadCreat(Thread_t **pth, void *(*start_rtn)(void *), void *arg)
497 {
498     sigset_t mask,old;
499     sigemptyset(&mask);
500     sigaddset(&mask, SIGALRM);
501     sigprocmask(SIG_BLOCK, &mask, &old);
502     //freed at threadJoin for simple implementation
503     *pth = malloc(sizeof(Thread_t));
504     #define PTHREAD_STACK_MIN 4096
505     //freed at threadJoin for simple implementation
506     (*pth)->stack = malloc(PTHREAD_STACK_MIN);
507     assert((*pth)->stack);
508     (*pth)->stacktop = (((int)(*pth)->stack + PTHREAD_STACK_MIN)&(0xfffff000));
509     (*pth)->stacksize = PTHREAD_STACK_MIN - (((int)(*pth)->stack + PTHREAD_STACK_MIN) - (*pth)->stacktop);
510     (*pth)->state = 0; // 0 JOINABLE 1 DETACHED
511     (*pth)->priority = 1; //one seconds
512     (*pth)->tick = (*pth)->priority;
513     (*pth)->tid = fetchTID();
514     sigprocmask(0,NULL,&((*pth)->sigmask));
515     /* set params */
516     void *dest = (*pth)->stacktop - 12;
517     memcpy(dest, pth, 4);
518     dest += 4;
519     memcpy(dest, &start_rtn, 4);
520     dest += 4;
521     memcpy(dest, &arg, 4);
522     (*pth)->regs._eip = &real_entry;
523     (*pth)->regs._esp = (*pth)->stacktop - 16;
524     (*pth)->regs._edi = 0;
525     (*pth)->regs._esi = 0;
526     (*pth)->regs._ebp = 0;
527     (*pth)->regs._eax = 0;
528     (*pth)->regs._ebx = 0;
529     (*pth)->regs._ecx = 0;
530     (*pth)->regs._edx = 0;
531     (*pth)->regs._eflags = 0;
532     appendThread(&live, (*pth));
533     sigprocmask(SIG_SETMASK, &old, NULL);
534     return 0;
535 }
536 
537 int threadJoin(Thread_t *pth, void **rval_ptr)
538 {
539 
540     sigset_t mask,old;
541     sigemptyset(&mask);
542     sigaddset(&mask, SIGALRM);
543     sigprocmask(SIG_BLOCK, &mask, &old);
544     Thread_t *find1, *find2;
545     find1 = findThread(&live, pth->tid);
546     find2 = findThread(&dead, pth->tid);
547     
548 
549     if((find1 == NULL)&&(find2 == NULL)){
550         sigprocmask(SIG_SETMASK, &old, NULL);
551         return -1;
552     }
553 
554     if(find2){
555         if(rval_ptr != NULL)
556             *rval_ptr = find2->retval;
557 
558         sigprocmask(SIG_SETMASK, &old, NULL);
559         return 0;
560     }
561     sigprocmask(SIG_SETMASK, &old, NULL);
562     while(1)
563     {
564         if((find2 = findThread(&dead, pth->tid))!= NULL){
565             if(rval_ptr!= NULL)
566                 *rval_ptr = find2->retval;
567 
568             pNode *tmp = deleteThread(&dead, pth->tid);
569             free(tmp);
570             free((Stack_t)find2->stack);
571             free(find2);
572             return 0;
573         }
574     }
575     return -1;
576 }
577 
578 void init()
579 {
580     initTimer();
581     initCursor(&live);
582     initCursor(&dead);
583     appendThread(&live, &pmain);
584     Alarm(hdr_ptr,mallocTimer(1, switch_to, 1, 1));
585 }
586 
587 void switch_to(int signo)
588 {
589     sigset_t mask,old;
590     sigemptyset(&mask);
591     sigaddset(&mask, SIGALRM);
592     sigprocmask(SIG_BLOCK, &mask, &old);
593     Regs regs;
594     //printf("");
595     if(signo == -1)
596     {
597         regs = live.current->data->regs;
598         sigprocmask(SIG_SETMASK, &old, NULL);
599         JMP(regs);
600         assert(0);
601     }
602     
603     int _edi;
604     int _esi;
605     int _ebp;
606     int _esp;
607     int _ebx;
608     int _edx;
609     int _ecx;
610     int _eax;
611     int _eip = &&_REENTERPOINT;
612     int _eflags;
613     live.current->data->__reenter = 0; 
614     /* save current context */
615     SAVE();
616 
617     /* save context in current thread */
618     live.current->data->regs._eflags = _eflags;
619     live.current->data->regs._eip = _eip;
620     live.current->data->regs._eax = _eax;
621     live.current->data->regs._ecx = _ecx;
622     live.current->data->regs._edx = _edx;
623     live.current->data->regs._ebx = _ebx;
624     live.current->data->regs._esp = _esp;
625     live.current->data->regs._ebp = _ebp;
626     live.current->data->regs._esi = _esi;
627     live.current->data->regs._edi = _edi;
628 
629     if(!live.current->data->__reenter)
630     {
631         goto _END;
632     }
633 
634 _REENTERPOINT:
635     regs = live.current->data->regs;
636 
637     if(live.current->data->__reenter){
638         live.current->data->__reenter = 0;
639         sigprocmask(SIG_SETMASK, &old, NULL);
640         return;
641     } 
642 
643 _END:
644     live.current->data->__reenter = 1;
645     regs = live.current->next->data->regs;
646     live.current = live.current->next;
647     sigprocmask(SIG_SETMASK, &old, NULL);
648     JMP(regs);
649     assert(0);
650 }
651 
652 /************************* Test *************************/
653 /**
654  * Note: The implementation is really bugy, right now only support compute in thread.
655  * Even standard I/O in the thread will cause I/O bus error or segmentation error because
656  * all pthread-reentrant function is not guaranteed in our thread model.
657  * (pthread_mutex_t cannot block thread in our model cause we modify eip directly)
658  */
659 void *sum1tod(void *d)
660 {
661     int i, k, j=0;
662 
663     for (i = 0; i <= (int)d; ++i)
664     {
665             /* code */
666             j+=i;      
667     }
668     return ((void *)j);
669 }
670 
671 int main(int argc, char const *argv[])
672 {
673     int res = 0;
674     int i;
675     init();
676     Thread_t *tid1, *tid2;
677     int *res1, *res2;
678     threadCreat(&tid1, sum1tod, 100);
679     threadCreat(&tid2, sum1tod, 100);
680     for (i = 0; i <= 100; ++i){
681         res+=i;
682     }
683 
684     threadJoin(tid1, &res1);
685     threadJoin(tid2, &res2);
686     printf("parallel compute: %d = 5050 * 3\n", (int)res1+(int)res2+(int)res);
687     return 0;
688 }