sched.h not copied but linked
authorDaniel Röhrig <daniel.roehrig@mailbox.tu-berlin.de>
Mon, 11 Nov 2013 16:55:29 +0000 (17:55 +0100)
committerDaniel Röhrig <daniel.roehrig@mailbox.tu-berlin.de>
Mon, 11 Nov 2013 16:55:29 +0000 (17:55 +0100)
Debugging doesn't work for me anymore.

framework/os/linux/os.c
framework/os/linux/sched.h [deleted file]
kernel/sched.new/core.c

index 70d6261..df206bc 100644 (file)
 #include <fw_types.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
-#include "sched.h"
+//TODO This avoids copying the sched.h into the folder
+#include "../../../kernel/sched.new/sched.h"
+
 
 extern struct fw_task *fw_idle_task;
+extern void context_switch(struct rq *rq, struct task_struct *prev, struct task_struct *next);
 
 //TODO Do this with linker magic (optimization)
 void os_printf(const char* formatstring, ...)
@@ -39,10 +42,6 @@ void os_create_task(fw_task_t *task)
        return;
 }
 
-//static inline void
-//context_switch(struct rq *rq, struct task_struct *prev,
-//            struct task_struct *next);
-extern void context_switch(struct rq *rq, struct task_struct *prev, struct task_struct *next);
 void os_dispatch(fw_task_t *task)
 {
        struct rq *rq;
diff --git a/framework/os/linux/sched.h b/framework/os/linux/sched.h
deleted file mode 100644 (file)
index 105adad..0000000
+++ /dev/null
@@ -1,346 +0,0 @@
-#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
-}
index d82bc49..b054bc8 100644 (file)
@@ -1700,6 +1700,7 @@ need_resched:
        rq->skip_clock_update = 0;
 //
        if (likely(prev != next)&&(next!=NULL)) {
+//     if (likely(prev != rq->curr)) {
 //             rq->nr_switches++;
 //             rq->curr = next;
 ////           ++*switch_count;
@@ -1719,9 +1720,10 @@ need_resched:
                cpu = smp_processor_id();
                rq = cpu_rq(cpu);
        }
-       else
+       else{
+//             printk("ELSE");
                raw_spin_unlock_irq(&rq->lock);
-
+       }
        post_schedule(rq);
 
        sched_preempt_enable_no_resched();