---

Generic Routines
[Multitasking]

Functions
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.

---

Detailed Description

The generic routines for task management.

---

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); }

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 ); }

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 ); }

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). Definition at line 579 of file task.c. { size_t PDBR_frame; uint32_t *PDBR; int i; // Create the virtual space of the task // PDBR = (uint32_t *)get_temp_page(); if (PDBR == NULL) { // Out of memory!!! // 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; // Free the page, but doesn't destroy the physical frame // free_temp_page( PDBR, FALSE ); return( PDBR_frame ); }

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; }

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. Definition at line 620 of file task.c. { static uint8_t __i386_quit[] = { 0xb8, 0x00, 0x00, 0x00, 0x00, // mov $0x0, %eax 0x89, 0xe5, // mov %esp, %ebp 0xcd, 0x80, // int $0x80 }; size_t *stack = (uint32_t *)( (stack_start - sizeof(size_t)) - ALIGN_UP(sizeof(size_t), sizeof(__i386_quit)) - sizeof(size_t) ); size_t *exit_point = stack; size_t *user_argv; int i; // We have not to null the stack to enforce page mapping for a // // user-mode task, because a stack fault is managed like a // // normal page fault. // // But In kernel mode a stack fault can cause a system reboot // // so we must enforce the page mapping in this case. // if ( privilege == KERNEL_PRIVILEGE ) memset((void *)(stack_start-stack_size), 0, stack_size/sizeof(size_t)); // Copy the exit code into the stack, because if we are in // // user-mode we cannot access to the kernel space without // // causing a page level protection fault. // memcpy((void *)stack, __i386_quit, sizeof(__i386_quit)); // Copy external parameters strings // for( i=0; i<argc; i++ ) { stack = (size_t *)((size_t)stack - strlen(argv[i]) - 1); strcpy((char *)stack, argv[i]); argv[i] = (char *)stack; } // Round down the stack pointer to the stack boundaries // stack = (size_t *)( TRUNC((size_t)stack, sizeof(size_t)) ); // Copy parameter string pointers // for( i=0; i<argc; i++ ) { *(--stack) = (size_t)(argv[argc-i-1]); } // Set the process argv pointer // user_argv = stack; *(--stack) = (size_t)user_argv; // Copy number of parameters value // *(--stack) = argc; // Copy the exit point address // *(--stack) = (size_t)(exit_point); // Return the initial stack pointer // return( stack ); }

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; }

---