__core_request no longer locks and calls proc code
[akaros.git] / kern / include / schedule.h
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 #ifndef ROS_KERN_SCHEDULE_H
10 #define ROS_KERN_SCHEDULE_H
11
12 #include <ros/common.h>
13 #include <sys/queue.h>
14
15 struct proc;    /* process.h includes us, but we need pointers now */
16 TAILQ_HEAD(proc_list, proc);            /* Declares 'struct proc_list' */
17
18 /* The ksched maintains an internal array of these: the global pcore map.  Note
19  * the prov_proc and alloc_proc are weak (internal) references, and should only
20  * be used as a ref source while the ksched has a valid kref. */
21 struct sched_pcore {
22         TAILQ_ENTRY(sched_pcore)        prov_next;                      /* on a proc's prov list */
23         TAILQ_ENTRY(sched_pcore)        alloc_next;                     /* on an alloc list (idle)*/
24         struct proc                                     *prov_proc;                     /* who this is prov to */
25         struct proc                                     *alloc_proc;            /* who this is alloc to */
26         unsigned int                            ignore_next_idle;       /* helps with lock order */
27 };
28 TAILQ_HEAD(sched_pcore_tailq, sched_pcore);
29
30 /* One of these embedded in every struct proc */
31 struct sched_proc_data {
32         TAILQ_ENTRY(proc)                       proc_link;                      /* tailq linkage */
33         struct proc_list                        *cur_list;                      /* which tailq we're on */
34         struct sched_pcore_tailq        prov_alloc_me;          /* prov cores alloced us */
35         struct sched_pcore_tailq        prov_not_alloc_me;      /* maybe alloc to others */
36         /* count of lists? */
37         /* other accounting info */
38 };
39
40 void schedule_init(void);
41
42 /************** Process management **************/
43 /* Tell the ksched about the process, which it will track cradle-to-grave */
44 void register_proc(struct proc *p);
45
46 /* Makes sure p is runnable.  Callers include event delivery, SCP yield, and new
47  * SCPs.  Will trigger the __sched_.cp_wakeup() callbacks. */
48 void proc_wakeup(struct proc *p);
49
50 /* The ksched starts the death process (lock ordering issue), which calls back
51  * to proc.c's __proc_destroy while holding the locks (or whatever) */
52 void proc_destroy(struct proc *p);
53
54 /* Changes the proc from an SCP to an MCP */
55 int proc_change_to_m(struct proc *p);
56
57 /************** Decision making **************/
58 /* Call the main scheduling algorithm.  Not clear yet if the main kernel will
59  * ever call this directly. */
60 void schedule(void);
61
62 /* Proc p's resource desires changed, or something in general that would lead to
63  * a new decision.  The process can directly poke the ksched via a syscall, so
64  * be careful of abuse. */
65 void poke_ksched(struct proc *p, int res_type);
66
67 /* Callbacks triggered from proc_wakeup() */
68 void __sched_mcp_wakeup(struct proc *p);
69 void __sched_scp_wakeup(struct proc *p);
70
71 /* The calling cpu/core has nothing to do and plans to idle/halt.  This is an
72  * opportunity to pick the nature of that halting (low power state, etc), or
73  * provide some other work (_Ss on LL cores). */
74 void cpu_bored(void);
75
76 /* Gets called when a pcore becomes idle (like in proc yield).  These are 'cg'
77  * cores, given to MCPs, that have been async returned to the ksched.  If the
78  * ksched preempts a core, this won't get called (unless it yielded first). */
79 void put_idle_core(struct proc *p, uint32_t coreid);
80 void put_idle_cores(struct proc *p, uint32_t *pc_arr, uint32_t num);
81
82 /* Available resources changed (plus or minus).  Some parts of the kernel may
83  * call this if a particular resource that is 'quantity-based' changes.  Things
84  * like available RAM to processes, bandwidth, etc.  Cores would probably be
85  * inappropriate, since we need to know which specific core is now free. */
86 void avail_res_changed(int res_type, long change);
87
88 /************** Proc's view of the world **************/
89 /* How many vcores p will think it can have */
90 uint32_t max_vcores(struct proc *p);
91
92 /************** Provisioning / Allocating *************/
93 /* This section is specific to a provisioning ksched.  Careful calling any of
94  * this from generic kernel code, since it might not be present in all kernel
95  * schedulers. */
96 void provision_core(struct proc *p, uint32_t pcoreid);
97
98 /************** Debugging **************/
99 void sched_diag(void);
100 void print_idlecoremap(void);
101 void print_resources(struct proc *p);
102 void print_all_resources(void);
103
104 #endif /* ROS_KERN_SCHEDULE_H */