Advertisement
Guest User

VM.c

a guest
Apr 4th, 2020
258
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 5.11 KB | None | 0 0
  1. #include <types.h>
  2. #include <kern/errno.h>
  3. #include <lib.h>
  4. #include <thread.h>
  5. #include <curthread.h>
  6. #include <addrspace.h>
  7. #include <vm.h>
  8. #include <machine/spl.h>
  9. #include <machine/tlb.h>
  10. #include <vfs.h>
  11. #include <elf.h>
  12.  
  13. /*
  14.  * Note! If OPT_DUMBVM is set, as is the case until you start the VM
  15.  * assignment, this file is not compiled or linked or in any way
  16.  * used. The cheesy hack versions in dumbvm.c are used instead.
  17.  */
  18.  
  19. /*
  20.  * alloc_kpages() and free_kpages() are called by kmalloc() and thus the whole
  21.  * kernel will not boot if these 2 functions are not completed.
  22.  */
  23.  
  24.  
  25. struct Coremap_struct *Coremap;
  26. size_t numofpgs;
  27. size_t staticpgs;
  28.  
  29. int init_vm = 0;
  30.  
  31. extern struct thread *curthr;
  32.  
  33. int check = 0;
  34.  
  35. struct semaphore* coremap_access; // used for every coremap access
  36.  
  37. u_int32_t firstpage_addspace;  
  38. u_int32_t lastpage_addspace;
  39. u_int32_t new_page;
  40. u_int32_t coremap_size;
  41.  
  42. void
  43. vm_bootstrap(void)
  44. {
  45.  
  46. // I made these global
  47.     // u_int32_t firstpage_addspace;  
  48.     // u_int32_t lastpage_addspace;
  49.     // u_int32_t new_page;
  50.     // u_int32_t coremap_size;
  51.  
  52.     coremap_access = sem_create("coremap_sem", 1); //FIXME: not sure where I should destroy this
  53.  
  54.     ram_getsize(&firstpage_addspace, &lastpage_addspace);
  55.  
  56.     numOfpgs = (lastpage_addspace - firstpage_addspace)/ PAGE_SIZE;
  57.  
  58.     Coremap = (struct Coremap_struct*)PADDR_TO_KVADDR(firstpage_addspace);
  59.    
  60.    
  61.     coremap_size = numOfpgs * sizeof(struct Coremap_struct);
  62.    
  63.  
  64.     new_page = firstpage_addspace + coremap_size;
  65.  
  66.  
  67.     int staticpgs = (new_page - firstpage_addspace) / PAGE_SIZE + 1;
  68.    
  69.    
  70.     int i;
  71.     for (i = 0; i < numofpgs; i++) {
  72.  
  73.         Coremap[i].addspace = NULL;
  74.         Coremap[i].id = i;
  75.         Coremap[i].phy_addspace = firstpage_addspace + PAGE_SIZE * i;
  76.  
  77.         if(i > staticPages) {
  78.             Coremap[i].vir_addspace = 0xDEADBEEF;
  79.             Coremap[i].state = 0;
  80.             Coremap[i].length = 0;
  81.         }
  82.         else {
  83.             Coremap[i].vir_addspace = PADDR_TO_KVADDR(Coremap[i].phy_addspace);
  84.             Coremap[i].state = 1;
  85.             Coremap[i].length = 1;
  86.                        
  87.         }
  88.     }
  89.  
  90.     init_vm = 1;
  91. }
  92.  
  93.  
  94. static
  95. paddr_t
  96. getppages(unsigned long npages)
  97. {
  98.     int spl;
  99.     paddr_t addr;
  100.  
  101.     spl = splhigh();
  102.  
  103.     addr = ram_stealmem(npages);
  104.    
  105.     splx(spl);
  106.     return addr;
  107. }
  108.  
  109. int free_id(){
  110.     int id = -50;
  111.     int i; 
  112.     for(i = 0; i < numofpgs; i++){
  113.         if(Coremap[i].state == 0){
  114.             id = i;
  115.             break;
  116.         }
  117.     }
  118.     return id;
  119. }
  120.  
  121.  
  122. vaddr_t alloc_oneormorepgs(int npgs){
  123.  
  124. if(numofpgs == 1){
  125.  
  126.     int free_id = free_id();
  127.     Coremap[free_id].length = 1;
  128.     Coremap[free_id].addspace = curthr->t_vmspace;
  129.     Coremap[free_id].state = 1;
  130.     Coremap[free_id].vir_addspace = PADDR_TO_KVADDR(Coremap[free_id].phy_addspace);
  131.    
  132.     return (Coremap[free_id].vir_addspace);
  133.  
  134. }
  135.  
  136. else{
  137.  
  138.     int cont = 1;
  139.     int i;
  140.     for(i = 0; i < numofpgs - 1; i++){
  141.         if(cont >= npgs)
  142.             break;
  143.         if((Coremap[i].state == 0) && (Coremap[i + 1].state == 0))
  144.             cont++;
  145.         else
  146.         {
  147.             cont = 1;// not sure if i can replace with continue; ?
  148.         }
  149.        
  150.     }
  151.  
  152.     int j = i - npgs +1;
  153.     if (cont >= npgs){
  154.         int k;
  155.         for(k = j; k < numofpgs + j; k++){
  156.             Coremap[k].length = 1;
  157.             Coremap[k].addspace = curthr->t_vmspace;
  158.             Coremap[k].state = 1;
  159.             Coremap[k].vir_addspace = PADDR_TO_KVADDR(Coremap[k].phy_addspace);
  160.         }
  161.        
  162.         return PADDR_TO_KVADDR(Coremap[j].phy_addspace);
  163.    
  164.     }
  165.     else{
  166.        
  167.         int flag = 0;
  168.         for(i = 0; i < numofpgs; i++){
  169.             if(flag >= numofpgs){
  170.                 check = 1;
  171.                 break;
  172.             }
  173.             if(Coremap[i].state == 1){
  174.                 flag = 0;
  175.                 continue;
  176.             }
  177.             else
  178.                 flag++;
  179.  
  180.         }
  181.         if(!check)
  182.             return NULL;
  183.            
  184.     }
  185.     int beg = i - numofpgs + 1;
  186.     for(i = beg; i < numofpgs + beg; i++){
  187.         Coremap[k].length = 1;
  188.         Coremap[k].addspace = curthr->t_vmspace;
  189.         Coremap[k].state = 1;
  190.         Coremap[k].vir_addspace = PADDR_TO_KVADDR(Coremap[k].phy_addspace);
  191.     }
  192.     return PADDR_TO_KVADDR(Coremap[beg].phy_addspace);
  193. }
  194.  
  195. }
  196.  
  197.  
  198. vaddr_t
  199. alloc_kpages(int npages)
  200. {
  201.     int spl;
  202.     spl = splhigh();
  203.  
  204.     if (init_vm == 1){
  205.         vaddr_t retval;
  206.         retval = alloc_oneormorepgs(npages);
  207.         splx(spl);
  208.         return retval;
  209.     }
  210.     else{
  211.         // copied form dumb vm not sure if this is the default condition
  212.         vaddr_t vaddr = getppages(npages);
  213.         splx(spl);
  214.         return PADDR_TO_KVADDR(vaddr);
  215.     }
  216.      
  217.     // (void)npages;
  218.     // return 0;
  219. }
  220.  
  221. void
  222. free_kpages(vaddr_t addr)
  223. {
  224.     /*
  225.      * Write this.
  226.      */
  227.  
  228.     u_int32_t phys_addr = KVADDR_TO_PADDR(addr);
  229.     u_int32_t core_index = (phys_addr - firstpage_addspace)/PAGE_SIZE;
  230.  
  231.     P(coremap_access);
  232.    
  233.     // Free everything (unless it's a kernel/fixed page)
  234.     // free the entire size of whatever process (can be x number of blocks)
  235.  
  236.         for ( ; Coremap[core_index].last != 1; core_index++){
  237.             // Coremap[core_index].id = ?
  238.             Coremap[core_index].addspace = NULL;
  239.             Coremap[core_index].free = 1;
  240.             Coremap[core_index].phy_addspace = NULL;
  241.             Coremap[core_index].vir_addspace = NULL;
  242.             Coremap[core_index].fixed = 0;
  243.             Coremap[core_index].dirty = 0;
  244.             Coremap[core_index].last = 0;
  245.             Coremap[core_index].length = 0;
  246.         }
  247.  
  248.     V(coremap_access);
  249.  
  250.     (void)addr;
  251. }
  252.  
  253. int
  254. vm_fault(int faulttype, vaddr_t faultaddress)
  255. {
  256.     /*
  257.      * Definitely write this.
  258.      */
  259.  
  260.     (void)faulttype;
  261.     (void)faultaddress;
  262.     return 0;
  263. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement