Exemplo n.º 1
0
void *MMU::palloc(size_t numberOfPages)
{
    size_t contiguousFoundPages = 0;
    size_t retpde = 0, retpte = 0;
    void *retval = nullptr;
    for (size_t pde = 0; pde < 1024 && contiguousFoundPages != numberOfPages; ++pde) {
        PageTable table = getOrCreateTable(pde);

        // look through page table
        for (size_t pte = 0; pte < 1024; ++pte) {
            PageEntry entry = table.entryAtIndex(pte);
            if (!entry.getFlag(kPresentBit)) { // found a page that isn't present (is available)
                if (contiguousFoundPages == 0) { // this is the first available page, set our return pointer to it
                    retpde = pde;
                    retpte = pte;
                }

                ++contiguousFoundPages;
                if (contiguousFoundPages == numberOfPages) { // done
                    retval = (void *) ((retpde << 22) | (retpte << 12));
                    break;
                }
            } else if (contiguousFoundPages) { // current page is used, reset our contiguous page count
                retval = nullptr;
                contiguousFoundPages = 0;
            }
        }
    }

    if (retval) { // if we succeeded in finding space
        allocatePages(retval, numberOfPages);
    }

    return retval;
}
Exemplo n.º 2
0
void *MMU::palloc(void *virtualAddress, size_t numberOfPages)
{
    uintptr_t address = reinterpret_cast<uintptr_t>(virtualAddress);
    if (address & 0xFFF) {
        return nullptr; // address is not page aligned
    }

    for (size_t i = 0; i < numberOfPages; ++i) {
        auto page = pageForAddress(reinterpret_cast<void*>(address));
        if (page.getFlag(kPresentBit)) {
            virtualAddress = nullptr; // can't allocate, not enough space
            break;
        }

        address += 0x1000; // increment to next page
    }

    if (virtualAddress) {
        allocatePages(virtualAddress, numberOfPages);
    }

    return virtualAddress;
}
Exemplo n.º 3
0
void isr_handler(struct regs r)
{
    if(r.int_number == 0)
    {
        printf("Exception : Divide by Zero\n");
        printf("Faulting instruction: %x\n",readcr2());
        KillisCalled(pcb_head, current_pcb->processID);
     
//      exit(0);
    }
    else if(r.int_number == 13)
    {
        printf("Exception : General Protection fault\n");
        printf("Faulting instruction: %x\n",readcr2());
        printf("Error code: %x\n",r.err_code);
      	KillisCalled(pcb_head, current_pcb->processID);
    }
    else if(r.int_number == 14)
    {
    	
        // printf("Page fault\t");
        // printf("Fault addr: %x\t",readcr2());
        // printf("Error code: %x\n",r.err_code);
		

	//while(1);//test 20th apr
        
        // New page fault handler
        
        uint64_t errorCode = r.err_code;
        uint64_t faultAddr = (uint64_t)readcr2();
        struct vma *vmas = current_pcb->first_vma;

    	if(!(errorCode & 0x4))//Page fault in kernel mode
    	{
		/*
		//allocate to heap if malloc ed
		if(faultAddr>=UHEAPSTART && faultAddr<=UHEAPLIMIT-PAGE_SIZE)
		{
			page_insert(current_pcb->pml4,alignDown((void *)faultAddr), page_alloc(), BIT_USER | BIT_RW | BIT_PRESENT);
			printf("Inserted page for heap mem in kernel space\n");
		}
		
		else
		{
		*/
    			printf("Page fault in kernel mode.\n");
    			
		//}
    	}	


	//AADY: 26th APR
	if(errorCode & 0x1) //Page present but page protection violation, check for COW
	{
		if(errorCode & 0x2)//If page fault on write
		{
			copy_on_write_handler(faultAddr);
		}
		return;
	}


    	//Find VMA corresponding to faulting address
    	vmas = findVMA(faultAddr, errorCode);
    	if(!vmas)//Illegal access
    	{
    		printf("Segmentation fault.\n");
    		//KILL PROCESS
    		KillisCalled(pcb_head, current_pcb->processID);

 		  			
    	}
    	else
    	{
    		 
    		allocatePages(vmas);//Allocate pages as per vma size
    		copyELF(vmas); //Copy binary contents
             	
    	}	
    }else if(r.int_number == 128){
        // handled directly
    }
    else
    {
        
        printf("Common : %d\n",r.int_number);
        while(1);
    }
    //return
}