vmm: refactor userspace's emsr_fakewrite()
[akaros.git] / kern / include / kthread.h
1 /* Copyright (c) 2010-13 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Kernel threading.  These are for blocking within the kernel for whatever
6  * reason, usually during blocking IO operations.  Check out
7  * Documentation/kthreads.txt for more info than you care about. */
8
9 #pragma once
10
11 #include <ros/common.h>
12 #include <ros/syscall.h>
13 #include <trap.h>
14 #include <sys/queue.h>
15 #include <atomic.h>
16 #include <setjmp.h>
17
18 struct errbuf {
19         struct jmpbuf jmpbuf;
20 };
21
22 struct proc;
23 struct kthread;
24 struct kth_db_info;
25 TAILQ_HEAD(kthread_tailq, kthread);
26 TAILQ_HEAD(kth_db_tailq, kth_db_info);
27
28 #define GENBUF_SZ 128   /* plan9 uses this as a scratch space, per syscall */
29
30 #define KTH_IS_KTASK                    (1 << 0)
31 #define KTH_SAVE_ADDR_SPACE             (1 << 1)
32 #define KTH_IS_RCU_KTASK                (1 << 2)
33
34 /* These flag sets are for toggling between ktasks and default/process ktasks */
35 /* These are the flags for *any* ktask */
36 #define KTH_KTASK_FLAGS                 (KTH_IS_KTASK)
37 /* These are the flags used for normal process context */
38 #define KTH_DEFAULT_FLAGS               (KTH_SAVE_ADDR_SPACE)
39
40 /* This captures the essence of a kernel context that we want to suspend.  When
41  * a kthread is running, we make sure its stacktop is the default kernel stack,
42  * meaning it will receive the interrupts from userspace. */
43 struct kthread {
44         struct jmpbuf                   context;
45         uintptr_t                       stacktop;
46         struct proc                     *proc;
47         struct syscall                  *sysc;
48         struct errbuf                   *errbuf;
49         TAILQ_ENTRY(kthread)            link;
50         /* ID, other shit, etc */
51         int                             flags;
52         char                            *name;
53         char                            generic_buf[GENBUF_SZ];
54         int                             errno;
55         char                            errstr[MAX_ERRSTR_LEN];
56         struct systrace_record          *strace;
57 };
58
59 #define KTH_DB_SEM                      1
60 #define KTH_DB_CV                       2
61
62 #ifdef CONFIG_SEMAPHORE_DEBUG
63
64 struct kth_db_info {
65         TAILQ_ENTRY(kth_db_info)        link;
66         unsigned int                    type;
67         bool                            on_list;
68 };
69
70 #define KTH_DB_INIT .db         = { .type = KTH_DB_SEM },
71
72 #else
73
74 struct kth_db_info {
75 };
76
77 #define KTH_DB_INIT
78
79 #endif
80
81
82 /* Semaphore for kthreads to sleep on.  0 or less means you need to sleep */
83 struct semaphore {
84         struct kth_db_info              db;
85         struct kthread_tailq            waiters;
86         int                             nr_signals;
87         spinlock_t                      lock;
88 };
89
90 #define SEMAPHORE_INITIALIZER(name, n)                                         \
91 {                                                                              \
92     .waiters    = TAILQ_HEAD_INITIALIZER((name).waiters),                      \
93     .nr_signals = (n),                                                         \
94     .lock       = SPINLOCK_INITIALIZER,                                        \
95     KTH_DB_INIT                                                                \
96 }
97
98 #define SEMAPHORE_INITIALIZER_IRQSAVE(name, n)                                 \
99 {                                                                              \
100     .waiters    = TAILQ_HEAD_INITIALIZER((name).waiters),                      \
101     .nr_signals = (n),                                                         \
102     .lock       = SPINLOCK_INITIALIZER_IRQSAVE,                                \
103     KTH_DB_INIT                                                                \
104 }
105
106 struct cond_var {
107         struct kth_db_info              db;
108         struct kthread_tailq            waiters;
109         spinlock_t                      *lock;  /* usually points to internal */
110         spinlock_t                      internal_lock;
111         unsigned long                   nr_waiters;
112 };
113
114 struct cv_lookup_elm {
115         TAILQ_ENTRY(cv_lookup_elm)      link;
116         TAILQ_ENTRY(cv_lookup_elm)      abortall_link;
117         struct cond_var                 *cv;
118         struct kthread                  *kthread;
119         struct syscall                  *sysc;
120         struct proc                     *proc;
121         atomic_t                        abort_in_progress;      /* 0 = no */
122 };
123 TAILQ_HEAD(cv_lookup_tailq, cv_lookup_elm);
124
125 uintptr_t get_kstack(void);
126 void put_kstack(uintptr_t stacktop);
127 uintptr_t *kstack_bottom_addr(uintptr_t stacktop);
128 void kthread_init(void);
129 struct kthread *__kthread_zalloc(void);
130 void __use_real_kstack(void (*f)(void *arg));
131 void restart_kthread(struct kthread *kthread);
132 void kthread_runnable(struct kthread *kthread);
133 void kthread_yield(void);
134 void kthread_usleep(uint64_t usec);
135 void ktask(char *name, void (*fn)(void*), void *arg);
136
137 static inline bool is_ktask(struct kthread *kthread)
138 {
139         return kthread->flags & KTH_IS_KTASK;
140 }
141
142 static inline bool is_rcu_ktask(struct kthread *kthread)
143 {
144         return kthread->flags & KTH_IS_RCU_KTASK;
145 }
146
147 void sem_init(struct semaphore *sem, int signals);
148 void sem_init_irqsave(struct semaphore *sem, int signals);
149 bool sem_trydown_bulk(struct semaphore *sem, int nr_signals);
150 bool sem_trydown(struct semaphore *sem);
151 void sem_down_bulk(struct semaphore *sem, int nr_signals);
152 void sem_down(struct semaphore *sem);
153 bool sem_up(struct semaphore *sem);
154 bool sem_trydown_bulk_irqsave(struct semaphore *sem, int nr_signals);
155 bool sem_trydown_irqsave(struct semaphore *sem);
156 void sem_down_bulk_irqsave(struct semaphore *sem, int nr_signals);
157 void sem_down_irqsave(struct semaphore *sem);
158 bool sem_up_irqsave(struct semaphore *sem);
159 void print_db_blk_info(pid_t pid);
160
161 void cv_init(struct cond_var *cv);
162 void cv_init_irqsave(struct cond_var *cv);
163 void cv_init_with_lock(struct cond_var *cv, spinlock_t *lock);
164 void cv_init_irqsave_with_lock(struct cond_var *cv, spinlock_t *lock);
165 void cv_lock(struct cond_var *cv);
166 void cv_unlock(struct cond_var *cv);
167 void cv_lock_irqsave(struct cond_var *cv, int8_t *irq_state);
168 void cv_unlock_irqsave(struct cond_var *cv, int8_t *irq_state);
169 void cv_wait_and_unlock(struct cond_var *cv);   /* does not mess with irqs */
170 void cv_wait(struct cond_var *cv);
171 void __cv_signal(struct cond_var *cv);
172 void __cv_broadcast(struct cond_var *cv);
173 void cv_signal(struct cond_var *cv);
174 void cv_broadcast(struct cond_var *cv);
175 void cv_signal_irqsave(struct cond_var *cv, int8_t *irq_state);
176 void cv_broadcast_irqsave(struct cond_var *cv, int8_t *irq_state);
177
178 bool abort_sysc(struct proc *p, uintptr_t sysc);
179 void abort_all_sysc(struct proc *p);
180 int abort_all_sysc_fd(struct proc *p, int fd);
181 void __reg_abortable_cv(struct cv_lookup_elm *cle, struct cond_var *cv);
182 void dereg_abortable_cv(struct cv_lookup_elm *cle);
183 bool should_abort(struct cv_lookup_elm *cle);
184
185 uintptr_t switch_to_ktask(void);
186 void switch_back_from_ktask(uintptr_t old_ret);
187
188 /* qlocks are plan9's binary sempahore, which are wrappers around our sems.
189  * Not sure if they'll need irqsave or normal sems. */
190 typedef struct semaphore qlock_t;
191 #define qlock_init(x) sem_init((x), 1)
192 #define qlock(x) sem_down(x)
193 #define qunlock(x) sem_up(x)
194 #define canqlock(x) sem_trydown(x)
195 #define QLOCK_INITIALIZER(name) SEMAPHORE_INITIALIZER(name, 1)