add simple prenptive multi task :D

Author: tas0dev

src/kernel/fs/vfs.c

@@ -178,23 +178,17 @@ void vfs_register_builtin_backends(void) {
 int vfs_mount_with_cache(struct block_cache *cache) {
 	if (!cache)
 		return -1;
-	printk("vfs: attempting to mount %d registered backends\n",
-	       backend_count);
+
 	for (int i = 0; i < backend_count; ++i) {
 		void *sb = NULL;
 		if (!backends[i])
 			continue;
-		printk("vfs: trying backend %s\n", backends[i]->name);
 		int r = -1;
 		if (backends[i]->mount_with_cache)
 			r = backends[i]->mount_with_cache(cache, &sb);
-		printk("vfs: backend %s mount result %d\n", backends[i]->name,
-		       r);
 		if (r == 0) {
 			active_backend = backends[i];
 			active_sb = sb;
-			printk("vfs: mounted backend %s\n",
-			       active_backend->name);
 			return 0;
 		}
 	}

src/kernel/interrupt/irq_preempt.c

@@ -3,6 +3,7 @@
 #include <driver/timer/apic.h>
 #include <util/console.h>
 #include <stdint.h>
+#include "irq_trace.h"
 
 // スタックレイアウト (regs_stack のインデックス):
 // 0: RAX
@@ -50,15 +51,16 @@ void irq_preempt_entry(uint64_t *regs_stack, uint32_t vec) {
 		t->regs.rip = regs_stack[15];
 		t->regs.rflags = regs_stack[17];
 
-		// RSP は RIP が置かれているスタック位置へのポインタとする
-		t->regs.rsp = (uint64_t)(&regs_stack[15]);
+		t->regs.rsp = (uint64_t)(&regs_stack[15]) + 8;
 
 		// CR3 を読み取って保存
 		uint64_t cr3;
 		asm volatile("mov %%cr3, %0" : "=r"(cr3));
 		t->regs.cr3 = cr3;
 	}
 
+	irq_trace_record_from_stack(regs_stack, vec);
+
 	// タイマ割り込みベクタならタイマーハンドラを即時実行
 	if (vec == 48) {
 		// APIC タイマの同期処理
@@ -70,4 +72,4 @@ void irq_preempt_entry(uint64_t *regs_stack, uint32_t vec) {
 	if (t) {
 		task_schedule_from_irq(&t->regs);
 	}
-}
+}

src/kernel/interrupt/irq_timer.c

@@ -3,6 +3,7 @@
 #include <task/multi_task.h>
 #include <driver/timer/apic.h>
 #include <stdint.h>
+#include "irq_trace.h"
 
 // IRQ 経路から呼ばれるスケジューラ関数（TCB のレジスタポインタを渡す）
 extern void task_schedule_from_irq(registers_t *irq_regs);
@@ -36,15 +37,20 @@ void irq_timer_entry(uint64_t *regs_stack) {
 		t->regs.rip = regs_stack[15];
 		t->regs.rflags = regs_stack[17];
 
-		uintptr_t saved_rsp =
-			(uintptr_t)regs_stack + (size_t)((15 + 3) * 8);
-		t->regs.rsp = saved_rsp;
+		/* RSP は RIP が置かれているスタック位置へのポインタとする
+		 * task_switch/task_restore が期待する形式に合わせて +8 を行う
+		 */
+		t->regs.rsp = (uint64_t)(&regs_stack[15]) + 8;
 
 		// CR3 は現在の CR3 を読み取って保存
 		uint64_t cr3val;
 		asm volatile("mov %%cr3, %0" : "=r"(cr3val));
 		t->regs.cr3 = cr3val;
 	}
 
-	task_schedule_from_irq(&t->regs);
+	irq_trace_record_from_stack(regs_stack, 48);
+
+	if (t) {
+		task_schedule_from_irq(&t->regs);
+	}
 }

src/kernel/interrupt/irq_trace.c

@@ -0,0 +1,59 @@
+#include "irq_trace.h"
+#include <task/multi_task.h>
+#include <stdint.h>
+#include <util/console.h>
+
+static irq_trace_entry_t irq_trace_buf[IRQ_TRACE_CAPACITY];
+static volatile unsigned irq_trace_head = 0; // next write index
+
+// IRQ-safe minimal record: no allocation, no printk
+void irq_trace_record(uint64_t vec, uint64_t rip, uint64_t rsp, uint64_t cr3,
+		      uint64_t rflags, uint32_t tid) {
+	unsigned idx = irq_trace_head++;
+	idx &= (IRQ_TRACE_CAPACITY - 1);
+	irq_trace_buf[idx].vec = vec;
+	irq_trace_buf[idx].rip = rip;
+	irq_trace_buf[idx].rsp = rsp;
+	irq_trace_buf[idx].cr3 = cr3;
+	irq_trace_buf[idx].rflags = rflags;
+	irq_trace_buf[idx].tid = tid;
+}
+
+// regs_stack layout assumed by irq stubs: see irq_stubs.asm
+// index 15 = RIP, index 17 = RFLAGS. RSP we record as pointer-based value
+void irq_trace_record_from_stack(uint64_t *regs_stack, uint32_t vec) {
+	uint64_t rip = regs_stack[15];
+	uint64_t rflags = regs_stack[17];
+	// saved RSP pointer: caller's code in IRQ handler will expect saved RSP
+	uint64_t rsp_ptr = (uint64_t)(&regs_stack[15]);
+
+	uint64_t cr3_val = 0;
+	asm volatile("mov %%cr3, %0" : "=r"(cr3_val));
+
+	uint32_t tid = 0;
+	task_t *t = task_current();
+	if (t)
+		tid = t->tid;
+
+	irq_trace_record(vec, rip, rsp_ptr, cr3_val, rflags, tid);
+}
+
+// Dump the buffer using printk — call only from non-IRQ context
+void irq_trace_dump(void) {
+	printk("--- IRQ trace dump (last %d entries) ---\n",
+	       IRQ_TRACE_CAPACITY);
+	unsigned start = (irq_trace_head >= IRQ_TRACE_CAPACITY) ?
+				 (irq_trace_head & (IRQ_TRACE_CAPACITY - 1)) :
+				 0;
+	unsigned count = (irq_trace_head >= IRQ_TRACE_CAPACITY) ?
+				 IRQ_TRACE_CAPACITY :
+				 irq_trace_head;
+	for (unsigned i = 0; i < count; ++i) {
+		unsigned idx = (start + i) & (IRQ_TRACE_CAPACITY - 1);
+		irq_trace_entry_t *e = &irq_trace_buf[idx];
+		printk("[%3u] vec=%u tid=%u rip=0x%lx rsp=0x%lx cr3=0x%lx rflags=0x%lx\n",
+		       (unsigned)i, (unsigned)e->vec, (unsigned)e->tid,
+		       (unsigned long)e->rip, (unsigned long)e->rsp,
+		       (unsigned long)e->cr3, (unsigned long)e->rflags);
+	}
+}

src/kernel/interrupt/irq_trace.h

@@ -0,0 +1,23 @@
+// Minimal IRQ trace buffer for lightweight recording from IRQ context.
+#ifndef IRQ_TRACE_H
+#define IRQ_TRACE_H
+
+#include <stdint.h>
+
+#define IRQ_TRACE_CAPACITY 1024
+
+typedef struct irq_trace_entry {
+	uint64_t vec;
+	uint64_t rip;
+	uint64_t rsp;
+	uint64_t cr3;
+	uint64_t rflags;
+	uint32_t tid;
+} irq_trace_entry_t;
+
+void irq_trace_record(uint64_t vec, uint64_t rip, uint64_t rsp, uint64_t cr3,
+		      uint64_t rflags, uint32_t tid);
+void irq_trace_record_from_stack(uint64_t *regs_stack, uint32_t vec);
+void irq_trace_dump(void);
+
+#endif // IRQ_TRACE_H

src/kernel/task/multi_task.c

@@ -387,6 +387,12 @@ void task_schedule(void) {
 
 	irq_restore(flags);
 
+	/* 非 IRQ コンテキストでトレースバッファをダンプ（必要なら） */
+	extern void irq_trace_dump(void);
+	if (next_task == &idle_task) {
+		irq_trace_dump();
+	}
+
 	// コンテキストスイッチ（異なるタスクの場合のみ）
 	if (old_task != next_task) {
 		task_switch(&old_task->regs, &next_task->regs);
@@ -401,16 +407,13 @@ void task_exit(void) {
 
 	if (current_task) {
 		current_task->state = TASK_STATE_DEAD;
-		printk("task_exit: Task '%s' (TID=%u) exited\n",
-		       current_task->name, (unsigned)current_task->tid);
 	}
 
 	irq_restore(flags);
 
 	// スケジューラを呼んで次のタスクへ
 	task_schedule();
 
-	// ここには戻ってこない
 	while (1) {
 		asm volatile("hlt");
 	}
@@ -432,8 +435,6 @@ void task_schedule_from_irq(registers_t *irq_regs) {
 	if (!scheduler_enabled || !current_task)
 		return;
 
-	/* IRQ コンテキストでは既に割り込みは無効化されているはず */
-
 	task_t *next_task = NULL;
 
 	/* レディキューから次のタスクを取得 */
@@ -471,13 +472,8 @@ void task_schedule_from_irq(registers_t *irq_regs) {
 	current_task = next_task;
 	next_task->state = TASK_STATE_RUNNING;
 
-	/* IRQ コンテキストでは既に元のレジスタは TCB に保存済みであるため
-	 * 古いレジスタを再保存する必要はない。直接新しいタスクを復元する。
-	 * irq_regs は呼び元で保存された current_task のレジスタへのポインタ。
-	 */
 	if (old_task != next_task) {
-		(void)irq_regs; /* 今の実装では current_task->regs に保存済みなので未使用 */
+		(void)irq_regs;
 		task_restore(&next_task->regs);
-		/* task_restore は新タスクへ復帰するため通常ここには戻らない */
 	}
 }

src/kernel/task/multi_task.h

@@ -97,16 +97,8 @@ void task_yield(void);
  */
 extern void task_switch(registers_t *old_regs, registers_t *new_regs);
 
-// IRQ コンテキストから呼ばれるスケジューラヘルパー
-// irq_regs: IRQ スタックから保存した現在タスクのレジスタ
 void task_schedule_from_irq(registers_t *irq_regs);
 
-// IRQ コンテキストから直接スケジューリングを行う
-// この関数は irq_timer_entry 等の IRQ ハンドラから呼ばれる。
-// (task_schedule_from_irq は上で定義済み)
-
-// 新しいタスクのレジスタを即時復元して実行する（アセンブリ）
-// 引数: rdi = registers_t * (復元対象)
 extern void task_restore(registers_t *new_regs);
 
 #endif /* _TASK_TASK_H */