Scheduler is now selectable in make menuconfig in kernel hacking.
[projects/modsched/linux.git] / kernel / sched / modsched / sched.h
1 #include <linux/sched.h>
2 #include <linux/sched/sysctl.h>
3 #include <linux/sched/rt.h>
4 #include <linux/spinlock.h>
5 #include <linux/stop_machine.h>
6
7 #include <linux/list.h>
8
9
10 struct task_group {
11 };
12
13
14 struct rq {
15         /* runqueue lock: */
16         raw_spinlock_t lock;
17
18         u64 nr_switches;
19         unsigned int nr_running;
20
21         struct list_head rq_list;
22
23         /*
24          * This is part of a global counter where only the total sum
25          * over all CPUs matters. A task can increase this counter on
26          * one CPU and if it got migrated afterwards it may decrease
27          * it on another CPU. Always updated under the runqueue lock:
28          */
29         unsigned long nr_uninterruptible;
30
31         struct task_struct *curr, *idle, *stop;
32
33         struct mm_struct *prev_mm;
34
35         u64 clock;
36         u64 clock_task;
37
38         atomic_t nr_iowait;
39
40         int skip_clock_update;
41
42 #ifdef CONFIG_SMP
43
44         /* cpu of this runqueue: */
45         int cpu;
46         int online;
47
48         struct llist_head wake_list;
49
50 #endif
51
52 };
53
54 static inline int cpu_of(struct rq *rq)
55 {
56 #ifdef CONFIG_SMP
57         return rq->cpu;
58 #else
59         return 0;
60 #endif
61 }
62
63 DECLARE_PER_CPU(struct rq, runqueues);
64
65 #define cpu_rq(cpu)             (&per_cpu(runqueues, (cpu)))
66 #define this_rq()               (&__get_cpu_var(runqueues))
67 #define task_rq(p)              cpu_rq(task_cpu(p))
68 #define cpu_curr(cpu)           (cpu_rq(cpu)->curr)
69 #define raw_rq()                (&__raw_get_cpu_var(runqueues))
70
71
72 #ifdef CONFIG_SMP
73
74 /*
75  * kernel/sched/sched.h:1105
76  * double_rq_lock - safely lock two runqueues
77  *
78  * Note this does not disable interrupts like task_rq_lock,
79  * you need to do so manually before calling.
80  */
81 static inline void double_rq_lock(struct rq *rq1, struct rq *rq2)
82         __acquires(rq1->lock)
83         __acquires(rq2->lock)
84 {
85         BUG_ON(!irqs_disabled());
86         if (rq1 == rq2) {
87                 raw_spin_lock(&rq1->lock);
88                 __acquire(rq2->lock);   /* Fake it out ;) */
89         } else {
90                 if (rq1 < rq2) {
91                         raw_spin_lock(&rq1->lock);
92                         raw_spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
93                 } else {
94                         raw_spin_lock(&rq2->lock);
95                         raw_spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
96                 }
97         }
98 }
99
100 /*
101  * kernel/sched/sched.h:1130
102  * double_rq_unlock - safely unlock two runqueues
103  *
104  * Note this does not restore interrupts like task_rq_unlock,
105  * you need to do so manually after calling.
106  */
107 static inline void double_rq_unlock(struct rq *rq1, struct rq *rq2)
108         __releases(rq1->lock)
109         __releases(rq2->lock)
110 {
111         raw_spin_unlock(&rq1->lock);
112         if (rq1 != rq2)
113                 raw_spin_unlock(&rq2->lock);
114         else
115                 __release(rq2->lock);
116 }
117
118 #endif
119
120 #ifndef prepare_arch_switch
121 # define prepare_arch_switch(next)      do { } while (0)
122 #endif
123 #ifndef finish_arch_switch
124 # define finish_arch_switch(prev)       do { } while (0)
125 #endif
126 #ifndef finish_arch_post_lock_switch
127 # define finish_arch_post_lock_switch() do { } while (0)
128 #endif
129
130 #ifndef __ARCH_WANT_UNLOCKED_CTXSW
131 static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
132 {
133 #ifdef CONFIG_SMP
134         /*
135          * We can optimise this out completely for !SMP, because the
136          * SMP rebalancing from interrupt is the only thing that cares
137          * here.
138          */
139         next->on_cpu = 1;
140 #endif
141 }
142
143 static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
144 {
145 #ifdef CONFIG_SMP
146         /*
147          * After ->on_cpu is cleared, the task can be moved to a different CPU.
148          * We must ensure this doesn't happen until the switch is completely
149          * finished.
150          */
151         smp_wmb();
152         prev->on_cpu = 0;
153 #endif
154 #ifdef CONFIG_DEBUG_SPINLOCK
155         /* this is a valid case when another task releases the spinlock */
156         rq->lock.owner = current;
157 #endif
158         /*
159          * If we are tracking spinlock dependencies then we have to
160          * fix up the runqueue lock - which gets 'carried over' from
161          * prev into current:
162          */
163         spin_acquire(&rq->lock.dep_map, 0, 0, _THIS_IP_);
164
165         raw_spin_unlock_irq(&rq->lock);
166 }
167
168 #else /* __ARCH_WANT_UNLOCKED_CTXSW */
169 static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
170 {
171 #ifdef CONFIG_SMP
172         /*
173          * We can optimise this out completely for !SMP, because the
174          * SMP rebalancing from interrupt is the only thing that cares
175          * here.
176          */
177         next->on_cpu = 1;
178 #endif
179         raw_spin_unlock(&rq->lock);
180 }
181
182 static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
183 {
184 #ifdef CONFIG_SMP
185         /*
186          * After ->on_cpu is cleared, the task can be moved to a different CPU.
187          * We must ensure this doesn't happen until the switch is completely
188          * finished.
189          */
190         smp_wmb();
191         prev->on_cpu = 0;
192 #endif
193         local_irq_enable();
194 }
195 #endif /* __ARCH_WANT_UNLOCKED_CTXSW */
196
197
198 void account_idle_ticks(unsigned long ticks);
199
200 void account_process_tick(struct task_struct *p, int user_tick);
201
202 void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
203
204 void calc_global_load(unsigned long ticks);
205
206 //void calc_load_enter_idle(void);
207
208 //void calc_load_exit_idle(void);
209
210 int can_nice(const struct task_struct *p, const int nice);
211
212 int idle_cpu(int cpu);
213
214 void __cpuinit init_idle(struct task_struct *idle, int cpu);
215
216 void __cpuinit init_idle_bootup_task(struct task_struct *idle);
217
218 void normalize_rt_tasks(void);
219
220 unsigned long nr_running(void);
221
222 unsigned long long nr_context_switches(void);
223
224 unsigned long nr_iowait(void);
225
226 void rt_mutex_setprio(struct task_struct *p, int prio);
227
228 u64 sched_clock_cpu(int cpu);
229
230 void sched_clock_init(void);;
231
232 void sched_fork(struct task_struct *p);
233
234 long sched_getaffinity(pid_t pid, struct cpumask *mask);
235
236 void sched_init(void);
237
238 void sched_init_smp(void);
239
240 int sched_rr_handler(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos);
241
242 long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
243
244 int sched_setscheduler(struct task_struct *p, int policy, const struct sched_param *param);
245
246 void sched_show_task(struct task_struct *p);
247
248 void schedule_tail(struct task_struct *prev);
249
250 void scheduler_tick(void);
251
252 //void sched_clock_init(void);
253
254 long sys_nice(int increment);
255
256 long sys_sched_getaffinity(pid_t pid, unsigned int len, unsigned long __user *user_mask_ptr);
257
258 long sys_sched_setaffinity(pid_t pid, unsigned int len, unsigned long __user *user_mask_ptr);
259
260 unsigned long long task_delta_exec(struct task_struct *);
261
262 int task_prio(const struct task_struct *p);
263
264 unsigned long long task_sched_runtime(struct task_struct *task);
265
266 unsigned long this_cpu_load(void);
267
268 void update_cpu_load_nohz(void);
269
270 void wake_up_new_task(struct task_struct *tsk);
271
272
273 int __sched _cond_resched(void);
274
275 asmlinkage void __sched schedule(void);
276
277 void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, void *key);
278
279 int wake_up_process(struct task_struct *p);
280
281 void __sched wait_for_completion(struct completion *x);
282
283 void complete(struct completion *x);
284
285 void __sched schedule_preempt_disabled(void);
286
287 int in_sched_functions(unsigned long addr);
288
289 void sched_clock_idle_sleep_event(void);
290
291 void sched_clock_idle_wakeup_event(u64 delta_ns);
292
293 int __cond_resched_lock(spinlock_t *lock);
294
295 u64 local_clock(void);
296
297 int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
298                           void *key);
299
300 int __sched wait_for_completion_killable(struct completion *x);
301
302 void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
303                         int nr_exclusive, void *key);
304
305 int wake_up_state(struct task_struct *p, unsigned int state);
306
307 void __sched yield(void);
308
309 inline int task_curr(const struct task_struct *p);
310
311 int task_nice(const struct task_struct *p);
312
313 void set_user_nice(struct task_struct *p, long nice);
314
315 void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key);
316
317 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive);
318
319 void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr);
320
321 static inline int task_current(struct rq *rq, struct task_struct *p)
322 {
323         return rq->curr == p;
324 }
325
326 static inline int task_running(struct rq *rq, struct task_struct *p)
327 {
328 #ifdef CONFIG_SMP
329         return p->on_cpu;
330 #else
331         return task_current(rq, p);
332 #endif
333 }
334
335 static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
336 {
337 #ifdef CONFIG_SMP
338         /*
339          * After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
340          * successfuly executed on another CPU. We must ensure that updates of
341          * per-task data have been completed by this moment.
342          */
343         smp_wmb();
344         task_thread_info(p)->cpu = cpu;
345 #endif
346 }