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