context_switch invoked by framework
[projects/modsched/linux.git] / kernel / sched.new / core.c
1 /*
2  *  kernel/sched/core.c
3  *
4  *  Kernel scheduler and related syscalls
5  *
6  *  Copyright (C) 1991-2002  Linus Torvalds
7  *
8  *
9  */
10
11 /**
12  * TODO:  2)        Input from register are not printed on the screen although corresponding
13  *                  interrupts are called. After the serial interrupt a thread (0xffff880007054cc0)
14  *                  is activated, which is probably responsible for the output. In our case that thread
15  *                  is already running, which should be not a problem. At the end a tty function (n_tty_write)
16  *                  must be called, which is not, in order to print the input.
17  *
18  *        3)        While boot up we encounter a kernel stack overflow, which seems to come randomly. Linux
19  *                  stack overflow checker gives us a warning but its to late to back trace.
20  *                  Maybe we should fix this one first in order to be sure that there are no side effects produced
21  *                  by this "error".
22  *
23  *        4)        We need to strip down clock.c since we use the default linux implementation.
24  */
25
26 #include <linux/init.h>
27 #include <asm/mmu_context.h>
28 #include <linux/completion.h>
29 #include <linux/kernel_stat.h>
30 #include <linux/blkdev.h>
31 #include <linux/syscalls.h>
32 #include <linux/kprobes.h>
33 #include <linux/delayacct.h>
34 #include <linux/export.h>
35 #include <linux/context_tracking.h>
36 #include <linux/kthread.h>
37 #include <linux/init_task.h>
38
39 #include <asm/switch_to.h>
40 #include <asm/tlb.h>
41 #include <linux/cgroup.h>
42 #include "sched.h"
43 #include "../workqueue_internal.h"
44 #include "../smpboot.h"
45
46 /*
47  * FRAMEWORK STUFF
48  */
49 //void init_modsched_framework(void* idletask);
50 void fw_init(void);
51 void *send_to_topic(int topic_id, void *ptr);
52
53 //
54 // Variables
55 //
56
57 /*
58  * kernel/sched/rt.c:10
59  * default timeslice is 100 msecs (used only for SCHED_RR tasks).
60  * Timeslices get refilled after they expire. RR_TIMESLICE is defined as
61  * (100 * HZ / 1000) and is assigned to sched_rr_timeslice.
62  */
63 int sched_rr_timeslice = RR_TIMESLICE;
64
65 /*
66  * kernel/sched/fair.c:80
67  * After fork, child runs first. If set to 0 (default) then
68  * parent will (try to) run first.
69  */
70 unsigned int sysctl_sched_child_runs_first = 0;
71
72 /*
73  * kernel/sched/core.c:289
74  * Period over which we measure -rt task cpu usage in us.
75  * default: 1s (1000000)
76  */
77 unsigned int sysctl_sched_rt_period = 1000000;
78
79 /*
80  * /kernel/sched/core.c:2081
81  * Variables and functions for calc_load
82  */
83 unsigned long avenrun[3];
84
85 /*
86  * kernel/sched/core.c:297
87  * part of the period that we allow rt tasks to run in us.
88  * default: 0.95s (950000)
89  */
90 int sysctl_sched_rt_runtime = 950000;
91
92 /*
93  * /kernel/sched/core.c:6866
94  *
95  */
96 struct task_group root_task_group;
97
98 /*
99  * /kernel/sched/core.c:6582
100  * Special case: If a kmalloc of a doms_cur partition (array of
101  * cpumask) fails, then fallback to a single sched domain,
102  * as determined by the single cpumask fallback_doms.
103  */
104 static cpumask_var_t fallback_doms;
105
106 /*
107  * /kernel/sched/core.c:5682
108  * cpus with isolated domains
109  */
110 static cpumask_var_t cpu_isolated_map;
111
112 /*
113  * /kernel/sched/core.c:5323
114  */
115 DEFINE_PER_CPU(int, sd_llc_id);
116
117 /*
118  * /kernel/sched/core.c:2623
119  * unknown
120  */
121 DEFINE_PER_CPU(struct kernel_stat, kstat);
122 DEFINE_PER_CPU(struct kernel_cpustat, kernel_cpustat);
123
124
125 /*
126  * /kernel/sched/core.c:291
127  */
128 __read_mostly int scheduler_running;
129
130 /*
131  * kernel/sched/core.c:113
132  */
133 DEFINE_MUTEX(sched_domains_mutex);
134 DEFINE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues);
135
136
137
138 /*
139  * __task_rq_lock - lock the rq @p resides on.
140  */
141 static inline struct rq *__task_rq_lock(struct task_struct *p)
142         __acquires(rq->lock)
143 {
144         struct rq *rq;
145
146         lockdep_assert_held(&p->pi_lock);
147
148         for (;;) {
149                 rq = task_rq(p);
150                 raw_spin_lock(&rq->lock);
151                 if (likely(rq == task_rq(p)))
152                         return rq;
153                 raw_spin_unlock(&rq->lock);
154         }
155 }
156
157
158
159 /*
160  * Lock/unlock task from runqueue
161  */
162
163 /*
164  * task_rq_lock - lock p->pi_lock and lock the rq @p resides on.
165  */
166 static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
167         __acquires(p->pi_lock)
168         __acquires(rq->lock)
169 {
170         struct rq *rq;
171
172         for (;;) {
173                 raw_spin_lock_irqsave(&p->pi_lock, *flags);
174                 rq = task_rq(p);
175                 raw_spin_lock(&rq->lock);
176                 if (likely(rq == task_rq(p)))
177                         return rq;
178                 raw_spin_unlock(&rq->lock);
179                 raw_spin_unlock_irqrestore(&p->pi_lock, *flags);
180         }
181 }
182
183 static void __task_rq_unlock(struct rq *rq)
184         __releases(rq->lock)
185 {
186         raw_spin_unlock(&rq->lock);
187 }
188
189 static inline void
190 task_rq_unlock(struct rq *rq, struct task_struct *p, unsigned long *flags)
191         __releases(rq->lock)
192         __releases(p->pi_lock)
193 {
194         raw_spin_unlock(&rq->lock);
195         raw_spin_unlock_irqrestore(&p->pi_lock, *flags);
196 }
197
198 ///*
199 // * this_rq_lock - lock this runqueue and disable interrupts.
200 // */
201 //static struct rq *this_rq_lock(void)
202 //      __acquires(rq->lock)
203 //{
204 //      struct rq *rq;
205 //
206 //      local_irq_disable();
207 //      rq = this_rq();
208 //      raw_spin_lock(&rq->lock);
209 //
210 //      return rq;
211 //}
212
213
214
215 /*
216  * Functions
217  */
218
219 /**
220  * kernel/sched/core.c:6872
221  * Initialize the scheduler
222  */
223 void sched_init(void)
224 {
225         int i;
226         unsigned long alloc_size = 0, ptr;
227
228 #ifdef CONFIG_CPUMASK_OFFSTACK
229         alloc_size += num_possible_cpus() * cpumask_size();
230 #endif
231         if (alloc_size) {
232                 ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);
233         }
234
235         // TODO: SMP
236 //#ifdef CONFIG_SMP
237 //      init_defrootdomain();
238 //#endif
239
240 //      init_rt_bandwidth(&def_rt_bandwidth,
241 //                      global_rt_period(), global_rt_runtime());
242
243         for_each_possible_cpu(i) {
244                 struct rq *rq;
245
246                 rq = cpu_rq(i);
247                 raw_spin_lock_init(&rq->lock);
248                 rq->nr_running = 0;
249                 INIT_LIST_HEAD(&rq->rq_list);
250
251 //              rq->calc_load_active = 0;
252 //              rq->calc_load_update = jiffies + LOAD_FREQ;
253
254 //              init_cfs_rq(&rq->cfs);
255 //              init_rt_rq(&rq->rt, rq);
256
257 //              rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
258
259 //              for (j = 0; j < CPU_LOAD_IDX_MAX; j++)
260 //                      rq->cpu_load[j] = 0;
261
262 //              rq->last_load_update_tick = jiffies;
263
264 #ifdef CONFIG_SMP
265 //              rq->sd = NULL;
266 //              rq->rd = NULL;
267 ////            rq->cpu_power = SCHED_POWER_SCALE;
268 //              rq->post_schedule = 0;
269 ////            rq->active_balance = 0;
270 ////            rq->next_balance = jiffies;
271 //              rq->push_cpu = 0;
272                 rq->cpu = i;
273                 rq->online = 0;
274 ////            rq->idle_stamp = 0;
275 ////            rq->avg_idle = 2*sysctl_sched_migration_cost;
276 //
277 //              INIT_LIST_HEAD(&rq->cfs_tasks);
278 //
279 //              rq_attach_root(rq, &def_root_domain);
280 //#ifdef CONFIG_NO_HZ
281 //              rq->nohz_flags = 0;
282 //#endif
283 #endif
284 //              init_rq_hrtick(rq);
285                 atomic_set(&rq->nr_iowait, 0);
286         }
287
288 //      set_load_weight(&init_task);
289
290         /*
291          * The boot idle thread does lazy MMU switching as well:
292          */
293         atomic_inc(&init_mm.mm_count);
294         enter_lazy_tlb(&init_mm, current);
295
296         /*
297          * Make us the idle thread. Technically, schedule() should not be
298          * called from this thread, however somewhere below it might be,
299          * but because we are the idle thread, we just pick up running again
300          * when this runqueue becomes "idle".
301          */
302         init_idle(current, smp_processor_id());
303
304 //      calc_load_update = jiffies + LOAD_FREQ;
305
306         /*
307          * During early bootup we pretend to be a normal task:
308          */
309 //      current->sched_class = &fair_sched_class;
310
311 #ifdef CONFIG_SMP
312         idle_thread_set_boot_cpu();
313 #endif
314 //      init_sched_fair_class();
315
316         fw_init();
317
318         scheduler_running = 1;
319 }
320
321 #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
322 static inline int preempt_count_equals(int preempt_offset)
323 {
324         int nested = (preempt_count() & ~PREEMPT_ACTIVE) + rcu_preempt_depth();
325
326         return (nested == preempt_offset);
327 }
328
329 void __might_sleep(const char *file, int line, int preempt_offset)
330 {
331         static unsigned long prev_jiffy;        /* ratelimiting */
332
333         rcu_sleep_check(); /* WARN_ON_ONCE() by default, no rate limit reqd. */
334         if ((preempt_count_equals(preempt_offset) && !irqs_disabled()) ||
335             system_state != SYSTEM_RUNNING || oops_in_progress)
336                 return;
337         if (time_before(jiffies, prev_jiffy + HZ) && prev_jiffy)
338                 return;
339         prev_jiffy = jiffies;
340
341         printk(KERN_ERR
342                 "BUG: sleeping function called from invalid context at %s:%d\n",
343                         file, line);
344         printk(KERN_ERR
345                 "in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
346                         in_atomic(), irqs_disabled(),
347                         current->pid, current->comm);
348
349         debug_show_held_locks(current);
350         if (irqs_disabled())
351                 print_irqtrace_events(current);
352         dump_stack();
353 }
354 EXPORT_SYMBOL(__might_sleep);
355 #endif
356
357 /*
358  * kernel/sched/core.c:1560
359  * Perform scheduler related setup for a newly forked process p.
360  * p is forked by current.
361  *
362  * __sched_fork() is basic setup used by init_idle() too:
363  */
364 static void __sched_fork(struct task_struct *p)
365 {
366         p->on_rq                                        = 0;
367
368         p->se.on_rq                                     = 0;
369         p->se.exec_start                        = 0;
370         p->se.sum_exec_runtime          = 0;
371         p->se.prev_sum_exec_runtime     = 0;
372         p->se.vruntime                          = 0;
373 }
374
375 /*
376  * kernel/sched/core.c:1622
377  * fork()/clone()-time setup:
378  */
379 void sched_fork(struct task_struct *p)
380 {
381 //      printk(">>sched_fork\n");
382         unsigned long flags;
383         int cpu = get_cpu();
384
385         __sched_fork(p);
386
387         /*
388          * We mark the process as running here. This guarantees that
389          * nobody will actually run it, and a signal or other external
390          * event cannot wake it up and insert it on the runqueue either.
391          */
392         p->state = TASK_RUNNING;
393
394         /*
395          * Make sure we do not leak PI boosting priority to the child.
396          */
397         p->prio = current->normal_prio;
398
399         raw_spin_lock_irqsave(&p->pi_lock, flags);
400         set_task_cpu(p, cpu);
401         raw_spin_unlock_irqrestore(&p->pi_lock, flags);
402
403 #if defined(CONFIG_SMP)
404         p->on_cpu = 0;
405 #endif
406 #ifdef CONFIG_PREEMPT_COUNT
407         /* Want to start with kernel preemption disabled. */
408         task_thread_info(p)->preempt_count = 1;
409 #endif
410
411         put_cpu();
412 }
413
414 /**
415  * /kernel/sched/core.c:4674
416  * init_idle - set up an idle thread for a given CPU
417  * @idle: task in question
418  * @cpu: cpu the idle task belongs to
419  *
420  * NOTE: this function does not set the idle thread's NEED_RESCHED
421  * flag, to make booting more robust.
422  */
423 void __cpuinit init_idle(struct task_struct *idle, int cpu)
424 {
425         struct rq *rq = cpu_rq(cpu);
426         unsigned long flags;
427
428         raw_spin_lock_irqsave(&rq->lock, flags);
429
430         __sched_fork(idle);
431         idle->state = TASK_RUNNING;
432         idle->se.exec_start = sched_clock();
433
434         do_set_cpus_allowed(idle, cpumask_of(cpu));
435         /*
436          * We're having a chicken and egg problem, even though we are
437          * holding rq->lock, the cpu isn't yet set to this cpu so the
438          * lockdep check in task_group() will fail.
439          *
440          * Similar case to sched_fork(). / Alternatively we could
441          * use task_rq_lock() here and obtain the other rq->lock.
442          *
443          * Silence PROVE_RCU
444          */
445         rcu_read_lock();
446         __set_task_cpu(idle, cpu);
447         rcu_read_unlock();
448
449         rq->curr = rq->idle = idle;
450 #if defined(CONFIG_SMP)
451         idle->on_cpu = 1;
452 #endif
453         raw_spin_unlock_irqrestore(&rq->lock, flags);
454
455         /* Set the preempt count _outside_ the spinlocks! */
456         task_thread_info(idle)->preempt_count = 0;
457
458 #if defined(CONFIG_SMP)
459         sprintf(idle->comm, "%s/%d", INIT_TASK_COMM, cpu);
460 #endif
461 }
462
463 /*
464  * /kernel/sched/cputime.c:436
465  * Account multiple ticks of idle time.
466  * @ticks: number of stolen ticks
467  */
468 void account_idle_ticks(unsigned long ticks)
469 {
470         //printk("\naccount_idle_ticks");
471
472         return;
473 }
474
475 /*
476  * /kernel/sched/cputime.c:397
477  * Account a single tick of cpu time.
478  * @p: the process that the cpu time gets accounted to
479  * @user_tick: indicates if the tick is a user or a system tick
480  */
481 void account_process_tick(struct task_struct *p, int user_tick)
482 {
483         //printk("\naccount_process_tick");
484
485         return;
486 }
487
488 /*
489  * /kernel/sched/core.c:2092
490  * get_avenrun - get the load average array
491  * @loads:    pointer to dest load array
492  * @offset:    offset to add
493  * @shift:    shift count to shift the result left
494  *
495  * These values are estimates at best, so no need for locking.
496  */
497 void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
498 {
499         //printk("\nget_avenrun");
500
501         return;
502 }
503
504 /*
505  * /kernel/sched/core.c:2363
506  * calc_load - update the avenrun load estimates 10 ticks after the
507  * CPUs have updated calc_load_tasks.
508  */
509 void calc_global_load(unsigned long ticks)
510 {
511 //      printk("\ncalc_global_load");
512
513         return;
514 }
515
516 /*
517  * /kernel/sched/core.c:2197
518  * We're going into NOHZ mode, if there's any pending delta, fold it
519  * into the pending idle delta.
520  */
521 /*void calc_load_enter_idle(void)
522 {
523         return;
524 }*/
525
526 /*
527  * /kernel/sched/core.c:2213
528  * If we're still before the sample window, we're done.
529  *
530  * We woke inside or after the sample window, this means we're already
531  * accounted through the nohz accounting, so skip the entire deal and
532  * sync up for the next window.
533  */
534 /*void calc_load_exit_idle(void)
535 {
536         return;
537 }*/
538
539 /*
540  * /kernel/sched/core.c:3668
541  * Check if a task can reduce its nice value
542  * @p: task
543  * @nice: nice value
544  */
545 int can_nice(const struct task_struct *p, const int nice)
546 {
547         //printk("\ncan_nice");
548
549         return 0;
550 }
551
552 /**
553  * kernel/sched/core.c:3768
554  * idle_task - return the idle task for a given cpu.
555  * @cpu: the processor in question.
556  */
557 struct task_struct *idle_task(int cpu)
558 {
559         return cpu_rq(cpu)->idle;
560 }
561
562 /**
563  * /kernel/sched/core.c:3742
564  * idle_cpu - is a given cpu idle currently?
565  * @cpu: the processor in question.
566  */
567 int idle_cpu(int cpu)
568 {
569         struct rq *rq = cpu_rq(cpu);
570
571         if (rq->curr != rq->idle)
572                 return 0;
573
574         if (rq->nr_running)
575                 return 0;
576
577 #ifdef CONFIG_SMP
578         if (!llist_empty(&rq->wake_list))
579                 return 0;
580 #endif
581
582         return 1;
583 }
584
585 /*
586  * /kernel/sched/core.c:4669
587  * Sets sched_class of idle task, see struct sched_class idle_sched_class;
588  */
589 void __cpuinit init_idle_bootup_task(struct task_struct *idle)
590 {
591         //printk("\ninit_idle_bootup_task");
592
593         return;
594 }
595
596 /*
597  * /kernel/sched/core.c:7108
598  * Calls private function
599  * static void normalize_task(struct rq *rq, struct task_struct *p)
600  */
601 void normalize_rt_tasks(void)
602 {
603         printk("\nnormalize_rt_tasks");
604
605         return;
606 }
607
608 /*
609  * /kernel/sched/core.c:1997
610  * nr_running and nr_context_switches:
611  *
612  * externally visible scheduler statistics:
613  *   current number of runnable threads
614  *   total number of context switches performed since bootup.
615  */
616 unsigned long nr_running(void)
617 {
618         printk("\nnr_running");
619
620         // TODO: SMP
621
622         return 0;
623 }
624
625 unsigned long long nr_context_switches(void)
626 {
627 //      printk("\nnr_context_switches");
628
629         int i;
630         unsigned long long sum = 0;
631
632         for_each_possible_cpu(i)
633                 sum += cpu_rq(i)->nr_switches;
634
635         return sum;
636 }
637
638 /*
639  * /kernel/sched/core.c:2008
640  * number of threads waiting on IO
641  */
642 unsigned long nr_iowait(void)
643 {
644         printk("\nnr_iowait");
645
646         // TODO: SMP
647
648         return 0;
649 }
650
651 /*
652  * kernel/sched/core.c:2018
653  */
654 unsigned long nr_iowait_cpu(int cpu)
655 {
656         printk("\nnr_iowait_cpu");
657
658         // TODO: SMP
659
660         return 0;
661 }
662
663 /*
664  * rt_mutex_setprio - set the current priority of a task
665  * @p: task
666  * @prio: prio value (kernel-internal form)
667  *
668  * This function changes the 'effective' priority of a task. It does
669  * not touch ->normal_prio like __setscheduler().
670  *
671  * Used by the rt_mutex code to implement priority inheritance logic.
672  */
673 void rt_mutex_setprio(struct task_struct *p, int prio)
674 {
675         printk("\nrt_mutex_setprio");
676
677         return;
678 }
679
680 /**
681  * sched_clock_cpu - returns current time in nanosec units
682  * using scheduler clock function.
683  * @param: cpu id
684  */
685 //u64 sched_clock_cpu(int cpu)
686 //{
687 //      return 0;
688 //}
689
690 /*
691  * kernel/sched/clock.c:350
692  * Initialize/Start scheduler clock.
693  */
694 //void sched_clock_init(void)
695 //{
696 //      return;
697 //}
698
699 /**
700  * kernel/sched/core.c:4213
701  * This functions stores the CPU affinity mask for the process or thread with the ID pid in the cpusetsize
702  * bytes long bitmap pointed to by cpuset. If successful, the function always initializes all bits in the
703  * cpu_set_t object and returns zero.
704  *
705  * If pid does not correspond to a process or thread on the system the or the function fails for some other
706  * reason, it returns -1 and errno is set to represent the error condition.
707  */
708 long sched_getaffinity(pid_t pid, struct cpumask *mask)
709 {
710         printk("\nsched_getaffinity");
711
712         // TODO: SMP
713
714         return 0;
715 }
716
717 /**
718  * kernel/sched/core.c:7571
719  */
720 int sched_rr_handler(struct ctl_table *table, int write,
721                 void __user *buffer, size_t *lenp,
722                 loff_t *ppos)
723 {
724         //printk("\nsched_rr_handler");
725
726         return 0;
727 }
728
729 /**
730  * kernel/sched/core.c:4111
731  * This function installs the cpusetsize bytes long affinity mask pointed to by cpuset for the process or
732  * thread with the ID pid. If successful the function returns zero and the scheduler will in future take the
733  * affinity information into account.
734  */
735 long sched_setaffinity(pid_t pid, const struct cpumask *new_mask)
736 {
737         //printk("\nsched_setaffinity");
738
739         return 0;
740 }
741
742 /**
743  * kernel/sched/core.c:3975
744  * sched_setscheduler - change the scheduling policy and/or RT priority of a thread.
745  * @p: the task in question.
746  * @policy: new policy.
747  * @param: structure containing the new RT priority.
748  *
749  * NOTE that the task may be already dead.
750  */
751 int sched_setscheduler(struct task_struct *p, int policy,
752                 const struct sched_param *param)
753 {
754         //printk("\nsched_setscheduler");
755
756         return 0;
757 }
758
759 /**
760  * kernel/sched/core.c:3993
761  * sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernelspace.
762  * @p: the task in question.
763  * @policy: new policy.
764  * @param: structure containing the new RT priority.
765  *
766  * Just like sched_setscheduler, only don't bother checking if the
767  * current context has permission.  For example, this is needed in
768  * stop_machine(): we create temporary high priority worker threads,
769  * but our caller might not have that capability.
770  */
771 int sched_setscheduler_nocheck(struct task_struct *p, int policy,
772 const struct sched_param *param)
773 {
774 //      //printk("\nsched_setscheduler_nocheck");
775
776         return 0;
777 }
778
779 /**
780  * kernel/sched/core.c:4601
781  */
782 void sched_show_task(struct task_struct *p)
783 {
784         //printk("\nsched_show_task");
785
786         return;
787 }
788
789 /**
790  * kernel/sched/core.c:652
791  */
792 void resched_task(struct task_struct *p)
793 {
794         int cpu;
795
796         assert_raw_spin_locked(&task_rq(p)->lock);
797
798         if (test_tsk_need_resched(p))
799                 return;
800
801         set_tsk_need_resched(p);
802
803         cpu = task_cpu(p);
804         if (cpu == smp_processor_id())
805                 return;
806
807         /* NEED_RESCHED must be visible before we test polling */
808         smp_mb();
809         if (!tsk_is_polling(p))
810                 smp_send_reschedule(cpu);
811
812 //      printk(">>resched_task %d\n",p->pid);
813 }
814
815 /**
816  * kernel/sched/core.c:1806
817  * prepare_task_switch - prepare to switch tasks
818  * @rq: the runqueue preparing to switch
819  * @prev: the current task that is being switched out
820  * @next: the task we are going to switch to.
821  *
822  * This is called with the rq lock held and interrupts off. It must
823  * be paired with a subsequent finish_task_switch after the context
824  * switch.
825  *
826  * prepare_task_switch sets up locking and calls architecture specific
827  * hooks.
828  */
829 static inline void
830 prepare_task_switch(struct rq *rq, struct task_struct *prev,
831                     struct task_struct *next)
832 {
833 //      trace_sched_switch(prev, next);
834 //      sched_info_switch(prev, next);
835 //      perf_event_task_sched_out(prev, next);
836 //      fire_sched_out_preempt_notifiers(prev, next);
837         prepare_lock_switch(rq, next);
838 //      prepare_arch_switch(next);
839 }
840
841 /**
842  * kernel/sched/core.c:1826
843  * finish_task_switch - clean up after a task-switch
844  * @rq: runqueue associated with task-switch
845  * @prev: the thread we just switched away from.
846  *
847  * finish_task_switch must be called after the context switch, paired
848  * with a prepare_task_switch call before the context switch.
849  * finish_task_switch will reconcile locking set up by prepare_task_switch,
850  * and do any other architecture-specific cleanup actions.
851  *
852  * Note that we may have delayed dropping an mm in context_switch(). If
853  * so, we finish that here outside of the runqueue lock. (Doing it
854  * with the lock held can cause deadlocks; see schedule() for
855  * details.)
856  */
857 static void finish_task_switch(struct rq *rq, struct task_struct *prev)
858         __releases(rq->lock)
859 {
860         struct mm_struct *mm = rq->prev_mm;
861         long prev_state;
862
863         rq->prev_mm = NULL;
864
865         /*
866          * A task struct has one reference for the use as "current".
867          * If a task dies, then it sets TASK_DEAD in tsk->state and calls
868          * schedule one last time. The schedule call will never return, and
869          * the scheduled task must drop that reference.
870          * The test for TASK_DEAD must occur while the runqueue locks are
871          * still held, otherwise prev could be scheduled on another cpu, die
872          * there before we look at prev->state, and then the reference would
873          * be dropped twice.
874          *              Manfred Spraul <manfred@colorfullife.com>
875          */
876         prev_state = prev->state;
877         vtime_task_switch(prev);
878 //      finish_arch_switch(prev);
879 //      perf_event_task_sched_in(prev, current);
880         finish_lock_switch(rq, prev);
881         finish_arch_post_lock_switch();
882
883 //      fire_sched_in_preempt_notifiers(current);
884         if (mm)
885                 mmdrop(mm);
886         if (unlikely(prev_state == TASK_DEAD)) {
887                 /*
888                  * Remove function-return probe instances associated with this
889                  * task and put them back on the free list.
890                  */
891                 kprobe_flush_task(prev);
892                 put_task_struct(prev);
893         }
894 }
895
896 #ifdef CONFIG_SMP
897
898 /* assumes rq->lock is held */
899 static inline void pre_schedule(struct rq *rq, struct task_struct *prev)
900 {
901 }
902
903 /* rq->lock is NOT held, but preemption is disabled */
904 static inline void post_schedule(struct rq *rq)
905 {
906 }
907
908 #else
909
910 static inline void pre_schedule(struct rq *rq, struct task_struct *p)
911 {
912 }
913
914 static inline void post_schedule(struct rq *rq)
915 {
916 }
917
918 #endif
919
920 /**
921  * kernel/sched/core.c:1905
922  * schedule_tail - first thing a freshly forked thread must call.
923  * @prev: the thread we just switched away from.
924  */
925 asmlinkage void schedule_tail(struct task_struct *prev)
926         __releases(rq->lock)
927 {
928 //      printk(">>schedule_tail %d\n",prev->pid);
929         struct rq *rq = this_rq();
930
931         finish_task_switch(rq, prev);
932
933         /*
934          * FIXME: do we need to worry about rq being invalidated by the
935          * task_switch?
936          */
937         // TODO: SMP
938         post_schedule(rq);
939
940         // TODO: replace this irq enable, maybe inside post_schedule
941         arch_local_irq_enable();
942
943 #ifdef __ARCH_WANT_UNLOCKED_CTXSW
944         /* In this case, finish_task_switch does not reenable preemption */
945         preempt_enable();
946 #endif
947         if (current->set_child_tid)
948                 put_user(task_pid_vnr(current), current->set_child_tid);
949 }
950
951
952 /**
953  * kernel/sched/core.c:769
954  */
955 static void update_rq_clock_task(struct rq *rq, s64 delta)
956 {
957 /*
958  * In theory, the compile should just see 0 here, and optimize out the call
959  * to sched_rt_avg_update. But I don't trust it...
960  */
961 #if defined(CONFIG_IRQ_TIME_ACCOUNTING) || defined(CONFIG_PARAVIRT_TIME_ACCOUNTING)
962         s64 steal = 0, irq_delta = 0;
963 #endif
964 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
965         irq_delta = irq_time_read(cpu_of(rq)) - rq->prev_irq_time;
966
967         /*
968          * Since irq_time is only updated on {soft,}irq_exit, we might run into
969          * this case when a previous update_rq_clock() happened inside a
970          * {soft,}irq region.
971          *
972          * When this happens, we stop ->clock_task and only update the
973          * prev_irq_time stamp to account for the part that fit, so that a next
974          * update will consume the rest. This ensures ->clock_task is
975          * monotonic.
976          *
977          * It does however cause some slight miss-attribution of {soft,}irq
978          * time, a more accurate solution would be to update the irq_time using
979          * the current rq->clock timestamp, except that would require using
980          * atomic ops.
981          */
982         if (irq_delta > delta)
983                 irq_delta = delta;
984
985         rq->prev_irq_time += irq_delta;
986         delta -= irq_delta;
987 #endif
988 #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
989         if (static_key_false((&paravirt_steal_rq_enabled))) {
990                 u64 st;
991
992                 steal = paravirt_steal_clock(cpu_of(rq));
993                 steal -= rq->prev_steal_time_rq;
994
995                 if (unlikely(steal > delta))
996                         steal = delta;
997
998                 st = steal_ticks(steal);
999                 steal = st * TICK_NSEC;
1000
1001                 rq->prev_steal_time_rq += steal;
1002
1003                 delta -= steal;
1004         }
1005 #endif
1006
1007         rq->clock_task += delta;
1008
1009 #if defined(CONFIG_IRQ_TIME_ACCOUNTING) || defined(CONFIG_PARAVIRT_TIME_ACCOUNTING)
1010         if ((irq_delta + steal) && sched_feat(NONTASK_POWER))
1011                 sched_rt_avg_update(rq, irq_delta + steal);
1012 #endif
1013 }
1014
1015 //static void update_rq_clock_task(struct rq *rq, s64 delta);
1016 void update_rq_clock(struct rq *rq)
1017 {
1018         s64 delta;
1019
1020         if (rq->skip_clock_update > 0)
1021                 return;
1022
1023         delta = sched_clock_cpu(cpu_of(rq)) - rq->clock;
1024         rq->clock += delta;
1025         update_rq_clock_task(rq, delta);
1026 }
1027
1028 /*
1029  * kernel/sched/core.c:2684
1030  * This function gets called by the timer code, with HZ frequency.
1031  * We call it with interrupts disabled.
1032  */
1033 void scheduler_tick(void)
1034 {
1035         int cpu = smp_processor_id();
1036         struct rq *rq = cpu_rq(cpu);
1037         struct task_struct *curr = rq->curr;
1038
1039         u64 now = rq->clock_task;
1040         unsigned long delta_exec;
1041
1042         sched_clock_tick();
1043
1044         raw_spin_lock(&rq->lock);
1045         update_rq_clock(rq);
1046
1047         /*
1048          * Update run-time statistics of the 'current'.
1049          */
1050         if (unlikely(!curr)) {
1051                 raw_spin_unlock(&rq->lock);
1052                 return;
1053         }
1054
1055         /*
1056          * Get the amount of time the current task was running
1057          * since the last time we changed load (this cannot
1058          * overflow on 32 bits):
1059          */
1060         delta_exec = (unsigned long)(now - curr->se.exec_start);
1061
1062         if (delta_exec > RR_TIMESLICE) {
1063                 resched_task(curr);
1064         }
1065
1066         raw_spin_unlock(&rq->lock);
1067
1068         // TODO: SMP for load balancing
1069 }
1070
1071 /*
1072  * kernel/sched/core.c:2649
1073  * Lock/unlock the current runqueue - to extract task statistics:
1074  */
1075 unsigned long long task_delta_exec(struct task_struct *p)
1076 {
1077         printk("\ntask_delta_exec");
1078
1079         // TODO: SMP
1080
1081         return 0;
1082 }
1083
1084 /**
1085  * kernel/sched/core.c:3727
1086  * task_prio - return the priority value of a given task.
1087  * @p: the task in question.
1088  *
1089  * This is the priority value as seen by users in /proc.
1090  * RT tasks are offset by -200. Normal tasks are centered
1091  * around 0, value goes from -16 to +15.
1092  */
1093 int task_prio(const struct task_struct *p)
1094 {
1095         //printk("\ntask_prio");
1096
1097         return 0;
1098 }
1099
1100 /*
1101  * kernel/sched/core.c:2667
1102  * Return accounted runtime for the task.
1103  * In case the task is currently running, return the runtime plus current's
1104  * pending runtime that have not been accounted yet.
1105  */
1106 unsigned long long task_sched_runtime(struct task_struct *task)
1107 {
1108         //printk("\ntask_sched_runtime");
1109
1110         return 0;
1111 }
1112
1113 /*
1114  * kernel/sched/core.c:2024
1115  * this_cpu_load - returns load of the cpu
1116  */
1117 unsigned long this_cpu_load(void)
1118 {
1119         //printk("\nthis_cpu_load");
1120
1121         // TODO: SMP, needed in case of load balancing per CPU
1122
1123         return 0;
1124 }
1125
1126 /*
1127  * kernel/sched/core.c:2556
1128  * update_cpu_load_nohz - called from tick_nohz_idle_exit() -- try and fix up the ticks we missed.
1129  */
1130 void update_cpu_load_nohz(void)
1131 {
1132         printk("\nupdate_cpu_load_nohz");
1133
1134         return;
1135 }
1136
1137
1138 /*
1139  * kernel/sched/core.c:1207
1140  * The caller (fork, wakeup) owns p->pi_lock, ->cpus_allowed is stable.
1141  */
1142 static inline
1143 int select_task_rq(struct task_struct *p, int sd_flags, int wake_flags)
1144 {
1145 //      printk(">>select_task_rq");
1146         int cpu = task_cpu(p);
1147 //      int cpu = p->sched_class->select_task_rq(p, sd_flags, wake_flags);
1148
1149         /*
1150          * In order not to call set_task_cpu() on a blocking task we need
1151          * to rely on ttwu() to place the task on a valid ->cpus_allowed
1152          * cpu.
1153          *
1154          * Since this is common to all placement strategies, this lives here.
1155          *
1156          * [ this allows ->select_task() to simply return task_cpu(p) and
1157          *   not worry about this generic constraint ]
1158          */
1159         if (unlikely(!cpumask_test_cpu(cpu, tsk_cpus_allowed(p)) ||
1160                      !cpu_online(cpu)))
1161                 cpu = cpumask_first(tsk_cpus_allowed(p)); //select_fallback_rq(task_cpu(p), p);
1162
1163         return cpu;
1164 }
1165
1166 /*
1167  * kernel/sched/core.c:736
1168  */
1169 void activate_task(struct rq *rq, struct task_struct *p, int flags)
1170 {
1171 //      printk(">>activate_task %d\n",p->pid);
1172         if (task_contributes_to_load(p))
1173                 rq->nr_uninterruptible--;
1174
1175 //      enqueue_task(rq, p, flags);
1176 //      list_add(&p->rq_tasks, &rq->rq_list);
1177
1178 //TODO: FRAMEWORK STUFF OR not?
1179 //      send_to_topic(0,p);
1180 }
1181
1182 /*
1183  * kernel/sched/core.c:744
1184  */
1185 void deactivate_task(struct rq *rq, struct task_struct *p, int flags)
1186 {
1187         printk(">>deactivate_task\n");
1188         if (task_contributes_to_load(p))
1189                 rq->nr_uninterruptible++;
1190
1191 //      dequeue_task(rq, p, flags);
1192 //      list_del(&p->rq_tasks);
1193 }
1194
1195 /*
1196  * kernel/sched/core.c:1275
1197  */
1198 static void ttwu_activate(struct rq *rq, struct task_struct *p, int en_flags)
1199 {
1200 //      printk(">>ttwu_activate %d\n",p->pid);
1201         activate_task(rq, p, en_flags);
1202         p->on_rq = 1;
1203
1204         /* if a worker is waking up, notify workqueue */
1205         if (p->flags & PF_WQ_WORKER)
1206         {
1207                 //TODO: remove the print and klammerns later
1208 //              printk(">>EFFING worker here\n");
1209                 wq_worker_waking_up(p, cpu_of(rq));
1210         }
1211 }
1212
1213 /*
1214  * kernel/sched/core.c:909
1215  */
1216 void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags)
1217 {
1218 //      const struct sched_class *class;
1219 //
1220 //      if (p->sched_class == rq->curr->sched_class) {
1221 //              rq->curr->sched_class->check_preempt_curr(rq, p, flags);
1222 //      } else {
1223 //              for_each_class(class) {
1224 //                      if (class == rq->curr->sched_class)
1225 //                              break;
1226 //                      if (class == p->sched_class) {
1227 //                              resched_task(rq->curr);
1228 //                              break;
1229 //                      }
1230 //              }
1231 //      }
1232         if (rq->curr == rq->idle)
1233                         resched_task(rq->curr);
1234
1235         /*
1236          * A queue event has occurred, and we're going to schedule.  In
1237          * this case, we can save a useless back to back clock update.
1238          */
1239         if (rq->curr->on_rq && test_tsk_need_resched(rq->curr))
1240                 rq->skip_clock_update = 1;
1241 }
1242
1243 /*
1244  * kernel/sched/core:1289
1245  * Mark the task runnable and perform wakeup-preemption.
1246  */
1247 static void
1248 ttwu_do_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
1249 {
1250 //      printk(">>ttwu_do_wakeup task %d\n",p->pid);
1251 //      trace_sched_wakeup(p, true);
1252         check_preempt_curr(rq, p, wake_flags);
1253
1254         p->state = TASK_RUNNING;
1255 //#ifdef CONFIG_SMP
1256 //      if (p->sched_class->task_woken)
1257 //              p->sched_class->task_woken(rq, p);
1258 //
1259 //      if (rq->idle_stamp) {
1260 //              u64 delta = rq->clock - rq->idle_stamp;
1261 //              u64 max = 2*sysctl_sched_migration_cost;
1262 //
1263 //              if (delta > max)
1264 //                      rq->avg_idle = max;
1265 //              else
1266 //                      update_avg(&rq->avg_idle, delta);
1267 //              rq->idle_stamp = 0;
1268 //      }
1269 //#endif
1270 }
1271
1272 /*
1273  * kernel/sched/core.c:1313
1274  */
1275 static void
1276 ttwu_do_activate(struct rq *rq, struct task_struct *p, int wake_flags)
1277 {
1278 //      printk(">>ttwu_do_activate\n");
1279 #ifdef CONFIG_SMP
1280         if (p->sched_contributes_to_load)
1281                 rq->nr_uninterruptible--;
1282 #endif
1283
1284         ttwu_activate(rq, p, ENQUEUE_WAKEUP | ENQUEUE_WAKING);
1285         ttwu_do_wakeup(rq, p, wake_flags);
1286 }
1287
1288 /*
1289  * kernel/sched/core.c:1394
1290  */
1291 static void ttwu_queue_remote(struct task_struct *p, int cpu)
1292 {
1293 //      printk(">>ttwu_queue_remote\n");
1294 #if defined(CONFIG_SMP)
1295         if (llist_add(&p->wake_entry, &cpu_rq(cpu)->wake_list))
1296                 smp_send_reschedule(cpu);
1297 #endif
1298 }
1299
1300 /*
1301  * kernel/sched/core.c:1406
1302  */
1303 static void ttwu_queue(struct task_struct *p, int cpu)
1304 {
1305         struct rq *rq = cpu_rq(cpu);
1306 //      printk(">>ttwu_queue task %d : cpu %d\n",p->pid, cpu);
1307
1308 #if defined(CONFIG_SMP)
1309         if (/*sched_feat(TTWU_QUEUE) && */!cpus_share_cache(smp_processor_id(), cpu)) {
1310                 sched_clock_cpu(cpu); /* sync clocks x-cpu */
1311                 ttwu_queue_remote(p, cpu);
1312                 return;
1313         }
1314 #endif
1315
1316         raw_spin_lock(&rq->lock);
1317         ttwu_do_activate(rq, p, 0);
1318         raw_spin_unlock(&rq->lock);
1319 }
1320
1321 /*
1322  * kernel/sched/core.c:1703
1323  * wake_up_new_task - wake up a newly created task for the first time.
1324  *
1325  * This function will do some initial scheduler statistics housekeeping
1326  * that must be done for every newly created context, then puts the task
1327  * on the runqueue and wakes it.
1328  */
1329 void wake_up_new_task(struct task_struct *p)
1330 {
1331         unsigned long flags;
1332         struct rq *rq;
1333 //      int cpu = 255;
1334
1335 //      TODO: FRAMEWORK ZEUGS
1336         send_to_topic(1,p);
1337
1338         raw_spin_lock_irqsave(&p->pi_lock, flags);
1339
1340 #ifdef CONFIG_SMP
1341         /*
1342          * Fork balancing, do it here and not earlier because:
1343          *  - cpus_allowed can change in the fork path
1344          *  - any previously selected cpu might disappear through hotplug
1345          */
1346         set_task_cpu(p, select_task_rq(p, SD_BALANCE_FORK, 0));
1347 //      printk("new thread\n");
1348 //      for_each_cpu(cpu, &(p->cpus_allowed)){
1349 //              printk("Asked for CPU #%d\n", cpu);
1350 //      }
1351
1352 #endif
1353
1354
1355         rq = __task_rq_lock(p);
1356 //      send_to_topic(1,p);
1357 //      printk(">>wake_up_new_task:");
1358         activate_task(rq, p, 0);
1359         p->on_rq = 1;
1360 //      trace_sched_wakeup_new(p, true);
1361         check_preempt_curr(rq, p, WF_FORK);
1362 //#ifdef CONFIG_SMP
1363 //      if (p->sched_class->task_woken)
1364 //              p->sched_class->task_woken(rq, p);
1365 //#endif
1366         task_rq_unlock(rq, p, &flags);
1367
1368         //TODO: FRAMEWORK ZEUGS
1369 //      send_to_topic(1,p);
1370
1371 //      printk(">>wake_up_new_task:");
1372 //      activate_task(rq, p, 0);
1373
1374 }
1375
1376 /*
1377  * kernel/sched/core:1330
1378  * Called in case the task @p isn't fully descheduled from its runqueue,
1379  * in this case we must do a remote wakeup. Its a 'light' wakeup though,
1380  * since all we need to do is flip p->state to TASK_RUNNING, since
1381  * the task is still ->on_rq.
1382  */
1383 static int ttwu_remote(struct task_struct *p, int wake_flags)
1384 {
1385 //      printk(">>ttwu_remote %d\n",p->pid);
1386         struct rq *rq;
1387         int ret = 0;
1388
1389         rq = __task_rq_lock(p);
1390         if (p->on_rq) {
1391                 ttwu_do_wakeup(rq, p, wake_flags);
1392                 ret = 1;
1393         }
1394         __task_rq_unlock(rq);
1395
1396         return ret;
1397 }
1398
1399 /**
1400  * kernel/sched/core.c:1439
1401  * try_to_wake_up - wake up a thread
1402  * @p: the thread to be awakened
1403  * @state: the mask of task states that can be woken
1404  * @wake_flags: wake modifier flags (WF_*)
1405  *
1406  * Put it on the run-queue if it's not already there. The "current"
1407  * thread is always on the run-queue (except when the actual
1408  * re-schedule is in progress), and as such you're allowed to do
1409  * the simpler "current->state = TASK_RUNNING" to mark yourself
1410  * runnable without the overhead of this.
1411  *
1412  * Returns %true if @p was woken up, %false if it was already running
1413  * or @state didn't match @p's state.
1414  */
1415 static int
1416 try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
1417 {
1418 //      printk(">>try_to_wake_up %d\n",p->pid);
1419
1420         unsigned long flags;
1421         int cpu, success = 0;
1422
1423         smp_wmb();
1424         raw_spin_lock_irqsave(&p->pi_lock, flags);
1425         if (!(p->state & state))
1426                 goto out;
1427
1428         success = 1; /* we're going to change ->state */
1429         cpu = task_cpu(p);
1430
1431         if (p->on_rq && ttwu_remote(p, wake_flags))
1432                 goto stat;
1433
1434 //      TODO:framework zeugs
1435         send_to_topic(0,p);
1436
1437 #ifdef CONFIG_SMP
1438         /*
1439          * If the owning (remote) cpu is still in the middle of schedule() with
1440          * this task as prev, wait until its done referencing the task.
1441          */
1442         while (p->on_cpu)
1443                 cpu_relax();
1444         /*
1445          * Pairs with the smp_wmb() in finish_lock_switch().
1446          */
1447         smp_rmb();
1448
1449 //      p->sched_contributes_to_load = !!task_contributes_to_load(p);
1450         p->state = TASK_WAKING;
1451
1452 //      if (p->sched_class->task_waking)
1453 //              p->sched_class->task_waking(p);
1454
1455         // TODO: simply not using select_task_rq :)
1456         cpu = select_task_rq(p, SD_BALANCE_WAKE, wake_flags);
1457         if (task_cpu(p) != cpu) {
1458                 wake_flags |= WF_MIGRATED;
1459                 set_task_cpu(p, cpu);
1460         }
1461 #endif /* CONFIG_SMP */
1462
1463
1464
1465         ttwu_queue(p, cpu);
1466 stat:
1467 //      raw_spin_unlock(&rq->lock);
1468 out:
1469         raw_spin_unlock_irqrestore(&p->pi_lock, flags);
1470
1471 //TODO: FRAMEWORK
1472 //send_to_topic(0,p);
1473
1474         return success;
1475 }
1476
1477 /**
1478  * kernel/sched/core.c:1497
1479  * try_to_wake_up_local - try to wake up a local task with rq lock held
1480  * @p: the thread to be awakened
1481  *
1482  * Put @p on the run-queue if it's not already there. The caller must
1483  * ensure that this_rq() is locked, @p is bound to this_rq() and not
1484  * the current task.
1485  */
1486 static void try_to_wake_up_local(struct task_struct *p)
1487 {
1488 //      printk(">>try_to_wake_up_local %d\n",p->pid);
1489         struct rq *rq = task_rq(p);
1490
1491         if (WARN_ON_ONCE(rq != this_rq()) ||
1492             WARN_ON_ONCE(p == current))
1493                 return;
1494
1495         lockdep_assert_held(&rq->lock);
1496
1497         if (!raw_spin_trylock(&p->pi_lock)) {
1498                 raw_spin_unlock(&rq->lock);
1499                 raw_spin_lock(&p->pi_lock);
1500                 raw_spin_lock(&rq->lock);
1501         }
1502
1503         if (!(p->state & TASK_NORMAL))
1504                 goto out;
1505
1506         if (!p->on_rq)
1507                 ttwu_activate(rq, p, ENQUEUE_WAKEUP);
1508
1509         ttwu_do_wakeup(rq, p, 0);
1510 //      ttwu_stat(p, smp_processor_id(), 0);
1511 out:
1512         raw_spin_unlock(&p->pi_lock);
1513 }
1514
1515 /*
1516  * kernel/sched/core.c:1931
1517  * context_switch - switch to the new MM and the new
1518  * thread's register state.
1519  */
1520 //static inline void
1521 void
1522 context_switch(struct rq *rq, struct task_struct *prev,
1523                struct task_struct *next)
1524 {
1525 //      printk(">>context_switch\n");
1526         struct mm_struct *mm, *oldmm;
1527
1528         prepare_task_switch(rq, prev, next);
1529
1530         mm = next->mm;
1531         oldmm = prev->active_mm;
1532         /*
1533          * For paravirt, this is coupled with an exit in switch_to to
1534          * combine the page table reload and the switch backend into
1535          * one hypercall.
1536          */
1537 //      arch_start_context_switch(prev);
1538
1539         if (!mm) {
1540                 next->active_mm = oldmm;
1541                 atomic_inc(&oldmm->mm_count);
1542                 enter_lazy_tlb(oldmm, next);
1543         }
1544         else
1545                 switch_mm(oldmm, mm, next);
1546
1547         if (!prev->mm) {
1548                 prev->active_mm = NULL;
1549                 rq->prev_mm = oldmm;
1550         }
1551         /*
1552          * Since the runqueue lock will be released by the next
1553          * task (which is an invalid locking op but in the case
1554          * of the scheduler it's an obvious special-case), so we
1555          * do an early lockdep release here:
1556          */
1557 #ifndef __ARCH_WANT_UNLOCKED_CTXSW
1558         spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
1559 #endif
1560
1561         context_tracking_task_switch(prev, next);
1562         /* Here we just switch the register state and the stack. */
1563         switch_to(prev, next, prev);
1564
1565         barrier();
1566         /*
1567          * this_rq must be evaluated again because prev may have moved
1568          * CPUs since it called schedule(), thus the 'rq' on its stack
1569          * frame will be invalid.
1570          */
1571         finish_task_switch(this_rq(), prev);
1572
1573 }
1574
1575 /*
1576  * kernel/sched/core.c:2875
1577  * __schedule() is the main scheduler function.
1578  *
1579  * The main means of driving the scheduler and thus entering this function are:
1580  *
1581  *   1. Explicit blocking: mutex, semaphore, waitqueue, etc.
1582  *
1583  *   2. TIF_NEED_RESCHED flag is checked on interrupt and userspace return
1584  *      paths. For example, see arch/x86/entry_64.S.
1585  *
1586  *      To drive preemption between tasks, the scheduler sets the flag in timer
1587  *      interrupt handler scheduler_tick().
1588  *
1589  *   3. Wakeups don't really cause entry into schedule(). They add a
1590  *      task to the run-queue and that's it.
1591  *
1592  *      Now, if the new task added to the run-queue preempts the current
1593  *      task, then the wakeup sets TIF_NEED_RESCHED and schedule() gets
1594  *      called on the nearest possible occasion:
1595  *
1596  *       - If the kernel is preemptible (CONFIG_PREEMPT=y):
1597  *
1598  *         - in syscall or exception context, at the next outmost
1599  *           preempt_enable(). (this might be as soon as the wake_up()'s
1600  *           spin_unlock()!)
1601  *
1602  *         - in IRQ context, return from interrupt-handler to
1603  *           preemptible context
1604  *
1605  *       - If the kernel is not preemptible (CONFIG_PREEMPT is not set)
1606  *         then at the next:
1607  *
1608  *          - cond_resched() call
1609  *          - explicit schedule() call
1610  *          - return from syscall or exception to user-space
1611  *          - return from interrupt-handler to user-space
1612  */
1613 static void __sched __schedule(void)
1614 {
1615         struct task_struct *prev, *next;
1616 //      unsigned long *switch_count = 0;
1617         struct rq *rq;
1618         int cpu;
1619
1620 need_resched:
1621         preempt_disable();
1622         cpu = smp_processor_id();
1623         rq = cpu_rq(cpu);
1624         rcu_note_context_switch(cpu);
1625         prev = rq->curr;
1626
1627 //      schedule_debug(prev);
1628
1629 //      if (sched_feat(HRTICK))
1630 //              hrtick_clear(rq);
1631
1632         raw_spin_lock_irq(&rq->lock);
1633
1634 //      switch_count = &prev->nivcsw;
1635         if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
1636                 if (unlikely(signal_pending_state(prev->state, prev))) {
1637                         prev->state = TASK_RUNNING;
1638                 } else {
1639 //                      deactivate_task(rq, prev, DEQUEUE_SLEEP);
1640                         prev->on_rq = 0;
1641
1642                         /*
1643                          * If a worker went to sleep, notify and ask workqueue
1644                          * whether it wants to wake up a task to maintain
1645                          * concurrency.
1646                          */
1647                         if (prev->flags & PF_WQ_WORKER) {
1648                                 struct task_struct *to_wakeup;
1649
1650                                 to_wakeup = wq_worker_sleeping(prev, cpu);
1651                                 if (to_wakeup)
1652                                         try_to_wake_up_local(to_wakeup);
1653                         }
1654                 }
1655 //              switch_count = &prev->nvcsw;
1656         }
1657
1658 //      if(prev->state & TASK_DEAD){
1659                 //task dead
1660 //              next = (struct task_struct *)send_to_topic(2,prev);
1661 //      }else
1662         if(prev->state && !(preempt_count() & PREEMPT_ACTIVE)){
1663                 //yield
1664                 next = (struct task_struct *)send_to_topic(4,prev);
1665         }else{
1666                 //tick
1667                 //printk("tick on cpu: %d\n",cpu);
1668                 next = (struct task_struct *)send_to_topic(3,NULL);
1669         }
1670
1671         pre_schedule(rq, prev);
1672
1673 //      if (unlikely(!rq->nr_running))
1674 //              idle_balance(cpu, rq);
1675
1676 //      put_prev_task(rq, prev);
1677 //      if ((prev != rq->idle) && prev->on_rq) {
1678 //              list_add_tail(&prev->rq_tasks, &rq->rq_list);
1679 //      }
1680 //
1681         /*      In case the only runnable task gets deactivated, we need to schedule
1682          *      the idle tasks.
1683          */
1684 //      next = pick_next_task(rq);
1685 //
1686 /*      if (!list_empty(&rq->rq_list)) {
1687                 assert_raw_spin_locked(&rq->lock);
1688 //              next = list_first_entry(&rq->rq_list, struct task_struct, rq_tasks);
1689 //              list_del(&next->rq_tasks);
1690         }
1691         else {
1692 //              next = rq->idle;
1693         }
1694 */
1695
1696 //      if(next)
1697 //              next->se.exec_start = rq->clock_task;
1698 //
1699         clear_tsk_need_resched(prev);
1700         rq->skip_clock_update = 0;
1701 //
1702         if (likely(prev != next)&&(next!=NULL)) {
1703 //              rq->nr_switches++;
1704 //              rq->curr = next;
1705 ////            ++*switch_count;
1706 //
1707 ////            printk("wechsel! PID: %d | CPU :%d | allows: %d\n",next->pid, cpu, next->cpus_allowed);
1708 //              context_switch(rq, prev, next); /* unlocks the rq */
1709 //
1710 //              // TODO: remove irq enable
1711                 arch_local_irq_enable();
1712 //
1713 //              /*
1714 //               * The context switch have flipped the stack from under us
1715 //               * and restored the local variables which were saved when
1716 //               * this task called schedule() in the past. prev == current
1717 //               * is still correct, but it can be moved to another cpu/rq.
1718 //               */
1719                 cpu = smp_processor_id();
1720                 rq = cpu_rq(cpu);
1721         }
1722         else
1723                 raw_spin_unlock_irq(&rq->lock);
1724
1725         post_schedule(rq);
1726
1727         sched_preempt_enable_no_resched();
1728         if (need_resched())
1729                 goto need_resched;
1730 }
1731
1732 /*
1733  * kernel/sched/core.c:2966
1734  */
1735 asmlinkage void __sched schedule(void)
1736 {
1737 //      struct task_struct *tsk = current;
1738 //
1739 //      if (!tsk->state || tsk_is_pi_blocked(tsk))
1740 //              return;
1741
1742         __schedule();
1743 }
1744 EXPORT_SYMBOL(schedule);
1745
1746 /*
1747  * kernel/sched/core.c:3125
1748  * The core wakeup function. Non-exclusive wakeups (nr_exclusive == 0) just
1749  * wake everything up. If it's an exclusive wakeup (nr_exclusive == small +ve
1750  * number) then we wake all the non-exclusive tasks and one exclusive task.
1751  *
1752  * There are circumstances in which we can try to wake a task which has already
1753  * started to run but is not in state TASK_RUNNING. try_to_wake_up() returns
1754  * zero in this (rare) case, and we handle it by continuing to scan the queue.
1755  */
1756 static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
1757                         int nr_exclusive, int wake_flags, void *key)
1758 {
1759 //      printk(">>__wake_up_common\n");
1760         wait_queue_t *curr, *next;
1761
1762         list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
1763                 unsigned flags = curr->flags;
1764
1765                 if (curr->func(curr, mode, wake_flags, key) &&
1766                                 (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
1767                         break;
1768         }
1769 }
1770
1771 /**
1772  * kernel/sched/core.c:3149
1773  * __wake_up - wake up threads blocked on a waitqueue.
1774  * @q: the waitqueue
1775  * @mode: which threads
1776  * @nr_exclusive: how many wake-one or wake-many threads to wake up
1777  * @key: is directly passed to the wakeup function
1778  *
1779  * It may be assumed that this function implies a write memory barrier before
1780  * changing the task state if and only if any tasks are woken up.
1781  */
1782 void __wake_up(wait_queue_head_t *q, unsigned int mode,
1783                         int nr_exclusive, void *key)
1784 {
1785         unsigned long flags;
1786
1787         spin_lock_irqsave(&q->lock, flags);
1788         __wake_up_common(q, mode, nr_exclusive, 0, key);
1789         spin_unlock_irqrestore(&q->lock, flags);
1790 }
1791 EXPORT_SYMBOL(__wake_up);
1792
1793 /**
1794  * kernel/sched/core.c:1536
1795  * wake_up_process - Wake up a specific process
1796  * @p: The process to be woken up.
1797  *
1798  * Attempt to wake up the nominated process and move it to the set of runnable
1799  * processes.  Returns 1 if the process was woken up, 0 if it was already
1800  * running.
1801  *
1802  * It may be assumed that this function implies a write memory barrier before
1803  * changing the task state if and only if any tasks are woken up.
1804  */
1805 int wake_up_process(struct task_struct *p)
1806 {
1807 //      printk(">>wake_up_process %d\n",p->pid);
1808         WARN_ON(task_is_stopped_or_traced(p));
1809         return try_to_wake_up(p, TASK_NORMAL, 0);
1810 }
1811 EXPORT_SYMBOL(wake_up_process);
1812
1813 static inline long __sched
1814 do_wait_for_common(struct completion *x,
1815                    long (*action)(long), long timeout, int state)
1816 {
1817         if (!x->done) {
1818                 DECLARE_WAITQUEUE(wait, current);
1819
1820                 __add_wait_queue_tail_exclusive(&x->wait, &wait);
1821                 do {
1822                         if (signal_pending_state(state, current)) {
1823                                 timeout = -ERESTARTSYS;
1824                                 break;
1825                         }
1826                         __set_current_state(state);
1827                         spin_unlock_irq(&x->wait.lock);
1828                         timeout = action(timeout);
1829                         spin_lock_irq(&x->wait.lock);
1830                 } while (!x->done && timeout);
1831                 __remove_wait_queue(&x->wait, &wait);
1832                 if (!x->done)
1833                         return timeout;
1834         }
1835         x->done--;
1836         return timeout ?: 1;
1837 }
1838
1839 static inline long __sched
1840 __wait_for_common(struct completion *x,
1841                   long (*action)(long), long timeout, int state)
1842 {
1843         might_sleep();
1844
1845         spin_lock_irq(&x->wait.lock);
1846         timeout = do_wait_for_common(x, action, timeout, state);
1847         spin_unlock_irq(&x->wait.lock);
1848         return timeout;
1849 }
1850
1851 static long __sched
1852 wait_for_common(struct completion *x, long timeout, int state)
1853 {
1854         return __wait_for_common(x, schedule_timeout, timeout, state);
1855 }
1856
1857 /**
1858  * kernel/sched/core.c:3322
1859  * wait_for_completion: - waits for completion of a task
1860  * @x:  holds the state of this particular completion
1861  *
1862  * This waits to be signaled for completion of a specific task. It is NOT
1863  * interruptible and there is no timeout.
1864  *
1865  * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
1866  * and interrupt capability. Also see complete().
1867  */
1868 void __sched wait_for_completion(struct completion *x)
1869 {
1870         wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
1871 }
1872 EXPORT_SYMBOL(wait_for_completion);
1873
1874 /**
1875  * kernel/sched/core.c:3231
1876  * complete: - signals a single thread waiting on this completion
1877  * @x:  holds the state of this particular completion
1878  *
1879  * This will wake up a single thread waiting on this completion. Threads will be
1880  * awakened in the same order in which they were queued.
1881  *
1882  * See also complete_all(), wait_for_completion() and related routines.
1883  *
1884  * It may be assumed that this function implies a write memory barrier before
1885  * changing the task state if and only if any tasks are woken up.
1886  */
1887 void complete(struct completion *x)
1888 {
1889 //      printk(">>complete\n");
1890         unsigned long flags;
1891
1892         spin_lock_irqsave(&x->wait.lock, flags);
1893         x->done++;
1894         __wake_up_common(&x->wait, TASK_NORMAL, 1, 0, NULL);
1895         spin_unlock_irqrestore(&x->wait.lock, flags);
1896 }
1897 EXPORT_SYMBOL(complete);
1898
1899 /**
1900  * kernel/sched/core.c:2995
1901  * schedule_preempt_disabled - called with preemption disabled
1902  *
1903  * Returns with preemption disabled. Note: preempt_count must be 1
1904  */
1905 void __sched schedule_preempt_disabled(void)
1906 {
1907         sched_preempt_enable_no_resched();
1908         schedule();
1909         preempt_disable();
1910 }
1911
1912 /*
1913  * kernel/sched/core.c:6858
1914  */
1915 int in_sched_functions(unsigned long addr)
1916 {
1917         printk("\nin_sched_functions");
1918
1919         return 0;
1920 }
1921
1922 /*
1923  * kernel/sched/core.c:4333
1924  * __cond_resched_lock() - if a reschedule is pending, drop the given lock,
1925  * call schedule, and on return reacquire the lock.
1926  *
1927  * This works OK both with and without CONFIG_PREEMPT. We do strange low-level
1928  * operations here to prevent schedule() from being called twice (once via
1929  * spin_unlock(), once by hand).
1930  */
1931 int __cond_resched_lock(spinlock_t *lock)
1932 {
1933         printk("\n__cond_resched_lock");
1934
1935         return 0;
1936 }
1937
1938 /*
1939  * kernel/sched/core.c:4315
1940  */
1941 static inline int should_resched(void)
1942 {
1943         return need_resched() && !(preempt_count() & PREEMPT_ACTIVE);
1944 }
1945
1946 static void __cond_resched(void)
1947 {
1948         add_preempt_count(PREEMPT_ACTIVE);
1949         __schedule();
1950         sub_preempt_count(PREEMPT_ACTIVE);
1951 }
1952
1953 int __sched _cond_resched(void)
1954 {
1955         if (should_resched()) {
1956                 __cond_resched();
1957                 return 1;
1958         }
1959         return 0;
1960 }
1961 EXPORT_SYMBOL(_cond_resched);
1962
1963 /*
1964  * kernel/sched/core.c:4333
1965  */
1966 int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags, void *key)
1967 {
1968         return try_to_wake_up(curr->private, mode, wake_flags);
1969 }
1970 EXPORT_SYMBOL(default_wake_function);
1971
1972 /**
1973  * kernel/sched/core.c:3426
1974  * wait_for_completion_killable: - waits for completion of a task (killable)
1975  * @x:  holds the state of this particular completion
1976  *
1977  * This waits to be signaled for completion of a specific task. It can be
1978  * interrupted by a kill signal.
1979  *
1980  * The return value is -ERESTARTSYS if interrupted, 0 if completed.
1981  */
1982 int __sched wait_for_completion_killable(struct completion *x)
1983 {
1984         long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);
1985         if (t == -ERESTARTSYS)
1986                 return t;
1987         return 0;
1988 }
1989 EXPORT_SYMBOL(wait_for_completion_killable);
1990
1991 /**
1992  * kernel/sched/core.c:3192
1993  * __wake_up_sync_key - wake up threads blocked on a waitqueue.
1994  * @q: the waitqueue
1995  * @mode: which threads
1996  * @nr_exclusive: how many wake-one or wake-many threads to wake up
1997  * @key: opaque value to be passed to wakeup targets
1998  *
1999  * The sync wakeup differs that the waker knows that it will schedule
2000  * away soon, so while the target thread will be woken up, it will not
2001  * be migrated to another CPU - ie. the two threads are 'synchronized'
2002  * with each other. This can prevent needless bouncing between CPUs.
2003  *
2004  * On UP it can prevent extra preemption.
2005  *
2006  * It may be assumed that this function implies a write memory barrier before
2007  * changing the task state if and only if any tasks are woken up.
2008  */
2009 void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
2010                         int nr_exclusive, void *key)
2011 {
2012         unsigned long flags;
2013         int wake_flags = WF_SYNC;
2014
2015         if (unlikely(!q))
2016                 return;
2017
2018         if (unlikely(!nr_exclusive))
2019                 wake_flags = 0;
2020
2021         spin_lock_irqsave(&q->lock, flags);
2022         __wake_up_common(q, mode, nr_exclusive, wake_flags, key);
2023         spin_unlock_irqrestore(&q->lock, flags);
2024 }
2025 EXPORT_SYMBOL_GPL(__wake_up_sync_key);
2026
2027 /*
2028  * kernel/sched/core.c:1543
2029  */
2030 int wake_up_state(struct task_struct *p, unsigned int state)
2031 {
2032         WARN_ON(task_is_stopped_or_traced(p));
2033         return try_to_wake_up(p, state, 0);
2034 }
2035 EXPORT_SYMBOL(wake_up_process);
2036
2037 /**
2038  * kernel/sched/core.c:4389
2039  * yield - yield the current processor to other threads.
2040  *
2041  * Do not ever use this function, there's a 99% chance you're doing it wrong.
2042  *
2043  * The scheduler is at all times free to pick the calling task as the most
2044  * eligible task to run, if removing the yield() call from your code breaks
2045  * it, its already broken.
2046  *
2047  * Typical broken usage is:
2048  *
2049  * while (!event)
2050  *      yield();
2051  *
2052  * where one assumes that yield() will let 'the other' process run that will
2053  * make event true. If the current task is a SCHED_FIFO task that will never
2054  * happen. Never use yield() as a progress guarantee!!
2055  *
2056  * If you want to use yield() to wait for something, use wait_event().
2057  * If you want to use yield() to be 'nice' for others, use cond_resched().
2058  * If you still want to use yield(), do not!
2059  */
2060 void __sched yield(void)
2061 {
2062         printk("\nyield");
2063
2064         // TODO: SMP
2065
2066         return;
2067 }
2068
2069 /**
2070  * kernel/sched/core.c:892
2071  * task_curr - is this task currently executing on a CPU?
2072  * @p: the task in question.
2073  */
2074 inline int task_curr(const struct task_struct *p)
2075 {
2076         printk("\ntask_curr");
2077
2078         // TODO: SMP
2079
2080         return 0;
2081 }
2082
2083 /**
2084  * kernel/sched/core.c:3736
2085  * task_nice - return the nice value of a given task.
2086  * @p: the task in question.
2087  */
2088 int task_nice(const struct task_struct *p)
2089 {
2090         printk("\ntask_nice");
2091
2092         return 0;
2093 }
2094
2095 /*
2096  * kernel/sched/core.c:3616
2097  */
2098 void set_user_nice(struct task_struct *p, long nice)
2099 {
2100 //      printk("\nset_user_nice");
2101
2102         return;
2103 }
2104
2105 /*
2106  * kernel/sched/core.c:3169
2107  */
2108 void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key)
2109 {
2110         printk("\n__wake_up_locked_key");
2111
2112         return;
2113 }
2114
2115 /*
2116  * kernel/sched/core.c:4474
2117  * This task is about to go to sleep on IO. Increment rq->nr_iowait so
2118  * that process accounting knows that this is a task in IO wait state.
2119  */
2120 void __sched io_schedule(void)
2121 {
2122 //      printk("\nio_schedule");
2123
2124         struct rq *rq = raw_rq();
2125
2126         delayacct_blkio_start();
2127         atomic_inc(&rq->nr_iowait);
2128         blk_flush_plug(current);
2129         current->in_iowait = 1;
2130         schedule();
2131         current->in_iowait = 0;
2132         atomic_dec(&rq->nr_iowait);
2133         delayacct_blkio_end();
2134 }
2135 EXPORT_SYMBOL(io_schedule);
2136
2137 /*
2138  * kernel/sched/core.c:4489
2139  */
2140 long __sched io_schedule_timeout(long timeout)
2141 {
2142 //      printk("\nio_schedule_timeout");
2143         struct rq *rq = raw_rq();
2144         long ret;
2145
2146         delayacct_blkio_start();
2147         atomic_inc(&rq->nr_iowait);
2148         blk_flush_plug(current);
2149         current->in_iowait = 1;
2150         ret = schedule_timeout(timeout);
2151         current->in_iowait = 0;
2152         atomic_dec(&rq->nr_iowait);
2153         delayacct_blkio_end();
2154         return ret;
2155 }
2156
2157
2158 /*
2159  * kernel/sched/core.c:7590
2160  */
2161 int sched_rt_handler(struct ctl_table *table, int write,
2162                 void __user *buffer, size_t *lenp,
2163                 loff_t *ppos)
2164 {
2165         //printk("\nsched_rt_handler");
2166
2167         return 0;
2168 }
2169
2170 /*
2171  * kernel/sched/core.c:3213
2172  * __wake_up_sync - see __wake_up_sync_key()
2173  */
2174 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
2175 {
2176         printk("\n__wake_up_sync");
2177
2178         return;
2179 }
2180
2181 /*
2182  * kernel/sched/core.c:3163
2183  * Same as __wake_up but called with the spinlock in wait_queue_head_t held.
2184  */
2185 void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr)
2186 {
2187         printk("\n__wake_up_locked");
2188
2189         return;
2190 }
2191
2192 /**
2193  * kernel/sched/core.c:3307
2194  */
2195 static long __sched
2196 wait_for_common_io(struct completion *x, long timeout, int state)
2197 {
2198         return __wait_for_common(x, io_schedule_timeout, timeout, state);
2199 }
2200
2201 /**
2202  * kernel/sched/core.c:3355
2203  * wait_for_completion_io: - waits for completion of a task
2204  * @x:  holds the state of this particular completion
2205  *
2206  * This waits to be signaled for completion of a specific task. It is NOT
2207  * interruptible and there is no timeout. The caller is accounted as waiting
2208  * for IO.
2209  */
2210 void __sched wait_for_completion_io(struct completion *x)
2211 {
2212         wait_for_common_io(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
2213 }
2214 EXPORT_SYMBOL(wait_for_completion_io);
2215
2216 /**
2217  * kernel/sched/core.c:3416
2218  * wait_for_completion_io_timeout: - waits for completion of a task (w/timeout)
2219  * @x:  holds the state of this particular completion
2220  * @timeout:  timeout value in jiffies
2221  *
2222  * This waits for either a completion of a specific task to be signaled or for a
2223  * specified timeout to expire. The timeout is in jiffies. It is not
2224  * interruptible. The caller is accounted as waiting for IO.
2225  *
2226  * The return value is 0 if timed out, and positive (at least 1, or number of
2227  * jiffies left till timeout) if completed.
2228  */
2229 unsigned long __sched
2230 wait_for_completion_io_timeout(struct completion *x, unsigned long timeout)
2231 {
2232         return wait_for_common_io(x, timeout, TASK_UNINTERRUPTIBLE);
2233 }
2234 EXPORT_SYMBOL(wait_for_completion_io_timeout);
2235
2236 /*
2237  * kernel/sched/core.c:4634
2238  */
2239 void show_state_filter(unsigned long state_filter)
2240 {
2241         //printk("\nshow_state_filter");
2242
2243         return;
2244 }
2245
2246 /**
2247  * kernel/sched/core.c:3251
2248  * complete_all: - signals all threads waiting on this completion
2249  * @x:  holds the state of this particular completion
2250  *
2251  * This will wake up all threads waiting on this particular completion event.
2252  *
2253  * It may be assumed that this function implies a write memory barrier before
2254  * changing the task state if and only if any tasks are woken up.
2255  */
2256 void complete_all(struct completion *x)
2257 {
2258         unsigned long flags;
2259
2260         spin_lock_irqsave(&x->wait.lock, flags);
2261         x->done += UINT_MAX/2;
2262         __wake_up_common(&x->wait, TASK_NORMAL, 0, 0, NULL);
2263         spin_unlock_irqrestore(&x->wait.lock, flags);
2264 }
2265 EXPORT_SYMBOL(complete_all);
2266
2267 /**
2268  * kernel/sched/core.c:3341
2269  * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
2270  * @x:  holds the state of this particular completion
2271  * @timeout:  timeout value in jiffies
2272  *
2273  * This waits for either a completion of a specific task to be signaled or for a
2274  * specified timeout to expire. The timeout is in jiffies. It is not
2275  * interruptible.
2276  *
2277  * The return value is 0 if timed out, and positive (at least 1, or number of
2278  * jiffies left till timeout) if completed.
2279  */
2280 unsigned long __sched
2281 wait_for_completion_timeout(struct completion *x, unsigned long timeout)
2282 {
2283         return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
2284 }
2285 EXPORT_SYMBOL(wait_for_completion_timeout);
2286
2287
2288
2289 /*
2290  *
2291  * SMP
2292  *
2293  */
2294 #ifdef CONFIG_SMP
2295
2296 struct migration_arg {
2297         struct task_struct *task;
2298         int dest_cpu;
2299 };
2300
2301 /*
2302  * kernel/sched/core.c:4822
2303  * Move (not current) task off this cpu, onto dest cpu. We're doing
2304  * this because either it can't run here any more (set_cpus_allowed()
2305  * away from this CPU, or CPU going down), or because we're
2306  * attempting to rebalance this task on exec (sched_exec).
2307  *
2308  * So we race with normal scheduler movements, but that's OK, as long
2309  * as the task is no longer on this CPU.
2310  *
2311  * Returns non-zero if task was successfully migrated.
2312  */
2313 static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
2314 {
2315
2316         struct rq *rq_dest, *rq_src;
2317         int ret = 0;
2318
2319         //TODO: testen!
2320         printk("!!MIGRIERE deb task %d zur cpu %d\n",p->pid,dest_cpu);
2321
2322         if (unlikely(!cpu_active(dest_cpu)))
2323                 return ret;
2324
2325         rq_src = cpu_rq(src_cpu);
2326         rq_dest = cpu_rq(dest_cpu);
2327
2328         raw_spin_lock(&p->pi_lock);
2329         double_rq_lock(rq_src, rq_dest);
2330         /* Already moved. */
2331         if (task_cpu(p) != src_cpu)
2332                 goto done;
2333         /* Affinity changed (again). */
2334         if (!cpumask_test_cpu(dest_cpu, tsk_cpus_allowed(p)))
2335                 goto fail;
2336
2337         /*
2338          * If we're not on a rq, the next wake-up will ensure we're
2339          * placed properly.
2340          */
2341         if (p->on_rq) {
2342 //              dequeue_task(rq_src, p, 0);
2343                 list_del(&p->rq_tasks);
2344                 // TODO: maybe not necessary hence double lock
2345                 p->on_rq = 0;
2346                 set_task_cpu(p, dest_cpu);
2347 //              enqueue_task(rq_dest, p, 0);
2348                 list_add(&p->rq_tasks, &rq_dest->rq_list);
2349                 // TODO: maybe not necessary hence double lock
2350                 p->on_rq = 1;
2351 //              check_preempt_curr(rq_dest, p, 0);
2352                 if (rq_dest->curr == rq_dest->idle)
2353                         resched_task(rq_dest->curr);
2354         }
2355 done:
2356         ret = 1;
2357 fail:
2358         double_rq_unlock(rq_src, rq_dest);
2359         raw_spin_unlock(&p->pi_lock);
2360         return ret;
2361 }
2362
2363 /*
2364  * kernel/sched/core:4865
2365  * migration_cpu_stop - this will be executed by a highprio stopper thread
2366  * and performs thread migration by bumping thread off CPU then
2367  * 'pushing' onto another runqueue.
2368  */
2369 static int migration_cpu_stop(void *data)
2370 {
2371         struct migration_arg *arg = data;
2372
2373         /*
2374          * The original target cpu might have gone down and we might
2375          * be on another cpu but it doesn't matter.
2376          */
2377         local_irq_disable();
2378         __migrate_task(arg->task, raw_smp_processor_id(), arg->dest_cpu);
2379         local_irq_enable();
2380         return 0;
2381 }
2382
2383
2384 static void set_rq_online(struct rq *rq)
2385 {
2386         if (!rq->online)
2387                 rq->online = 1;
2388 }
2389
2390 /*
2391 static void set_rq_offline(struct rq *rq)
2392 {
2393         if (rq->online)
2394                 rq->online = 0;
2395 }
2396 */
2397
2398 /*
2399  * migration_call - callback that gets triggered when a CPU is added.
2400  * Here we can start up the necessary migration thread for the new CPU.
2401  */
2402 static int __cpuinit
2403 migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
2404 {
2405         int cpu = (long)hcpu;
2406         unsigned long flags;
2407         struct rq *rq = cpu_rq(cpu);
2408
2409         switch (action & ~CPU_TASKS_FROZEN) {
2410
2411         case CPU_UP_PREPARE:
2412 //              rq->calc_load_update = calc_load_update;
2413                 break;
2414
2415         case CPU_ONLINE:
2416                 /* Update our root-domain */
2417                 raw_spin_lock_irqsave(&rq->lock, flags);
2418 //              if (rq->rd) {
2419 //                      BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
2420 //
2421                         set_rq_online(rq);
2422 //              }
2423                 raw_spin_unlock_irqrestore(&rq->lock, flags);
2424                 break;
2425
2426 #ifdef CONFIG_HOTPLUG_CPU
2427         case CPU_DYING:
2428                 sched_ttwu_pending();
2429                 /* Update our root-domain */
2430                 raw_spin_lock_irqsave(&rq->lock, flags);
2431 //              if (rq->rd) {
2432 //                      BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
2433                         set_rq_offline(rq);
2434 //              }
2435                 migrate_tasks(cpu);
2436                 BUG_ON(rq->nr_running != 1); /* the migration thread */
2437                 raw_spin_unlock_irqrestore(&rq->lock, flags);
2438                 break;
2439
2440         case CPU_DEAD:
2441 //              calc_load_migrate(rq);
2442                 break;
2443 #endif
2444         }
2445
2446 //      update_max_interval();
2447
2448         return NOTIFY_OK;
2449 }
2450
2451 /*
2452  * Register at high priority so that task migration (migrate_all_tasks)
2453  * happens before everything else.  This has to be lower priority than
2454  * the notifier in the perf_event subsystem, though.
2455  */
2456 static struct notifier_block __cpuinitdata migration_notifier = {
2457         .notifier_call = migration_call,
2458         .priority = CPU_PRI_MIGRATION,
2459 };
2460
2461 static int __cpuinit sched_cpu_active(struct notifier_block *nfb,
2462                                       unsigned long action, void *hcpu)
2463 {
2464         switch (action & ~CPU_TASKS_FROZEN) {
2465         case CPU_STARTING:
2466         case CPU_DOWN_FAILED:
2467                 set_cpu_active((long)hcpu, true);
2468                 return NOTIFY_OK;
2469         default:
2470                 return NOTIFY_DONE;
2471         }
2472 }
2473
2474 static int __cpuinit sched_cpu_inactive(struct notifier_block *nfb,
2475                                         unsigned long action, void *hcpu)
2476 {
2477         switch (action & ~CPU_TASKS_FROZEN) {
2478         case CPU_DOWN_PREPARE:
2479                 set_cpu_active((long)hcpu, false);
2480                 return NOTIFY_OK;
2481         default:
2482                 return NOTIFY_DONE;
2483         }
2484 }
2485
2486 static int __init migration_init(void)
2487 {
2488         void *cpu = (void *)(long)smp_processor_id();
2489         int err;
2490
2491         /* Initialize migration for the boot CPU */
2492         err = migration_call(&migration_notifier, CPU_UP_PREPARE, cpu);
2493         BUG_ON(err == NOTIFY_BAD);
2494         migration_call(&migration_notifier, CPU_ONLINE, cpu);
2495         register_cpu_notifier(&migration_notifier);
2496
2497         /* Register cpu active notifiers */
2498         cpu_notifier(sched_cpu_active, CPU_PRI_SCHED_ACTIVE);
2499         cpu_notifier(sched_cpu_inactive, CPU_PRI_SCHED_INACTIVE);
2500
2501         return 0;
2502 }
2503 early_initcall(migration_init);
2504
2505
2506
2507 void do_set_cpus_allowed(struct task_struct *p,
2508                                const struct cpumask *new_mask)
2509 {
2510 //      if (p->sched_class && p->sched_class->set_cpus_allowed)
2511 //              p->sched_class->set_cpus_allowed(p, new_mask);
2512
2513         cpumask_copy(&p->cpus_allowed, new_mask);
2514         p->nr_cpus_allowed = cpumask_weight(new_mask);
2515 }
2516
2517 int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
2518 {
2519         unsigned long flags;
2520         struct rq *rq;
2521         unsigned int dest_cpu;
2522         int ret = 0;
2523
2524         rq = task_rq_lock(p, &flags);
2525
2526         if (cpumask_equal(&p->cpus_allowed, new_mask))
2527                 goto out;
2528
2529         if (!cpumask_intersects(new_mask, cpu_active_mask)) {
2530                 ret = -EINVAL;
2531                 goto out;
2532         }
2533
2534         if (unlikely((p->flags & PF_THREAD_BOUND) && p != current)) {
2535                 ret = -EINVAL;
2536                 goto out;
2537         }
2538
2539         do_set_cpus_allowed(p, new_mask);
2540
2541         /* Can the task run on the task's current CPU? If so, we're done */
2542         if (cpumask_test_cpu(task_cpu(p), new_mask))
2543                 goto out;
2544
2545         dest_cpu = cpumask_any_and(cpu_active_mask, new_mask);
2546         if (p->on_rq) {
2547                 struct migration_arg arg = { p, dest_cpu };
2548                 /* Need help from migration thread: drop lock and wait. */
2549                 task_rq_unlock(rq, p, &flags);
2550                 stop_one_cpu(cpu_of(rq), migration_cpu_stop, &arg);
2551                 tlb_migrate_finish(p->mm);
2552                 return 0;
2553         }
2554 out:
2555         task_rq_unlock(rq, p, &flags);
2556
2557         return ret;
2558 }
2559 EXPORT_SYMBOL_GPL(set_cpus_allowed_ptr);
2560
2561 static void sched_ttwu_pending(void)
2562 {
2563         struct rq *rq = this_rq();
2564         struct llist_node *llist = llist_del_all(&rq->wake_list);
2565         struct task_struct *p;
2566
2567         raw_spin_lock(&rq->lock);
2568
2569         while (llist) {
2570                 p = llist_entry(llist, struct task_struct, wake_entry);
2571                 llist = llist_next(llist);
2572                 ttwu_do_activate(rq, p, 0);
2573         }
2574
2575         raw_spin_unlock(&rq->lock);
2576 }
2577
2578 void scheduler_ipi(void)
2579 {
2580         if (llist_empty(&this_rq()->wake_list)) // && !got_nohz_idle_kick())
2581                         return;
2582
2583         /*
2584          * Not all reschedule IPI handlers call irq_enter/irq_exit, since
2585          * traditionally all their work was done from the interrupt return
2586          * path. Now that we actually do some work, we need to make sure
2587          * we do call them.
2588          *
2589          * Some archs already do call them, luckily irq_enter/exit nest
2590          * properly.
2591          *
2592          * Arguably we should visit all archs and update all handlers,
2593          * however a fair share of IPIs are still resched only so this would
2594          * somewhat pessimize the simple resched case.
2595          */
2596         irq_enter();
2597         sched_ttwu_pending();
2598
2599         /*
2600          * Check if someone kicked us for doing the nohz idle load balance.
2601          */
2602         if (unlikely(/*got_nohz_idle_kick() && */!need_resched())) {
2603 //              this_rq()->idle_balance = 1;
2604                 raise_softirq_irqoff(SCHED_SOFTIRQ);
2605         }
2606         irq_exit();
2607 }
2608
2609 /*
2610  * kernel/sched/core.c:1011
2611  * wait_task_inactive - wait for a thread to unschedule.
2612  *
2613  * If @match_state is nonzero, it's the @p->state value just checked and
2614  * not expected to change.  If it changes, i.e. @p might have woken up,
2615  * then return zero.  When we succeed in waiting for @p to be off its CPU,
2616  * we return a positive number (its total switch count).  If a second call
2617  * a short while later returns the same number, the caller can be sure that
2618  * @p has remained unscheduled the whole time.
2619  *
2620  * The caller must ensure that the task *will* unschedule sometime soon,
2621  * else this function might spin for a *long* time. This function can't
2622  * be called with interrupts off, or it may introduce deadlock with
2623  * smp_call_function() if an IPI is sent by the same process we are
2624  * waiting to become inactive.
2625  */
2626 unsigned long wait_task_inactive(struct task_struct *p, long match_state)
2627 {
2628         unsigned long flags;
2629         int running, on_rq;
2630         unsigned long ncsw;
2631         struct rq *rq;
2632
2633         for (;;) {
2634                 /*
2635                  * We do the initial early heuristics without holding
2636                  * any task-queue locks at all. We'll only try to get
2637                  * the runqueue lock when things look like they will
2638                  * work out!
2639                  */
2640                 rq = task_rq(p);
2641
2642                 /*
2643                  * If the task is actively running on another CPU
2644                  * still, just relax and busy-wait without holding
2645                  * any locks.
2646                  *
2647                  * NOTE! Since we don't hold any locks, it's not
2648                  * even sure that "rq" stays as the right runqueue!
2649                  * But we don't care, since "task_running()" will
2650                  * return false if the runqueue has changed and p
2651                  * is actually now running somewhere else!
2652                  */
2653                 while (task_running(rq, p)) {
2654                         if (match_state && unlikely(p->state != match_state))
2655                                 return 0;
2656                         cpu_relax();
2657                 }
2658
2659                 /*
2660                  * Ok, time to look more closely! We need the rq
2661                  * lock now, to be *sure*. If we're wrong, we'll
2662                  * just go back and repeat.
2663                  */
2664                 rq = task_rq_lock(p, &flags);
2665 //              trace_sched_wait_task(p);
2666                 running = task_running(rq, p);
2667                 on_rq = p->on_rq;
2668                 ncsw = 0;
2669                 if (!match_state || p->state == match_state)
2670                         ncsw = p->nvcsw | LONG_MIN; /* sets MSB */
2671                 task_rq_unlock(rq, p, &flags);
2672
2673                 /*
2674                  * If it changed from the expected state, bail out now.
2675                  */
2676                 if (unlikely(!ncsw))
2677                         break;
2678
2679                 /*
2680                  * Was it really running after all now that we
2681                  * checked with the proper locks actually held?
2682                  *
2683                  * Oops. Go back and try again..
2684                  */
2685                 if (unlikely(running)) {
2686                         cpu_relax();
2687                         continue;
2688                 }
2689
2690                 /*
2691                  * It's not enough that it's not actively running,
2692                  * it must be off the runqueue _entirely_, and not
2693                  * preempted!
2694                  *
2695                  * So if it was still runnable (but just not actively
2696                  * running right now), it's preempted, and we should
2697                  * yield - it could be a while.
2698                  */
2699                 if (unlikely(on_rq)) {
2700                         ktime_t to = ktime_set(0, NSEC_PER_SEC/HZ);
2701
2702                         set_current_state(TASK_UNINTERRUPTIBLE);
2703                         schedule_hrtimeout(&to, HRTIMER_MODE_REL);
2704                         continue;
2705                 }
2706
2707                 /*
2708                  * Ahh, all good. It wasn't running, and it wasn't
2709                  * runnable, which means that it will never become
2710                  * running in the future either. We're all done!
2711                  */
2712                 break;
2713         }
2714
2715         return ncsw;
2716 }
2717
2718 /***
2719  * kernel/sched/core:1116
2720  * kick_process - kick a running thread to enter/exit the kernel
2721  * @p: the to-be-kicked thread
2722  *
2723  * Cause a process which is running on another CPU to enter
2724  * kernel-mode, without any delay. (to get signals handled.)
2725  *
2726  * NOTE: this function doesn't have to take the runqueue lock,
2727  * because all it wants to ensure is that the remote task enters
2728  * the kernel. If the IPI races and the task has been migrated
2729  * to another CPU then no harm is done and the purpose has been
2730  * achieved as well.
2731  */
2732 void kick_process(struct task_struct *p)
2733 {
2734         int cpu;
2735
2736         preempt_disable();
2737         cpu = task_cpu(p);
2738         if ((cpu != smp_processor_id()) && task_curr(p))
2739                 smp_send_reschedule(cpu);
2740         preempt_enable();
2741 }
2742 EXPORT_SYMBOL_GPL(kick_process);
2743
2744 void sched_set_stop_task(int cpu, struct task_struct *stop)
2745 {
2746         printk("\nsched_set_stop_task");
2747 }
2748
2749 bool completion_done(struct completion *x)
2750 {
2751         printk("\ncompletion_done");
2752
2753         return 0;
2754 }
2755
2756 /*
2757  * kernel/sched/core:2605
2758  * sched_exec - execve() is a valuable balancing opportunity, because at
2759  * this point the task has the smallest effective memory and cache footprint.
2760  */
2761 void sched_exec(void)
2762 {
2763         struct task_struct *p = current;
2764         unsigned long flags;
2765         int dest_cpu;
2766
2767         raw_spin_lock_irqsave(&p->pi_lock, flags);
2768         dest_cpu = select_task_rq(p, SD_BALANCE_EXEC, 0);
2769         if (dest_cpu == smp_processor_id())
2770                 goto unlock;
2771
2772         if (likely(cpu_active(dest_cpu))) {
2773                 struct migration_arg arg = { p, dest_cpu };
2774
2775                 raw_spin_unlock_irqrestore(&p->pi_lock, flags);
2776                 stop_one_cpu(task_cpu(p), migration_cpu_stop, &arg);
2777                 return;
2778         }
2779 unlock:
2780         raw_spin_unlock_irqrestore(&p->pi_lock, flags);
2781 }
2782
2783 void set_task_cpu(struct task_struct *p, unsigned int new_cpu)
2784 {
2785 #ifdef CONFIG_SCHED_DEBUG
2786         /*
2787          * We should never call set_task_cpu() on a blocked task,
2788          * ttwu() will sort out the placement.
2789          */
2790         WARN_ON_ONCE(p->state != TASK_RUNNING && p->state != TASK_WAKING &&
2791                         !(task_thread_info(p)->preempt_count & PREEMPT_ACTIVE));
2792
2793 #ifdef CONFIG_LOCKDEP
2794         /*
2795          * The caller should hold either p->pi_lock or rq->lock, when changing
2796          * a task's CPU. ->pi_lock for waking tasks, rq->lock for runnable tasks.
2797          *
2798          * sched_move_task() holds both and thus holding either pins the cgroup,
2799          * see task_group().
2800          *
2801          * Furthermore, all task_rq users should acquire both locks, see
2802          * task_rq_lock().
2803          */
2804         WARN_ON_ONCE(debug_locks && !(lockdep_is_held(&p->pi_lock) ||
2805                                       lockdep_is_held(&task_rq(p)->lock)));
2806 #endif
2807 #endif
2808
2809         // TODO: SMP, needs to implemented while using load balancing
2810 //      trace_sched_migrate_task(p, new_cpu);
2811 //
2812 //      if (task_cpu(p) != new_cpu) {
2813 //              struct task_migration_notifier tmn;
2814 //
2815 //              if (p->sched_class->migrate_task_rq)
2816 //                      p->sched_class->migrate_task_rq(p, new_cpu);
2817 //              p->se.nr_migrations++;
2818 //              perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, NULL, 0);
2819 //
2820 //              tmn.task = p;
2821 //              tmn.from_cpu = task_cpu(p);
2822 //              tmn.to_cpu = new_cpu;
2823 //
2824 //              atomic_notifier_call_chain(&task_migration_notifier, 0, &tmn);
2825 //      }
2826
2827         __set_task_cpu(p, new_cpu);
2828 }
2829
2830 /**
2831  * kernel/sched/core.c:6820
2832  */
2833 void __init sched_init_smp(void)
2834 {
2835         cpumask_var_t non_isolated_cpus;
2836
2837         alloc_cpumask_var(&non_isolated_cpus, GFP_KERNEL);
2838         alloc_cpumask_var(&fallback_doms, GFP_KERNEL);
2839
2840 //      sched_init_numa();
2841
2842         get_online_cpus();
2843         mutex_lock(&sched_domains_mutex);
2844 //      init_sched_domains(cpu_active_mask);
2845         cpumask_andnot(non_isolated_cpus, cpu_possible_mask, cpu_isolated_map);
2846         if (cpumask_empty(non_isolated_cpus))
2847                 cpumask_set_cpu(smp_processor_id(), non_isolated_cpus);
2848         mutex_unlock(&sched_domains_mutex);
2849         put_online_cpus();
2850
2851 //      hotcpu_notifier(sched_domains_numa_masks_update, CPU_PRI_SCHED_ACTIVE);
2852 //      hotcpu_notifier(cpuset_cpu_active, CPU_PRI_CPUSET_ACTIVE);
2853 //      hotcpu_notifier(cpuset_cpu_inactive, CPU_PRI_CPUSET_INACTIVE);
2854
2855         /* RT runtime code needs to handle some hotplug events */
2856 //      hotcpu_notifier(update_runtime, 0);
2857
2858 //      init_hrtick();
2859
2860         /* Move init over to a non-isolated CPU */
2861         if (set_cpus_allowed_ptr(current, non_isolated_cpus) < 0)
2862                 BUG();
2863 //      sched_init_granularity();
2864         free_cpumask_var(non_isolated_cpus);
2865
2866 //      init_sched_rt_class();
2867 }
2868
2869 bool cpus_share_cache(int this_cpu, int that_cpu)
2870 {
2871         return per_cpu(sd_llc_id, this_cpu) == per_cpu(sd_llc_id, that_cpu);
2872 }
2873
2874 #else
2875
2876 /**
2877  * kernel/sched/core.c:6856
2878  */
2879 void sched_init_smp(void)
2880 {
2881         //printk("\nsched_init_smp");
2882
2883         return;
2884 }
2885 #endif /* CONFIG_SMP */
2886
2887
2888
2889 /*
2890  * Syscalls
2891  *
2892  * Help:
2893  * SYSCALL_DEFINEx will be replaced by asmlinkage data_type function_name
2894  * asmlinkage:  tells the compile that the arguments of the function are
2895  *                              not placed in the registers but rather to find on stack
2896  */
2897
2898 /*
2899  * kernel/sched/core.c:3686
2900  * sys_nice - change the priority of the current process.
2901  * @increment: priority increment
2902  *
2903  * sys_setpriority is a more generic, but much slower function that
2904  * does similar things.
2905  */
2906 SYSCALL_DEFINE1(nice, int, increment)
2907 {
2908         printk("SYSCALL nice\n");
2909         return 0;
2910 }
2911
2912 /**
2913  * kernel/sched/core.c:4248
2914  * sys_sched_getaffinity - get the cpu affinity of a process
2915  * @pid: pid of the process
2916  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
2917  * @user_mask_ptr: user-space pointer to hold the current cpu mask
2918  */
2919 SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len,
2920                 unsigned long __user *, user_mask_ptr)
2921 {
2922         printk("SYSCALL sched_getaffinity\n");
2923         return 0;
2924 }
2925
2926 /**
2927  * kernel/sched/core.c:4197
2928  * sys_sched_setaffinity - set the cpu affinity of a process
2929  * @pid: pid of the process
2930  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
2931  * @user_mask_ptr: user-space pointer to the new cpu mask
2932  */
2933 SYSCALL_DEFINE3(sched_setaffinity, pid_t, pid, unsigned int, len,
2934                 unsigned long __user *, user_mask_ptr)
2935 {
2936         printk("SYSCALL sched_setaffinity\n");
2937
2938         // TODO: SMP
2939
2940         return 0;
2941 }
2942
2943 /**
2944  * kernel/sched/core.c:4562
2945  * sys_sched_rr_get_interval - return the default timeslice of a process.
2946  * @pid: pid of the process.
2947  * @interval: userspace pointer to the timeslice value.
2948  *
2949  * this syscall writes the default timeslice value of a given process
2950  * into the user-space timespec buffer. A value of '0' means infinity.
2951  */
2952 SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
2953                 struct timespec __user *, interval)
2954 {
2955         printk("SYSCALL sched_rr_get_interval\n");
2956         return 0;
2957 }
2958
2959 /**
2960  * kernel/sched/core.c:4282
2961  * sys_sched_yield - yield the current processor to other threads.
2962  *
2963  * This function yields the current CPU to other tasks. If there are no
2964  * other threads running on this CPU then this function will return.
2965  */
2966 SYSCALL_DEFINE0(sched_yield)
2967 {
2968         printk("SYSCALL sched_yield\n");
2969         return 0;
2970 }
2971
2972 /**
2973  * kernel/sched/core.c:4027
2974  * sys_sched_setscheduler - set/change the scheduler policy and RT priority
2975  * @pid: the pid in question.
2976  * @policy: new policy.
2977  * @param: structure containing the new RT priority.
2978  */
2979 SYSCALL_DEFINE3(sched_setscheduler, pid_t, pid, int, policy,
2980                 struct sched_param __user *, param)
2981 {
2982         return 0;
2983 }
2984
2985 /**
2986  * kernel/sched/core.c:4051
2987  * sys_sched_getscheduler - get the policy (scheduling class) of a thread
2988  * @pid: the pid in question.
2989  */
2990 SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
2991 {
2992         return 0;
2993 }
2994
2995 /**
2996  * kernel/sched/core.c:4512
2997  * sys_sched_get_priority_max - return maximum RT priority.
2998  * @policy: scheduling class.
2999  *
3000  * this syscall returns the maximum rt_priority that can be used
3001  * by a given scheduling class.
3002  */
3003 SYSCALL_DEFINE1(sched_get_priority_max, int, policy)
3004 {
3005         return 0;
3006 }
3007
3008 /**
3009  * kernel/sched/core.c:4537
3010  * sys_sched_get_priority_min - return minimum RT priority.
3011  * @policy: scheduling class.
3012  *
3013  * this syscall returns the minimum rt_priority that can be used
3014  * by a given scheduling class.
3015  */
3016 SYSCALL_DEFINE1(sched_get_priority_min, int, policy)
3017 {
3018         return 0;
3019 }
3020
3021 /**
3022  * kernel/sched/core.c:4042
3023  * sys_sched_setparam - set/change the RT priority of a thread
3024  * @pid: the pid in question.
3025  * @param: structure containing the new RT priority.
3026  */
3027 SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)
3028 {
3029         return 0;
3030 }
3031
3032 /**
3033  * kernel/sched/core.c:4077
3034  * sys_sched_getparam - get the RT priority of a thread
3035  * @pid: the pid in question.
3036  * @param: structure containing the RT priority.
3037  */
3038 SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
3039 {
3040         return 0;
3041 }