Added global scheduler functions of linux and FreeBSD to the framework. p/jkrieg/kbs_fbsd
authorJens Krieg <jkrieg@mailbox.tu-berlin.de>
Thu, 12 Dec 2013 13:26:11 +0000 (14:26 +0100)
committerJens Krieg <jkrieg@mailbox.tu-berlin.de>
Thu, 12 Dec 2013 13:26:11 +0000 (14:26 +0100)
The functions has been sorted by purpose.

sys/framework/os/freebsd/fbsd_sched.c
sys/framework/os/linux/linux_sched.c

index b847776..5eeab9f 100644 (file)
@@ -13,6 +13,8 @@
 
 
 
+
+
 /**
  * \brief      Called from proc0_init() to setup the scheduler fields.
  */
@@ -22,112 +24,103 @@ void schedinit(void)
 }
 
 /**
- * \brief      This is only somewhat accurate since given many processes of the same
- *                     priority they will switch when their slices run out, which will be
- *                     at most sched_slice stathz ticks.
+ * \brief      Update the remaining time slice of the thread.
  *
- * @return     Returns a time slice in Hz.
+ * @param      td              Thread that shall be modified.
  */
-int sched_rr_interval(void)
+void sched_clock(struct thread *td)
 {
-       return 0;
+
 }
 
 /**
- * \brief      Update a thread's priority when it is lent another thread's
- *                     priority.
+ * \brief      Called once per hz tick.
  *
- * @param      td              Thread that shall be modified.
- * @param      prio    Lent priority value of another thread.
+ * @param      cnt
  */
-void sched_lend_prio(struct thread *td, u_char prio)
+void sched_tick(int cnt)
 {
-
+       /* Empty by design. */
 }
 
 /**
- * \brief      Restore a thread's priority when priority propagation is
- *                     over. The prio argument is the minimum priority the thread
- *                     needs to have to satisfy other possible priority lending
- *                     requests. If the thread's regular priority is less
- *                     important than prio, the thread will keep a priority boost
- *                     of prio.
+ * \brief      The actual idle process.
  *
- * @param      td              Thread that shall be modified.
- * @param      prio    Old priority value of the thread.
+ * @param      dummy   Free to abusse.
  */
-void sched_unlend_prio(struct thread *td, u_char prio)
+void sched_idletd(void *dummy)
 {
 
 }
 
 /**
- * \brief      Standard entry for setting the priority to an absolute value.
+ * \brief      Switch threads. This function has to handle threads coming in while
+ *                     blocked for some reason, running, or idle. It also must deal with
+ *                     migrating a thread from one queue to another as running threads may
+ *                     be assigned elsewhere via binding.
  *
- * @param      td              Thread that shall be modified.
- * @param      prio    Set the priority value of the given thread.
+ * @param      td              Running thread.
+ * @param      newtd   Should always be NULL.
+ * @param      flags   Flags can be consider in the scheduling decision.
  */
-void sched_prio(struct thread *td, u_char prio)
+void sched_switch(struct thread *td, struct thread *newtd, int flags)
 {
 
 }
 
 /**
- * \brief      Set the base user priority, does not effect current running priority.
+ * \brief      Penalize the parent for creating a new child and initialize the child's
+ *                     priority.
  *
- * @param      td              Thread that shall be modified.
- * @param      prio    Set user base priority value of the given thread.
+ * @param      td              Parent.
+ * @param      child   Thread to be forked from parent.
  */
-void sched_user_prio(struct thread *td, u_char prio)
+void sched_fork(struct thread *td, struct thread *child)
 {
 
 }
 
 /**
- * \brief      Update a thread's user priority when it is lent another thread's user
- *                     priority.
+ * \brief      Fork a new thread, may be within the same process.
  *
- * @param      td              Thread that shall be modified.
- * @param      prio    Lent user priority value of another thread.
+ * @param      td              Parent.
+ * @param      child   Thread to be forked from parent.
  */
-void sched_lend_user_prio(struct thread *td, u_char prio)
+void sched_fork_thread(struct thread *td, struct thread *child)
 {
 
 }
 
 /**
- * \brief      Switch threads. This function has to handle threads coming in while
- *                     blocked for some reason, running, or idle. It also must deal with
- *                     migrating a thread from one queue to another as running threads may
- *                     be assigned elsewhere via binding.
+ * \brief      This is called from fork_exit(). Just acquire the correct locks and
+ *                     let fork do the rest of the work.
  *
- * @param      td              Running thread.
- * @param      newtd   Should always be NULL.
- * @param      flags   Flags can be consider in the scheduling decision.
+ * @param      td              Thread that shall be forked soon.
  */
-void sched_switch(struct thread *td, struct thread *newtd, int flags)
+void sched_fork_exit(struct thread *td)
 {
 
 }
 
 /**
- * \brief      Adjust thread priorities as a result of a nice request.
+ * \brief      Choose the highest priority thread to run. The thread is removed from
+ *                     the run-queue while running however the load remains.
  *
- * @param      p               Process pointer.
- * @param      nice    Set nice value of process and change his priority as well.
+ * @return     Next thread to run.
  */
-void sched_nice(struct proc *p, int nice)
+struct thread* sched_choose(void)
 {
-
+       return 0;
 }
 
 /**
- * \brief      Record the sleep time for the interactivity scorer.
+ * \brief      Select the target thread queue and add a thread to it. Request
+ *                     preemption or IPI a remote processor if required.
  *
- * @param      td              Thread that shall be modified.
- * @param      prio    Priority value set to the thread and store the sleep time.
+ * @param      td              Thread add to e.g. a run-queue
+ * @param      flags   Properties of the new thread.
  */
-void sched_sleep(struct thread *td, int prio)
+void sched_add(struct thread *td, int flags)
 {
 
 }
@@ -154,29 +147,6 @@ void sched_class(struct thread *td, int class)
 
 }
 
-/**
- * \brief      Penalize the parent for creating a new child and initialize the child's
- *                     priority.
- *
- * @param      td              Parent.
- * @param      child   Thread to be forked from parent.
- */
-void sched_fork(struct thread *td, struct thread *child)
-{
-
-}
-
-/**
- * \brief      Fork a new thread, may be within the same process.
- *
- * @param      td              Parent.
- * @param      child   Thread to be forked from parent.
- */
-void sched_fork_thread(struct thread *td, struct thread *child)
-{
-
-}
-
 /**
  * \brief      Return some of the child's priority and interactivity to the parent.
  *
@@ -203,101 +173,108 @@ void sched_exit_thread(struct thread *td, struct thread *child)
 }
 
 /**
- * \brief      This is called from fork_exit(). Just acquire the correct locks and
- *                     let fork do the rest of the work.
+ * \brief      Update a thread's priority when it is lent another thread's
+ *                     priority.
  *
- * @param      td              Thread that shall be forked soon.
+ * @param      td              Thread that shall be modified.
+ * @param      prio    Lent priority value of another thread.
  */
-void sched_fork_exit(struct thread *td)
+void sched_lend_prio(struct thread *td, u_char prio)
 {
 
 }
 
 /**
- * \brief      Used by void ipi_bitmap_handler(struct trapframe frame);
- *                     sys/amd64/amd64/mp_machdep.c:1267
+ * \brief      Restore a thread's priority when priority propagation is
+ *                     over. The prio argument is the minimum priority the thread
+ *                     needs to have to satisfy other possible priority lending
+ *                     requests. If the thread's regular priority is less
+ *                     important than prio, the thread will keep a priority boost
+ *                     of prio.
  *
- * @param      td              Thread to be preemted.
+ * @param      td              Thread that shall be modified.
+ * @param      prio    Old priority value of the thread.
  */
-void sched_preempt(struct thread *td)
+void sched_unlend_prio(struct thread *td, u_char prio)
 {
 
 }
 
 /**
- * \brief      Fix priorities on return to user-space. Priorities may be elevated due
- *                     to static priorities in msleep() or similar.
+ * \brief      Standard entry for setting the priority to an absolute value.
  *
  * @param      td              Thread that shall be modified.
+ * @param      prio    Set the priority value of the given thread.
  */
-void sched_userret(struct thread *td)
+void sched_prio(struct thread *td, u_char prio)
 {
 
 }
 
 /**
- * \brief      Update the remaining time slice of the thread.
+ * \brief      Set the base user priority, does not effect current running priority.
  *
  * @param      td              Thread that shall be modified.
+ * @param      prio    Set user base priority value of the given thread.
  */
-void sched_clock(struct thread *td)
+void sched_user_prio(struct thread *td, u_char prio)
 {
 
 }
 
 /**
- * \brief      Called once per hz tick.
+ * \brief      Update a thread's user priority when it is lent another thread's user
+ *                     priority.
  *
- * @param      cnt
+ * @param      td              Thread that shall be modified.
+ * @param      prio    Lent user priority value of another thread.
  */
-void sched_tick(int cnt)
+void sched_lend_user_prio(struct thread *td, u_char prio)
 {
-       /* Empty by design. */
+
 }
 
 /**
- * \brief      Return whether the current CPU has runnable tasks. Used for in-kernel
- *                     cooperative idle threads.
+ * \brief      Fix priorities on return to user-space. Priorities may be elevated due
+ *                     to static priorities in msleep() or similar.
  *
- * @return     0: no load, 1: load
+ * @param      td              Thread that shall be modified.
  */
-int sched_runnable(void)
+void sched_userret(struct thread *td)
 {
-       return 0;
+
 }
 
 /**
- * \brief      Choose the highest priority thread to run. The thread is removed from
- *                     the run-queue while running however the load remains.
+ * \brief      Used by void ipi_bitmap_handler(struct trapframe frame);
+ *                     sys/amd64/amd64/mp_machdep.c:1267
  *
- * @return     Next thread to run.
+ * @param      td              Thread to be preemted.
  */
-struct thread* sched_choose(void)
+void sched_preempt(struct thread *td)
 {
-       return 0;
+
 }
 
 /**
- * \brief      Select the target thread queue and add a thread to it. Request
- *                     preemption or IPI a remote processor if required.
+ * \brief      Basic yield call.
  *
- * @param      td              Thread add to e.g. a run-queue
- * @param      flags   Properties of the new thread.
+ * @param      td              Thread that yields.
  */
-void sched_add(struct thread *td, int flags)
+void sched_relinquish(struct thread *td)
 {
 
 }
 
 /**
- * \brief      Fetch cpu utilization information. Updates on demand.
+ * \brief      Adjust thread priorities as a result of a nice request.
  *
- * @param      td              Thread to be evaluated.
- * @return     CPU utilization of the thread.
+ * @param      p               Process pointer.
+ * @param      nice    Set nice value of process and change his priority as well.
  */
-fixpt_t sched_pctcpu(struct thread *td)
+void sched_nice(struct proc *p, int nice)
 {
-       return 0;
+
 }
 
 /**
@@ -344,13 +321,48 @@ int sched_is_bound(struct thread *td)
 }
 
 /**
- * \brief      Basic yield call.
+ * \brief      This is only somewhat accurate since given many processes of the same
+ *                     priority they will switch when their slices run out, which will be
+ *                     at most sched_slice stathz ticks.
  *
- * @param      td              Thread that yields.
+ * @return     Returns a time slice in Hz.
  */
-void sched_relinquish(struct thread *td)
+int sched_rr_interval(void)
+{
+       return 0;
+}
+
+/**
+ * \brief      Record the sleep time for the interactivity scorer.
+ *
+ * @param      td              Thread that shall be modified.
+ * @param      prio    Priority value set to the thread and store the sleep time.
+ */
+void sched_sleep(struct thread *td, int prio)
+{
+
+}
+
+/**
+ * \brief      Return whether the current CPU has runnable tasks. Used for in-kernel
+ *                     cooperative idle threads.
+ *
+ * @return     0: no load, 1: load
+ */
+int sched_runnable(void)
 {
+       return 0;
+}
 
+/**
+ * \brief      Fetch cpu utilization information. Updates on demand.
+ *
+ * @param      td              Thread to be evaluated.
+ * @return     CPU utilization of the thread.
+ */
+fixpt_t sched_pctcpu(struct thread *td)
+{
+       return 0;
 }
 
 /**
@@ -383,20 +395,10 @@ int sched_sizeof_thread(void)
        return 0;
 }
 
-/**
- * \brief      The actual idle process.
- *
- * @param      dummy   Free to abusse.
- */
-void sched_idletd(void *dummy)
-{
-
-}
-
 /**
  * \brief      A CPU is entering for the first time or a thread is exiting.
  *
- * @param      td              Thread to be thrown away.
+ * @param      td              Thread to be thrown away. Choose a new one to be scheduled.
  */
 void sched_throw(struct thread *td)
 {
index 401355b..8f3f947 100644 (file)
@@ -5,6 +5,28 @@
  *      Author: jkrieg
  */
 
+#include <linux/init.h>
+#include <asm/mmu_context.h>
+#include <linux/completion.h>
+#include <linux/kernel_stat.h>
+#include <linux/blkdev.h>
+#include <linux/syscalls.h>
+#include <linux/kprobes.h>
+#include <linux/delayacct.h>
+#include <linux/export.h>
+#include <linux/context_tracking.h>
+#include <linux/kthread.h>
+#include <linux/init_task.h>
+
+#include <asm/switch_to.h>
+#include <asm/tlb.h>
+#include <linux/cgroup.h>
+#include "sched.h"
+#include "../workqueue_internal.h"
+#include "../smpboot.h"
+
+
+
 /*
  * kernel/sched/rt.c:10
  * default timeslice is 100 msecs (used only for SCHED_RR tasks).
@@ -67,85 +89,84 @@ DEFINE_PER_CPU(struct kernel_cpustat, kernel_cpustat);
 
 
 
-//
-// Functions
-//
 
-/*
- * /kernel/sched/cputime.c:436
- * Account multiple ticks of idle time.
- * @ticks: number of stolen ticks
+
+
+/**
+ * kernel/sched/core.c:6872
+ * Initialize the scheduler
  */
-void account_idle_ticks(unsigned long ticks)
+void sched_init(void)
 {
     return;
 }
 
-/*
- * /kernel/sched/cputime.c:397
- * Account a single tick of cpu time.
- * @p: the process that the cpu time gets accounted to
- * @user_tick: indicates if the tick is a user or a system tick
+/**
+ * kernel/sched/core.c:6850
  */
-void account_process_tick(struct task_struct *p, int user_tick)
+void sched_init_smp(void)
 {
     return;
 }
 
-/*
- * /kernel/sched/core.c:2092
- * get_avenrun - get the load average array
- * @loads:    pointer to dest load array
- * @offset:    offset to add
- * @shift:    shift count to shift the result left
+/**
+ * /kernel/sched/core.c:4674
+ * init_idle - set up an idle thread for a given CPU
+ * @idle: task in question
+ * @cpu: cpu the idle task belongs to
  *
- * These values are estimates at best, so no need for locking.
+ * NOTE: this function does not set the idle thread's NEED_RESCHED
+ * flag, to make booting more robust.
  */
-void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
+void __cpuinit init_idle(struct task_struct *idle, int cpu)
 {
     return;
 }
 
 /*
- * /kernel/sched/core.c:2363
- * calc_load - update the avenrun load estimates 10 ticks after the
- * CPUs have updated calc_load_tasks.
+ * /kernel/sched/core.c:4669
+ * Sets sched_class of idle task, see struct sched_class idle_sched_class;
  */
-void calc_global_load(unsigned long ticks)
+void __cpuinit init_idle_bootup_task(struct task_struct *idle)
 {
     return;
 }
 
 /*
- * /kernel/sched/core.c:2197
- * We're going into NOHZ mode, if there's any pending delta, fold it
- * into the pending idle delta.
+ * kernel/sched/clock.c:350
+ * Initialize/Start scheduler clock.
  */
-void calc_load_enter_idle(void)
+void sched_clock_init(void)
 {
     return;
 }
 
 /*
- * /kernel/sched/core.c:2213
- * If we're still before the sample window, we're done.
- *
- * We woke inside or after the sample window, this means we're already
- * accounted through the nohz accounting, so skip the entire deal and
- * sync up for the next window.
+ * kernel/sched/core.c:2684
+ * This function gets called by the timer code, with HZ frequency.
+ * We call it with interrupts disabled.
  */
-void calc_load_exit_idle(void)
+void scheduler_tick(void)
 {
     return;
 }
 
-/*
- * /kernel/sched/core.c:3668
- * Check if a task can reduce its nice value
- * @p: task
- * @nice: nice value
+/**
+ * sched_clock_cpu - returns current time in nanosec units
+ * using scheduler clock function.
+ * @param: cpu id
  */
-int can_nice(const struct task_struct *p, const int nice)
+u64 sched_clock_cpu(int cpu)
+{
+    return 0;
+}
+
+/**
+ * kernel/sched/core.c:892
+ * task_curr - is this task currently executing on a CPU?
+ * @p: the task in question.
+ */
+inline int task_curr(const struct task_struct *p)
 {
     return 0;
 }
@@ -170,523 +191,522 @@ int idle_cpu(int cpu)
     return 0;
 }
 
-/**
- * /kernel/sched/core.c:4674
- * init_idle - set up an idle thread for a given CPU
- * @idle: task in question
- * @cpu: cpu the idle task belongs to
- *
- * NOTE: this function does not set the idle thread's NEED_RESCHED
- * flag, to make booting more robust.
+/*
+ * kernel/sched/core.c:2966
  */
-void __cpuinit init_idle(struct task_struct *idle, int cpu)
+asmlinkage void __sched schedule(void)
 {
     return;
 }
 
 /*
- * /kernel/sched/core.c:4669
- * Sets sched_class of idle task, see struct sched_class idle_sched_class;
+ * kernel/sched/core.c:1622
+ * fork()/clone()-time setup:
  */
-void __cpuinit init_idle_bootup_task(struct task_struct *idle)
+void sched_fork(struct task_struct *p)
 {
     return;
 }
 
-/*
- * /kernel/sched/core.c:7108
- * Calls private function
- * static void normalize_task(struct rq *rq, struct task_struct *p)
+/**
+ * kernel/sched/core.c:1905
+ * schedule_tail - first thing a freshly forked thread must call.
+ * @prev: the thread we just switched away from.
  */
-void normalize_rt_tasks(void)
+void schedule_tail(struct task_struct *prev)
 {
     return;
 }
 
 /*
- * /kernel/sched/core.c:1997
- * nr_running and nr_context_switches:
+ * kernel/sched/core.c:1703
+ * wake_up_new_task - wake up a newly created task for the first time.
  *
- * externally visible scheduler statistics:
- *   current number of runnable threads
- *   total number of context switches performed since bootup.
+ * This function will do some initial scheduler statistics housekeeping
+ * that must be done for every newly created context, then puts the task
+ * on the runqueue and wakes it.
  */
-unsigned long nr_running(void)
+void wake_up_new_task(struct task_struct *tsk)
 {
-    return 0;
+    return;
 }
 
-unsigned long long nr_context_switches(void)
+/**
+ * kernel/sched/core.c:1536
+ * wake_up_process - Wake up a specific process
+ * @p: The process to be woken up.
+ *
+ * Attempt to wake up the nominated process and move it to the set of runnable
+ * processes.  Returns 1 if the process was woken up, 0 if it was already
+ * running.
+ *
+ * It may be assumed that this function implies a write memory barrier before
+ * changing the task state if and only if any tasks are woken up.
+ */
+int wake_up_process(struct task_struct *p)
 {
     return 0;
 }
 
 /*
- * /kernel/sched/core.c:2017
- * number of threads waiting on IO
+ * kernel/sched/core.c:4333
  */
-unsigned long nr_iowait(void)
+int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags, void *key)
 {
     return 0;
 }
 
-/*
- * rt_mutex_setprio - set the current priority of a task
- * @p: task
- * @prio: prio value (kernel-internal form)
- *
- * This function changes the 'effective' priority of a task. It does
- * not touch ->normal_prio like __setscheduler().
+/**
+ * kernel/sched/core.c:3149
+ * __wake_up - wake up threads blocked on a waitqueue.
+ * @q: the waitqueue
+ * @mode: which threads
+ * @nr_exclusive: how many wake-one or wake-many threads to wake up
+ * @key: is directly passed to the wakeup function
  *
- * Used by the rt_mutex code to implement priority inheritance logic.
+ * It may be assumed that this function implies a write memory barrier before
+ * changing the task state if and only if any tasks are woken up.
  */
-void rt_mutex_setprio(struct task_struct *p, int prio)
+void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, void *key)
 {
     return;
 }
 
-/**
- * sched_clock_cpu - returns current time in nanosec units
- * using scheduler clock function.
- * @param: cpu id
+/*
+ * kernel/sched/core.c:1543
  */
-u64 sched_clock_cpu(int cpu)
+int wake_up_state(struct task_struct *p, unsigned int state)
 {
     return 0;
 }
 
-/*
- * kernel/sched/clock.c:350
- * Initialize/Start scheduler clock.
+/**
+ * kernel/sched/core.c:3213
+ * __wake_up_sync - see __wake_up_sync_key()
  */
-void sched_clock_init(void)
+void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
 {
     return;
 }
 
-/*
- * kernel/sched/core.c:1622
- * fork()/clone()-time setup:
+/**
+ * kernel/sched/core.c:3192
+ * __wake_up_sync_key - wake up threads blocked on a waitqueue.
+ * @q: the waitqueue
+ * @mode: which threads
+ * @nr_exclusive: how many wake-one or wake-many threads to wake up
+ * @key: opaque value to be passed to wakeup targets
+ *
+ * The sync wakeup differs that the waker knows that it will schedule
+ * away soon, so while the target thread will be woken up, it will not
+ * be migrated to another CPU - ie. the two threads are 'synchronized'
+ * with each other. This can prevent needless bouncing between CPUs.
+ *
+ * On UP it can prevent extra preemption.
+ *
+ * It may be assumed that this function implies a write memory barrier before
+ * changing the task state if and only if any tasks are woken up.
  */
-void sched_fork(struct task_struct *p)
+void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
+            int nr_exclusive, void *key)
 {
     return;
 }
 
 /**
- * kernel/sched/core.c:4213
- * This functions stores the CPU affinity mask for the process or thread with the ID pid in the cpusetsize
- * bytes long bitmap pointed to by cpuset. If successful, the function always initializes all bits in the
- * cpu_set_t object and returns zero.
- *
- * If pid does not correspond to a process or thread on the system the or the function fails for some other
- * reason, it returns -1 and errno is set to represent the error condition.
+ * kernel/sched/core.c:3163
+ * Same as __wake_up but called with the spinlock in wait_queue_head_t held.
  */
-long sched_getaffinity(pid_t pid, struct cpumask *mask)
+void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr)
 {
-    return 0;
+    return;
 }
 
 /**
- * kernel/sched/core.c:6872
- * Initialize the scheduler
+ * kernel/sched/core.c:3169
  */
-void sched_init(void)
+void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key)
 {
     return;
 }
 
 /**
- * kernel/sched/core.c:6850
+ * kernel/sched/core.c:3231
+ * complete: - signals a single thread waiting on this completion
+ * @x:  holds the state of this particular completion
+ *
+ * This will wake up a single thread waiting on this completion. Threads will be
+ * awakened in the same order in which they were queued.
+ *
+ * See also complete_all(), wait_for_completion() and related routines.
+ *
+ * It may be assumed that this function implies a write memory barrier before
+ * changing the task state if and only if any tasks are woken up.
  */
-void sched_init_smp(void)
+void complete(struct completion *x)
 {
     return;
 }
 
 /**
- * kernel/sched/core.c:7571
+ * kernel/sched/core.c:3251
+ * complete_all: - signals all threads waiting on this completion
+ * @x:  holds the state of this particular completion
+ *
+ * This will wake up all threads waiting on this particular completion event.
+ *
+ * It may be assumed that this function implies a write memory barrier before
+ * changing the task state if and only if any tasks are woken up.
  */
-int sched_rr_handler(struct ctl_table *table, int write,
-        void __user *buffer, size_t *lenp,
-        loff_t *ppos)
+void complete_all(struct completion *x)
 {
-    return 0;
+    return;
 }
 
 /**
- * kernel/sched/core.c:4111
- * This function installs the cpusetsize bytes long affinity mask pointed to by cpuset for the process or
- * thread with the ID pid. If successful the function returns zero and the scheduler will in future take the
- * affinity information into account.
- */
-long sched_setaffinity(pid_t pid, const struct cpumask *new_mask)
-{
-    return 0;
-}
-
-/**
- * kernel/sched/core.c:3975
- * sched_setscheduler - change the scheduling policy and/or RT priority of a thread.
- * @p: the task in question.
- * @policy: new policy.
- * @param: structure containing the new RT priority.
+ * kernel/sched/core.c:3322
+ * wait_for_completion: - waits for completion of a task
+ * @x:  holds the state of this particular completion
  *
- * NOTE that the task may be already dead.
+ * This waits to be signaled for completion of a specific task. It is NOT
+ * interruptible and there is no timeout.
+ *
+ * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
+ * and interrupt capability. Also see complete().
  */
-int sched_setscheduler(struct task_struct *p, int policy,
-        const struct sched_param *param)
+void __sched wait_for_completion(struct completion *x)
 {
-    return 0;
+    return;
 }
 
 /**
- * kernel/sched/core.c:3993
- * sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernelspace.
- * @p: the task in question.
- * @policy: new policy.
- * @param: structure containing the new RT priority.
+ * kernel/sched/core.c:3341
+ * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
+ * @x:  holds the state of this particular completion
+ * @timeout:  timeout value in jiffies
  *
- * Just like sched_setscheduler, only don't bother checking if the
- * current context has permission.  For example, this is needed in
- * stop_machine(): we create temporary high priority worker threads,
- * but our caller might not have that capability.
+ * This waits for either a completion of a specific task to be signaled or for a
+ * specified timeout to expire. The timeout is in jiffies. It is not
+ * interruptible.
+ *
+ * The return value is 0 if timed out, and positive (at least 1, or number of
+ * jiffies left till timeout) if completed.
  */
-int sched_setscheduler_nocheck(struct task_struct *p, int policy,
-const struct sched_param *param)
+unsigned long __sched wait_for_completion_timeout(struct completion *x, unsigned long timeout)
 {
     return 0;
 }
 
 /**
- * kernel/sched/core.c:4601
+ * kernel/sched/core.c:3355
+ * wait_for_completion_io: - waits for completion of a task
+ * @x:  holds the state of this particular completion
+ *
+ * This waits to be signaled for completion of a specific task. It is NOT
+ * interruptible and there is no timeout. The caller is accounted as waiting
+ * for IO.
  */
-void sched_show_task(struct task_struct *p)
+void __sched wait_for_completion_io(struct completion *x)
 {
     return;
 }
 
 /**
- * kernel/sched/core.c:1905
- * schedule_tail - first thing a freshly forked thread must call.
- * @prev: the thread we just switched away from.
+ * kernel/sched/core.c:3426
+ * wait_for_completion_killable: - waits for completion of a task (killable)
+ * @x:  holds the state of this particular completion
+ *
+ * This waits to be signaled for completion of a specific task. It can be
+ * interrupted by a kill signal.
+ *
+ * The return value is -ERESTARTSYS if interrupted, 0 if completed.
  */
-void schedule_tail(struct task_struct *prev)
+int __sched wait_for_completion_killable(struct completion *x)
 {
-    return;
+    return 0;
 }
 
-/*
- * kernel/sched/core.c:2684
- * This function gets called by the timer code, with HZ frequency.
- * We call it with interrupts disabled.
+/**
+ * kernel/sched/core.c:4474
+ * This task is about to go to sleep on IO. Increment rq->nr_iowait so
+ * that process accounting knows that this is a task in IO wait state.
  */
-void scheduler_tick(void)
+void __sched io_schedule(void)
 {
     return;
 }
 
-/*
- * kernel/sched/core.c:2649
- * Lock/unlock the current runqueue - to extract task statistics:
+/**
+ * kernel/sched/core.c:4489
  */
-unsigned long long task_delta_exec(struct task_struct *p)
+long __sched io_schedule_timeout(long timeout)
 {
     return 0;
 }
 
 /**
- * kernel/sched/core.c:3727
- * task_prio - return the priority value of a given task.
- * @p: the task in question.
+ * kernel/sched/core.c:4389
+ * yield - yield the current processor to other threads.
  *
- * This is the priority value as seen by users in /proc.
- * RT tasks are offset by -200. Normal tasks are centered
- * around 0, value goes from -16 to +15.
+ * Do not ever use this function, there's a 99% chance you're doing it wrong.
+ *
+ * The scheduler is at all times free to pick the calling task as the most
+ * eligible task to run, if removing the yield() call from your code breaks
+ * it, its already broken.
+ *
+ * Typical broken usage is:
+ *
+ * while (!event)
+ *     yield();
+ *
+ * where one assumes that yield() will let 'the other' process run that will
+ * make event true. If the current task is a SCHED_FIFO task that will never
+ * happen. Never use yield() as a progress guarantee!!
+ *
+ * If you want to use yield() to wait for something, use wait_event().
+ * If you want to use yield() to be 'nice' for others, use cond_resched().
+ * If you still want to use yield(), do not!
  */
-int task_prio(const struct task_struct *p)
+void __sched yield(void)
 {
-    return 0;
+    return;
 }
 
-/*
- * kernel/sched/core.c:2667
- * Return accounted runtime for the task.
- * In case the task is currently running, return the runtime plus current's
- * pending runtime that have not been accounted yet.
+/**
+ * kernel/sched/core.c:2995
+ * schedule_preempt_disabled - called with preemption disabled
+ *
+ * Returns with preemption disabled. Note: preempt_count must be 1
  */
-unsigned long long task_sched_runtime(struct task_struct *task)
+void __sched schedule_preempt_disabled(void)
 {
-    return 0;
+    return;
 }
 
 /*
- * kernel/sched/core.c:2024
- * this_cpu_load - returns load of the cpu
+ * kernel/sched/core.c:4315
  */
-unsigned long this_cpu_load(void)
+int __sched _cond_resched(void)
 {
     return 0;
 }
 
 /*
- * kernel/sched/core.c:2556
- * update_cpu_load_nohz - called from tick_nohz_idle_exit() -- try and fix up the ticks we missed.
+ * kernel/sched/core.c:4333
+ * __cond_resched_lock() - if a reschedule is pending, drop the given lock,
+ * call schedule, and on return reacquire the lock.
+ *
+ * This works OK both with and without CONFIG_PREEMPT. We do strange low-level
+ * operations here to prevent schedule() from being called twice (once via
+ * spin_unlock(), once by hand).
  */
-void update_cpu_load_nohz(void)
+int __cond_resched_lock(spinlock_t *lock)
 {
-    return;
+    return 0;
 }
 
-/*
- * kernel/sched/core.c:1703
- * wake_up_new_task - wake up a newly created task for the first time.
- *
- * This function will do some initial scheduler statistics housekeeping
- * that must be done for every newly created context, then puts the task
- * on the runqueue and wakes it.
+/**
+ * kernel/sched/core.c:3736
+ * task_nice - return the nice value of a given task.
+ * @p: the task in question.
  */
-void wake_up_new_task(struct task_struct *tsk)
+int task_nice(const struct task_struct *p)
 {
-    return;
+    return 0;
 }
 
 /*
- * kernel/sched/core.c:4315
+ * /kernel/sched/core.c:3668
+ * Check if a task can reduce its nice value
+ * @p: task
+ * @nice: nice value
  */
-int __sched _cond_resched(void)
+int can_nice(const struct task_struct *p, const int nice)
 {
     return 0;
 }
 
-/*
- * kernel/sched/core.c:2966
+/**
+ * kernel/sched/core.c:3616
  */
-asmlinkage void __sched schedule(void)
+void set_user_nice(struct task_struct *p, long nice)
 {
     return;
 }
 
 /**
- * kernel/sched/core.c:3149
- * __wake_up - wake up threads blocked on a waitqueue.
- * @q: the waitqueue
- * @mode: which threads
- * @nr_exclusive: how many wake-one or wake-many threads to wake up
- * @key: is directly passed to the wakeup function
+ * kernel/sched/core.c:3727
+ * task_prio - return the priority value of a given task.
+ * @p: the task in question.
  *
- * It may be assumed that this function implies a write memory barrier before
- * changing the task state if and only if any tasks are woken up.
+ * This is the priority value as seen by users in /proc.
+ * RT tasks are offset by -200. Normal tasks are centered
+ * around 0, value goes from -16 to +15.
  */
-void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, void *key)
+int task_prio(const struct task_struct *p)
 {
-    return;
+    return 0;
 }
 
 /**
- * kernel/sched/core.c:1536
- * wake_up_process - Wake up a specific process
- * @p: The process to be woken up.
- *
- * Attempt to wake up the nominated process and move it to the set of runnable
- * processes.  Returns 1 if the process was woken up, 0 if it was already
- * running.
- *
- * It may be assumed that this function implies a write memory barrier before
- * changing the task state if and only if any tasks are woken up.
+ * kernel/sched/core.c:4111
+ * This function installs the cpusetsize bytes long affinity mask pointed to by cpuset for the process or
+ * thread with the ID pid. If successful the function returns zero and the scheduler will in future take the
+ * affinity information into account.
  */
-int wake_up_process(struct task_struct *p)
+long sched_setaffinity(pid_t pid, const struct cpumask *new_mask)
 {
     return 0;
 }
 
 /**
- * kernel/sched/core.c:3322
- * wait_for_completion: - waits for completion of a task
- * @x:  holds the state of this particular completion
- *
- * This waits to be signaled for completion of a specific task. It is NOT
- * interruptible and there is no timeout.
+ * kernel/sched/core.c:4213
+ * This functions stores the CPU affinity mask for the process or thread with the ID pid in the cpusetsize
+ * bytes long bitmap pointed to by cpuset. If successful, the function always initializes all bits in the
+ * cpu_set_t object and returns zero.
  *
- * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
- * and interrupt capability. Also see complete().
+ * If pid does not correspond to a process or thread on the system the or the function fails for some other
+ * reason, it returns -1 and errno is set to represent the error condition.
  */
-void __sched wait_for_completion(struct completion *x)
+long sched_getaffinity(pid_t pid, struct cpumask *mask)
 {
-    return;
+    return 0;
 }
 
-/**
- * kernel/sched/core.c:3231
- * complete: - signals a single thread waiting on this completion
- * @x:  holds the state of this particular completion
- *
- * This will wake up a single thread waiting on this completion. Threads will be
- * awakened in the same order in which they were queued.
- *
- * See also complete_all(), wait_for_completion() and related routines.
- *
- * It may be assumed that this function implies a write memory barrier before
- * changing the task state if and only if any tasks are woken up.
+/*
+ * kernel/sched/core.c:2667
+ * Return accounted runtime for the task.
+ * In case the task is currently running, return the runtime plus current's
+ * pending runtime that have not been accounted yet.
  */
-void complete(struct completion *x)
+unsigned long long task_sched_runtime(struct task_struct *task)
 {
-    return;
+    return 0;
 }
 
-/**
- * kernel/sched/core.c:2995
- * schedule_preempt_disabled - called with preemption disabled
- *
- * Returns with preemption disabled. Note: preempt_count must be 1
+/*
+ * /kernel/sched/cputime.c:436
+ * Account multiple ticks of idle time.
+ * @ticks: number of stolen ticks
  */
-void __sched schedule_preempt_disabled(void)
+void account_idle_ticks(unsigned long ticks)
 {
     return;
 }
 
 /*
- * kernel/sched/core.c:6858
+ * /kernel/sched/cputime.c:397
+ * Account a single tick of cpu time.
+ * @p: the process that the cpu time gets accounted to
+ * @user_tick: indicates if the tick is a user or a system tick
  */
-int in_sched_functions(unsigned long addr)
+void account_process_tick(struct task_struct *p, int user_tick)
 {
-    return 0;
+    return;
 }
 
 /*
- * kernel/sched/core.c:4333
- * __cond_resched_lock() - if a reschedule is pending, drop the given lock,
- * call schedule, and on return reacquire the lock.
- *
- * This works OK both with and without CONFIG_PREEMPT. We do strange low-level
- * operations here to prevent schedule() from being called twice (once via
- * spin_unlock(), once by hand).
+ * kernel/sched/core.c:2024
+ * this_cpu_load - returns load of the cpu
  */
-int __cond_resched_lock(spinlock_t *lock)
+unsigned long this_cpu_load(void)
 {
     return 0;
 }
 
 /*
- * kernel/sched/core.c:4333
+ * /kernel/sched/core.c:2363
+ * calc_load - update the avenrun load estimates 10 ticks after the
+ * CPUs have updated calc_load_tasks.
  */
-int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags, void *key)
+void calc_global_load(unsigned long ticks)
 {
-    return 0;
+    return;
 }
 
-/**
- * kernel/sched/core.c:3426
- * wait_for_completion_killable: - waits for completion of a task (killable)
- * @x:  holds the state of this particular completion
- *
- * This waits to be signaled for completion of a specific task. It can be
- * interrupted by a kill signal.
- *
- * The return value is -ERESTARTSYS if interrupted, 0 if completed.
+/*
+ * /kernel/sched/core.c:2197
+ * We're going into NOHZ mode, if there's any pending delta, fold it
+ * into the pending idle delta.
  */
-int __sched wait_for_completion_killable(struct completion *x)
+void calc_load_enter_idle(void)
 {
-    return 0;
+    return;
 }
 
-/**
- * kernel/sched/core.c:3192
- * __wake_up_sync_key - wake up threads blocked on a waitqueue.
- * @q: the waitqueue
- * @mode: which threads
- * @nr_exclusive: how many wake-one or wake-many threads to wake up
- * @key: opaque value to be passed to wakeup targets
- *
- * The sync wakeup differs that the waker knows that it will schedule
- * away soon, so while the target thread will be woken up, it will not
- * be migrated to another CPU - ie. the two threads are 'synchronized'
- * with each other. This can prevent needless bouncing between CPUs.
- *
- * On UP it can prevent extra preemption.
+/*
+ * /kernel/sched/core.c:2213
+ * If we're still before the sample window, we're done.
  *
- * It may be assumed that this function implies a write memory barrier before
- * changing the task state if and only if any tasks are woken up.
+ * We woke inside or after the sample window, this means we're already
+ * accounted through the nohz accounting, so skip the entire deal and
+ * sync up for the next window.
  */
-void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
-            int nr_exclusive, void *key)
+void calc_load_exit_idle(void)
 {
     return;
 }
 
 /*
- * kernel/sched/core.c:1543
+ * kernel/sched/core.c:2649
+ * Lock/unlock the current runqueue - to extract task statistics:
  */
-int wake_up_state(struct task_struct *p, unsigned int state)
+unsigned long long task_delta_exec(struct task_struct *p)
 {
     return 0;
 }
 
-/**
- * kernel/sched/core.c:4389
- * yield - yield the current processor to other threads.
- *
- * Do not ever use this function, there's a 99% chance you're doing it wrong.
- *
- * The scheduler is at all times free to pick the calling task as the most
- * eligible task to run, if removing the yield() call from your code breaks
- * it, its already broken.
- *
- * Typical broken usage is:
- *
- * while (!event)
- *     yield();
- *
- * where one assumes that yield() will let 'the other' process run that will
- * make event true. If the current task is a SCHED_FIFO task that will never
- * happen. Never use yield() as a progress guarantee!!
- *
- * If you want to use yield() to wait for something, use wait_event().
- * If you want to use yield() to be 'nice' for others, use cond_resched().
- * If you still want to use yield(), do not!
+/*
+ * kernel/sched/core.c:2556
+ * update_cpu_load_nohz - called from tick_nohz_idle_exit() -- try and fix up the ticks we missed.
  */
-void __sched yield(void)
+void update_cpu_load_nohz(void)
 {
     return;
 }
 
-/**
- * kernel/sched/core.c:892
- * task_curr - is this task currently executing on a CPU?
- * @p: the task in question.
+/*
+ * /kernel/sched/core.c:2092
+ * get_avenrun - get the load average array
+ * @loads:    pointer to dest load array
+ * @offset:    offset to add
+ * @shift:    shift count to shift the result left
+ *
+ * These values are estimates at best, so no need for locking.
  */
-inline int task_curr(const struct task_struct *p)
+void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
 {
-    return 0;
+    return;
 }
 
-/**
- * kernel/sched/core.c:3736
- * task_nice - return the nice value of a given task.
- * @p: the task in question.
+/*
+ * /kernel/sched/core.c:1997
+ * nr_running and nr_context_switches:
+ *
+ * externally visible scheduler statistics:
+ *   current number of runnable threads
+ *   total number of context switches performed since bootup.
  */
-int task_nice(const struct task_struct *p)
+unsigned long nr_running(void)
 {
     return 0;
 }
 
-/*
- * kernel/sched/core.c:3616
- */
-void set_user_nice(struct task_struct *p, long nice)
+unsigned long long nr_context_switches(void)
 {
-    return;
+    return 0;
 }
 
 /*
- * kernel/sched/core.c:3169
+ * /kernel/sched/core.c:2017
+ * number of threads waiting on IO
  */
-void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key)
+unsigned long nr_iowait(void)
 {
-    return;
+    return 0;
 }
 
-/*
+/**
  * kernel/sched/core.c:2018
  */
 unsigned long nr_iowait_cpu(int cpu)
@@ -694,104 +714,104 @@ unsigned long nr_iowait_cpu(int cpu)
     return 0;
 }
 
-/*
- * kernel/sched/core.c:4474
- * This task is about to go to sleep on IO. Increment rq->nr_iowait so
- * that process accounting knows that this is a task in IO wait state.
+/**
+ * kernel/sched/core.c:4601
  */
-void __sched io_schedule(void)
+void sched_show_task(struct task_struct *p)
 {
     return;
 }
 
-/*
- * kernel/sched/core.c:4489
+/**
+ * kernel/sched/core.c:4634
  */
-long __sched io_schedule_timeout(long timeout)
+void show_state_filter(unsigned long state_filter)
 {
-    return 0;
+    return;
 }
 
 /*
- * kernel/sched/core.c:7590
+ * /kernel/sched/core.c:7108
+ * Calls private function
+ * static void normalize_task(struct rq *rq, struct task_struct *p)
  */
-int sched_rt_handler(struct ctl_table *table, int write,
-        void __user *buffer, size_t *lenp,
-        loff_t *ppos)
+void normalize_rt_tasks(void)
 {
-    return 0;
+    return;
 }
 
 /*
- * kernel/sched/core.c:3213
- * __wake_up_sync - see __wake_up_sync_key()
+ * rt_mutex_setprio - set the current priority of a task
+ * @p: task
+ * @prio: prio value (kernel-internal form)
+ *
+ * This function changes the 'effective' priority of a task. It does
+ * not touch ->normal_prio like __setscheduler().
+ *
+ * Used by the rt_mutex code to implement priority inheritance logic.
  */
-void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
+void rt_mutex_setprio(struct task_struct *p, int prio)
 {
     return;
 }
 
-/*
- * kernel/sched/core.c:3163
- * Same as __wake_up but called with the spinlock in wait_queue_head_t held.
+/**
+ * kernel/sched/core.c:3975
+ * sched_setscheduler - change the scheduling policy and/or RT priority of a thread.
+ * @p: the task in question.
+ * @policy: new policy.
+ * @param: structure containing the new RT priority.
+ *
+ * NOTE that the task may be already dead.
  */
-void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr)
+int sched_setscheduler(struct task_struct *p, int policy,
+        const struct sched_param *param)
 {
-    return;
+    return 0;
 }
 
 /**
- * kernel/sched/core.c:3355
- * wait_for_completion_io: - waits for completion of a task
- * @x:  holds the state of this particular completion
+ * kernel/sched/core.c:3993
+ * sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernelspace.
+ * @p: the task in question.
+ * @policy: new policy.
+ * @param: structure containing the new RT priority.
  *
- * This waits to be signaled for completion of a specific task. It is NOT
- * interruptible and there is no timeout. The caller is accounted as waiting
- * for IO.
+ * Just like sched_setscheduler, only don't bother checking if the
+ * current context has permission.  For example, this is needed in
+ * stop_machine(): we create temporary high priority worker threads,
+ * but our caller might not have that capability.
  */
-void __sched wait_for_completion_io(struct completion *x)
+int sched_setscheduler_nocheck(struct task_struct *p, int policy,
+const struct sched_param *param)
 {
-    return;
+    return 0;
 }
 
-/*
- * kernel/sched/core.c:4634
+/**
+ * kernel/sched/core.c:7590
  */
-void show_state_filter(unsigned long state_filter)
+int sched_rt_handler(struct ctl_table *table, int write,
+        void __user *buffer, size_t *lenp,
+        loff_t *ppos)
 {
-    return;
+    return 0;
 }
 
 /**
- * kernel/sched/core.c:3251
- * complete_all: - signals all threads waiting on this completion
- * @x:  holds the state of this particular completion
- *
- * This will wake up all threads waiting on this particular completion event.
- *
- * It may be assumed that this function implies a write memory barrier before
- * changing the task state if and only if any tasks are woken up.
+ * kernel/sched/core.c:7571
  */
-void complete_all(struct completion *x)
+int sched_rr_handler(struct ctl_table *table, int write,
+        void __user *buffer, size_t *lenp,
+        loff_t *ppos)
 {
-    return;
+    return 0;
 }
 
-/**
- * kernel/sched/core.c:3341
- * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
- * @x:  holds the state of this particular completion
- * @timeout:  timeout value in jiffies
- *
- * This waits for either a completion of a specific task to be signaled or for a
- * specified timeout to expire. The timeout is in jiffies. It is not
- * interruptible.
- *
- * The return value is 0 if timed out, and positive (at least 1, or number of
- * jiffies left till timeout) if completed.
+/*
+ * kernel/sched/core.c:6858
  */
-unsigned long __sched
-wait_for_completion_timeout(struct completion *x, unsigned long timeout)
+int in_sched_functions(unsigned long addr)
 {
     return 0;
 }