void procA(void) { int vpage = 9000; int npages = 100; bsd_t bs = 1; char *addr; int i = 0; addr = (char *) (vpage * NBPG); get_bs(bs, npages); if (xmmap(vpage, bs, npages) == SYSERR) { kprintf("xmmap call failed\n"); return; } kprintf("data in %s..\n", __func__); addr = (char *) (vpage * NBPG) + NBPG; for (i = 0; i < 26; ++i) { kprintf("0x%08x: %c\n", addr, *addr); addr += NBPG; } xmunmap(vpage); return; }
void procA(void) { int rc = EMPTY; int vpage = 6000; int npages = 100; int bs_id = 5; char *x; char temp; rc = get_bs(bs_id, npages); kprintf("get_bs in %s.. %d\n", __func__, rc); rc = xmmap(vpage, bs_id, npages); kprintf("xmmap in %s.. %d\n", rc); x = (char *) (vpage * NBPG); kprintf("%s trying to access vaddr 0x%08x\n", __func__, x); *x = 'Y'; temp = *x; kprintf("value of temp in %s.. %c\n", __func__, temp); sleep(10); rc = xmunmap(vpage); kprintf("xmunmap in %s.. %d\n", __func__, rc); rc = release_bs(bs_id); kprintf("release_bs in %s.. %d\n", __func__, rc); return; }
/*------------------------------------------------------------------------- * kill_process - releases frames *------------------------------------------------------------------------- */ int kill_process(int pid) { int i; bs_map_t * bsmap; bs_map_t * prev; bs_map_t * curr; int pdbr,frame; STATWORD ps; disable(ps); for (i = 0; i < MAX_ID; i++) { bsmap = &bsm_tab[i]; if(bsmap->bs_status == BSM_UNMAPPED) continue; prev = bsmap; curr = bsmap->nextMap; while(curr != NULL) { if (curr->bs_pid == pid ) { xmunmap(curr->bs_vpno); } prev = curr; curr = curr->nextMap; } } pdbr = &proctab[pid].pdbr; frame = (pdbr/NBPG)-FRAME0; //release frame of page directory free_frm(frame); restore(ps); return OK; }
void proc1_test4(int* ret) { char *addr; int i; get_bs(MYBS1, 100); if (xmmap(MYVPNO1, MYBS1, 100) == SYSERR) { kprintf("xmmap call failed\n"); *ret = TFAILED; sleep(3); return; } addr = (char*) MYVADDR1; for (i = 0; i < 26; i++) { *(addr + i * NBPG) = 'A' + i; } sleep(6); /*Shoud see what proc 2 updated*/ for (i = 0; i < 26; i++) { /*expected output is abcde.....*/ if (*(addr + i * NBPG) != 'a'+i){ *ret = TFAILED; break; } } xmunmap(MYVPNO1); release_bs(MYBS1); return; }
void proc2_test4(int *ret) { char *addr; int i; get_bs(MYBS1, 100); if (xmmap(MYVPNO2, MYBS1, 100) == SYSERR) { kprintf("xmmap call failed\n"); *ret = TFAILED; sleep(3); return; } addr = (char*) MYVADDR2; /*Shoud see what proc 1 updated*/ for (i = 0; i < 26; i++) { /*expected output is ABCDEF.....*/ if (*(addr + i * NBPG) != 'A'+i){ *ret = TFAILED; break; } } /*Update the content, proc1 should see it*/ for (i = 0; i < 26; i++) { *(addr + i * NBPG) = 'a' + i; } xmunmap(MYVPNO2); release_bs(MYBS1); return; }
void proc1_test1(char *msg, int lck) { char *addr; int i; get_bs(TEST1_BS, 200); if (xmmap(PROC1_VPNO, TEST1_BS, 200) == SYSERR) { kprintf("xmmap call failed\n"); sleep(3); return; } addr = (char*) PROC1_VADDR; for (i = 0; i < 26; i++) { *(addr + i * NBPG) = 'A' + i; } sleep(6); for (i = 0; i < 26; i++) { kprintf("0x%08x: %c\n", addr + i * NBPG, *(addr + i * NBPG)); } xmunmap(PROC1_VPNO); return; }
void proc1_test1(char *msg ) { char *addr; int i; get_bs(TEST1_BS, 100); if (xmmap(PROC1_VPNO, TEST1_BS, 100) == SYSERR) { kprintf("xmmap call failed\n"); sleep(3); return; } addr = (char*) PROC1_VADDR; for (i = 0; i < 26; i++) { register char a; *(addr + i * NBPG) = a = 'A' + i; kprintf("%s Writing 0x%x: %c a=%c\n", msg, (addr + i * NBPG), *(addr + i * NBPG),a); } sleep(1); for (i = 25; i >=0; i--) { kprintf("%s 0x%08x: %c\n",msg, addr + i * NBPG, *(addr + i * NBPG)); } xmunmap(PROC1_VPNO); sleep(10); release_bs(TEST1_BS); return; }
void kill_task2(int sem) { int i,j; int rc; char * x; char *addr = (char*) 0x50000000; bsd_t bsid = 5; int npages = 5; kprintf("kill_task2... start consuming.\n"); get_bs(bsid, npages); rc = xmmap(VA2VPNO(addr), bsid, npages); if (rc == SYSERR) { kprintf("xmmap call failed\n"); return 0; } kprintf("kill_task2.. sleeping 5\n"); sleep(5); // Read back all of the values from memory and print them out x = addr; kprintf("kill_task2 end: "); for (i = 0; i < npages; i++) { for (j = 0; j < 5; j++) { kprintf("%c", *(x + j)); } kprintf(" "); x += NBPG; //go to the next page } kprintf("\n"); kprintf("kill_task2.. sleeping 5\n"); sleep(5); // NOTE: This is after other task has been killed // Read back all of the values from memory and print them out x = addr; kprintf("kill_task2 end: "); for (i = 0; i < npages; i++) { for (j = 0; j < 5; j++) { kprintf("%c", *(x + j)); } kprintf(" "); x += NBPG; //go to the next page } kprintf("\n"); sleep(1); xmunmap(VA2VPNO(addr)); release_bs(bsid); }
/* Test if mmap can allocate a page. This is necessary because setrlimit does not fail even if it reduces the RLIMIT_AS limit below what is currently needed by the process. */ static bool mmap_works (void) { void *ptr = mmap (NULL, 1, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); if (ptr == MAP_FAILED) return false; xmunmap (ptr, 1); return true; }
proc_share2(char c) { char *x; char temp_b; xmmap(60000, 4, 100); x = (char *)(60000 * NBPG); sleep(10); kprintf("\nReading from proc 2 %c (should be Y) and no page fault should be generated\n", *x); xmunmap(60000); }
proc_share1(char c) { char *x; char temp; get_bs(4, 100); xmmap(70000, 4, 100); /* This call simply creates an entry in the backing store mapping */ x = (char *)(70000*NBPG); *x = 'Y'; /* write into virtual memory, will create a fault and system should proceed as in the prev example */ kprintf("\nReading from proc 1 %c\n", *x); /* read back and check */ sleep(5); xmunmap(70000); }
////////////////////////////////////////////////////////////////////////// // random_access (tests replacement policies) ////////////////////////////////////////////////////////////////////////// void random_access_test() { int i, x, rc; char *addr = (char*) 0x50000000; char *w; bsd_t bsid = 7; int npages = 40; pt_t * pt; virt_addr_t * vaddr; kprintf("\nRandom access test\n"); srand(25); // some random seed rc = get_bs(bsid, npages); if (rc == SYSERR) { kprintf("get_bs call failed\n"); return 0; } rc = xmmap(VA2VPNO(addr), bsid, npages); if (rc == SYSERR) { kprintf("xmmap call failed\n"); return 0; } for (i=0; i<50; i++) { // Get a number between 0 and npages // This number will be the page offset from the // beginning of the backing store that we will access x = ((int) rand()) % npages; // Get the virtual address w = addr + x*NBPG; *w = 'F'; vaddr = &w; pt = VPNO2VA(proctab[currpid].pd[vaddr->pd_offset].pt_base); kprintf("Just accessed vaddr:0x%08x frame:%d bspage:%d\n", w, PA2FID(VPNO2VA(pt[vaddr->pt_offset].p_base)), x); } xmunmap(VA2VPNO(addr)); release_bs(bsid); }
/*-------------------------------------------------------------------------------------*/ void proc1_test3(int i,int* ret) { char *addr; int bsize; int r; get_bs(i, 100); if (xmmap(MYVPNO1, i, 100) == SYSERR) { *ret = TFAILED; return 0; } sleep(4); xmunmap(MYVPNO1); release_bs(i); return; }
int main() { int vpage = 5000; int npages = 100; bsd_t bs = 1; char *addr; int i = 0; int pA = 0; kprintf("\n\nHello World, Xinu lives\n\n"); pA = create(procA, 1024, 20, "procA", 0, 0); addr = (char *) (vpage * NBPG); get_bs(bs, npages); if (xmmap(vpage, bs, npages) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } for (i = 0; i < 26; ++i){ *addr = 'A' + i; addr += NBPG; } kprintf("data in %s..\n", __func__); addr = (char *) (vpage * NBPG); for (i = 0; i < 26; ++i) { kprintf("0x%08x: %c\n", addr, *addr); addr += NBPG; } xmunmap(vpage); release_bs(bs); resume(pA); sleep(10); return 0; }
static bool run(int argc, char **argv) { Elf64_Ehdr *elf; int i; struct stat s; i = 1; while (i < argc) { elf = init(argv[i], &s); if ((unsigned long int)s.st_size < sizeof(Elf64_Ehdr)) return (ERR("Le taille du header est incorrect")); if (!my_objdump(elf, argv[i], s.st_size)) return (false); xmunmap((void *)elf, s.st_size); i++; } return (true); }
/*----------------------------------------------------------------*/ void proc_test2(int i,int j,int* ret,int s) { char *addr; int bsize; int r; bsize = get_bs(i, j); if (bsize != 50) *ret = TFAILED; r = xmmap(MYVPNO1, i, j); if (j<=50 && r == SYSERR){ *ret = TFAILED; } if (j> 50 && r != SYSERR){ *ret = TFAILED; } sleep(s); if (r != SYSERR) xmunmap(MYVPNO1); release_bs(i); return; }
void peakLoadTestLaunch(){ int i, pid[15]; get_bs(15,128); xmmap(0xFFF80,15,128); // *(char *)( 0xFFF80*NBPG) = 'P'; *(char *)( (0xFFF80+127)*NBPG + NBPG -1) = 'L'; for(i=0;i<15;i++) { pid[i] = vcreate(peakLoadTest, 2000, 128, 10, "peakLoadTest", 1,i); if(pid[i] == SYSERR) { kprintf("Unable to launch virtual mem process. Test FAIL\n"); } resume(pid[i]); //sleep(1); } xmunmap(0xFFF80); sleep(100); kprintf("Wake Launch\n"); release_bs(15); kprintf("Exit Launch\n"); }
/*-------------------------------------------------------------------------------------*/ void proc1_test6(int *ret) { char *vaddr, *addr0, *addr_lastframe, *addr_last; int i, j; int tempaddr; int addrs[1200]; int maxpage = (NFRAMES - (5 + 1 + 1 + 1)); int vaddr_beg = 0x40000000; int vpno; for(i = 0; i < MAX_BSTORE; i++){ tempaddr = vaddr_beg + 100 * NBPG * i; vaddr = (char *) tempaddr; vpno = tempaddr >> 12; get_bs(i, 100); if (xmmap(vpno, i, 100) == SYSERR) { *ret = TFAILED; kprintf("xmmap call failed\n"); sleep(3); return; } for (j = 0; j < 100; j++) { *(vaddr + j * NBPG) = 'A' + i; } for (j = 0; j < 100; j++) { if (*(vaddr + j * NBPG) != 'A'+i){ *ret = TFAILED; break; } } xmunmap(vpno); release_bs(i); } return; }
void procB(void) { int rc = EMPTY; int vpage = 8000; int npages = 100; int bs_id = 5; char *x; char temp; rc = get_bs(bs_id, npages); kprintf("get_bs in %s.. %d\n", __func__, rc); rc = xmmap(vpage, bs_id, npages); kprintf("xmmap in %s.. %d\n", rc); x = (char *) (vpage * NBPG); kprintf("%s trying to access vaddr 0x%08x\n", __func__, x); temp = *x; kprintf("value of temp in %s.. %c\n", __func__, temp); sleep(1); enable_paging(); *x = 's'; temp = *x; kprintf("value of temp in %s.. %c\n", __func__, temp); rc = xmunmap(vpage); kprintf("xmunmap in %s.. %d\n", __func__, rc); /* Try to access VM after unmapping it. The process should be killed. */ kprintf("value of temp in %s.. %c\n", __func__, *x); kprintf("This line should never be printed!\n"); rc = release_bs(bs_id); kprintf("release_bs in %s.. %d\n", __func__, rc); return; }
void proc2_test1(char *msg, int a, int b, char *string) { char *addr; int i; get_bs(TEST1_BS, 100); if (xmmap(PROC2_VPNO, TEST1_BS, 100) == SYSERR) { kprintf("xmmap call failed\n"); sleep(3); return; } addr = (char*) PROC2_VADDR; for (i = 0; i < 26; i++) { kprintf("%s 0x%08x: %c\n",msg, addr + i * NBPG, *(addr + i * NBPG)); } xmunmap(PROC2_VPNO); release_bs(TEST1_BS); kprintf("Multi arg check: %d %d %s \n",a,b,string); return; }
void pageLoader(char *msg, u_long vpage){ int i,sum,j,inc; int *x; get_bs(TEST1_BS, 100); if (xmmap(vpage, TEST1_BS, 100) == SYSERR) { kprintf("xmmap call failed\n"); sleep(3); return; } for(i=0,sum=1,j=0,inc=-1;i<100;i++) { if(i%4==0) inc = -inc; j+=inc; x = (int *) ((vpage<<12) + (4+j)*NBPG); *x=i; sum += *x; kprintf("%s: Writing to @[0x%08x] (j=%d) (inc=%d) = %d\n",msg,x,j,inc,*x); sleep(1); } kprintf("%s: Final sum = %d\n",msg,sum); xmunmap(vpage); release_bs(TEST1_BS); }
void fifo_test() { // 7 frames allocated before this int i,j,k; int vpno = 8192; int frames = 7; frames++; for(i=0; i<8; i++){ char *c = (char *)((vpno+(i*128))*NBPG); get_bs(i,128); xmmap(VAD2VPN(c), i, 128); // 1 frame for PT every 8 cycles for(j=0; j<128; j++){ frames++; // 128 frames for data c[j*NBPG] = 'A'+i; } if(i == 7){ for(j=8; j<16; j++){ char * b = (char*)((1024 +j)*NBPG); if(b[0] != 'H'){ kprintf("Test Failed expected H got %c at frame %d\n", b[0], j); break; } } if(j == 16) kprintf("Test Passed \n"); } } sleep(2); for(i=0; i<8; i++){ xmunmap( vpno+ (i*128) ); release_bs(i); } }
int pe_end(Pe *pe) { Pe *parent = NULL; if (pe == NULL) { /* This is allowed and is a no-op. */ return 0; } if (pe->ref_count != 0 && --pe->ref_count != 0) { int result = pe->ref_count; return result; } parent = pe->parent; switch (pe->kind) { case PE_K_NONE: case PE_K_MZ: break; case PE_K_PE_OBJ: case PE_K_PE_EXE: case PE_K_PE_ROM: case PE_K_PE64_OBJ: case PE_K_PE64_EXE: { Pe_ScnList *list = &pe->state.pe.scns; do { size_t cnt = list->max; while (cnt-- > 0) { Pe_Scn *scn = &list->data[cnt]; if ((scn->shdr_flags & PE_F_MALLOCED)) xfree(scn->shdr); if (scn->data_base != scn->rawdata_base) xfree(scn->data_base); if (pe->map_address == NULL) xfree(scn->rawdata_base); } Pe_ScnList *oldp = list; list = list->next; assert(list == NULL || oldp->cnt == oldp->max); if (oldp != &pe->state.pe.scns) xfree(oldp); } while (list); } break; case PE_K_NUM: default: break; } if (pe->map_address != NULL && parent == NULL) { if (pe->flags & PE_F_MALLOCED) xfree(pe->map_address); else if (pe->flags & PE_F_MMAPPED) xmunmap(pe->map_address, pe->maximum_size); } xfree(pe); return (parent != NULL && parent->ref_count ? pe_end(parent) : 0); }
void test_func8_2() { int PAGE0 = 0x40000; int i,j,temp; int addrs[1200]; int cnt = 0; //can go up to (NFRAMES - 5 frames for null prc - 1pd for main - 1pd + 1pt frames for this proc) //frame for pages will be from 1032-2047 int maxpage = (NFRAMES - (5 + 1 + 1 + 1)); for (i=0;i<=maxpage/100;i++){ if(get_bs(i,100) == SYSERR) { kprintf("get_bs call failed \n"); return; } if (xmmap(PAGE0+i*100, i, 100) == SYSERR) { kprintf("xmmap call failed\n"); return; } for(j=0;j < 100;j++) { //store the virtual addresses addrs[cnt++] = (PAGE0+(i*100) + j) << 12; } } /* all of these should generate page fault, no page replacement yet acquire all free frames, starting from 1032 to 2047, lower frames are acquired first */ char *zero_addr = (char*) 0x0; for(i=0; i < maxpage-1; i++) { *((int *)addrs[i]) = i + 1; if (i + 1 != *((int *)(zero_addr + (i + 1032) * NBPG))) { kprintf("\tFAILED!\n"); kprintf("AA 0x%08x: %d\n", (int *)addrs[i], *((int *)addrs[i])); kprintf("BB 0x%08x: %d\n", zero_addr + (i + 1032) * NBPG, *((int *)(zero_addr + (i + 1032) * NBPG))); } } for(i=0; i < maxpage/3; i++) { *((int *)addrs[i]) = i * 4 + 1; } i = maxpage-1; *((int *)addrs[i]) = i + 1; //trigger page replacement, this should clear all access bits of all pages kprintf("\t8.2 Expected replaced frame: %d\n\t",1032+maxpage/3); *((int *)addrs[maxpage]) = maxpage * 5 + 1; temp = *((int *)addrs[maxpage]); if (temp != *((int *)((1032+maxpage/3) * NBPG))) { kprintf("\tFAILED!\n"); kprintf("AA 0x%08x: %d\n", (int *)addrs[maxpage], *((int *)addrs[maxpage])); kprintf("BB 0x%08x: %d\n", (1032+maxpage/3) * NBPG, *((int *)((1032+maxpage/3) * NBPG))); } for (i=0;i<=maxpage/100;i++){ xmunmap(PAGE0+(i*100)); release_bs(i); } }
void test_aging() { bsd_t bs1 = get_free_bs(); get_bs(bs1, 256); bsd_t bs2 = get_free_bs(); get_bs(bs2, 256); bsd_t bs3 = get_free_bs(); get_bs(bs3, 256); bsd_t bs4 = get_free_bs(); get_bs(bs4, 249); if (xmmap(40000, bs1, 256) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } if (xmmap(50000, bs2, 256) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } if (xmmap(60000, bs3, 256) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } if (xmmap(70000, bs4, 249) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } int i = 0; char *addr = (char *)(40000*NBPG); for (i = 0; i < 256; i++) { *addr = 500 + i; addr += NBPG; //increment by one page each time } addr = (char *)(50000*NBPG); for (i = 0; i < 256; i++) { *addr = 1000 + i; addr += NBPG; //increment by one page each time } addr = (char *)(60000*NBPG); for (i = 0; i < 256; i++) { *addr = 1500 + i; addr += NBPG; //increment by one page each time } addr = (char *)(70000*NBPG); for (i = 0; i < 245; i++) { *addr = 2000 + i; addr += NBPG; //increment by one page each time } //create 1 page fault which will result in page replacement bsd_t bs5 = get_free_bs(); get_bs(bs5, 1); if (xmmap(80000, bs5, 1) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } addr = (char *)(80000*NBPG); *addr = 'A'; //accessing the next in queue page for replacement kprintf("\nbreak\n"); addr = (char *)(40002*NBPG); *addr = 'P'; kprintf("\nHopefully avoided page %lu data %c\n",(unsigned long)addr, *addr); //create another page fault bsd_t bs6 = get_free_bs(); get_bs(bs6, 1); if (xmmap(90000, bs6, 1) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } addr = (char *)(90000*NBPG); *addr = 'B'; kprintf("\nPAGE STATES: %d %d\n",frm_tab[1032-1024].status, frm_tab[1034-1024].status); xmunmap(40000); xmunmap(50000); xmunmap(60000); xmunmap(70000); xmunmap(80000); xmunmap(90000); }
void test_sharing_fifo() { int prA = vcreate(proc_share_fifo1, 100, 250, 25, "procA", 'd'); resume(prA); int prB = vcreate(proc_share_fifo2, 100, 250, 25, "procB", 'd'); resume(prB); bsd_t bs1 = get_free_bs(); get_bs(bs1, 256); bsd_t bs2 = get_free_bs(); get_bs(bs2, 256); bsd_t bs3 = get_free_bs(); get_bs(bs3, 242); if (xmmap(40000, bs1, 256) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } if (xmmap(50000, bs2, 256) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } if (xmmap(60000, bs3, 242) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } int i = 0; char *addr = (char *)(40000*NBPG); for (i = 0; i < 256; i++) { *addr = 500 + i; addr += NBPG; //increment by one page each time } addr = (char *)(50000*NBPG); for (i = 0; i < 256; i++) { *addr = 1000 + i; addr += NBPG; //increment by one page each time } addr = (char *)(60000*NBPG); for (i = 0; i < 242; i++) { *addr = 1500 + i; addr += NBPG; //increment by one page each time } //generating a page fault bsd_t bs5 = get_free_bs(); get_bs(bs5, 1); if (xmmap(30000, bs5, 1) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } addr = (char *)(30000*NBPG); *addr = 'C'; sleep(20); xmunmap(40000); xmunmap(50000); xmunmap(60000); xmunmap(30000); }
/******************************************************************************* * Name: release_bs * * Desc: Releases a BS from a process so that it can be used by other * processes. All memory mappings should have been unmapped before * calling this routine. * * Params: * bs_id - id of the BS to be released * * Returns: SYSCALL * OK - if everything goes fine * SYSERR - otherwise (eg., process still has some mappings lefts and so on) ******************************************************************************/ SYSCALL release_bs(bsd_t bs_id) { struct pentry *pptr = NULL; bs_map_t *bsptr = NULL; STATWORD ps; disable(ps); DTRACE_START; if (FALSE == BS_IS_ID_VALID(bs_id)) { DTRACE("DBG$ %d %s> bad bs id %d\n", currpid, __func__, bs_id); goto RESTORE_AND_RETURN_ERROR; } pptr = P_GET_PPTR(currpid); bsptr = bsm_get_ptr_for_pid(bs_id, currpid); if (TRUE == BS_IS_VHEAP(bs_id)) { if (currpid == bsptr->bsm_pid) { /* The BS is a vheap of the currpid. Check if the proc has an * explicit mapping to vaddr range of the BS. If so, return error. */ if ((BS_VHEAP != bsptr->bsm_status) || (BS_UNMAPPED != bsptr->bsm_status)) { DTRACE("DBG$ %d %s> bs id %d is a vheap of currpid %d, but " \ "currpid has an active mapping to this bs id\n", \ currpid, __func__, bs_id, currpid); goto RESTORE_AND_RETURN_ERROR; } if (SYSERR == xmunmap(VPAGE_TO_VADDR(bsptr->bsm_vpno))) { DTRACE("DBG$ %d %s> xmunmap() failed for vheap pid %d, " \ "bs id %d, vpage %d, vaadr 0x%08x\n", \ currpid, __func__, currpid, bs_id, bsptr->bsm_vpno, VPAGE_TO_VADDR(bsptr->bsm_vpno)); goto RESTORE_AND_RETURN_ERROR; } else { DTRACE("DBG$ %d %s> vheap removed for pid %d, " \ "bs id %d, vpage %d, vaadr 0x%08x\n", \ currpid, __func__, currpid, bs_id, bsptr->bsm_vpno, VPAGE_TO_VADDR(bsptr->bsm_vpno)); DTRACE("DBG$ %d %s> bs id %d state set to BS_FREE\n", \ currpid, __func__, bs_id); bsm_tab[bs_id]->bsm_status = BS_FREE; pptr->bs[bs_id] = BS_FREE; goto RESTORE_AND_RETURN_OK; } } else { DTRACE("DBG$ %d %s> bs id %d is a vheap of pid %d, but " \ "currpid %d is trying to release it\n", \ currpid, __func__, bs_id, bsptr->bsm_pid); goto RESTORE_AND_RETURN_ERROR; } } switch (pptr->bs[bs_id]) { case BS_FREE: case BS_VHEAP: case BS_MAPPED: /* Invalid BS states when calling release_bs(). Error out. */ DTRACE("DBG$ %d %s> pid %d is trying to release bs id %d " \ "which is neither being-used nor unmapped, state %d\n", \ currpid, __func__, bs_id, pptr->bs[bs_id]); goto RESTORE_AND_RETURN_ERROR; case BS_INUSE: case BS_UNMAPPED: /* Valid states of BS when release_bs() is called. Free the BS if no * active mappings are present. */ pptr->bs[bs_id] = BS_FREE; if (0 == BS_GET_COUNT(bs_id)) { bsm_tab[bs_id]->bsm_status = BS_FREE; bsm_tab[bs_id]->bsm_pid = EMPTY; bsm_tab[bs_id]->bsm_isvheap = FALSE; bsm_tab[bs_id]->bsm_vpno = 0; bsm_tab[bs_id]->bsm_npages = 0; bsm_tab[bs_id]->bsm_sem = 0; bsm_tab[bs_id]->bsm_next = NULL; DTRACE("DBG$ %d %s> bs id %d state changed to BS_FREE\n", \ currpid, __func__, bs_id); } else { DTRACE("DBG$ %d %s> release_bs() by pid %d on bs id %d is " \ "valid, but there are other mappings to the bs.. not " \ "chaning the state to BS_FREE\n", \ currpid, __func__, currpid, bs_id); } goto RESTORE_AND_RETURN_OK; default: goto RESTORE_AND_RETURN_OK; } RESTORE_AND_RETURN_OK: DTRACE("DBG$ %d %s> returning OK\n", currpid, __func__); DTRACE_END; restore(ps); return OK; RESTORE_AND_RETURN_ERROR: DTRACE("DBG$ %d %s> returning SYSERR\n", currpid, __func__); DTRACE_END; restore(ps); return SYSERR; }
void test_xmap_fifo() { bsd_t bs1 = get_free_bs(); get_bs(bs1, 256); bsd_t bs2 = get_free_bs(); get_bs(bs2, 256); bsd_t bs3 = get_free_bs(); get_bs(bs3, 256); bsd_t bs4 = get_free_bs(); get_bs(bs4, 249); if (xmmap(40000, bs1, 256) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } if (xmmap(50000, bs2, 256) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } if (xmmap(60000, bs3, 256) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } if (xmmap(70000, bs4, 249) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } int i = 0; char *addr = (char *)(40000*NBPG); for (i = 0; i < 256; i++) { *addr = 500 + i; addr += NBPG; //increment by one page each time } addr = (char *)(50000*NBPG); for (i = 0; i < 256; i++) { *addr = 1000 + i; addr += NBPG; //increment by one page each time } addr = (char *)(60000*NBPG); for (i = 0; i < 256; i++) { *addr = 1500 + i; addr += NBPG; //increment by one page each time } addr = (char *)(70000*NBPG); for (i = 0; i < 245; i++) { *addr = 2000 + i; addr += NBPG; //increment by one page each time } //create 10 page faults which will result in page replacement bsd_t bs5 = get_free_bs(); get_bs(bs5, 10); if (xmmap(80000, bs5, 10) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } addr = (char *)(80000*NBPG); for(i = 0; i < 10; i++) { *addr = 2500 + i; addr += NBPG; //increment by one page each time //accessing the 8th page here to prevent replacement in aging char *temp = (char *)(40006*NBPG); *temp = 'P'; } //unmapping first bs xmunmap(40000); //creating and mapping new bs. Now while accessing these there should not be a replacement call kprintf("\n\nTHERE SHOULD BE NO PAGE REPLACEMENT BEYOND THIS LINE"); bsd_t bs6 = 6; get_bs(bs6, 10); if (xmmap(90000, bs6, 10) == SYSERR) { kprintf("xmmap call failed\n"); return 0; } addr = (char *)(90000*NBPG); for (i = 0; i < 10; i++) { *addr = 'A' + i; addr += NBPG; //increment by one page each time } //reading the new bs addr = (char *)(90000*NBPG); for (i = 0; i < 10; i++) { kprintf("\n0x%08x: %c", addr, *addr); addr += 4096; //increment by one page each time } }
void shmemconsumer(int sem) { int i,j; int rc; char * x; char *addr = (char*) 0x50000000; bsd_t bsid = 5; int npages = 5; kprintf("shmemconsumer... start consuming.\n"); get_bs(bsid, npages); rc = xmmap(VA2VPNO(addr), bsid, npages); if (rc == SYSERR) { kprintf("xmmap call failed\n"); return 0; } // Consume x = addr; for (i = 0; i < npages; i++) { for (j = 0; j < 5; j++) { // get semaphore rc = wait(sem); if (rc == SYSERR) { kprintf("shmemconsumer: sem returned SYSERR\n"); return; } kprintf("read: 0x%08x = %c\n", (x + j), *(x + j)); signal(sem); sleep(1); } x += NBPG; //go to the next page } // Read back all of the values from memory and print them out x = addr; rc = wait(sem); kprintf("shmemconsumer end: "); if (rc == SYSERR) { kprintf("shmemconsumer: sem returned SYSERR\n"); return; } for (i = 0; i < npages; i++) { for (j = 0; j < 5; j++) { kprintf("%c", *(x + j)); } kprintf(" "); x += NBPG; //go to the next page } kprintf("\n"); signal(sem); sleep(1); xmunmap(VA2VPNO(addr)); release_bs(bsid); }
void proc1_test2() { kprintf("\nRuning proc1_test2() \n\n"); int i,temp; i = 0; kprintf("&i = %8x, i = %d\n",&i,i); int *y; struct mblock *x; kprintf("************************************\n"); x = vgetmem(1000); //x= (struct mblock *)x; kprintf("x=%8x \t x->mnext=%8x \t x->mlen=%d\n",x,x->mnext,x->mlen); y=x; kprintf("&y=%x y=%x *y=%d\n",&y,y,*y); *y = 100; kprintf("&y=%x y=%x *y=%d\n",&y,y,*y); y++; kprintf("&y=%x y=%x *y=%d\n",&y,y,*y); *y = 200; kprintf("&y=%x y=%x *y=%d\n",&y,y,*y); temp = *y; kprintf("temp=%d\n",temp); kprintf("####################################\n"); vfreemem(--y,1000); kprintf("\n vfreemem(x,1000); \n\n"); /* kprintf("************************************\n"); x = vgetmem(1000); kprintf("####################################\n"); vfreemem(x,500); kprintf("\n freemem(x,500); \n\n"); kprintf("************************************\n"); x = vgetmem(1000); kprintf("####################################\n"); vfreemem(x+500,500); kprintf("\n freemem(x+500,500); \n\n"); */ kprintf("************************************\n"); i = get_bs(4, 100); kprintf("i=%d\n",i); kprintf("####################################\n"); xmmap(7000,4,100); char *addr =7000*4096; kprintf("&addr=%x addr=%x *addr=%c\n",&addr,addr,*addr); *addr = 'Y'; kprintf("&addr=%x addr=%x *addr=%c\n",&addr,addr,*addr); char tem = *addr; kprintf("tem=%c\n",tem); xmunmap(7000); release_bs(4); kprintf("************************************\n"); /* int *x; kprintf("ready to allocate heap space\n"); x = vgetmem(1024); kprintf("heap allocated at %x\n", x); *x = 100; *(x + 1) = 200; kprintf("heap variable: %d %d\n", *x, *(x + 1)); vfreemem(x, 1024); */ }