Refactor to move alloc stuff to corealloc.c (4/7)
[akaros.git] / kern / include / corerequest.h
1 /* Copyright (c) 2009, 2012, 2015 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * Valmon Leymarie <leymariv@berkeley.edu>
4  * Kevin Klues <klueska@cs.berkeley.edu>
5  * See LICENSE for details.
6  */
7
8 #pragma once
9
10 /* The core request algorithm maintains an internal array of these: the
11  * global pcore map. Note the prov_proc and alloc_proc are weak (internal)
12  * references, and should only be used as a ref source while the ksched has a
13  * valid kref. */
14 struct sched_pcore {
15         TAILQ_ENTRY(sched_pcore)   prov_next;    /* on a proc's prov list */
16         TAILQ_ENTRY(sched_pcore)   alloc_next;   /* on an alloc list (idle)*/
17         struct proc                *prov_proc;   /* who this is prov to */
18         struct proc                *alloc_proc;  /* who this is alloc to */
19 };
20 TAILQ_HEAD(sched_pcore_tailq, sched_pcore);
21
22 struct core_request_data {
23         struct sched_pcore_tailq  prov_alloc_me;      /* prov cores alloced us */
24         struct sched_pcore_tailq  prov_not_alloc_me;  /* maybe alloc to others */
25 };
26
27 /* Initialize any data assocaited with doing core allocation. */
28 void corealloc_init(void);
29
30 /* Initialize any data associated with provisiong cores to a process. */
31 void coreprov_proc_init(struct proc *p);
32
33 /* Track the pcore properly when it is allocated to p. This code assumes that
34  * the scheduler that uses it holds a lock for the duration of the call. */
35 void __track_core_alloc(struct proc *p, uint32_t pcoreid);
36
37 /* Track the pcore properly when it is deallocated from p. This code assumes
38  * that the scheduler that uses it holds a lock for the duration of the call.
39  * */
40 void __track_core_dealloc(struct proc *p, uint32_t pcoreid);
41
42 /* Bulk interface for __track_core_dealloc */
43 void __track_core_dealloc_bulk(struct proc *p, uint32_t *pc_arr,
44                                uint32_t nr_cores);
45
46 /* Get/Put an idle core from our pcore list and return its core_id. Don't
47  * consider the chosen core in the future when handing out cores to a
48  * process. This code assumes that the scheduler that uses it holds a lock
49  * for the duration of the call. This will not give out provisioned cores.
50  * The gets return the coreid on success, -1 or -error on failure. */
51 int __get_any_idle_core(void);
52 int __get_specific_idle_core(int coreid);
53 void __put_idle_core(int coreid);
54
55 /* Provision a core to proc p. This code assumes that the scheduler that uses
56  * it holds a lock for the duration of the call. */
57 void __provision_core(struct proc *p, struct sched_pcore *spc);
58
59 /* Unprovision all cores from proc p. This code assumes that the scheduler
60  * that uses * it holds a lock for the duration of the call. */
61 void __unprovision_all_cores(struct proc *p);
62
63 /* Print a list of the cores currently provisioned to p. */
64 void print_proc_coreprov(struct proc *p);
65
66 /* Print the processes attached to each provisioned core. */
67 void print_coreprov_map(void);
68
69 static inline uint32_t spc2pcoreid(struct sched_pcore *spc)
70 {
71         extern struct sched_pcore *all_pcores;
72
73         return spc - all_pcores;
74 }
75
76 static inline struct sched_pcore *pcoreid2spc(uint32_t pcoreid)
77 {
78         extern struct sched_pcore *all_pcores;
79
80         return &all_pcores[pcoreid];
81 }
82
83 static inline struct proc *get_alloc_proc(struct sched_pcore *c)
84 {
85         return c->alloc_proc;
86 }
87
88 static inline struct proc *get_prov_proc(struct sched_pcore *c)
89 {
90         return c->prov_proc;
91 }