Able to boot up with I/O errors. Therefore interaction not possible. Few functions...
authorAnton Eisenbraun <anton.e@mailbox.tu-berlin.de>
Thu, 4 Jul 2013 17:22:55 +0000 (19:22 +0200)
committerAnton Eisenbraun <anton.e@mailbox.tu-berlin.de>
Thu, 4 Jul 2013 17:22:55 +0000 (19:22 +0200)
arch/x86/kernel/process.c
kernel/kthread.c
kernel/sched.new/core.c

index d14fdda..3a4504b 100644 (file)
@@ -321,9 +321,9 @@ void cpu_idle(void)
 
        while (1) {
                tick_nohz_idle_enter();
-
+//             printk("\n RUNQUEUE is empty!!!\n");
                while (!need_resched()) {
-                       printk("fertig k├Ânnen nach hause gehen\n");
+                       break;
                        rmb();
 
                        if (cpu_is_offline(smp_processor_id()))
@@ -355,8 +355,8 @@ void cpu_idle(void)
                           has already called exit_idle. But some idle
                           loops can be woken up without interrupt. */
                        __exit_idle();
-               }
 
+               }
                tick_nohz_idle_exit();
                preempt_enable_no_resched();
                schedule();
index 9eb7fed..7187b2d 100644 (file)
@@ -140,6 +140,7 @@ void kthread_parkme(void)
        __kthread_parkme(to_kthread(current));
 }
 
+volatile unsigned int thread_counter = 0;
 static int kthread(void *_create)
 {
        /* Copy data: it's on kthread's stack */
@@ -149,6 +150,8 @@ static int kthread(void *_create)
        struct kthread self;
        int ret;
 
+       thread_counter++;
+
        self.flags = 0;
        self.data = data;
        init_completion(&self.exited);
@@ -167,6 +170,9 @@ static int kthread(void *_create)
                __kthread_parkme(&self);
                ret = threadfn(data);
        }
+
+       thread_counter--;
+       printk("\nThread counter: %i", thread_counter);
        /* we can't just return, we must preserve "self" on stack */
        do_exit(ret);
 }
index beea0d6..c17921c 100644 (file)
@@ -8,6 +8,19 @@
  *
  */
 
+/**
+ * TODO:       It looks like we are idle at boot up for a short period.
+ *                     Therefore idle have to give up the CPU at some point.
+ *                     Right now it is solved via a break, which is VERY inefficient. Further
+ *                     idle is kept in the run queue.
+ *                     How ever we are able to boot with some I/O errors, due to the fact
+ *                     some essential function are not implemented yet (ASSUMTION).
+ *
+ * FIXME:      - Resched idle in efficient way (remove from run queue)
+ *                     - Implement wait_for_complition_timeout
+ *                     - Implement try_to_wake_up_local?
+ */
+
 #include <linux/init.h>
 #include <asm/mmu_context.h>
 #include <linux/completion.h>
@@ -91,9 +104,6 @@ __read_mostly int scheduler_running;
 DEFINE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues);
 
 
-
-
-
 //
 // Functions
 //
@@ -237,8 +247,7 @@ void sched_fork(struct task_struct *p)
  */
 void account_idle_ticks(unsigned long ticks)
 {
-       volatile int i = 1;
-       while(i--);
+       printk("\naccount_idle_ticks");
 
        return;
 }
@@ -251,8 +260,7 @@ void account_idle_ticks(unsigned long ticks)
  */
 void account_process_tick(struct task_struct *p, int user_tick)
 {
-       volatile int i = 1;
-       while(i--);
+       //printk("\naccount_process_tick");
 
        return;
 }
@@ -268,8 +276,7 @@ void account_process_tick(struct task_struct *p, int user_tick)
  */
 void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
 {
-       volatile int i = 1;
-       while(i--);
+       printk("\nget_avenrun");
 
        return;
 }
@@ -281,6 +288,8 @@ void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
  */
 void calc_global_load(unsigned long ticks)
 {
+//     printk("\ncalc_global_load");
+
        return;
 }
 
@@ -315,6 +324,8 @@ void calc_global_load(unsigned long ticks)
  */
 int can_nice(const struct task_struct *p, const int nice)
 {
+       printk("\ncan_nice");
+
        return 0;
 }
 
@@ -325,6 +336,8 @@ int can_nice(const struct task_struct *p, const int nice)
  */
 struct task_struct *idle_task(int cpu)
 {
+       printk("\ntask_struct");
+
        return 0;
 }
 
@@ -335,6 +348,8 @@ struct task_struct *idle_task(int cpu)
  */
 int idle_cpu(int cpu)
 {
+       printk("\nidle_cpu");
+
        return 0;
 }
 
@@ -344,6 +359,8 @@ int idle_cpu(int cpu)
  */
 void __cpuinit init_idle_bootup_task(struct task_struct *idle)
 {
+       printk("\ninit_idle_bootup_task");
+
        return;
 }
 
@@ -354,6 +371,8 @@ void __cpuinit init_idle_bootup_task(struct task_struct *idle)
  */
 void normalize_rt_tasks(void)
 {
+       printk("\nnormalize_rt_tasks");
+
        return;
 }
 
@@ -367,11 +386,15 @@ void normalize_rt_tasks(void)
  */
 unsigned long nr_running(void)
 {
+       printk("\nnr_running");
+
        return 0;
 }
 
 unsigned long long nr_context_switches(void)
 {
+       printk("\nnr_context_switches");
+
        return 0;
 }
 
@@ -381,6 +404,8 @@ unsigned long long nr_context_switches(void)
  */
 unsigned long nr_iowait(void)
 {
+       printk("\nnr_iowait");
+
        return 0;
 }
 
@@ -396,6 +421,8 @@ unsigned long nr_iowait(void)
  */
 void rt_mutex_setprio(struct task_struct *p, int prio)
 {
+       printk("\nrt_mutex_setprio");
+
        return;
 }
 
@@ -429,6 +456,8 @@ void rt_mutex_setprio(struct task_struct *p, int prio)
  */
 long sched_getaffinity(pid_t pid, struct cpumask *mask)
 {
+       printk("\nsched_getaffinity");
+
        return 0;
 }
 
@@ -437,6 +466,8 @@ long sched_getaffinity(pid_t pid, struct cpumask *mask)
  */
 void sched_init_smp(void)
 {
+       printk("\nsched_init_smp");
+
        return;
 }
 
@@ -447,6 +478,8 @@ int sched_rr_handler(struct ctl_table *table, int write,
                void __user *buffer, size_t *lenp,
                loff_t *ppos)
 {
+       printk("\nsched_rr_handler");
+
        return 0;
 }
 
@@ -458,6 +491,8 @@ int sched_rr_handler(struct ctl_table *table, int write,
  */
 long sched_setaffinity(pid_t pid, const struct cpumask *new_mask)
 {
+       printk("\nsched_setaffinity");
+
        return 0;
 }
 
@@ -473,6 +508,8 @@ 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)
 {
+       printk("\nsched_setscheduler");
+
        return 0;
 }
 
@@ -491,6 +528,8 @@ int sched_setscheduler(struct task_struct *p, int policy,
 int sched_setscheduler_nocheck(struct task_struct *p, int policy,
 const struct sched_param *param)
 {
+//     printk("\nsched_setscheduler_nocheck");
+
        return 0;
 }
 
@@ -499,6 +538,8 @@ const struct sched_param *param)
  */
 void sched_show_task(struct task_struct *p)
 {
+       printk("\nsched_show_task");
+
        return;
 }
 
@@ -647,6 +688,8 @@ void scheduler_tick(void)
  */
 unsigned long long task_delta_exec(struct task_struct *p)
 {
+       printk("\ntask_delta_exec");
+
        return 0;
 }
 
@@ -661,6 +704,8 @@ unsigned long long task_delta_exec(struct task_struct *p)
  */
 int task_prio(const struct task_struct *p)
 {
+       printk("\ntask_prio");
+
        return 0;
 }
 
@@ -672,6 +717,8 @@ int task_prio(const struct task_struct *p)
  */
 unsigned long long task_sched_runtime(struct task_struct *task)
 {
+       printk("\ntask_sched_runtime");
+
        return 0;
 }
 
@@ -681,6 +728,8 @@ unsigned long long task_sched_runtime(struct task_struct *task)
  */
 unsigned long this_cpu_load(void)
 {
+       printk("\nthis_cpu_load");
+
        return 0;
 }
 
@@ -690,6 +739,8 @@ unsigned long this_cpu_load(void)
  */
 void update_cpu_load_nohz(void)
 {
+       printk("\nupdate_cpu_load_nohz");
+
        return;
 }
 
@@ -820,7 +871,6 @@ context_switch(struct rq *rq, struct task_struct *prev,
  *          - return from interrupt-handler to user-space
  */
 volatile int kernel_blub = 0;
-volatile int kernel_bla = 0;
 static void __sched __schedule(void)
 {
        struct task_struct *prev, *next;
@@ -879,24 +929,26 @@ need_resched:
 //     put_prev_task(rq, prev);
 //     next = pick_next_task(rq);
 
-       next = list_first_entry(&rq->rq_list, struct task_struct, rq_tasks);
-       list_del(&next->rq_tasks);
-//     if(prev->pid != 0) {
-//             list_add_tail(&prev->rq_tasks, &rq->rq_list);
-//     }
-//     else {
+       /*XXX:  In case the only runnable task gets deactivated, we need to schedule
+        *              the idle tasks to prevent a kernel panic. Anyway at the bootup procedure
+        *              this should be never the case.
+        */
+       if(!list_empty(&rq->rq_list)) {
+               next = list_first_entry(&rq->rq_list, struct task_struct, rq_tasks);
+               list_del(&next->rq_tasks);
                list_add_tail(&next->rq_tasks, &rq->rq_list);
-//     }
+       }
+       else
+               next = rq->idle;
 
-       printk("\nKernel_thread counter: %i", kernel_blub++);
+       //printk("\nKernel_thread counter: %i", kernel_blub++);
 
 //     if (next == (struct task_struct*)0xffff880007054000)
 //             //printk("\nKernel_init counter: %i", kernel_blub++);
 //             kernel_blub++;
 
        if (kernel_blub == 1329) {
-               printk("\nKernel_thread counter: %i", kernel_bla);
-               kernel_bla++;
+               printk("\nWe are most likely to die now");
        }
 
 //     clear_tsk_need_resched(prev);
@@ -971,9 +1023,13 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
        success = 1; /* we're going to change ->state */
        cpu = task_cpu(p);
 
-       list_add(&p->rq_tasks, &rq->rq_list);
        p->on_rq = 1;
        p->state = TASK_RUNNING;
+       list_add(&p->rq_tasks, &rq->rq_list);
+
+       /* if a worker is waking up, notify workqueue */
+       if (p->flags & PF_WQ_WORKER)
+               wq_worker_waking_up(p, 0);
 
 out:
        raw_spin_unlock_irqrestore(&p->pi_lock, flags);
@@ -1176,8 +1232,7 @@ void __sched schedule_preempt_disabled(void)
  */
 int in_sched_functions(unsigned long addr)
 {
-       volatile int i = 1;
-       while(i--);
+       printk("\nin_sched_functions");
 
        return 0;
 }
@@ -1193,8 +1248,7 @@ int in_sched_functions(unsigned long addr)
  */
 int __cond_resched_lock(spinlock_t *lock)
 {
-       volatile int i = 1;
-       while(i--);
+       printk("\n__cond_resched_lock");
 
        return 0;
 }
@@ -1296,8 +1350,7 @@ int wake_up_state(struct task_struct *p, unsigned int state)
  */
 void __sched yield(void)
 {
-       volatile int i = 1;
-       while(i--);
+       printk("\nyield");
 
        return;
 }
@@ -1309,8 +1362,7 @@ void __sched yield(void)
  */
 inline int task_curr(const struct task_struct *p)
 {
-       volatile int i = 1;
-       while(i--);
+       printk("\ntask_curr");
 
        return 0;
 }
@@ -1322,6 +1374,8 @@ inline int task_curr(const struct task_struct *p)
  */
 int task_nice(const struct task_struct *p)
 {
+       printk("\ntask_nice");
+
        return 0;
 }
 
@@ -1330,6 +1384,8 @@ int task_nice(const struct task_struct *p)
  */
 void set_user_nice(struct task_struct *p, long nice)
 {
+//     printk("\nset_user_nice");
+
        return;
 }
 
@@ -1338,6 +1394,8 @@ 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)
 {
+       printk("\n__wake_up_locked_key");
+
        return;
 }
 
@@ -1346,6 +1404,8 @@ void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key)
  */
 unsigned long nr_iowait_cpu(int cpu)
 {
+       printk("\nnr_iowait_cpu");
+
        return 0;
 }
 
@@ -1356,6 +1416,8 @@ unsigned long nr_iowait_cpu(int cpu)
  */
 void __sched io_schedule(void)
 {
+       printk("\nio_schedule");
+
        return;
 }
 
@@ -1364,6 +1426,8 @@ void __sched io_schedule(void)
  */
 long __sched io_schedule_timeout(long timeout)
 {
+       printk("\nio_schedule_timeout");
+
        return 0;
 }
 
@@ -1374,6 +1438,8 @@ int sched_rt_handler(struct ctl_table *table, int write,
                void __user *buffer, size_t *lenp,
                loff_t *ppos)
 {
+       printk("\nsched_rt_handler");
+
        return 0;
 }
 
@@ -1383,6 +1449,8 @@ int sched_rt_handler(struct ctl_table *table, int write,
  */
 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
 {
+       printk("\n__wake_up_sync");
+
        return;
 }
 
@@ -1392,9 +1460,20 @@ 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)
 {
+       printk("\n__wake_up_locked");
+
        return;
 }
 
+/**
+ * kernel/sched/core.c:3307
+ */
+static long __sched
+wait_for_common_io(struct completion *x, long timeout, int state)
+{
+       return __wait_for_common(x, io_schedule_timeout, timeout, state);
+}
+
 /**
  * kernel/sched/core.c:3355
  * wait_for_completion_io: - waits for completion of a task
@@ -1406,17 +1485,17 @@ void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr)
  */
 void __sched wait_for_completion_io(struct completion *x)
 {
-       volatile int i = 1;
-       while(i--);
-
-       return;
+       wait_for_common_io(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
 }
+EXPORT_SYMBOL(wait_for_completion_io);
 
 /*
  * kernel/sched/core.c:4634
  */
 void show_state_filter(unsigned long state_filter)
 {
+       printk("\nshow_state_filter");
+
        return;
 }
 
@@ -1457,8 +1536,7 @@ EXPORT_SYMBOL(complete_all);
 unsigned long __sched
 wait_for_completion_timeout(struct completion *x, unsigned long timeout)
 {
-       volatile int i = 1;
-       while(i--);
+       printk("\nwait_for_completion_timeout");
 
        return 0;
 }