added sched.h
authorRené Sechting <sechting@mailbox.tu-berlin.de>
Mon, 11 Nov 2013 15:08:36 +0000 (16:08 +0100)
committerRené Sechting <sechting@mailbox.tu-berlin.de>
Mon, 11 Nov 2013 15:08:36 +0000 (16:08 +0100)
framework/os/linux/sched.h [new file with mode: 0644]

diff --git a/framework/os/linux/sched.h b/framework/os/linux/sched.h
new file mode 100644 (file)
index 0000000..105adad
--- /dev/null
@@ -0,0 +1,346 @@
+#include <linux/sched.h>
+#include <linux/sched/sysctl.h>
+#include <linux/sched/rt.h>
+#include <linux/spinlock.h>
+#include <linux/stop_machine.h>
+
+#include <linux/list.h>
+
+
+struct task_group {
+};
+
+
+struct rq {
+       /* runqueue lock: */
+       raw_spinlock_t lock;
+
+       u64 nr_switches;
+       unsigned int nr_running;
+
+       struct list_head rq_list;
+
+       /*
+        * This is part of a global counter where only the total sum
+        * over all CPUs matters. A task can increase this counter on
+        * one CPU and if it got migrated afterwards it may decrease
+        * it on another CPU. Always updated under the runqueue lock:
+        */
+       unsigned long nr_uninterruptible;
+
+       struct task_struct *curr, *idle, *stop;
+
+       struct mm_struct *prev_mm;
+
+       u64 clock;
+       u64 clock_task;
+
+       atomic_t nr_iowait;
+
+       int skip_clock_update;
+
+#ifdef CONFIG_SMP
+
+       /* cpu of this runqueue: */
+       int cpu;
+       int online;
+
+       struct llist_head wake_list;
+
+#endif
+
+};
+
+static inline int cpu_of(struct rq *rq)
+{
+#ifdef CONFIG_SMP
+       return rq->cpu;
+#else
+       return 0;
+#endif
+}
+
+DECLARE_PER_CPU(struct rq, runqueues);
+
+#define cpu_rq(cpu)            (&per_cpu(runqueues, (cpu)))
+#define this_rq()              (&__get_cpu_var(runqueues))
+#define task_rq(p)             cpu_rq(task_cpu(p))
+#define cpu_curr(cpu)          (cpu_rq(cpu)->curr)
+#define raw_rq()               (&__raw_get_cpu_var(runqueues))
+
+
+#ifdef CONFIG_SMP
+
+/*
+ * kernel/sched/sched.h:1105
+ * double_rq_lock - safely lock two runqueues
+ *
+ * Note this does not disable interrupts like task_rq_lock,
+ * you need to do so manually before calling.
+ */
+static inline void double_rq_lock(struct rq *rq1, struct rq *rq2)
+       __acquires(rq1->lock)
+       __acquires(rq2->lock)
+{
+       BUG_ON(!irqs_disabled());
+       if (rq1 == rq2) {
+               raw_spin_lock(&rq1->lock);
+               __acquire(rq2->lock);   /* Fake it out ;) */
+       } else {
+               if (rq1 < rq2) {
+                       raw_spin_lock(&rq1->lock);
+                       raw_spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
+               } else {
+                       raw_spin_lock(&rq2->lock);
+                       raw_spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
+               }
+       }
+}
+
+/*
+ * kernel/sched/sched.h:1130
+ * double_rq_unlock - safely unlock two runqueues
+ *
+ * Note this does not restore interrupts like task_rq_unlock,
+ * you need to do so manually after calling.
+ */
+static inline void double_rq_unlock(struct rq *rq1, struct rq *rq2)
+       __releases(rq1->lock)
+       __releases(rq2->lock)
+{
+       raw_spin_unlock(&rq1->lock);
+       if (rq1 != rq2)
+               raw_spin_unlock(&rq2->lock);
+       else
+               __release(rq2->lock);
+}
+
+#endif
+
+#ifndef prepare_arch_switch
+# define prepare_arch_switch(next)     do { } while (0)
+#endif
+#ifndef finish_arch_switch
+# define finish_arch_switch(prev)      do { } while (0)
+#endif
+#ifndef finish_arch_post_lock_switch
+# define finish_arch_post_lock_switch()        do { } while (0)
+#endif
+
+#ifndef __ARCH_WANT_UNLOCKED_CTXSW
+static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
+{
+#ifdef CONFIG_SMP
+       /*
+        * We can optimise this out completely for !SMP, because the
+        * SMP rebalancing from interrupt is the only thing that cares
+        * here.
+        */
+       next->on_cpu = 1;
+#endif
+}
+
+static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
+{
+#ifdef CONFIG_SMP
+       /*
+        * After ->on_cpu is cleared, the task can be moved to a different CPU.
+        * We must ensure this doesn't happen until the switch is completely
+        * finished.
+        */
+       smp_wmb();
+       prev->on_cpu = 0;
+#endif
+#ifdef CONFIG_DEBUG_SPINLOCK
+       /* this is a valid case when another task releases the spinlock */
+       rq->lock.owner = current;
+#endif
+       /*
+        * If we are tracking spinlock dependencies then we have to
+        * fix up the runqueue lock - which gets 'carried over' from
+        * prev into current:
+        */
+       spin_acquire(&rq->lock.dep_map, 0, 0, _THIS_IP_);
+
+       raw_spin_unlock_irq(&rq->lock);
+}
+
+#else /* __ARCH_WANT_UNLOCKED_CTXSW */
+static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
+{
+#ifdef CONFIG_SMP
+       /*
+        * We can optimise this out completely for !SMP, because the
+        * SMP rebalancing from interrupt is the only thing that cares
+        * here.
+        */
+       next->on_cpu = 1;
+#endif
+       raw_spin_unlock(&rq->lock);
+}
+
+static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
+{
+#ifdef CONFIG_SMP
+       /*
+        * After ->on_cpu is cleared, the task can be moved to a different CPU.
+        * We must ensure this doesn't happen until the switch is completely
+        * finished.
+        */
+       smp_wmb();
+       prev->on_cpu = 0;
+#endif
+       local_irq_enable();
+}
+#endif /* __ARCH_WANT_UNLOCKED_CTXSW */
+
+
+void account_idle_ticks(unsigned long ticks);
+
+void account_process_tick(struct task_struct *p, int user_tick);
+
+void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
+
+void calc_global_load(unsigned long ticks);
+
+//void calc_load_enter_idle(void);
+
+//void calc_load_exit_idle(void);
+
+int can_nice(const struct task_struct *p, const int nice);
+
+int idle_cpu(int cpu);
+
+void __cpuinit init_idle(struct task_struct *idle, int cpu);
+
+void __cpuinit init_idle_bootup_task(struct task_struct *idle);
+
+void normalize_rt_tasks(void);
+
+unsigned long nr_running(void);
+
+unsigned long long nr_context_switches(void);
+
+unsigned long nr_iowait(void);
+
+void rt_mutex_setprio(struct task_struct *p, int prio);
+
+u64 sched_clock_cpu(int cpu);
+
+void sched_clock_init(void);;
+
+void sched_fork(struct task_struct *p);
+
+long sched_getaffinity(pid_t pid, struct cpumask *mask);
+
+void sched_init(void);
+
+void sched_init_smp(void);
+
+int sched_rr_handler(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos);
+
+long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
+
+int sched_setscheduler(struct task_struct *p, int policy, const struct sched_param *param);
+
+void sched_show_task(struct task_struct *p);
+
+void schedule_tail(struct task_struct *prev);
+
+void scheduler_tick(void);
+
+//void sched_clock_init(void);
+
+long sys_nice(int increment);
+
+long sys_sched_getaffinity(pid_t pid, unsigned int len, unsigned long __user *user_mask_ptr);
+
+long sys_sched_setaffinity(pid_t pid, unsigned int len, unsigned long __user *user_mask_ptr);
+
+unsigned long long task_delta_exec(struct task_struct *);
+
+int task_prio(const struct task_struct *p);
+
+unsigned long long task_sched_runtime(struct task_struct *task);
+
+unsigned long this_cpu_load(void);
+
+void update_cpu_load_nohz(void);
+
+void wake_up_new_task(struct task_struct *tsk);
+
+
+int __sched _cond_resched(void);
+
+asmlinkage void __sched schedule(void);
+
+void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, void *key);
+
+int wake_up_process(struct task_struct *p);
+
+void __sched wait_for_completion(struct completion *x);
+
+void complete(struct completion *x);
+
+void __sched schedule_preempt_disabled(void);
+
+int in_sched_functions(unsigned long addr);
+
+void sched_clock_idle_sleep_event(void);
+
+void sched_clock_idle_wakeup_event(u64 delta_ns);
+
+int __cond_resched_lock(spinlock_t *lock);
+
+u64 local_clock(void);
+
+int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
+                         void *key);
+
+int __sched wait_for_completion_killable(struct completion *x);
+
+void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
+                       int nr_exclusive, void *key);
+
+int wake_up_state(struct task_struct *p, unsigned int state);
+
+void __sched yield(void);
+
+inline int task_curr(const struct task_struct *p);
+
+int task_nice(const struct task_struct *p);
+
+void set_user_nice(struct task_struct *p, long nice);
+
+void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key);
+
+void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive);
+
+void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr);
+
+static inline int task_current(struct rq *rq, struct task_struct *p)
+{
+       return rq->curr == p;
+}
+
+static inline int task_running(struct rq *rq, struct task_struct *p)
+{
+#ifdef CONFIG_SMP
+       return p->on_cpu;
+#else
+       return task_current(rq, p);
+#endif
+}
+
+static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
+{
+#ifdef CONFIG_SMP
+       /*
+        * After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
+        * successfuly executed on another CPU. We must ensure that updates of
+        * per-task data have been completed by this moment.
+        */
+       smp_wmb();
+       task_thread_info(p)->cpu = cpu;
+#endif
+}