02433b6f0e8291f838cf5129c2181cbee3a3e081
[openafs.git] / src / lwp / lwp_nt.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /* For NT, LWP is implemented on top of fibers. The design attempts to
11  * follow the current LWP implementation so that we are not using 2 LWP
12  * models. The parts of the Unix LWP model that are not actually used in
13  * AFS have not been implemented at all. With the exception of preemption,
14  * adding those parts to this NT base would be a matter of adding routines.
15  *
16  * required lib is kernel32.lib, header is winbase.h
17  */
18
19 #include <afs/param.h>
20 #ifdef AFS_NT40_ENV
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <afs/afsutil.h>
24 #include "lwp.h"
25
26
27 static struct lwp_ctl *lwp_init;
28 #define LWPANCHOR (*lwp_init)
29
30 PROCESS lwp_cpptr;
31
32 char lwp_debug = 0;
33
34 #define  READY          2
35 #define  WAITING                3
36 #define  DESTROYED      4
37 #define QWAITING                5
38
39 /* Debugging macro */
40 #ifdef DEBUG
41 #define Debug(level, msg)\
42          if (lwp_debug && lwp_debug >= level) {\
43              printf("***LWP (0x%x): ", lwp_cpptr);\
44              printf msg;\
45              putchar('\n');\
46          }
47
48 #else
49 #define Debug(level, msg)
50 #endif
51
52
53 /* Forward declarations */
54 static void Dispatcher(void);
55 static void Exit_LWP(void);
56 static void Abort_LWP(char *msg);
57 static VOID WINAPI Enter_LWP(PVOID fiberData);
58 static void Initialize_PCB(PROCESS pcb, int priority, int stacksize,
59                            int (*funP)(), void *argP, char *name);
60
61 static void Dispose_of_Dead_PCB();
62 static void Free_PCB();
63 static int Internal_Signal();
64 static void purge_dead_pcbs(void);
65
66 static void lwp_remove(PROCESS p, struct QUEUE *q);
67 static void insert(PROCESS p, struct QUEUE *q);
68 static void move(PROCESS p, struct QUEUE *from, struct QUEUE *to);
69
70 /* biggest LWP stack created so far - used by IOMGR */
71 int lwp_MaxStackSeen = 0;
72
73 #ifdef DEBUG
74 static void Dump_One_Process(PROCESS pid);
75 static void Dump_Processes(void);
76 #endif
77
78 int lwp_nextindex;
79
80 #define MAX_PRIORITIES  (LWP_MAX_PRIORITY+1)
81
82 /* Invariant for runnable queues: The head of each queue points to the
83  * currently running process if it is in that queue, or it points to the
84  * next process in that queue that should run.
85  */
86 struct QUEUE {
87     PROCESS     head;
88     int         count;
89 } runnable[MAX_PRIORITIES], blocked;
90
91 /* Iterator macro */
92 #define for_all_elts(var, q, body)\
93         {\
94             register PROCESS var, _NEXT_;\
95             register int _I_;\
96             for (_I_=q.count, var = q.head; _I_>0; _I_--, var=_NEXT_) {\
97                 _NEXT_ = var -> next;\
98                 body\
99             }\
100         }
101
102
103 int lwp_MinStackSize = 0;
104 /* LWP_InitializeProcessSupport - setup base support for fibers.
105  *
106  * Arguments:
107  *      priority - priority of main thread.
108  *
109  * Returns:
110  *      pid - return this process
111  *      value:
112  *      LWP_SUCCESS (else aborts)
113  *      
114  */
115 int LWP_InitializeProcessSupport(int priority, PROCESS *pid)
116 {
117     PROCESS pcb;
118     register int i;
119     char* value;
120
121     Debug(0, ("Entered LWP_InitializeProcessSupport"))
122     if (lwp_init != NULL) return LWP_SUCCESS;
123
124     if (priority >= MAX_PRIORITIES) return LWP_EBADPRI;
125
126     pcb = (PROCESS)malloc(sizeof(*pcb));
127     if (pcb == NULL)
128         Abort_LWP("Insufficient Storage to Initialize LWP PCB");
129     (void) memset((void*)pcb, 0, sizeof(*pcb));
130     pcb->fiber = ConvertThreadToFiber(pcb);
131     if (pcb == NULL) 
132         Abort_LWP("Cannot convert main thread to LWP fiber");
133
134     lwp_init = (struct lwp_ctl *) malloc(sizeof(struct lwp_ctl));
135     if (lwp_init == NULL)
136         Abort_LWP("Insufficient Storage to Initialize LWP CTL");
137     (void) memset((void*)lwp_init, 0, sizeof(struct lwp_ctl));
138
139     for (i=0; i<MAX_PRIORITIES; i++) {
140         runnable[i].head = NULL;
141         runnable[i].count = 0;
142     }
143     blocked.head = NULL;
144     blocked.count = 0;
145
146     LWPANCHOR.processcnt = 1;
147     LWPANCHOR.outerpid = pcb;
148     LWPANCHOR.outersp = NULL;
149
150
151     Initialize_PCB(pcb, priority, 0, NULL, NULL,
152                 "Main Process [created by LWP]");   
153
154     lwp_cpptr = pcb;
155     Debug(10, ("Init: Insert 0x%x into runnable at priority %d\n", pcb, priority))
156     insert(pcb, &runnable[priority]);
157
158     if ( ( value = getenv("AFS_LWP_STACK_SIZE")) == NULL )
159         lwp_MinStackSize = AFS_LWP_MINSTACKSIZE;        
160     else
161         lwp_MinStackSize = (AFS_LWP_MINSTACKSIZE>atoi(value)?
162                                 AFS_LWP_MINSTACKSIZE : atoi(value));
163    
164     *pid = pcb;
165
166     return LWP_SUCCESS;
167 }
168
169 /* LWP_CreateProcess - create a new fiber and start executing it.
170  *
171  * Arguments:
172  *      funP - start function
173  *      stacksize - size of 
174  *      priority - LWP priority
175  *      argP - initial parameter for start function
176  *      name - name of LWP
177  *
178  * Return:
179  *      pid - handle of created LWP
180  *      value:
181  *      0 - success
182  *      LWP_EINIT - error in intialization.
183  *
184  */
185 int LWP_CreateProcess(int (*funP)(), int stacksize, int priority, void *argP,
186                       char *name, PROCESS *pid)
187 {
188     PROCESS pcb;
189     
190     purge_dead_pcbs();
191
192     pcb = (PROCESS)malloc(sizeof(*pcb));
193     if (pcb == NULL)
194         return LWP_ENOMEM;
195     (void) memset((void*)pcb, 0, sizeof(*pcb));
196
197     /*
198      * on some systems (e.g. hpux), a minimum usable stack size has
199      * been discovered
200      */
201     if (stacksize < lwp_MinStackSize) {
202       stacksize = lwp_MinStackSize;
203     }
204     /* more stack size computations; keep track of for IOMGR */
205     if (lwp_MaxStackSeen < stacksize)
206         lwp_MaxStackSeen = stacksize;
207
208     pcb->fiber = CreateFiber(stacksize, Enter_LWP, pcb);
209     if (pcb->fiber == NULL) {
210         free((void*)pcb);
211         return LWP_EINIT;
212     }
213     Debug(0, ("Create: pcb=0x%x, funP=0x%x, argP=0x%x\n", pcb, funP, argP))
214     /* Fiber is now created, so fill in PCB */
215     Initialize_PCB(pcb, priority, stacksize, funP, argP, name);
216     Debug(10, ("Create: Insert 0x%x into runnable at priority %d\n", pcb, priority))
217     insert(pcb, &runnable[priority]);
218
219     LWPANCHOR.processcnt++;
220
221     /* And hand off execution. */
222     SwitchToFiber(pcb->fiber);
223
224     *pid = pcb;
225
226     return LWP_SUCCESS;
227 }
228
229 int LWP_DestroyProcess(PROCESS pid)
230 {
231     Debug(0, ("Entered Destroy_Process"))
232     if (!lwp_init)
233         return LWP_EINIT;
234
235     
236     if (lwp_cpptr != pid) {
237         Dispose_of_Dead_PCB(pid);
238     } else {
239         pid->status = DESTROYED;
240         move(pid, &runnable[pid->priority], &blocked);
241     }
242
243     Dispatcher();
244
245     return LWP_SUCCESS;
246 }
247
248 int LWP_QWait(void)
249 {
250     PROCESS tp;
251     (tp=lwp_cpptr) -> status = QWAITING;
252     lwp_remove(tp, &runnable[tp->priority]);
253     Dispatcher();
254     return LWP_SUCCESS;
255 }
256
257 int LWP_QSignal(PROCESS pid)
258 {
259     if (pid->status == QWAITING) {
260         pid->status = READY;
261         Debug(10, ("QSignal: Insert 0x%x into runnable at priority %d\n", pid, pid->priority))
262         insert(pid, &runnable[pid->priority]);
263         return LWP_SUCCESS;
264     }
265     else return LWP_ENOWAIT;
266 }
267
268 int LWP_CurrentProcess(PROCESS *pid)
269 {
270     Debug(0, ("Entered Current_Process"))
271     if (lwp_init) {
272             *pid = lwp_cpptr;
273             return LWP_SUCCESS;
274     } else
275         return LWP_EINIT;
276 }
277
278 int LWP_DispatchProcess(void)           /* explicit voluntary preemption */
279 {
280     Debug(2, ("Entered Dispatch_Process"))
281     if (lwp_init) {
282         Dispatcher();
283         return LWP_SUCCESS;
284     } else
285         return LWP_EINIT;
286 }
287
288
289 #ifdef DEBUG
290 static void Dump_Processes(void)
291 {
292     if (lwp_init) {
293         register int i;
294         for (i=0; i<MAX_PRIORITIES; i++)
295             for_all_elts(x, runnable[i], {
296                 printf("[Priority %d]\n", i);
297                 Dump_One_Process(x);
298             })
299         for_all_elts(x, blocked, { Dump_One_Process(x); })
300     } else
301         printf("***LWP: LWP support not initialized\n");
302 }
303 #endif
304
305
306 int LWP_GetProcessPriority(pid, priority)       /* returns process priority */
307     PROCESS pid;
308     int *priority;
309 {
310     Debug(0, ("Entered Get_Process_Priority"))
311     if (lwp_init) {
312         *priority = pid->priority;
313         return 0;
314     } else
315         return LWP_EINIT;
316 }
317
318 static int Internal_Signal(char *event)
319 {
320     int rc = LWP_ENOWAIT;
321     int i;
322
323     Debug(0, ("Entered Internal_Signal [event id 0x%x]", event))
324     if (!lwp_init) return LWP_EINIT;
325     if (event == NULL) return LWP_EBADEVENT;
326     for_all_elts(temp, blocked, {
327         if (temp->status == WAITING)
328             for (i=0; i < temp->eventcnt; i++) {
329                 if (temp -> eventlist[i] == event) {
330                     temp -> eventlist[i] = NULL;
331                     rc = LWP_SUCCESS;
332                     Debug(0, ("Signal satisfied for PCB 0x%x", temp))
333                     if (--temp->waitcnt == 0) {
334                         temp -> status = READY;
335                         temp -> wakevent = i+1;
336                         move(temp, &blocked, &runnable[temp->priority]);
337                         break;
338                     }
339                 }
340             }
341     })
342     return rc;
343 }
344
345 /* signal the occurence of an event */
346 int LWP_INTERNALSIGNAL(void *event, int yield)
347 {
348     Debug(2, ("Entered LWP_SignalProcess"))
349     if (lwp_init) {
350         int rc;
351         rc = Internal_Signal(event);
352         if (yield)
353             Dispatcher();
354         return rc;
355     } else
356         return LWP_EINIT;
357 }
358
359 int LWP_TerminateProcessSupport()       /* terminate all LWP support */
360 {
361     register int i;
362
363     Debug(0, ("Entered Terminate_Process_Support"))
364     if (lwp_init == NULL) return LWP_EINIT;
365     if (lwp_cpptr != LWPANCHOR.outerpid)
366         Abort_LWP("Terminate_Process_Support invoked from wrong process!");
367     /* Is this safe??? @@@ */
368     for (i=0; i<MAX_PRIORITIES; i++)
369         for_all_elts(cur, runnable[i], { Free_PCB(cur); })
370     for_all_elts(cur, blocked, { Free_PCB(cur); })
371     free(lwp_init);
372     lwp_init = NULL;
373     return LWP_SUCCESS;
374 }
375
376 int LWP_MwaitProcess(int wcount, void **evlist)
377 {
378     int ecount, i;
379
380     Debug(0, ("Entered Mwait_Process [waitcnt = %d]", wcount))
381     if (evlist == NULL) {
382         Dispatcher();
383         return LWP_EBADCOUNT;
384     }
385
386     for (ecount = 0; evlist[ecount] != NULL; ecount++) ;
387
388     if (ecount == 0) {
389         Dispatcher();
390         return LWP_EBADCOUNT;
391     }
392
393     if (!lwp_init)
394         return LWP_EINIT;
395
396     if (wcount>ecount || wcount<0) {
397         Dispatcher();
398         return LWP_EBADCOUNT;
399     }
400     if (ecount > lwp_cpptr->eventlistsize) {
401
402         void **save_eventlist = lwp_cpptr->eventlist;
403         lwp_cpptr->eventlist = (char **)realloc(lwp_cpptr->eventlist,
404                                                 ecount*sizeof(char *));
405         if (lwp_cpptr->eventlist == NULL) {
406             lwp_cpptr->eventlist = save_eventlist;
407             Dispatcher();
408             return LWP_ENOMEM;
409         }
410         lwp_cpptr->eventlistsize = ecount;
411     }
412     for (i=0; i<ecount; i++) lwp_cpptr -> eventlist[i] = evlist[i];
413     if (wcount > 0) {
414         lwp_cpptr->status = WAITING;
415
416         move(lwp_cpptr, &runnable[lwp_cpptr->priority], &blocked);
417
418     }
419     lwp_cpptr->wakevent = 0;
420     lwp_cpptr->waitcnt = wcount;
421     lwp_cpptr->eventcnt = ecount;
422
423     Dispatcher();
424
425     return LWP_SUCCESS;
426 }
427
428 int LWP_WaitProcess(void *event)                /* wait on a single event */
429 {
430     void *tempev[2];
431
432     Debug(2, ("Entered Wait_Process"))
433     if (event == NULL) return LWP_EBADEVENT;
434     tempev[0] = event;
435     tempev[1] = NULL;
436     return LWP_MwaitProcess(1, tempev);
437 }
438
439
440 /* Internal Support Routines */
441 static void Initialize_PCB(PROCESS pcb, int priority, int stacksize,
442                            int (*funP)(), void *argP, char *name)
443 {
444     int i = 0;
445
446     Debug(4, ("Entered Initialize_PCB"))
447     if (name != NULL)
448         while (((pcb->name[i] = name[i]) != '\0') && (i < 31)) i++;
449     pcb->name[31] = '\0';
450     pcb->priority = priority;
451     pcb->stacksize = stacksize;
452     pcb->funP = funP;
453     pcb->argP = argP;
454     pcb->status = READY;
455     pcb->eventlist = (void**)malloc(EVINITSIZE*sizeof(void*));
456     pcb->eventlistsize =  pcb->eventlist ? EVINITSIZE : 0;
457     pcb->eventcnt = 0;
458     pcb->wakevent = 0;
459     pcb->waitcnt = 0;
460     pcb->next = pcb->prev = (PROCESS)NULL;
461     pcb->iomgrRequest = (struct IoRequest*)NULL;
462     pcb->index = lwp_nextindex ++;
463 }
464
465
466 VOID WINAPI Enter_LWP(PVOID fiberData)
467 {
468     PROCESS pcb = (PROCESS)fiberData;
469
470 /* next lines are new..... */
471     lwp_cpptr = pcb;
472
473     Debug(2, ("Enter_LWP: pcb=0x%x, funP=0x%x, argP=0x%x\n", pcb, pcb->funP, pcb->argP))
474
475     (*pcb->funP)(pcb->argP);
476
477     LWP_DestroyProcess(pcb);
478     Dispatcher();
479 }
480
481 static void Abort_LWP(char *msg)
482 {
483     Debug(0, ("Entered Abort_LWP"))
484     printf("***LWP: %s\n",msg);
485 #ifdef DEBUG
486     printf("***LWP: Abort --- dumping PCBs ...\n");
487     Dump_Processes();
488 #endif
489     Exit_LWP();
490 }
491
492 #ifdef DEBUG
493 static void Dump_One_Process(PROCESS pid)
494 {
495     int i;
496
497     printf("***LWP: Process Control Block at 0x%x\n", pid);
498     printf("***LWP: Name: %s\n", pid->name);
499     if (pid->funP != NULL)
500         printf("***LWP: Initial entry point: 0x%x\n", pid->funP);
501     switch (pid->status) {
502         case READY:     printf("READY");     break;
503         case WAITING:   printf("WAITING");   break;
504         case DESTROYED: printf("DESTROYED"); break;
505         default:        printf("unknown");
506     }
507     putchar('\n');
508     printf("***LWP: Priority: %d \tInitial parameter: 0x%x\n",
509             pid->priority, pid->argP);
510     if (pid->stacksize != 0) {
511         printf("***LWP:  Stacksize: %d\n", pid->stacksize);
512     }
513     if (pid->eventcnt > 0) {
514         printf("***LWP: Number of events outstanding: %d\n", pid->waitcnt);
515         printf("***LWP: Event id list:");
516         for (i=0;i<pid->eventcnt;i++)
517             printf(" 0x%x", pid->eventlist[i]);
518         putchar('\n');
519     }
520     if (pid->wakevent>0)
521         printf("***LWP: Number of last wakeup event: %d\n", pid->wakevent);
522 }
523 #endif
524
525
526 static void purge_dead_pcbs(void)
527 {
528     for_all_elts(cur, blocked, { if (cur->status == DESTROYED) Dispose_of_Dead_PCB(cur); })
529 }
530
531 int LWP_TraceProcesses = 0;
532
533 static void Dispatcher(void)
534 {
535     register int i;
536 #ifdef DEBUG
537     static int dispatch_count = 0;
538
539     if (LWP_TraceProcesses > 0) {
540         for (i=0; i<MAX_PRIORITIES; i++) {
541             printf("[Priority %d, runnable (%d):", i, runnable[i].count);
542             for_all_elts(p, runnable[i], {
543                 printf(" \"%s\"", p->name);
544             })
545             puts("]");
546         }
547         printf("[Blocked (%d):", blocked.count);
548         for_all_elts(p, blocked, {
549             printf(" \"%s\"", p->name);
550         })
551         puts("]");
552     }
553 #endif
554     /* Move head of current runnable queue forward if current LWP is still
555      *in it.
556      */
557     if (lwp_cpptr != NULL && lwp_cpptr == runnable[lwp_cpptr->priority].head)
558         runnable[lwp_cpptr->priority].head =
559             runnable[lwp_cpptr->priority].head -> next;
560     /* Find highest priority with runnable processes. */
561     for (i=MAX_PRIORITIES-1; i>=0; i--)
562         if (runnable[i].head != NULL) break;
563
564     if (i < 0) Abort_LWP("No READY processes");
565
566 #ifdef DEBUG
567     if (LWP_TraceProcesses > 0)
568         printf("Dispatch %d [PCB at 0x%x] \"%s\"\n", ++dispatch_count,
569                runnable[i].head, runnable[i].head->name);
570 #endif
571
572     lwp_cpptr = runnable[i].head;
573     SwitchToFiber(lwp_cpptr->fiber);
574 }
575
576 void lwp_abort(void)
577 {
578     afs_NTAbort();
579 }
580
581 static void Exit_LWP(void)
582 {
583
584     lwp_abort();
585 }
586
587 static void Delete_PCB(PROCESS pid)
588 {
589     Debug(4, ("Entered Delete_PCB"))
590     lwp_remove(pid, (pid->status==WAITING || pid->status==DESTROYED
591                      ? &blocked
592                      : &runnable[pid->priority]));
593     LWPANCHOR.processcnt--;
594 }
595
596 static void Free_PCB(PROCESS pid)
597 {
598     Debug(4, ("Entered Free_PCB"))
599     if (pid->fiber != NULL) {
600         DeleteFiber(pid->fiber);
601     }
602     if (pid->eventlist != NULL)  free((void*)pid->eventlist);
603     free((void*)pid);
604 }
605
606 static void Dispose_of_Dead_PCB(PROCESS cur)
607 {
608     Debug(4, ("Entered Dispose_of_Dead_PCB"))
609     Delete_PCB(cur);
610     Free_PCB(cur);
611 }
612
613 /* Queue manipulation. */
614 static void lwp_remove(PROCESS p, struct QUEUE *q)
615 {
616     /* Special test for only element on queue */
617     if (q->count == 1)
618         q -> head = NULL;
619     else {
620         /* Not only element, do normal remove */
621         p -> next -> prev = p -> prev;
622         p -> prev -> next = p -> next;
623     }
624     /* See if head pointing to this element */
625     if (q->head == p) q -> head = p -> next;
626     q->count--;
627     p -> next = p -> prev = NULL;
628 }
629
630 static void insert(PROCESS p, struct QUEUE *q)
631 {
632     if (q->head == NULL) {      /* Queue is empty */
633         q -> head = p;
634         p -> next = p -> prev = p;
635     } else {                    /* Regular insert */
636         p -> prev = q -> head -> prev;
637         q -> head -> prev -> next = p;
638         q -> head -> prev = p;
639         p -> next = q -> head;
640     }
641     q->count++;
642 }
643
644 static void move(PROCESS p, struct QUEUE *from, struct QUEUE *to)
645 {
646     lwp_remove(p, from);
647     insert(p, to);
648 }
649 #endif /* AFS_NT40_ENV */