From 5d1b82edf9b8ec4462884e453024190647495614 Mon Sep 17 00:00:00 2001 From: FKHals <5229803-FKHals@users.noreply.gitlab.com> Date: Thu, 28 Sep 2023 11:34:47 +0200 Subject: [PATCH] [REMOVE?] Debug Prints! --- kernel/behave.c | 4 ++-- kernel/fork.c | 2 ++ kernel/sched/core.c | 40 +++++++++++++++++++++++++++++++++++++++- kernel/sched/fair.c | 13 +++++++++++++ kernel/sched/pb.c | 18 +++++++++++++++++- kernel/sched/sched.h | 37 +++++++++++++++++++++++++++++-------- 6 files changed, 102 insertions(+), 12 deletions(-) diff --git a/kernel/behave.c b/kernel/behave.c index eac8d5f69ebb..758e8a809795 100644 --- a/kernel/behave.c +++ b/kernel/behave.c @@ -258,9 +258,9 @@ void debug_print_procs(void) { printk(KERN_WARNING "-----\nPROCS:\n"); for(i = 0; i <= procs->curr_proc_index; i++) { p = procs->process_buffer[i]; - printk(KERN_WARNING "index: %lu, root: %lli, last: %lli, children: %lli, next_sib: %lli\n", + printk(KERN_WARNING "index: %lu, root: %lli, last: %lli, children: %lli, next_sib: %lli, chld_num: %llu\n", // calculate indices instead of using the pointers for more readability and represent NULL-values with -1 - i, task_2_index(p.root), task_2_index(p.last), pbm_2_index(p.children), pbm_2_index(p.next_sib)); + i, task_2_index(p.root), task_2_index(p.last), pbm_2_index(p.children), pbm_2_index(p.next_sib), p.child_count); } printk(KERN_WARNING "^^^^^\n"); } diff --git a/kernel/fork.c b/kernel/fork.c index f2d26cbec452..6464b8454ce3 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -2037,6 +2037,8 @@ long _do_fork(unsigned long clone_flags, if (is_relevant_process(current)) { printk(KERN_EMERG "DO FORK CALLED by: '%s' %u\n", current->comm ,parent_pid); fork_date = pbm_fork_parent_new_task(current); + } else { + //printk(KERN_EMERG "Non relevant fork by: '%s' %u\n", current->comm ,parent_pid); } /* diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 964c5fac143e..0c0d85026611 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -770,11 +770,25 @@ static inline void dequeue_task(struct rq *rq, struct task_struct *p, int flags) if (!(flags & DEQUEUE_SAVE)) sched_info_dequeued(rq, p); + /*if (is_relevant_process(p)) { + printk(KERN_WARNING "DEQUEUE: %u, %li, %s, blck? %i, %s\n", + p->pid, p->state, p->comm, p->state != TASK_RUNNING && p->state != TASK_WAKING && !p->on_rq, + p->sched_class == &fair_sched_class ? "fair" : + (p->sched_class == &pb_sched_class ? "pb" : + "other")); + }*/ + p->sched_class->dequeue_task(rq, p, flags); } void activate_task(struct rq *rq, struct task_struct *p, int flags) { + /*if (strstr((const char*)p->comm, "test_")) { + printk(KERN_WARNING "\033[1m" "\033[36m" "Activate task: %li, %u, %s, %s" "\033[0m" "\n", p->state, p->pid, p->comm, + p->sched_class == &fair_sched_class ? "fair" : + (p->sched_class == &pb_sched_class ? "pb" : + "other")); + }*/ if (task_contributes_to_load(p)) rq->nr_uninterruptible--; @@ -2609,6 +2623,12 @@ static struct rq *finish_task_switch(struct task_struct *prev) struct mm_struct *mm = rq->prev_mm; long prev_state; + /* + if (prev->pid > 1500) { + printk(KERN_WARNING "\033[1m" "\033[36m" "FINISH SWITCHING FROM %u TO %u" "\033[0m" "\n", prev->pid, current->pid); + } + */ + /* * The previous task will have left us with a preempt_count of 2 * because it left us after: @@ -2648,6 +2668,9 @@ static struct rq *finish_task_switch(struct task_struct *prev) if (mm) mmdrop(mm); if (unlikely(prev_state == TASK_DEAD)) { + /*if (prev->pid > 1500) { + printk(KERN_WARNING "\033[1m" "\033[36m" "CLEANING DEAD TASK: %u" "\033[0m" "\n", prev->pid); + }*/ if (prev->sched_class->task_dead) prev->sched_class->task_dead(prev); @@ -3300,6 +3323,9 @@ static void __sched notrace __schedule(bool preempt) if (unlikely(signal_pending_state(prev->state, prev))) { prev->state = TASK_RUNNING; } else { + /*if (prev->pid > 1000) { + printk(KERN_WARNING "\033[1m" "\033[36m" "Deactivate Task: %u" "\033[0m" "\n", prev->pid); + }*/ deactivate_task(rq, prev, DEQUEUE_SLEEP | DEQUEUE_NOCLOCK); prev->on_rq = 0; @@ -3325,7 +3351,17 @@ static void __sched notrace __schedule(bool preempt) } next = pick_next_task(rq, prev, &rf); - + /*if (!strstr((const char*)next->comm, "kworker") && !strstr((const char*)prev->comm, "kworker") + && !strstr((const char*)next->comm, "systemd") && !strstr((const char*)prev->comm, "systemd") + && !strstr((const char*)next->comm, "swapper") && !strstr((const char*)prev->comm, "swapper") + && !strstr((const char*)next->comm, "ksoftirqd") && !strstr((const char*)prev->comm, "ksoftirqd")) { + printk(KERN_WARNING "PREV: %u, %li, %s, blck? %i -> NEXT: %u, %li, %s, blck? %i, %s\n", + prev->pid, prev->state, prev->comm, prev->state != TASK_RUNNING && prev->state != TASK_WAKING && !prev->on_rq, + next->pid, next->state, next->comm, next->state != TASK_RUNNING && next->state != TASK_WAKING && !next->on_rq, + next->sched_class == &fair_sched_class ? "fair" : + (next->sched_class == &pb_sched_class ? "pb" : + "other")); + }*/ clear_tsk_need_resched(prev); clear_preempt_need_resched(); @@ -3360,6 +3396,7 @@ void __noreturn do_task_dead(void) * To avoid it, we have to wait for releasing tsk->pi_lock which * is held by try_to_wake_up() */ + //printk(KERN_WARNING "\033[1m" "\033[32m" "BEFORE __SCHEDULE" "\033[0m" "\n"); smp_mb(); raw_spin_unlock_wait(¤t->pi_lock); @@ -3370,6 +3407,7 @@ void __noreturn do_task_dead(void) current->flags |= PF_NOFREEZE; __schedule(false); + //printk(KERN_WARNING "\033[1m" "\033[36m" "AFTER __SCHEDULE" "\033[0m" "\n"); BUG(); /* Avoid "noreturn function does return" - but don't continue if BUG() is a NOP: */ diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index a440ce43d472..d2392c196dea 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -364,6 +364,11 @@ static inline void list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq) static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq) { if (cfs_rq->on_list) { +/* struct task_struct* p = task_of(cfs_rq->curr); + //if (p->pid > 1000) { + printk(KERN_WARNING "\033[1m" "\033[36m" "Delete Task Leaf: %u" "\033[0m" "\n", + p->pid); + //}*/ list_del_rcu(&cfs_rq->leaf_cfs_rq_list); cfs_rq->on_list = 0; } @@ -3503,6 +3508,13 @@ void sync_entity_load_avg(struct sched_entity *se) */ void remove_entity_load_avg(struct sched_entity *se) { + if (se) { + struct task_struct* p = task_of(se); + printk(KERN_WARNING "\033[1m" "\033[36m" "Remove Scheduler Entity of task: %li, %u, %s, %s" "\033[0m" "\n", p->state, p->pid, p->comm, + p->sched_class == &fair_sched_class ? "fair" : + (p->sched_class == &pb_sched_class ? "pb" : + "other")); + } struct cfs_rq *cfs_rq = cfs_rq_of(se); /* @@ -6195,6 +6207,7 @@ pick_next_task_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf } if (next_mode == PB_EXEC_MODE) { + // printk("PICKING NEXT EXEC TASK"); return RETRY_TASK; } diff --git a/kernel/sched/pb.c b/kernel/sched/pb.c index 2b73632a2eef..078893af316b 100644 --- a/kernel/sched/pb.c +++ b/kernel/sched/pb.c @@ -70,6 +70,7 @@ SYSCALL_DEFINE2(pb_set_plan, pid_t, reference_proc, pid_t, root_proc) { pb_rq->root_proc = task; pb_rq->num_exited_procs = pbm->child_count; + printk(KERN_WARNING "Submit Plan\n"); res = pb_submit_plan(rq); if (res == -1) { @@ -352,12 +353,17 @@ static struct task_struct * pick_next_task_pb(struct rq *rq, next_mode = determine_next_mode_pb(rq); pb->mode = next_mode; +/* if (pb->is_initialized) { + printk(KERN_WARNING "PICK NEXT TASK\n"); + }*/ + if (next_mode == PB_DISABLED_MODE && current_mode == PB_EXEC_MODE) { // After Plan is done do the cleanup // FIXME: This should be done for all processes on exit and not just for the last one in the plan?! //terminate_perf_event(&(get_pevent_by_pid(plan_rt_state_peek_proc()->pid))); // TODO: Check if we have to free the memory or if perf takes care of it // see 'perf_event_release_kernel(struct perf_event *event)' in core.c + //printk(KERN_WARNING "DO PLAN CLEANUP\n"); } /** * This handles the case where the program to be run is dead before the @@ -396,6 +402,16 @@ static struct task_struct * pick_next_task_pb(struct rq *rq, } picked = plan_rt_state_peek_proc(); + + // testing: if the picked process is waiting for other processes, can we just run the parent? + if (picked && prev) { +// int is_waiting_prev; +// int is_waiting = picked->signal ? !list_empty_careful(&(picked->signal->wait_chldexit.head)) : -1; +// is_waiting_prev = prev->signal ? !list_empty_careful(&(prev->signal->wait_chldexit.head)) : -1; +// printk("Prev Task: %p (%i, %s); state: %li, waiting? %i, need-reschd? %i\n", prev, prev->pid, prev->comm, prev->state, is_waiting_prev, test_tsk_need_resched(prev)); +// printk("Picked Task: %p (%i, %s); state: %li, waiting? %i, need-reschd? %i\n", picked, picked->pid, picked->comm, picked->state, is_waiting, test_tsk_need_resched(picked)); + printk("Pick Next: %i (%s), state: %li ==> %i (%s), state: %li\n", prev->pid, prev->comm, prev->state, picked->pid, picked->comm, picked->state); + } } return picked; @@ -429,7 +445,7 @@ static void task_tick_pb(struct rq *rq, struct task_struct *p, int queued) pb->count_pb_cycles++; - // printk("TICK #%d\n",pb->count_pb_cycles); + //printk("TICK #%llu: pid=%u status=%ld\n",pb->count_pb_cycles, p->pid, p->state); if (determine_next_mode_pb(rq) != PB_EXEC_MODE && pb->mode == PB_EXEC_MODE) { //printk("Reschudling in task_tick_pb"); diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h index 33c903978992..f8033746484a 100644 --- a/kernel/sched/sched.h +++ b/kernel/sched/sched.h @@ -908,8 +908,29 @@ static inline int determine_next_mode_pb(struct rq *rq) { int mode = PB_DISABLED_MODE; struct pb_rq *pb = &(rq->pb); - - if (pb->c_entry < pb->size) +/* + if (pb->mode != PB_DISABLED_MODE) { + printk(KERN_WARNING "Mode: %s, Stack empty? %i, Plan initialized? %i\n", + pb->mode == PB_EXEC_MODE ? "EXEC" : (pb->mode == PB_ADMIN_MODE ? "ADMIN" : "DISABLED"), + plan_rt_state_is_empty(), + pb->is_initialized + ); + printk(KERN_WARNING "PB/Admin Cycles: (%llu / %llu), Plan not finished? %i\n", + pb->count_pb_cycles, pb->count_admin_cycles, !is_plan_finished(pb) + ); + printk(KERN_WARNING "Task %u waiting? %i, State: %li, PC: %lu, sched: %p waiting? %i\n", + plan_rt_state_is_empty() ? -1 : plan_rt_state_peek_proc()->pid, + plan_rt_state_is_empty() ? 0 : list_empty_careful(&(plan_rt_state_peek_proc()->signal->wait_chldexit.head)), + plan_rt_state_is_empty() ? -1 : plan_rt_state_peek_proc()->state, + // get instruction pointer + plan_rt_state_is_empty() ? 0x0 : task_pt_regs(plan_rt_state_peek_proc())->ip, + plan_rt_state_is_empty() ? 0x0 : plan_rt_state_peek_proc()->sched_class, + plan_rt_state_is_empty() ? -1 : !list_empty_careful(&(plan_rt_state_peek_proc()->signal->wait_chldexit.head)) + ); + plan_rt_state_debug_print(); + } +*/ + if (!is_plan_finished(pb)) { // initial switch if (pb->mode == PB_DISABLED_MODE && pb->is_initialized) @@ -976,12 +997,12 @@ static inline int determine_next_mode_pb(struct rq *rq) } } - // if (mode == PB_ADMIN_MODE && pb->mode != mode) { - // printk("Next Mode is PB_ADMIN_MODE"); - // } - // if (mode == PB_EXEC_MODE && pb->mode != mode) { - // printk("Next Mode is PB_EXEC_MODE"); - // } +/* if (mode == PB_ADMIN_MODE && pb->mode != mode) { + printk("Next Mode is PB_ADMIN_MODE"); + } + if (mode == PB_EXEC_MODE && pb->mode != mode) { + printk("Next Mode is PB_EXEC_MODE"); + }*/ return mode; } -- GitLab