Ec Class Reference

Public Member Functions
ALWAYS_INLINE NORETURN void	make_current ()

Static Public Member Functions
HOT static NORETURN void	ret_user_sysexit ()
static NORETURN void	ret_user_iret () asm("ret_user_iret")
static NORETURN void	idle ()
static void	root_setup (mword)
HOT NORETURN static REGPARM_1 void	syscall_handler (uint8 a) asm("syscall_handler")
	System call handler.
static ALWAYS_INLINE void *	operator new (size_t)
static ALWAYS_INLINE void	operator delete (void *)

Public Attributes
Ec *	next

Static Public Attributes
static Ec *	current

Constructor & Destructor Documentation

Ec()

Ec::Ec

(

)

{
    regs.cs  = SEL_USER_CODE;
    regs.ds  = SEL_USER_DATA;
    regs.es  = SEL_USER_DATA;
    regs.ss  = SEL_USER_DATA;
    regs.efl = 0x200;           // IF = 1
}

Member Function Documentation

idle()

void Ec::idle ( )

static

{
    for (;;)
 
    UNREACHED;
}

make_current()

ALWAYS_INLINE NORETURN void Ec::make_current ( )

inline

        {
            current = this;
            Tss::run.sp0 = reinterpret_cast<mword>(exc_regs() + 1);
            Ec::ret_user_sysexit();
            UNREACHED; // Tell the compiler to not generate function epilog
        }

operator delete()

ALWAYS_INLINE void Ec::operator delete ( void * )

inlinestatic

{ /* nop */ }

operator new()

ALWAYS_INLINE void * Ec::operator new ( size_t )

inlinestatic

{ return Kalloc::allocator.alloc(sizeof (Ec)); }

ret_user_iret()

void Ec::ret_user_iret ( )

static

{
    asm volatile ("lea %0, %%esp;" // Load address of current->regs
                  "popa;"          // Restore all generic registers from there
                  "pop %%gs;"      // Restore segment registers
                  "pop %%fs;"
                  "pop %%es;"
                  "pop %%ds;"
                  "add $8, %%esp;" // Skip Exc_regs::err and vec
                  "iret"           // Return (restore %cs, %eip, %eflags)
                  : : "m" (current->regs) : "memory");
 
    UNREACHED;
}

ret_user_sysexit()

void Ec::ret_user_sysexit ( )

static

{
    asm volatile ("lea %0, %%esp;" // Load address of current->regs
                  "popa;"          // Restore all registers from there
                  "sti;"           // Enable interrupts
                  "sysexit"
                  : : "m" (current->regs) : "memory");
 
    UNREACHED;
}

root_setup()

void Ec::root_setup ( mword mbi_addr )

static

{
    // Bootloader passed us the "Multiboot information" data
    // structure. Among other things, it contains the physical address
    // of the user space application we want to execute.
 
    // To access the data at physical address, we have to "map" them
    // to virtual memory. Ptab::remap() creates a temporary mapping of
    // one 4 MB page.
    Multiboot * mbi = static_cast<Multiboot *>(Ptab::remap (mbi_addr));
 
    if (!(mbi->flags & Multiboot::MODULES) || (mbi->mods_count < 1))
        panic ("No multiboot modules\n");
 
    // Copy module desciptor to local variable
    Multiboot_module mod = *static_cast<Multiboot_module *>(Ptab::remap (mbi->mods_addr));
 
    // Get ELF header from the binary
    Eh *eh = static_cast<Eh *>(Ptab::remap(mod.mod_start));
    if (eh->ei_magic != 0x464c457f || eh->ei_class != 1 || eh->ei_data != 1 || eh->type != 2 || eh->machine != 3)
        panic ("No ELF");
 
    current->regs.edx = eh->entry; // Initial eip (why edx? see sysexit instruction)
 
    unsigned count = eh->ph_count;
 
    Ph *ph = static_cast<Ph *>(Ptab::remap(mod.mod_start + eh->ph_offset));
 
    for (unsigned i = 0; i < count; i++, ph++) {
 
        if (ph->type == Ph::PT_LOAD) {
 
            if (ph->f_size > ph->m_size || ph->v_addr % PAGE_SIZE != ph->f_offs % PAGE_SIZE)
                panic ("Bad ELF");
 
            mword attr;
            if (ph->flags & Ph::PF_W)
                attr = Ptab::PRESENT | Ptab::USER | Ptab::RW;
            else
                attr = Ptab::PRESENT | Ptab::USER;
 
            mword virt = align_dn(ph->v_addr, PAGE_SIZE);
            mword phys = align_dn(ph->f_offs + mod.mod_start, PAGE_SIZE);
            mword fsize = align_up(ph->v_addr % PAGE_SIZE + ph->f_size, PAGE_SIZE);
            mword msize = align_up(ph->v_addr % PAGE_SIZE + ph->m_size, PAGE_SIZE);
 
            while (msize > 0) {
                if (fsize == 0) {
                    void *page = Kalloc::allocator.alloc_page (1, Kalloc::FILL_0);
                    if (!page)
                        panic ("Not enough memory\n");
                    phys = Kalloc::virt2phys (page);
                }
                if (!Ptab::insert_mapping(virt, phys, attr))
                    panic ("Not enough memory\n");
                phys += PAGE_SIZE;
                virt += PAGE_SIZE;
                msize -= PAGE_SIZE;
                fsize -= fsize ? PAGE_SIZE : 0;
            }
 
            // Zero .bss
            if ((ph->m_size > ph->f_size) && (attr & Ptab::RW))
                memset(reinterpret_cast<void*>(ph->v_addr + ph->f_size),
                       0x00, ph->m_size - ph->f_size);
 
            Ec::break_min = Ec::break_current = virt;
        }
    }
 
    // Allocate one page of memory for user space stack
    void *stack = Kalloc::allocator.alloc_page (1, Kalloc::FILL_0);
    if (!stack)
        panic ("Not enough memory\n");
 
    // Map the stack page at address below 0xc0000000 (starting at 0xbffff000)
    if (!Ptab::insert_mapping (0xbffff000, Kalloc::virt2phys (stack),
                              Ptab::PRESENT | Ptab::RW | Ptab::USER))
        panic ("Not enough memory\n");
 
    current->regs.ecx = 0xc0000000;   // Initial esp (why ecx? see sysexit instruction)
 
    current->next = current;
}

syscall_handler()

void Ec::syscall_handler ( uint8 a )

static

System call handler.

Parameters

[in]

a

Value of the al register before the system call

{
    // Get access to registers stored during entering the system - see
    // entry_sysenter in entry.S
    Sys_regs * r = current->sys_regs();
    Syscall_numbers number = static_cast<Syscall_numbers> (a);
 
    switch (number) {
        case sys_print: {
            // Tisk řetězce na sériovou linku
            char *data = reinterpret_cast<char*>(r->esi);
            unsigned len = r->edi;
            for (unsigned i = 0; i < len; i++)
                printf("%c", data[i]);
            break;
        }
        case sys_sum: {
            // Naprosto nepotřebné systémové volání na sečtení dvou čísel
            int first_number = r->esi;
            int second_number = r->edi;
            r->eax = first_number + second_number;
            break;
        }
        // TODO: Add your system calls here
        default:
            printf ("unknown syscall %d\n", number);
            break;
    };
 
    ret_user_sysexit();
}

---

The documentation for this class was generated from the following files:

• include/ec.h
• src/ec.cc
• src/ec_syscall.cc