Import backup from 2005-09-13

kernel/proc/hash.cpp

@@ -37,17 +37,11 @@ int hash::add(u32_t key, void *val)
 	for (u32_t i = 0; i < myTable[hashed].size(); i++)
 		if ( myTable[hashed][i].key == key )
 			return -1;			// key exists already
-	kprintf("hash.cpp: %d (slot %d) -> %d\n", key, hashed, val);
 	hash_entry_t he = {key, val};
-	kprintf("hash.cpp: going to add {%d, %d} to vector %d\n", he.key, he.data, hashed);
 	myTable[hashed].add(he);
-	kprintf("hash.cpp: finished adding %d -> %d\n",
-		myTable[hashed][myTable[hashed].size()-1].key,
-		myTable[hashed][myTable[hashed].size()-1].data);
 	mySize++;
 	if ( mySize > (hash_primes[mySizeIndex] << 1) )	// re-hash
 	{
-		kprintf("re-hashing\n");
 		vector< vector<hash_entry_t> > oldTable = myTable;
 		mySizeIndex++;
 		myTable = vector< vector<hash_entry_t> >();
@@ -99,7 +93,7 @@ int hash::exists(u32_t key)
 
 u32_t hash::hash_key(u32_t key)
 {
-	return key % hash_primes[mySizeIndex];
+	return ((key * 11) + mySizeIndex) % hash_primes[mySizeIndex];
 }
 
 u32_t hash::size()

kernel/proc/proc.cpp

@@ -27,9 +27,12 @@ extern "C" {
 u32_t	cur_task = 0;
 u32_t	n_processes = 0;
 tss_t	tss0;
+u32_t	pid_base = 1024;
+u32_t	pid_index = 0;
 }
 
 hash	*processes;
+vector<u32_t> *pids;
 
 int	proc_init()
 {
@@ -37,54 +40,54 @@ int	proc_init()
 	memset(&tss0, 0, sizeof(tss_t));
 	tss0.ss0 = SEG_KERNEL_DATA;
 	tss0.esp0 = VIRT_STACK_TOP;
-	kprintf("make new hash\n");
 	processes = new hash();
-	vector< vector<int> > test;
-	for (u32_t i = 0; i < 5; i++)
-		test.add(vector<int>());
-	for (u32_t i = 0; i < 5; i++)
-		for (u32_t j = 0; j < 3; j++)
-			test[i].add(i*10+j);
-	for (u32_t i = 0; i < 5; i++)
-		for (u32_t j = 0; j < 3; j++)
-			kprintf("<%d>", test[i][j]);
-	for (u32_t i = 0; i < 11; i++)
-	{
-		kprintf("add %d to hash\n", i);
-		processes->add(i, (void *) i);
-	}
-	kprintf("\n\n");
-	processes->dump();
-	kprintf("\n\n");
-	for (u32_t i = 0; i < 11; i++)
-	{
-		kprintf("get %d from hash\n", i);
-		if (i != (u32_t)processes->get(i))
-			kprintf(" !=: %d -> %d\n", i, processes->get(i));
-		processes->remove(i);
-	}
-	kprintf("size: %d\n", processes->size());
-
+	process_t *proc = (process_t *)New(process_t);
+	proc->p_page_dir = read_cr3();
+	proc->page_dir = (u32_t *)0xFFFFF000;
+	processes->add(0, proc);
+	pids = new vector<u32_t>();
+	pids->add(0);
 	return 0;
 }
 
 void	proc_sched(int_stack_t *int_stack)
 {
+	u32_t new_pid_index = (pid_index + 1) % pids->size();
+	switch_task(int_stack, (*pids)[new_pid_index]);
+	pid_index = new_pid_index;
+}
 
+u32_t	get_pid()
+{
+	u32_t potential = pid_base;
+	while (processes->exists(potential))
+	{
+		potential++;
+		if (potential == 0)
+			potential = PROC_MIN_USER_PID;
+	}
+	pid_base = potential + 1;
+	if (pid_base == 0)
+		pid_base = PROC_MIN_USER_PID;
+	return potential;
 }
 
 void	switch_task(int_stack_t *int_stack, u32_t new_task)
 {
-//	memcpy((*processes)[cur_task]->int_stack, int_stack, sizeof(int_stack_t));
+	memcpy(&((process_t *)processes->get(cur_task))->int_stack,
+		(void *) int_stack,
+		sizeof(int_stack_t));
 	cur_task = new_task;
-//	memcpy(int_stack, (*processes)[cur_task]->int_stack, sizeof(int_stack_t));
-//	write_cr3((*processes)[cur_task]->p_page_dir);
+	memcpy(int_stack, &((process_t *)processes->get(cur_task))->int_stack,
+		sizeof(int_stack_t));
+	write_cr3( ((process_t *)processes->get(cur_task))->p_page_dir );
 }
 
 u32_t	create_task(void *base, u32_t image_size, u32_t bss_size, void *entry)
 {
-	u32_t pid;
-//	processes[++n_processes] = create_process(base, image_size, bss_size, entry);
+	u32_t pid = get_pid();
+	processes->add(pid, create_process(base, image_size, bss_size, entry));
+	pids->add(pid);
 	return pid;
 }
 

kernel/proc/proc.h

@@ -13,6 +13,8 @@ extern "C" {
 #include "hos_defines.h"
 #include "kernel.h"
 
+#define PROC_MIN_USER_PID 1024
+
 typedef struct
 {
 	u32_t	*page_dir;	/* Page directory with physical PT addys */
@@ -67,6 +69,7 @@ typedef struct
 
 int	proc_init();
 void	proc_sched(int_stack_t *int_stack);
+u32_t	get_pid();
 void	switch_task(int_stack_t *int_stack, u32_t new_task);
 u32_t	create_task(void *base, u32_t image_size, u32_t bss_size, void *entry);
 process_t *create_process(void *base, u32_t image_size, u32_t bss_size, void *entry);