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);
*/
}
