Move to a queue-based system call tracing
[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 TAILQ_HEAD(kthread_tailq, kthread);
21 TAILQ_HEAD(semaphore_tailq, semaphore);
22
23 #define GENBUF_SZ 128   /* plan9 uses this as a scratch space, per syscall */
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         char                                            generic_buf[GENBUF_SZ];
39         struct systrace_record          *trace;
40 };
41
42 /* Semaphore for kthreads to sleep on.  0 or less means you need to sleep */
43 struct semaphore {
44         struct kthread_tailq            waiters;
45         int                                             nr_signals;
46         spinlock_t                                      lock;
47         bool                                            irq_okay;
48 #ifdef CONFIG_SEMAPHORE_DEBUG
49         TAILQ_ENTRY(semaphore)          link;
50         bool                                            is_on_list;     /* would like better sys/queue.h */
51         uintptr_t                                       bt_pc;          /* program counter of last down */
52         uintptr_t                                       bt_fp;          /* frame pointer of last down */
53         uint32_t                                        calling_core;
54 #endif
55 };
56
57 struct cond_var {
58         struct semaphore                        sem;
59         spinlock_t                                      *lock;          /* usually points to internal_ */
60         spinlock_t                                      internal_lock;
61         unsigned long                           nr_waiters;
62         bool                                            irq_okay;
63 };
64
65 struct cv_lookup_elm {
66         TAILQ_ENTRY(cv_lookup_elm)      link;
67         TAILQ_ENTRY(cv_lookup_elm)      abortall_link;          /* only used in abort_all */
68         struct cond_var                         *cv;
69         struct kthread                          *kthread;
70         struct syscall                          *sysc;
71         struct proc                                     *proc;
72         atomic_t                                        abort_in_progress;      /* 0 = no */
73 };
74 TAILQ_HEAD(cv_lookup_tailq, cv_lookup_elm);
75
76 uintptr_t get_kstack(void);
77 void put_kstack(uintptr_t stacktop);
78 uintptr_t *kstack_bottom_addr(uintptr_t stacktop);
79 void kthread_init(void);
80 struct kthread *__kthread_zalloc(void);
81 void restart_kthread(struct kthread *kthread);
82 void kthread_runnable(struct kthread *kthread);
83 void kthread_yield(void);
84 void ktask(char *name, void (*fn)(void*), void *arg);
85 /* Debugging */
86 void check_poison(char *msg);
87
88 void sem_init(struct semaphore *sem, int signals);
89 void sem_init_irqsave(struct semaphore *sem, int signals);
90 bool sem_trydown(struct semaphore *sem);
91 void sem_down(struct semaphore *sem);
92 bool sem_up(struct semaphore *sem);
93 bool sem_trydown_irqsave(struct semaphore *sem, int8_t *irq_state);
94 void sem_down_irqsave(struct semaphore *sem, int8_t *irq_state);
95 bool sem_up_irqsave(struct semaphore *sem, int8_t *irq_state);
96 void print_sem_info(struct semaphore *sem);
97 void print_all_sem_info(void);
98
99 void cv_init(struct cond_var *cv);
100 void cv_init_irqsave(struct cond_var *cv);
101 void cv_init_with_lock(struct cond_var *cv, spinlock_t *lock);
102 void cv_init_irqsave_with_lock(struct cond_var *cv, spinlock_t *lock);
103 void cv_lock(struct cond_var *cv);
104 void cv_unlock(struct cond_var *cv);
105 void cv_lock_irqsave(struct cond_var *cv, int8_t *irq_state);
106 void cv_unlock_irqsave(struct cond_var *cv, int8_t *irq_state);
107 void cv_wait_and_unlock(struct cond_var *cv);   /* does not mess with irqs */
108 void cv_wait(struct cond_var *cv);
109 void __cv_signal(struct cond_var *cv);
110 void __cv_broadcast(struct cond_var *cv);
111 void cv_signal(struct cond_var *cv);
112 void cv_broadcast(struct cond_var *cv);
113 void cv_signal_irqsave(struct cond_var *cv, int8_t *irq_state);
114 void cv_broadcast_irqsave(struct cond_var *cv, int8_t *irq_state);
115
116 bool abort_sysc(struct proc *p, struct syscall *sysc);
117 void abort_all_sysc(struct proc *p);
118 int abort_all_sysc_fd(struct proc *p, int fd);
119 void __reg_abortable_cv(struct cv_lookup_elm *cle, struct cond_var *cv);
120 void dereg_abortable_cv(struct cv_lookup_elm *cle);
121 bool should_abort(struct cv_lookup_elm *cle);
122
123 /* qlocks are plan9's binary sempahore, which are wrappers around our sems */
124 typedef struct semaphore qlock_t;
125 #define qlock_init(x) sem_init((x), 1)
126 #define qlock(x) sem_down(x)
127 #define qunlock(x) sem_up(x)
128 #define canqlock(x) sem_trydown(x)
129
130 #endif /* ROS_KERN_KTHREAD_H */