Helper to spawn kernel tasks (ktasks)
[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 #ifndef ROS_KERN_KTHREAD_H
10 #define ROS_KERN_KTHREAD_H
11
12 #include <ros/common.h>
13 #include <trap.h>
14 #include <sys/queue.h>
15 #include <atomic.h>
16
17 struct proc;
18 struct kthread;
19 struct semaphore;
20 struct semaphore_entry;
21 TAILQ_HEAD(kthread_tailq, kthread);
22 LIST_HEAD(semaphore_list, semaphore_entry);
23
24
25 /* This captures the essence of a kernel context that we want to suspend.  When
26  * a kthread is running, we make sure its stacktop is the default kernel stack,
27  * meaning it will receive the interrupts from userspace. */
28 struct kthread {
29         struct kernel_ctx                       context;
30         uintptr_t                                       stacktop;
31         struct proc                                     *proc;
32         struct syscall                          *sysc;
33         void                                            *errbuf;        /* TODO: avoiding include loops */
34         TAILQ_ENTRY(kthread)            link;
35         /* ID, other shit, etc */
36         bool                                            is_ktask;       /* default is FALSE */
37         char                                            *name;
38 };
39
40 /* Semaphore for kthreads to sleep on.  0 or less means you need to sleep */
41 struct semaphore {
42         struct kthread_tailq            waiters;
43         int                                             nr_signals;
44         spinlock_t                                      lock;
45         bool                                            irq_okay;
46 };
47
48 struct cond_var {
49         struct semaphore                        sem;
50         spinlock_t                                      *lock;          /* usually points to internal_ */
51         spinlock_t                                      internal_lock;
52         unsigned long                           nr_waiters;
53         bool                                            irq_okay;
54 };
55
56 /* TODO: consider building this into struct semaphore */
57 struct semaphore_entry {
58         struct semaphore sem;
59         int fd;
60         LIST_ENTRY(semaphore_entry) link;
61 };
62
63 uintptr_t get_kstack(void);
64 void put_kstack(uintptr_t stacktop);
65 uintptr_t *kstack_bottom_addr(uintptr_t stacktop);
66 void kthread_init(void);
67 struct kthread *__kthread_zalloc(void);
68 void restart_kthread(struct kthread *kthread);
69 void kthread_runnable(struct kthread *kthread);
70 void kthread_yield(void);
71 void ktask(char *name, void (*fn)(void*), void *arg);
72 /* Debugging */
73 void check_poison(char *msg);
74
75 void sem_init(struct semaphore *sem, int signals);
76 void sem_init_irqsave(struct semaphore *sem, int signals);
77 void sem_down(struct semaphore *sem);
78 bool sem_up(struct semaphore *sem);
79 void sem_down_irqsave(struct semaphore *sem, int8_t *irq_state);
80 bool sem_up_irqsave(struct semaphore *sem, int8_t *irq_state);
81
82 void cv_init(struct cond_var *cv);
83 void cv_init_irqsave(struct cond_var *cv);
84 void cv_init_with_lock(struct cond_var *cv, spinlock_t *lock);
85 void cv_init_irqsave_with_lock(struct cond_var *cv, spinlock_t *lock);
86 void cv_lock(struct cond_var *cv);
87 void cv_unlock(struct cond_var *cv);
88 void cv_lock_irqsave(struct cond_var *cv, int8_t *irq_state);
89 void cv_unlock_irqsave(struct cond_var *cv, int8_t *irq_state);
90 void cv_wait_and_unlock(struct cond_var *cv);   /* does not mess with irqs */
91 void cv_wait(struct cond_var *cv);
92 void __cv_signal(struct cond_var *cv);
93 void __cv_broadcast(struct cond_var *cv);
94 void cv_signal(struct cond_var *cv);
95 void cv_broadcast(struct cond_var *cv);
96 void cv_signal_irqsave(struct cond_var *cv, int8_t *irq_state);
97 void cv_broadcast_irqsave(struct cond_var *cv, int8_t *irq_state);
98
99 #endif /* ROS_KERN_KTHREAD_H */