Move some files so the vanilla kernel builds again.
[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 //}