typedef struct task
{
   struct
   {
      struct TSS_t TSS;
      struct GDTgate_t LDT[2];
      int tssIdx;
      int ldtIdx;
      page_directory_t *page_directory;   // Page directory.
   }System;
   
   struct
   {
      int dynamic;
      int nice;
   }Priority;

   struct
   {
      u32int esp, ebp;         // Stack and base pointers.
      u32int eip;            // Instruction pointer.
      u32int kernel_stack;         // Kernel stack location.
   }Address;
   
   struct
   {
      struct task *next;         // The next task in a linked list.
      struct task *back;         // The back task in a linked list.
   }Link;
   
   char name[64];               //Name process
   enum status_t status;            //Status process
   int pid;               // Process ID.
} task_t;

void switch_task()
{
   if (!current_task)
      return;

   u32int esp, ebp, eip;
   asm volatile("mov %%esp, %0" : "=r"(esp));
   asm volatile("mov %%ebp, %0" : "=r"(ebp));

   eip = read_eip();

   // Have we just switched tasks?
   if (eip == 0x12345)
      return;

   // No, we didn't switch tasks. Let's save some register values and switch.
   current_task->Address.eip = eip;
   current_task->Address.esp = esp;
   current_task->Address.ebp = ebp;
   
   if (current_task->Link.next)
   {
      // Get the next task to run.
      current_task = current_task->Link.next;
      // If we fell off the end of the linked list start again at the beginning.
   }
   else
   {
      current_task = ready_queue;
   }

   eip = current_task->Address.eip;
   esp = current_task->Address.esp;
   ebp = current_task->Address.ebp;
   
   asm volatile("                   \
         cli;             \
         mov %0, %%ecx;   \
         mov %1, %%esp;   \
         mov %2, %%ebp;   \
         mov %3, %%cr3;   \
         mov $0x12345, %%eax; \
         sti;             \
         jmp *%%ecx       "
                : : "r"(eip), "r"(esp), "r"(ebp), "r"(current_directory->physicalAddr));
}

asm volatile("sti");