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(&current->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