コード例 #1
0
ファイル: proc.c プロジェクト: tmfahey/cs537
// Grow current process's memory by n bytes.
// Return 0 on success, -1 on failure.
int
growproc(int n)
{
    uint sz;

    sz = proc->sz;
    if(n > 0) {
        //prevent heap from overwriting our stack
        int se=proc->se;
        int page_n = PGROUNDUP(n);
        int heap_size = PGROUNDUP(proc->sz);
        if((heap_size + page_n) > (se - PGSIZE)) {
            //panic("Heap is overwriting stack!"); //just return -1 is sufficient. No need to panic!
            return -1;
        }
        if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)
            return -1;
    } else if(n < 0) {
        if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)
            return -1;
    }
    proc->sz = sz;
    switchuvm(proc);
    return 0;
}
コード例 #2
0
ファイル: exec.c プロジェクト: aunali1/exopc
int
map_section(int k, int fd, SCNHDR *shdr, int envid) {
  u_int page_count;
  Pte *ptes;
  int i, retval = 0, type;
  off_t curloc = lseek(fd, 0, SEEK_CUR);
  u32 start, zero_start, len;

  if (!strcmp(shdr->s_name, ".text"))
    type = MS_TEXT;
  else if (!strcmp(shdr->s_name, ".data"))
    type = MS_DATA;
  else if (!strcmp(shdr->s_name, ".bss"))
    type = MS_BSS;
  else
    {
      type = MS_UNKNOWN;
      return 0;
    }

  page_count = PGNO(PGROUNDUP(shdr->s_size));
  if (type == MS_BSS) {
    start = PGROUNDUP(shdr->s_vaddr);
    if (start != shdr->s_vaddr) page_count--;
  }
  else
    start = shdr->s_vaddr;
  if ((ptes = malloc(sizeof(Pte) * page_count)) == 0) {
    return -1;
  }
  for (i=0; i < page_count; i++)
    ptes[i] = PG_U|PG_W|PG_P;
  
  if (sys_self_insert_pte_range(k, ptes, page_count, TEMP_REGION) < 0 ||
      sys_insert_pte_range(k, &vpt[PGNO(TEMP_REGION)], page_count, 
			   start, k, envid) < 0 ||
      (type != MS_BSS &&
       (lseek(fd, shdr->s_scnptr, SEEK_SET) != shdr->s_scnptr ||
	read(fd, (void*)TEMP_REGION, shdr->s_size) != shdr->s_size ||
	lseek(fd, curloc, SEEK_SET) != curloc))) {
    retval = -1;
  }
  if (type == MS_BSS) {
    zero_start = TEMP_REGION;
    len = page_count * NBPG;
  } else {
    zero_start = TEMP_REGION + shdr->s_size;
    len = NBPG - (zero_start & PGMASK);
  }
  bzero((void*)zero_start, len);
  if (type == MS_TEXT)
    mprotect((void*)TEMP_REGION, page_count*NBPG, PROT_READ);
  for (i=0; i < page_count; i++)
    ptes[i] = 0;
  sys_self_insert_pte_range(k, ptes, page_count, TEMP_REGION);
  if (retval == -1)
    sys_insert_pte_range(k, ptes, page_count, start, k, envid);
  return retval;
}
コード例 #3
0
ファイル: kmem.cpp プロジェクト: qhjindev/jinos
void kmem_t::init_range(void* vstart, void* vend) {
  vstart = (char*)PGROUNDUP((uint)vstart);
  vend = (char*)PGROUNDUP((uint)vend);
  int startpfn = MAP_NR(vstart);
  int endpfn = MAP_NR(vend);
  int j=0;
  for(int i = startpfn; vstart < vend; i++, j++) {
    page_t* page = pages + i;
    page->vaddr = (void*)vstart;
    free_page(page);
    vstart += PGSIZE;
  }
}
コード例 #4
0
ファイル: vg_transtab.c プロジェクト: svn2github/valgrind-3
/* Find an empty sector and bring it into use.  If there isn't one,
   try and allocate one.  If that fails, return -1. */
static
Int maybe_commission_sector ( void )
{
   Char msg[100];
   Int  s;
   for (s = 0; s < VG_TC_N_SECTORS; s++) {
      if (vg_tc[s] != NULL && vg_tc_used[s] == 0) {
         vg_tc_age[s] = overall_in_count;
         VG_(sprintf)(msg, "after  commission of sector %d "
                           "at time %d", 
                           s, vg_tc_age[s]);
         pp_tt_tc_status ( msg );
#        ifdef DEBUG_TRANSTAB
         VG_(sanity_check_tt_tc)();
#        endif
         return s;
      }
   }
   for (s = 0; s < VG_TC_N_SECTORS; s++) {
      if (vg_tc[s] == NULL) {
#if 1
         vg_tc[s] = VG_(get_memory_from_mmap) 
                       ( vg_tc_sector_szB, "trans-cache(sector)" );
#else
         // Alternative: put translations in an mmap'd file.  The main
         // reason is to help OProfile -- OProfile can assign time spent in
         // translations to a particular file.  The file format doesn't
         // really matter, which is good because it's not really readable,
         // being generated code but not a proper ELF file.
	 Char buf[20];
	 static Int count = 0;
	 Int fd;
	 
	 VG_(sprintf)(buf, ".transtab.%d", count++);

	 fd = VG_(open)(buf, VKI_O_RDWR|VKI_O_CREAT|VKI_O_TRUNC, 0700);
	 //VG_(unlink)(buf);
	 VG_(do_syscall)(__NR_ftruncate, fd, PGROUNDUP(vg_tc_sector_szB));
	 vg_tc[s] = VG_(mmap)(0, PGROUNDUP(vg_tc_sector_szB), VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC, VKI_MAP_SHARED, 0, fd, 0);
	 VG_(close)(fd);
#endif
         vg_tc_used[s] = 0;
         VG_(sprintf)(msg, "after  allocation of sector %d (size %d)", 
                           s, vg_tc_sector_szB );
         pp_tt_tc_status ( msg );
         return maybe_commission_sector();
      }
   }
   return -1;
}
コード例 #5
0
ファイル: shexec.c プロジェクト: aunali1/exopc
static int
__zero_segment (int envid, u_int start, u_int sz)
{
  u_int temp_pages;

  assert (!(start & PGMASK)); 

  temp_pages = (u_int)__malloc(PGROUNDUP(sz));
  if (temp_pages == 0) return -1;

  /* alloc pages for this segment and map into our address space writeable */
  if (__vm_alloc_region (temp_pages, sz, 0, PG_P|PG_U|PG_W) < 0) {
    __free((void*)temp_pages);
    return -1;
  }
  /* and map them into the other address space */
  if (__vm_share_region (temp_pages, sz, 0, 0, envid, start) < 0) {
    __free((void*)temp_pages);
    return -1;
  }
  /* zero the pages */
  bzero ((void *)temp_pages, sz);
  /* and remove our mapping of the pages */
  if (__vm_free_region (temp_pages, sz, 0) < 0) {
    __free((void*)temp_pages);
    return -1;
  }

  __free((void*)temp_pages);
  return 0;
}  
コード例 #6
0
ファイル: vm.c プロジェクト: daisyfy1991/cs537
// Deallocate user pages to bring the process size from oldsz to
// newsz.  oldsz and newsz need not be page-aligned, nor does newsz
// need to be less than oldsz.  oldsz can be larger than the actual
// process size.  Returns the new process size.
int
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  pte_t *pte;
  uint a, pa;

  if(newsz >= oldsz)
    return oldsz;

  a = PGROUNDUP(newsz);
  int isShmem; //added by Ying
  for(; a  < oldsz; a += PGSIZE){
    isShmem = 0; //added by Ying
    pte = walkpgdir(pgdir, (char*)a, 0);
    if(pte && (*pte & PTE_P) != 0){
      pa = PTE_ADDR(*pte);

      //added by Ying
      int i;
      for (i = 0; i < 4; i++) {
          if (pa == (unsigned int)shmem_addr[i])
            isShmem = 1;
      }
      if (isShmem) continue;

      if(pa == 0)
        panic("kfree");
      kfree((char*)pa);
      *pte = 0;
    }
  }
  return newsz;
}
コード例 #7
0
ファイル: vm.c プロジェクト: arielqw/ariel-ami
// Deallocate user pages to bring the process size from oldsz to
// newsz.  oldsz and newsz need not be page-aligned, nor does newsz
// need to be less than oldsz.  oldsz can be larger than the actual
// process size.  Returns the new process size.
int
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  pte_t *pte;
  uint a, pa;

  if(newsz >= oldsz)
    return oldsz;

  a = PGROUNDUP(newsz);
  for(; a  < oldsz; a += PGSIZE){
    pte = walkpgdir(pgdir, (char*)a, 0);
    if(!pte)
      a += (NPTENTRIES - 1) * PGSIZE;
    else if((*pte & PTE_P) != 0){
      pa = PTE_ADDR(*pte);
      if(pa == 0)
        panic("kfree");
      char *v = p2v(pa);
      kfree(v);
      *pte = 0;
    }
  }
  return newsz;
}
コード例 #8
0
ファイル: vm.c プロジェクト: TBReinhart/os_4
// Deallocate user pages to bring the process size from oldsz to
// newsz.  oldsz and newsz need not be page-aligned, nor does newsz
// need to be less than oldsz.  oldsz can be larger than the actual
// process size.  Returns the new process size.
int
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  pte_t *pte;
  uint a, pa;

  if(newsz >= oldsz)
    return oldsz;

  a = PGROUNDUP(newsz);
  for(; a  < oldsz; a += PGSIZE){
    pte = walkpgdir(pgdir, (char*)a, 0);
    if(!pte)
      a += (NPTENTRIES - 1) * PGSIZE;
    else if((*pte & PTE_P) != 0){
      pa = PTE_ADDR(*pte);
      if(pa == 0)
        panic("kfree");
      acquire(&r_c.lock);
      r_c.ref_count[pa / 4096] --;
      if(r_c.ref_count[pa / 4096] == 0) {
        char *v = p2v(pa);
        kfree(v);
      }
      release(&r_c.lock);
      *pte = 0;
    }
  }
  return newsz;
}
コード例 #9
0
ファイル: vm.c プロジェクト: satote2/xv6
// Allocate page tables and physical memory to grow process from oldsz to
// newsz, which need not be page aligned.  Returns new size or 0 on error.
int
allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  char *mem;
  uint a;

  if(newsz >= KERNBASE)
    return 0;
  if(newsz < oldsz)
    return oldsz;

  cprintf("%d \n", oldsz);
  cprintf("%d \n", newsz);

  a = PGROUNDUP(oldsz);
  for(; a < newsz; a += PGSIZE){
    mem = kalloc();
    if(mem == 0){
      cprintf("allocuvm out of memory\n");
      deallocuvm(pgdir, newsz, oldsz);
      return 0;
    }
    memset(mem, 0, PGSIZE);
    mappages(pgdir, (char*)a, PGSIZE, v2p(mem), PTE_W|PTE_U);
  }
  return newsz;
}
コード例 #10
0
ファイル: fault.c プロジェクト: aunali1/exopc
int register_pagefault_handler (uint vastart, int len,
				int (*handler)(uint,int))
{
   handler_t *tmp = handlers;
   uint vaend = PGROUNDUP (vastart+len);

   vastart = PGROUNDDOWN (vastart);

   while (tmp) {
      if ((vastart >= tmp->vastart) && (vastart < tmp->vaend)) {
         return (-1);
      }
      if ((vaend >= tmp->vastart) && (vaend < tmp->vaend)) {
         return (-1);
      }
      if ((vastart < tmp->vastart) && (vaend >= tmp->vaend)) {
         return (-1);
      }
      tmp = tmp->next;
   }

   tmp = (handler_t *) __malloc (sizeof(handler_t));
   assert(tmp);
   tmp->vastart = vastart;
   tmp->vaend = vaend;
   tmp->handler = handler;
   tmp->next = handlers;
   handlers = tmp;

   /* kprintf ("(%d) pagefault_handler registered for %x -- %x\n", geteid(),
      tmp->vastart, tmp->vaend); */

   return (0);
}
コード例 #11
0
ファイル: vm.c プロジェクト: zambur/Course-Work
// Allocate page tables and physical memory to grow process from oldsz to
// newsz, which need not be page aligned.  Returns new size or 0 on error.
int
allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  char *mem;
  uint a;

  if(newsz > USERTOP)
    return 0;
  if(newsz < oldsz)
    return oldsz;

  a = PGROUNDUP(oldsz);
  for(; a < newsz; a += PGSIZE){
    mem = kalloc();
    if(mem == 0){
      cprintf("proc %d: allocuvm out of memory\n", proc->pid);
      cprintf("proc %d: newsz: %d\n", proc->pid, newsz);
      cprintf("proc %d: oldsz: %d\n", proc->pid, oldsz);
      deallocuvm(pgdir, newsz, oldsz);
      return 0;
    }
    memset(mem, 0, PGSIZE);
    mappages(pgdir, (char*)a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
  }
  return newsz;
}
コード例 #12
0
ファイル: kalloc.c プロジェクト: kalfazed/Operating-System
void freerange(void *vstart, void *vend)
{
  char *p;
  p = (char*)PGROUNDUP((uint)vstart);
  for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
    kfree(p);
}
コード例 #13
0
ファイル: vm.c プロジェクト: baileyparker/xv6-public
// Allocate page tables and physical memory to grow process from oldsz to
// newsz, which need not be page aligned.  Returns new size or 0 on error.
int
allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  char *mem;
  uint a;

  if(newsz >= KERNBASE)
    return 0;
  if(newsz < oldsz)
    return oldsz;

  a = PGROUNDUP(oldsz);
  for(; a < newsz; a += PGSIZE){
    mem = kalloc();
    if(mem == 0){
      cprintf("allocuvm out of memory\n");
      deallocuvm(pgdir, newsz, oldsz);
      return 0;
    }
    memset(mem, 0, PGSIZE);
    if (mappages(pgdir, (char*)a, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0)
      panic("allocuvm: cannot create pagetable");
  }
  return newsz;
}
コード例 #14
0
ファイル: vm.c プロジェクト: byan23/OS_P3
// Allocate page tables and physical memory to grow process from oldsz to
// newsz, which need not be page aligned.  Returns new size or 0 on error.
int
allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  char *mem;
  uint a;

  if(newsz > USERTOP)
    return 0;
  if(newsz < oldsz)
    return oldsz;

  a = PGROUNDUP(oldsz);
  for(; a < newsz; a += PGSIZE){
    mem = kalloc();
    if(mem == 0){
      cprintf("allocuvm out of memory\n");
      deallocuvm(pgdir, newsz, oldsz);
      return 0;
    }
    //cprintf("alloc a new page starting at: %x\n", mem);
    memset(mem, 0, PGSIZE);
    mappages(pgdir, (char*)a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
  }
  return newsz;
}
コード例 #15
0
ファイル: vg_memory.c プロジェクト: svn2github/valgrind-3
/* set new protection flags on an address range */
void VG_(mprotect_range)(Addr a, UInt len, UInt prot)
{
   Segment *s, *next;
   static const Bool debug = False || mem_debug;

   if (debug)
      VG_(printf)("mprotect_range(%p, %d, %x)\n", a, len, prot);

   /* Everything must be page-aligned */
   vg_assert((a & (VKI_BYTES_PER_PAGE-1)) == 0);
   len = PGROUNDUP(len);

   VG_(split_segment)(a);
   VG_(split_segment)(a+len);

   for(s = VG_(SkipList_Find)(&sk_segments, &a);
       s != NULL && s->addr < a+len;
       s = next)
   {
      next = VG_(SkipNode_Next)(&sk_segments, s);
      if (s->addr < a)
	 continue;

      s->prot = prot;
   }

   merge_segments(a, len);
}
コード例 #16
0
ファイル: sysmmap.c プロジェクト: jdetter/Chronos
/* int munmap(void* addr, size_t length) */
int sys_munmap(void)
{
	void* addr;
	size_t length;

	if(syscall_get_int((int*)&addr, 0)) return -1;
        if(syscall_get_int((int*)&length, 1)) return -1;

	/* Is the address okay? */
	uintptr_t address = (uintptr_t)addr;
	if(length == 0) return -1;
	/* Address must be page aligned */
	if(address != PGROUNDDOWN(address)) return -1;

	/* Address must be in the proper range */
	if(address < PGROUNDUP(rproc->heap_end) + PGSIZE ||
			address >= PGROUNDDOWN(rproc->mmap_start) ||
			address + length > PGROUNDDOWN(rproc->mmap_start))
		return -1;

	uintptr_t x;
	for(x = 0;x < length;x += PGSIZE)
		vm_unmappage(x + address, rproc->pgdir);

	return 0;
}
コード例 #17
0
// Allocate page tables and physical memory to grow process from oldsz to
// newsz, which need not be page aligned.  Returns new size or 0 on error.
int
allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  char *mem;
  uint a;

  //interesting -video
  if(newsz > USERTOP)
    return 0;
  if(newsz < oldsz)
    return oldsz;

  a = PGROUNDUP(oldsz);
  for(; a < newsz; a += PGSIZE){
    mem = kalloc();
    if(mem == 0){
      cprintf("allocuvm out of memory\n");
      deallocuvm(pgdir, newsz, oldsz);
      return 0;
    }
    //clear page cause it might hold sensitive info
    memset(mem, 0, PGSIZE);
    mappages(pgdir, (char*)a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
  }
  return newsz;
}
コード例 #18
0
ファイル: cacheman.c プロジェクト: jdetter/Chronos
void cman_init(void)
{
	/* Zero our space */
	size_t sz = PGROUNDUP(KVM_DISK_E - KVM_DISK_S);
	memset((void*)KVM_DISK_S, 0, sz);
	head = (void*)KVM_DISK_S;
	head->sz = sz;
}
コード例 #19
0
int
main(int argc, char *argv[])
{

  ppid = getpid();

  char *brk = sbrk(0);
  sbrk(PGROUNDUP(brk) - (uint)brk);
  char *start = sbrk(0);

  // should fail for address zero, which shouldn't be mapped in
  // the process any more because of part a of project
  assert(mprotect(0, 1) == -1);
  assert(munprotect(0, 1) == -1);

  printf(1, "starting address is %d\n", (uint)start);

  assert(mprotect(start, 1) == -1);
  assert(munprotect(start, 1) == -1);

  sbrk(PGSIZE * 1);
  assert(mprotect(start, 2) == -1);
  assert(munprotect(start, 2) == -1);

  assert(mprotect(start + 1, 1) == -1);
  assert(munprotect(start + 1, 1) == -1);

  assert(mprotect(start, 0) == -1);
  assert(munprotect(start, 0) == -1);

  assert(mprotect(start, -2) == -1);
  assert(munprotect(start, -2) == -1);

  assert(mprotect(start, 1) == 0);
  assert(munprotect(start, 1) == 0);

  // protect page again to check that permissions
  // carry over on fork
  assert(mprotect(start, 1) == 0);
  int rv = fork();
  if (rv < 0) {
    printf(1, "Fork failed.  Oops.  This shouldn't happen, right?!\n");
  } else if (rv == 0) {
    printf(1, "Attempting to write to protected memory in a child process\n");
    printf(1, "This should cause the child to die if the test succeeds\n");
    *start = 55; // this should cause the child proc to DIR
    printf(1, "TEST FAILED (if you got here, child didn't crash)\n");
    exit();
  } else {
    assert(munprotect(start, 1) == 0);
    wait();
  }

   printf(1, "TEST PASSED\n");

   exit();
}
コード例 #20
0
ファイル: kalloc.c プロジェクト: hubert-he/xv6
void
freerange(void *vstart, void *vend)
{
    char *p;
    p = (char*)PGROUNDUP((uint)vstart);
	cprintf("p = %x %x vend = %x\n", p, vstart, vend);
    for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
        kfree(p);
}
コード例 #21
0
ファイル: vg_memory.c プロジェクト: svn2github/valgrind-3
Addr VG_(find_map_space)(Addr addr, UInt len, Bool for_client)
{
   static const Bool debug = False || mem_debug;
   Segment *s;
   Addr ret;
   Addr limit = (for_client ? VG_(client_end) : VG_(valgrind_mmap_end));

   if (addr == 0)
      addr = for_client ? VG_(client_mapbase) : VG_(valgrind_base);
   else {
      /* leave space for redzone and still try to get the exact
	 address asked for */
      addr -= VKI_BYTES_PER_PAGE;
   }
   ret = addr;

   /* Everything must be page-aligned */
   vg_assert((addr & (VKI_BYTES_PER_PAGE-1)) == 0);
   len = PGROUNDUP(len);

   len += VKI_BYTES_PER_PAGE * 2; /* leave redzone gaps before and after mapping */

   if (debug)
      VG_(printf)("find_map_space: ret starts as %p-%p client=%d\n",
		  ret, ret+len, for_client);

   for(s = VG_(SkipList_Find)(&sk_segments, &ret);
       s != NULL && s->addr < (ret+len);
       s = VG_(SkipNode_Next)(&sk_segments, s))
   {
      if (debug)
	 VG_(printf)("s->addr=%p len=%d (%p) ret=%p\n",
		     s->addr, s->len, s->addr+s->len, ret);

      if (s->addr < (ret + len) && (s->addr + s->len) > ret)
	 ret = s->addr+s->len;
   }

   if (debug) {
      if (s)
	 VG_(printf)("  s->addr=%p ->len=%d\n", s->addr, s->len);
      else
	 VG_(printf)("  s == NULL\n");
   }

   if ((limit - len) < ret)
      ret = 0;			/* no space */
   else
      ret += VKI_BYTES_PER_PAGE; /* skip leading redzone */

   if (debug)
      VG_(printf)("find_map_space(%p, %d, %d) -> %p\n",
		  addr, len, for_client, ret);
   
   return ret;
}
コード例 #22
0
ファイル: kalloc.c プロジェクト: KWMalik/Homework-3
// Initialize free list of physical pages.
void
kinit(void)
{
  char *p;

  initlock(&kmem.lock, "kmem");
  p = (char*)PGROUNDUP((uint)newend);
  for(; p + PGSIZE <= (char*)p2v(PHYSTOP); p += PGSIZE)
    kfree(p);
}
コード例 #23
0
ファイル: kalloc.c プロジェクト: MyXOF/xv6
// Initialize free list of physical pages.
void
kinit(void)
{
  extern char end[];

  initlock(&kmem.lock, "kmem");
  char *p = (char*)PGROUNDUP((uint)end);
  for( ; p + PGSIZE - 1 < (char*) PHYSTOP; p += PGSIZE)
    kfree(p);
}
コード例 #24
0
ファイル: proc.c プロジェクト: yonatana/OS
void *shmat(int shmid, int shmflg){
  char * memory;
  uint size;
  void* ret = (void*) -1;
  int i;
  int flag_for =0;
  acquire(&shmtable.lock);
  if(shmtable.shmarray[shmid].size > 0){
    size = PGROUNDUP(proc->sz);
    ret =(void*)size;
    if(size + PGSIZE >= KERNBASE){
      cprintf("shmat:not enogh memory\n");
      release(&shmtable.lock);
      return (void*)-1;
    }
    //all is fine
    for(i = 0;shmtable.shmarray[shmid].addr[i] && size < KERNBASE;i++){
      //find the adress of the memory
      memory = shmtable.shmarray[shmid].addr[i];
      flag_for =1; //we did at least one page
      if(shmflg == SHM_RDONLY){
	mappages(proc->pgdir, (char*)size, PGSIZE, v2p(memory), PTE_U); 
	size += PGSIZE;
	break;
      }
      else if(shmflg == SHM_RDWR){
	mappages(proc->pgdir, (char*)size, PGSIZE, v2p(memory), PTE_W|PTE_U);
	size += PGSIZE;
	break;
      }
      else{//default
	flag_for = 0;
	size += PGSIZE;
      }
    }//end of for 
    if(flag_for){
      proc->sz =size;
      shmtable.shmarray[shmid].linkcounter++;
    }
    else{
      ret =(void*) -1;
      cprintf("shmat: no shmflg (flag_for = 0\n");
    }
  }
  else{ 
    cprintf("shmat: the memory isn't there\n");
    release(&shmtable.lock);
    return (void*)-1;
  }
  shmtable.shmarray[shmid].virtual_addr =ret;
  proc->va[shmid]=ret;
  release(&shmtable.lock);
  return ret; 
}
コード例 #25
0
ファイル: kalloc.c プロジェクト: Aalphabets/xv6
char*
enter_alloc(void)
{
    if(newend == 0)
        newend = end;

    void *p = (void)PGROUNDUP((uint)newend);
    memset(p, 0, PGSIZE);
    newend = newend + PGSIZE;
    return p;

}
コード例 #26
0
ファイル: cacheman.c プロジェクト: jdetter/Chronos
void* cman_alloc(size_t sz)
{
	if(sz == 0) return NULL;

	sz = PGROUNDUP(sz);
	struct cman_node* curr = head;
	struct cman_node* last = NULL;
	struct cman_node* result = NULL;

	/* Search for a node with enough room */
	while(curr)
	{
		if(curr->sz >= sz)
		{
			result = curr;
			break;
		}
		last = curr;
		curr = curr->next;
	}

	/* Did we find anything? */
	if(!result)
	{
		cprintf("cman: Disk cache out of space!\n");
		return NULL;
	}

	if(sz == result->sz)
	{
		/* Consume the node */
		if(last)
		{
			/* update the head */
			head = result->next;
		} else {
			/* Update the broken pointer */
			last->next = result->next;
		}
	} else {
		/* Partition this node */
		
		curr = result;
		/* Assign result */
		result = (struct cman_node*)(((char*)curr) + sz);
		/* Modify the size */
		curr->sz -= sz;
	}

	result->next = NULL;
	return (void*)result;
}
コード例 #27
0
ファイル: kalloc.c プロジェクト: KWMalik/Homework-3
// A simple page allocator to get off the ground during entry
char *
enter_alloc(void)
{
  if (newend == 0)
    newend = end;

  if ((uint) newend >= KERNBASE + 0x400000)
    panic("only first 4Mbyte are mapped during entry");
  void *p = (void*)PGROUNDUP((uint)newend);
  memset(p, 0, PGSIZE);
  newend = newend + PGSIZE;
  return p;
}
コード例 #28
0
ファイル: vm.c プロジェクト: treejames/xv6
// Deallocate user pages to bring the process size from oldsz to
// newsz.  oldsz and newsz need not be page-aligned, nor does newsz
// need to be less than oldsz.  oldsz can be larger than the actual
// process size.  Returns the new process size.
int
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  char *a = (char *)PGROUNDUP(newsz);
  char *last = PGROUNDDOWN(oldsz - 1);
  for(; a <= last; a += PGSIZE){
    pte_t *pte = walkpgdir(pgdir, a, 0);
    if(pte && (*pte & PTE_P) != 0){
      uint pa = PTE_ADDR(*pte);
      if(pa == 0)
        panic("kfree");
      kfree((void *) pa);
      *pte = 0;
    }
  }
  return newsz < oldsz ? newsz : oldsz;
}
コード例 #29
0
ファイル: vg_memory.c プロジェクト: svn2github/valgrind-3
Addr VG_(client_alloc)(Addr addr, UInt len, UInt prot, UInt flags)
{
   len = PGROUNDUP(len);

   if (!(flags & SF_FIXED))
      addr = VG_(find_map_space)(addr, len, True);

   flags |= SF_CORE;

   if (VG_(mmap)((void *)addr, len, prot,
		 VKI_MAP_FIXED | VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS | VKI_MAP_CLIENT,
		 -1, 0) == (void *)addr) {
      VG_(map_segment)(addr, len, prot, flags);
      return addr;
   }

   return 0;
}
コード例 #30
0
ファイル: vc.c プロジェクト: aunali1/exopc
/* Returns 0 on success */
int memmap(void *va, size_t length, int prot, void *pa)
{
    u_int numcompleted=0, i;
    u_int num_pages = PGNO(PGROUNDUP(length));
    int err;
    Pte *ptes = alloca(num_pages * sizeof(Pte));

    for (i = 0; i < num_pages; i++)
	ptes[i] = ((int)pa + i*NBPG) | prot | PG_GUEST;
    
    err = sys_insert_pte_range(0, ptes, num_pages, (u_int)va, &numcompleted,
			       0 /*  u_int ke FIXME */, vmstate.eid);
    
    if (err || numcompleted!=num_pages)
	return -1;
    else
	return 0;
}