---

task.c File Reference

Task Management. More...

#include <const.h>
#include <stdlib.h>
#include <string.h>
#include <arch/i386.h>
#include <arch/interrupt.h>
#include <arch/mem.h>
#include <arch/paging.h>
#include <arch/v86.h>
#include <kernel/console.h>
#include <kernel/clock.h>
#include <kernel/elf32.h>
#include <kernel/fat.h>
#include <kernel/kmalloc.h>
#include <kernel/queue.h>
#include <kernel/semaphore.h>
#include <kernel/shell.h>
#include <kernel/umalloc.h>
#include <kernel/task.h>

Go to the source code of this file.

Functions
void	do_idle ()
	Simply do nothing...
void	kpager ()
	This special kernel thread provides to free the memory space and resources owned by the zombie tasks.
pid_t	new_pid ()
	Create a new pid. Returns: The new pid created.
pid_t	get_pid ()
	Return the current task pid if there is a curr_task. Returns: The current task pid.
task_t *	get_curr_task ()
	Get the current task. Returns: The current task structure pointer.
char *	get_pname ()
	Return the current task name if there is a curr_task. Returns: The current task name.
task_t *	create_kthread (void *address, char *pname)
	Create a new kernel thread. Parameters: address  The address of the starting point for the thread. pname  The name of the new thread. Returns: A pointer to the new-created task structure. Exceptions: NULL  If an error occurs (in particular out-of-memory).
task_t *	create_process (void *address, void *buffer, size_t size, char *pname, int privilege)
	Create a new process. Parameters: address  The address of the starting point for the thread. buffer  An address to a buffer where is placed the executable code. size  The size of the executable code buffer. pname  The name of the new task. privilege  The privilege level of the new task: KERNEL_PRIVILEGE USER_PRIVILEGE Returns: A pointer to the new-created task structure. Exceptions: NULL  If an error occurs (in particular out-of-memory).
size_t	new_vspace ()
	Create a new virtual space. Returns: The physical address of the page directory for the new virtual space. Exceptions: NULL  If an error occurs (in particular out-of-memory).
uint32_t *	task_setup_stack (int argc, char **argv, addr_t stack_start, size_t stack_size, int privilege)
	Initialize the stack for a new process. Parameters: argc  The number of arguments passed to the new process. argv  A pointer to the argument strings. NOTE: The content of argv may be changed!!! stack_start  Where the stack is placed in memory. stack_size  The size of the stack in bytes. privilege  The privilege of the task. Returns: The starting stack pointer after initialization.
task_t *	new_task (char *filename, int argc, char **argv, int privilege)
	Execute a file creating a new task. Parameters: filename  The name of the file to execute. argc  The number of arguments passed to the new process. argv  The arguments passed to the new process. argv  A pointer to the argument strings. privilege  The privilege level of the new task: KERNEL_PRIVILEGE USER_PRIVILEGE Returns: A pointer to the new-created task structure. Exceptions: NULL  If an error occurs (in particular out-of-memory).
bool	kill (pid_t pid)
	Kill a task by the pid. Parameters: pid  The process id. Returns: TRUE if the task has been successfully killed FALSE if the task cannot be killed.
void	auto_kill (int n)
	Kill the current running task. Parameters: n  The return code.
pid_t	waitpid (pid_t pid, int *status, int options)
	Wait for the exit of a child. Parameters: pid  The child process id -1 to wait for the exit of a generic child. status  Reports the status of the child. options  Options flags. Returns: The pid of the child or -1 if the process has not been found.
void	sleep_task (task_t *p)
	Sleep a process if it is awake. Parameters: p  The structure of the task to sleep.
void	wakeup_task (task_t *p)
	Wakeup a process if it is sleeping. Parameters: p  The structure of the task to wakeup.
void	sched_enter_critical_region ()
	Disable the scheduling of the other tasks. Warning: ATTENTION!!! Remember to call sched_leave_critical_region() when the task exits from the critical region. Otherwise the whole system could be blocked, because the scheduling of the other tasks is disabled after a task calls this function.
void	sched_leave_critical_region ()
	Re-enable scheduling for the other tasks.
bool	is_sched_enabled ()
	Return if the scheduling is enabled or not. Returns: TRUE if the scheduling is enabled FALSE otherwise.
__inline__ void	scheduler ()
	This is a simple round robin scheduler.
void	dispatcher ()
	The dispatcher.
void	init_multitasking ()
	Initialize the multitasking management.
void	ps ()
	Print the state of every process from the ready, wait and zombie queues.
Variables
size_t	K_PDBR [PAGE_SIZE/sizeof(size_t)]
	Master page directory.
queue_t *	ready_queue = NULL
	A pointer to ready queue. Declared in task.c.
queue_t *	wait_queue = NULL
	Wait-queue: tasks are waiting for I/O.
queue_t *	zombie_queue = NULL
	Zombie-queue: tasks are dying.
task_t *	curr_task = NULL
	A pointer to the current running task structure. Declared in task.c.
task_t *	idle_task = NULL
	IDLE task structure. Initialized in init_multitasking().
task_t *	kpagd = NULL
	KPager daemon.
atomic_t	last_pid
	Last used pid.
semaphore_t	sched_enabled
	A semaphore to enable or disable scheduling (used to manage critical regions).

---

Detailed Description

Task Management.

Author:

Andrea Righi <drizzt@inwind.it>

Date:

Last update:
2003-12-15 Andrea Righi: Added temporary memory operators to get and free the temporary mapped pages.
2003-12-16 Andrea Righi: Fixed mutual exclusion bug in kill() and waitpid()

Note:

Copyright (©) 2003 Andrea Righi

Definition in file task.c.

---

Function Documentation

void auto_kill (  int    n )

Kill the current running task. Parameters: n  The return code. This routine move the current task from the ready queue to the zombie queue. Then the kpager() daemon should provide to free the memory and resources owned by this task. Definition at line 949 of file task.c. { kill( curr_task->pid ); }

task_t* create_kthread (  void *    address, char *    pname )

Create a new kernel thread. Parameters: address  The address of the starting point for the thread. pname  The name of the new thread. Returns: A pointer to the new-created task structure. Exceptions: NULL  If an error occurs (in particular out-of-memory). This routine initialize a new kernel thread structure and add this thread to the ready queue. Definition at line 234 of file task.c. { task_t *new_task; byte *pl0_stack; sched_enter_critical_region(); // --- Create the task structure -------------------------------// //! //! IA-32 Intel(R) Architecture Software Developer's Manual //! Volume 3: System Programming Guide - Chapter 6 - reports: //! //! "If paging is used, care should be taken to avoid placing a //! page boundary within the part of the TSS that the processor //! reads during a task switch (the first 104 bytes). If a page //! boundary is placed within this part of the TSS, the pages on //! either side of the boundary must be present at the same time //! and contiguous in physical memory. //! //! The reason for this restriction is that when accessing a TSS //! during a task switch, the processor reads and writes into //! the first 104 bytes of each TSS from contiguous physical //! addresses beginning with the physical address of the first //! byte of the TSS. It may not perform address translation at a //! page boundary if one occurs within this area. So, after the //! TSS access begins, if a part of the 104 bytes is not both //! present and physically contiguous, the processor will access //! incorrect TSS information, without generating a page-fault //! exception. The reading of this incorrect information will //! generally lead to an unrecoverable exception later in the //! task switch process..." new_task = kmemalign(PAGE_SIZE, sizeof(task_t)); if (new_task == NULL) { // Out of virtual memory!!! // set_color(LIGHT_RED); kprintf("\n\rOut of virtual memory!!! Cannot create task [%s]\n\r", pname); set_color(DEFAULT_COLOR); sched_leave_critical_region(); return(NULL); } memset(new_task, 0, sizeof(task_t)); // --- Create the pl0-stack --- // pl0_stack = kmalloc(STACK_SIZE); if (pl0_stack == NULL) { // Out of virtual memory!!! // set_color(LIGHT_RED); kprintf("\n\rOut of virtual memory!!! Cannot create task [%s]\n\r", pname); set_color(DEFAULT_COLOR); // Free the previous allocated space // kfree((void *)new_task); sched_leave_critical_region(); return(NULL); } // Null the stack to enforce the page mapping // memset(pl0_stack, 0, STACK_SIZE); // Setup the pl0-stack // new_task->tss.ss0 = new_task->tss.ss = KERNEL_STACK; new_task->tss.esp0 = new_task->tss.esp = new_task->pl0_stack = (dword)(pl0_stack+STACK_SIZE-sizeof(uint32_t)); // --- Setup the TSS --- // new_task->tss_sel = setup_GDT_entry(sizeof(tss_IO_t), (dword)&(new_task->tss), TSS_SEG, 0); // Setup the task PDBR => get the kernel PDBR // new_task->tss.cr3 = GET_PDBR(); // Setup the IO port mapping // new_task->tss.io_map_addr = sizeof(tss_t); // Setup general registers // new_task->tss.ds = new_task->tss.es = KERNEL_DATA; new_task->tss.fs = new_task->tss.gs = KERNEL_DATA; new_task->tss.eflags = EFLAGS_IF | 0x02; // Initialize general purpose registers // new_task->tss.eax = new_task->tss.ebx = new_task->tss.ecx = new_task->tss.edx = new_task->tss.esi = new_task->tss.edi = 0; // Initialize LDTR (Local Descriptor Table Register) // // No LDTs for now... new_task->tss.ldtr = 0; // Initialize debug trap // // If set to 1 the processor generate a debug exception when a task switch to this task occurs... new_task->tss.trace = 0; // Setup starting address // new_task->tss.cs = KERNEL_CODE; new_task->tss.eip = (dword)address; // --- Get a pid --- // new_task->pid = new_pid(); // --- Store the name --- // // The last character must be ever '\0' (end of string) // strncpy(new_task->name, pname, sizeof(new_task->name)-2); // --- Set the type --- // new_task->type = KTHREAD_T; // --- Set the parent process --- // new_task->father = curr_task; // --- Set the console --- // new_task->console = curr_task->console; // --- Insert the task into the ready queue --- // new_task->state = READY; add_queue(&ready_queue, new_task); sched_leave_critical_region(); return (new_task); }

task_t* create_process (  void *    address, void *    buffer, size_t    size, char *    pname, int    privilege )

Create a new process. Parameters: address  The address of the starting point for the thread. buffer  An address to a buffer where is placed the executable code. size  The size of the executable code buffer. pname  The name of the new task. privilege  The privilege level of the new task: KERNEL_PRIVILEGE USER_PRIVILEGE Returns: A pointer to the new-created task structure. Exceptions: NULL  If an error occurs (in particular out-of-memory). This routine initializes the new task structure, copies the content of the buffer to the entry point address and then add the new task to the ready queue. Definition at line 374 of file task.c. { task_t *new_task; byte *pl0_stack; dword *PDBR; dword PDBR_frame, i; register dword cr3; sched_enter_critical_region(); // --- Create the task structure -------------------------------// //! //! IA-32 Intel(R) Architecture Software Developer's Manual //! Volume 3: System Programming Guide - Chapter 6 - reports: //! //! "If paging is used, care should be taken to avoid placing a //! page boundary within the part of the TSS that the processor //! reads during a task switch (the first 104 bytes). If a page //! boundary is placed within this part of the TSS, the pages on //! either side of the boundary must be present at the same time //! and contiguous in physical memory. //! //! The reason for this restriction is that when accessing a TSS //! during a task switch, the processor reads and writes into //! the first 104 bytes of each TSS from contiguous physical //! addresses beginning with the physical address of the first //! byte of the TSS. It may not perform address translation at a //! page boundary if one occurs within this area. So, after the //! TSS access begins, if a part of the 104 bytes is not both //! present and physically contiguous, the processor will access //! incorrect TSS information, without generating a page-fault //! exception. The reading of this incorrect information will //! generally lead to an unrecoverable exception later in the //! task switch process..." new_task = kmemalign(PAGE_SIZE, sizeof(task_t)); if (new_task == NULL) { // Out of virtual memory!!! // set_color(LIGHT_RED); kprintf("\n\rOut of virtual memory!!! Cannot create task [%s]\n\r", pname); set_color(DEFAULT_COLOR); sched_leave_critical_region(); return(NULL); } memset(new_task, 0, sizeof(task_t)); // --- Create the pl0-stack --- // pl0_stack = kmalloc(STACK_SIZE); if (pl0_stack == NULL) { // Out of virtual memory!!! // set_color(LIGHT_RED); kprintf("\n\rOut of virtual memory!!! Cannot create task [%s]\n\r", pname); set_color(DEFAULT_COLOR); // Free the previous allocated space // kfree((void *)new_task); sched_leave_critical_region(); return(NULL); } // Null the stack to enforce the page mapping // memset(pl0_stack, 0, STACK_SIZE); // Setup the pl0-stack // new_task->tss.ss0 = KERNEL_STACK; new_task->tss.esp0 = new_task->pl0_stack = (dword)(pl0_stack+STACK_SIZE-sizeof(uint32_t)); // --- Setup the TSS --- // new_task->tss_sel = setup_GDT_entry(sizeof(tss_IO_t), (dword)&(new_task->tss), TSS_SEG, 0); // --- Create the virtual space of the task ------------------- // PDBR = (dword *)get_temp_page(); if ( PDBR == NULL ) { // Out of memory!!! Free the previous allocated memory. // set_color(LIGHT_RED); kprintf("\n\rOut memory!!! Cannot create task [%s]\n\r", pname); set_color(DEFAULT_COLOR); // Free the previous allocated space // kfree((void *)(pl0_stack)); kfree((void *)new_task); // Destroy the TSS // remove_GDT_entry(new_task->tss_sel); // Free the sched_leave_critical_region(); return(NULL); } PDBR_frame = vir_to_phys( (dword)PDBR ); // Initialize PDBR // memset(PDBR, 0, PAGE_SIZE); for (i=K_VIR_START/(PAGE_SIZE*1024); i<1024; i++) PDBR[i] = K_PDBR[i]; // Map page directory into itself // PDBR[1023] = PDBR_frame | P_PRESENT | P_WRITE; // Unmap the temporary page, without free the physical frame // free_temp_page(PDBR, FALSE); // Temporary switch to the new address space // // // // QUESTION: cr3 is in the stack... if I switch into the new // // address space can I ever see the old cr3 value??? // // // // RE: Yes, but only if cr3 is stored into a register... // // And if the value should be stored into the stack, here we // // are at CPL0, so we're using the 0-privileged stack, so, // // since the 0-privileged stack space is shared between every // // task and also the kernel, we're ever able to see the stored // // cr3 value... // __asm__ __volatile__ ("movl %%cr3, %0" : "=r"(cr3) : ); __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(PDBR_frame)); // --- Create the user space --- // // Create the task stack // new_task->tss.ss = (privilege == KERNEL_PRIVILEGE) ? KERNEL_STACK : USER_STACK | 3; if ( privilege == KERNEL_PRIVILEGE ) new_task->tss.esp = new_task->pl0_stack; else new_task->tss.esp = (dword)(TASK_STACK_START-sizeof(size_t)); // Map the user code and data space. // // ("address" is the virtual task space, "buffer" is the // // kernel space where the task-code is located). // if (address != buffer) { memcpy(address, buffer, size); } // Restore the old address space // __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(cr3)); // Setup the task PDBR // new_task->tss.cr3 = PDBR_frame; // Setup the IO port mapping // new_task->tss.io_map_addr = sizeof(tss_t); // Setup general registers // if ( privilege == KERNEL_PRIVILEGE ) new_task->tss.ds = new_task->tss.es = new_task->tss.fs = new_task->tss.gs = KERNEL_DATA; else new_task->tss.ds = new_task->tss.es = new_task->tss.fs = new_task->tss.gs = USER_DATA | 3; new_task->tss.eflags = EFLAGS_IF | 0x02; if ( privilege == USER_PRIVILEGE ) // User tasks must have the I/O privilege level // // at the lower level // new_task->tss.eflags |= EFLAGS_IOPL3; // Initialize general purpose registers // new_task->tss.eax = new_task->tss.ebx = new_task->tss.ecx = new_task->tss.edx = new_task->tss.esi = new_task->tss.edi = 0; // Initialize LDTR (Local Descriptor Table Register) // // No LDTs for now... new_task->tss.ldtr = 0; // Initialize debug trap // // If set to 1 the processor generates a debug exception when a // // task switch to this task occurs... // new_task->tss.trace = 0; // Setup starting address // new_task->tss.cs = (privilege == KERNEL_PRIVILEGE) ? KERNEL_CODE : USER_CODE | 3; new_task->tss.eip = (dword)address; // --- Get a pid --- // new_task->pid = new_pid(); // --- Store the name --- // // The last character must be ever '\0' (end of string) // strncpy(new_task->name, pname, sizeof(new_task->name)-2); // --- Set the type --- // new_task->type = PROCESS_T; // --- Set the parent process --- // new_task->father = curr_task; // --- Set the console --- // if( curr_task ) new_task->console = curr_task->console; // --- Insert the task into the ready queue --- // new_task->state = READY; add_queue(&ready_queue, new_task); sched_leave_critical_region(); return (new_task); }

void dispatcher (    )

The dispatcher. This routine supplies to change the context of the tasks. It is invoked at every clock tick. You can change the frequency of the ticks changing the value of the HZ definition. Definition at line 1131 of file task.c. { task_t *prev_task; // Call the clock task at every tick // clock_thread(); // Can we switch to another process?! // if ( atomic_read(&sched_enabled) ) { // Store the previous task // prev_task = curr_task; // Select a new task // scheduler(); if ( prev_task != curr_task ) { if ( prev_task->tss.cr3 != curr_task->tss.cr3 ) { // Update the page directory of the // // new task with the kernel page // // directory in the kernel memory area. // __asm__ __volatile__ ( "movl %%eax, %%cr3\n" "cld\n" "rep movsl\n" "movl %%ebx, %%cr3" : : "a"(curr_task->tss.cr3), "b"(prev_task->tss.cr3), "D"((dword *)PAGE_DIR_MAP+(K_VIR_START/(PAGE_SIZE*1024))), "S"((dword *)K_PDBR+(K_VIR_START/(PAGE_SIZE*1024))), "c"((PAGE_DIR_MAP/(PAGE_SIZE*1024)) - (K_VIR_START/(PAGE_SIZE*1024))) ); __asm__("" : : : "%eax", "%ebx", "%ecx", "%edi", "%esi"); } // Re-enable master interrupt controller // outportb(PORT_8259_M, EOI); // Perform the task switch // jmp_to_tss(curr_task->tss_sel); } } }

void do_idle (    )

Simply do nothing... This is the default thread to execute when the system has to do nothing. Definition at line 73 of file task.c. { while(TRUE) { enable(); idle(); } }

task_t* get_curr_task (    )

Get the current task. Returns: The current task structure pointer. Definition at line 203 of file task.c. { return( curr_task ); }

pid_t get_pid (    )

Return the current task pid if there is a curr_task. Returns: The current task pid. Definition at line 186 of file task.c. { if ( !curr_task ) return( NULL ); return( curr_task->pid ); }

char* get_pname (    )

Return the current task name if there is a curr_task. Returns: The current task name. Definition at line 210 of file task.c. { if ( !curr_task ) return( NULL ); return( curr_task->name ); }

void init_multitasking (    )

Initialize the multitasking management. Definition at line 1185 of file task.c. { // Initialize pid counter. atomic_set(&last_pid, 0); // Initialize scheduler critical region flag. INIT_MUTEX( &sched_enabled ); // Create the "init" task. curr_task = create_process(NULL, NULL, 0, "init", KERNEL_PRIVILEGE); // Set the console. curr_task->console=1; // Set the type. curr_task->type = KTHREAD_T; // Load task register. __asm__ __volatile__ ("ltr %%ax" : : "a" (curr_task->tss_sel)); __asm__ __volatile__ ("" : : : "ax"); // Load virtual space. __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(curr_task->tss.cr3)); // Initialize the IDLE task. // The IDLE task is a special task, // it's always ready but never present in the ready queue. idle_task = create_kthread(&do_idle, "idle"); idle_task->console=0; rem_queue(&ready_queue, idle_task); // Initialize KPager thread kpagd = create_kthread(&kpager, "kpagerd"); kpagd->console = 0; // Install the dispatcher. install_irq_handler( TIMER_IRQ, (void *)&dispatcher ); }

bool is_sched_enabled (    )

Return if the scheduling is enabled or not. Returns: TRUE if the scheduling is enabled FALSE otherwise. Definition at line 1070 of file task.c. { if( atomic_read(&sched_enabled) ) return( TRUE ); else return( FALSE ); }

bool kill (  pid_t    pid )

Kill a task by the pid. Parameters: pid  The process id. Returns: TRUE if the task has been successfully killed FALSE if the task cannot be killed. This routine move the task having the pid from the ready queue to the zombie queue. Then the kpager() daemon should provide to free the memory and resources owned by this task. Definition at line 881 of file task.c. { // Queues where to search the processes // static queue_t **q[] = { &ready_queue, &wait_queue }; task_t *p = curr_task; bool retval = FALSE; register int i, j, n; // No running processes(???) => quit! // if ( p==NULL ) return(FALSE); sched_enter_critical_region(); // Explore every task queue // for ( i=0; i<_countof(q); i++) for ( j=0, n=count_queue(q[i]); j<n; j++ ) { // Get the next task in the queue // p = pick_queue( q[i] ); if ( p->pid == pid ) { // Move the task from the queue to the // // zombie queue // if ( rem_queue(q[i], p) ) { add_queue(&zombie_queue, p); p->state = ZOMBIE; // Wake-up the kpager daemon // wakeup_task( kpagd ); // Wake-up the father // if ( p->father != NULL ) wakeup_task( p->father ); // Task killed! // retval = TRUE; } } else { // If the process p is a child of the // // process to kill we have to set its // // father to NULL // if ( p->father != NULL ) if ( (p->father)->pid == pid ) p->father = NULL; } } // Check if the task has killed itself // if (curr_task->pid == pid) { sched_leave_critical_region(); // Wait for the dispatcher // do_idle(); } sched_leave_critical_region(); return( retval ); }

pid_t new_pid (    )

Create a new pid. Returns: The new pid created. This routine generate a pid using an atomic increment. Definition at line 178 of file task.c. { atomic_inc(&last_pid); return(atomic_read(&last_pid)); }

task_t* new_task (  char *    filename, int    argc, char **    argv, int    privilege )

Execute a file creating a new task. Parameters: filename  The name of the file to execute. argc  The number of arguments passed to the new process. argv  The arguments passed to the new process. argv  A pointer to the argument strings. privilege  The privilege level of the new task: KERNEL_PRIVILEGE USER_PRIVILEGE Returns: A pointer to the new-created task structure. Exceptions: NULL  If an error occurs (in particular out-of-memory). This routine can execute only ELF32 files. The file is loaded in a temporary buffer, then the sections are copied into memory and the task structure is initialized. At the end of this the new task is putted into the ready queue. Definition at line 697 of file task.c. { uint32_t temp_PDBR; task_t *task; byte *pl0_stack; size_t PDBR, entry; void *filebuffer; int filesize = get_file_size(filename); if ( filesize < 0 ) return(NULL); // Load the ELF32 file into the buffer // filebuffer = kmalloc(filesize); if ( elf32_load_file(filename, filebuffer)<0 ) { kfree(filebuffer); return(NULL); } sched_enter_critical_region(); // Create the task structure // task = kmemalign(PAGE_SIZE, sizeof(task_t)); if ( task == NULL ) { sched_leave_critical_region(); kfree(filebuffer); return(NULL); } memset(task, 0, sizeof(task_t)); // Create the PL0-stack // pl0_stack = kmalloc(STACK_SIZE); if (pl0_stack == NULL) { // Out of virtual memory!!! // // Free the previous allocated space // kfree((void *)task); kfree(filebuffer); sched_leave_critical_region(); return(NULL); } // Null the stack to enforce the page mapping // memset(pl0_stack, 0, STACK_SIZE); // Setup the PL0-stack // task->tss.ss0 = KERNEL_STACK; task->tss.esp0 = task->pl0_stack = (dword)(pl0_stack+STACK_SIZE-sizeof(uint32_t)); // Setup the TSS // task->tss_sel = setup_GDT_entry(sizeof(tss_IO_t), (dword)&(task->tss), TSS_SEG, 0); // Create the new virtual space // PDBR = new_vspace(); if ( PDBR == NULL ) { // Out of memory !!! // // Destroy the TSS // remove_GDT_entry(task->tss_sel); // Free the previous allocated space // kfree((void *)(pl0_stack)); kfree((void *)task); kfree(filebuffer); sched_leave_critical_region(); return(NULL); } // Temporary switch to the new address space // __asm__ __volatile__ ("movl %%cr3, %0" : "=r"(temp_PDBR) : ); __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(PDBR)); // Copy the file sections into memory // entry = elf32_copy_sections(filebuffer); if ( entry == NULL ) { // Restore the old address space // __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(temp_PDBR)); // Free the PDBR frame // push_frame(PDBR/PAGE_SIZE); // Destroy the TSS // remove_GDT_entry(task->tss_sel); // Free the previous allocated space // kfree((void *)(pl0_stack)); kfree((void *)task); kfree(filebuffer); sched_leave_critical_region(); return(NULL); } // Create the task stack. task->tss.ss = (privilege == KERNEL_PRIVILEGE) ? KERNEL_STACK : USER_STACK | 3; if ( privilege == KERNEL_PRIVILEGE ) task->tss.esp = (uint32_t)task_setup_stack(argc, argv, task->pl0_stack, STACK_SIZE, privilege); else task->tss.esp = (uint32_t)task_setup_stack(argc, argv, TASK_STACK_START, STACK_SIZE, privilege); // Initialize the user heap. umalloc_init( TASK_HEAP_START, TASK_HEAP_DEFAULT_SIZE ); // Restore the old address space // __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(temp_PDBR)); // Setup the task PDBR // task->tss.cr3 = PDBR; // Setup the IO port mapping // task->tss.io_map_addr = sizeof(tss_t); // Setup general registers // if ( privilege == KERNEL_PRIVILEGE ) task->tss.ds = task->tss.es = task->tss.fs = task->tss.gs = KERNEL_DATA; else task->tss.ds = task->tss.es = task->tss.fs = task->tss.gs = USER_DATA | 3; task->tss.eflags = EFLAGS_IF | 0x02; if ( privilege == USER_PRIVILEGE ) // User privilege must be the I/O privilege set to the // // lower level // task->tss.eflags |= EFLAGS_IOPL3; // Initialize general purpose registers // task->tss.eax = task->tss.ebx = task->tss.ecx = task->tss.edx = task->tss.esi = task->tss.edi = 0; // Initialize LDTR (Local Descriptor Table Register) // // No LDTs for now... task->tss.ldtr = 0; // Initialize debug trap // // If set to 1 the processor generate a debug exception when a task switch to this task occurs... task->tss.trace = 0; // Setup starting address // task->tss.cs = (privilege == KERNEL_PRIVILEGE) ? KERNEL_CODE : USER_CODE | 3; task->tss.eip = entry; // Get a pid // task->pid = new_pid(); // Store the name // // The last character must be ever '\0' (end of string) // strncpy(task->name, filename, sizeof(task->name)-2); // Set the type // task->type = PROCESS_T; // Set the parent process // task->father = curr_task; // Set the console // task->console = curr_task->console; // Insert the task into the ready queue // task->state = READY; add_queue(&ready_queue, task); // Well done! // kfree(filebuffer); sched_leave_critical_region(); return( task ); }

void ps (    )

Print the state of every process from the ready, wait and zombie queues. Definition at line 1234 of file task.c. { task_t *p; int count, i; if ((p = curr_task)==NULL) return; // Header // kprintf("\n\rPID STATE CONSOLE CMD"); sched_enter_critical_region(); // Ready processes // for(i=0, count=count_queue(&ready_queue); i<count; i++) { // Get the next task in the ready queue // p = pick_queue(&ready_queue); // Print process informations // kprintf("\n\r%u", p->pid); gotoxy(12, -1); kputchar('R'); gotoxy(22, -1); if (p->console) kprintf("tty%u", p->console); else kputchar('?'); gotoxy(34, -1); kprintf("%s", p->name); } // Wait processes // for(i=0, count=count_queue(&wait_queue); i<count; i++) { // Get the next task in the wait queue // p = pick_queue(&wait_queue); // Print process informations // kprintf("\n\r%u", p->pid); gotoxy(12, -1); kputchar('W'); gotoxy(22, -1); if (p->console) kprintf("tty%u", p->console); else kputchar('?'); gotoxy(34, -1); kprintf("%s", p->name); } // Zombie processes // for(i=0, count=count_queue(&zombie_queue); i<count; i++) { // Get the next task in the zombie queue // p = pick_queue(&zombie_queue); // Print process informations // kprintf("\n\r%u", p->pid); gotoxy(12, -1); kputchar('Z'); gotoxy(22, -1); if (p->console) kprintf("tty%u", p->console); else kputchar('?'); gotoxy(34, -1); kprintf("%s", p->name); } sched_leave_critical_region(); kprintf("\n\r"); }

void sched_enter_critical_region (    )

Disable the scheduling of the other tasks. Warning: ATTENTION!!! Remember to call sched_leave_critical_region() when the task exits from the critical region. Otherwise the whole system could be blocked, because the scheduling of the other tasks is disabled after a task calls this function. Definition at line 1055 of file task.c. { DOWN( &sched_enabled ); }

void sched_leave_critical_region (    )

Re-enable scheduling for the other tasks. Definition at line 1061 of file task.c. { UP( &sched_enabled ); }

void sleep_task (  task_t *    p )

Sleep a process if it is awake. Parameters: p  The structure of the task to sleep. Definition at line 1024 of file task.c. { p->state = WAIT; }

pid_t waitpid (  pid_t    pid, int *    status, int    options )

Wait for the exit of a child. Parameters: pid  The child process id -1 to wait for the exit of a generic child. status  Reports the status of the child. options  Options flags. Returns: The pid of the child or -1 if the process has not been found. Todo: status flags and options flags not yet implemented! Definition at line 966 of file task.c. { // Queues where to search the processes // static queue_t **q[] = { &ready_queue, &wait_queue }; task_t *p; int i, j, n; bool found = FALSE; dword IF = GET_IF(); // A task can't wait for yourself! // if (curr_task->pid == pid) return(0); repeat: sched_enter_critical_region(); // Search into every task queue // for( i=0; i<_countof(q); i++ ) { for( j=0, n = count_queue( q[i] ); j<n; j++ ) { p = pick_queue( q[i] ); if ( (p->father == curr_task) && ((pid==-1) || (p->pid==pid)) ) { // Found! // found = TRUE; // Update the pid of the child that we // // are waiting (when pid is -1). // pid = p->pid; // Move the current task (father) into // // the wait queue and wait // if ( rem_queue(&ready_queue, curr_task) ) { add_queue(&wait_queue, curr_task); curr_task->state = WAIT; } sched_leave_critical_region(); // Sleeped! // // Now wait for the dispatcher // enable(); idle(); // Task waked-up! Check if the child // // that we are waiting is dead // goto repeat; } } } sched_leave_critical_region(); SET_IF(IF); // Return the child pid or -1 if the process has not been found // return( (found) ? pid : -1 ); }

void wakeup_task (  task_t *    p )

Wakeup a process if it is sleeping. Parameters: p  The structure of the task to wakeup. Definition at line 1031 of file task.c. { p->state = READY; }

---

Variable Documentation

size_t K_PDBR[PAGE_SIZE/sizeof(size_t)]

Master page directory. Definition at line 36 of file task.c.

---