Proc data structure management, env gutting
[akaros.git] / kern / src / schedule.c
1 /*
2  * Copyright (c) 2009 The Regents of the University of California
3  * Barret Rhoden <brho@cs.berkeley.edu>
4  * See LICENSE for details.
5  *
6  * Scheduling and dispatching.
7  */
8
9 #ifdef __SHARC__
10 #pragma nosharc
11 #endif
12
13 #include <schedule.h>
14 #include <process.h>
15 #include <monitor.h>
16 #include <stdio.h>
17 #include <assert.h>
18 #include <atomic.h>
19 #include <sys/queue.h>
20
21 // This could be useful for making scheduling decisions.  
22 /* Physical coremap: each index is a physical core id, with a proc ptr for
23  * whoever *should be or is* running.  Very similar to current, which is what
24  * process is *really* running there. */
25 struct proc *pcoremap[MAX_NUM_CPUS];
26
27 void schedule_init(void)
28 {
29         TAILQ_INIT(&proc_runnablelist);
30         return;
31 }
32
33 void schedule_proc(struct proc *p)
34 {
35         spin_lock_irqsave(&runnablelist_lock);
36         printd("Scheduling PID: %d\n", p->pid);
37         TAILQ_INSERT_TAIL(&proc_runnablelist, p, proc_link);
38         spin_unlock_irqsave(&runnablelist_lock);
39         return;
40 }
41
42 /* TODO: race here.  it's possible that p was already removed from the
43  * list (by schedule()), while proc_destroy is trying to remove it from the
44  * list.  schedule()'s proc_run() won't actually run it (since it's DYING), but
45  * this code will probably fuck up. */
46 void deschedule_proc(struct proc *p)
47 {
48         spin_lock_irqsave(&runnablelist_lock);
49         printd("Descheduling PID: %d\n", p->pid);
50         TAILQ_REMOVE(&proc_runnablelist, p, proc_link);
51         spin_unlock_irqsave(&runnablelist_lock);
52         return;
53 }
54
55 /*
56  * FIFO - just pop the head from the list and run it.
57  * Using irqsave spinlocks for now, since this could be called from a timer
58  * interrupt handler (though ought to be in a bottom half or something).
59  */
60 void schedule(void)
61 {
62         struct proc *p;
63         
64         spin_lock_irqsave(&runnablelist_lock);
65         p = TAILQ_FIRST(&proc_runnablelist);
66         if (p) {
67                 TAILQ_REMOVE(&proc_runnablelist, p, proc_link);
68                 spin_unlock_irqsave(&runnablelist_lock);
69                 printd("PID of proc i'm running: %d\n", p->pid);
70                 proc_run(p);
71         } else {
72                 spin_unlock_irqsave(&runnablelist_lock);
73                 printk("No processes to schedule, enjoy the Monitor!\n");
74                 while (1)
75                         monitor(NULL);
76         }
77         return;
78 }
79
80 void dump_proclist(struct proc_list *list)
81 {
82         struct proc *p;
83         TAILQ_FOREACH(p, list, proc_link)
84                 printk("PID: %d\n", p->pid);
85         return;
86 }