Exemple #1
0
/* 在pf表示的虚拟内存池中申请pg_cnt个虚拟页,
 * 成功则返回虚拟页的起始地址, 失败则返回NULL */
static void* vaddr_get(enum pool_flags pf, uint32_t pg_cnt) {
   int vaddr_start = 0, bit_idx_start = -1;
   uint32_t cnt = 0;
   if (pf == PF_KERNEL) {     // 内核内存池
      bit_idx_start  = bitmap_scan(&kernel_vaddr.vaddr_bitmap, pg_cnt);
      if (bit_idx_start == -1) {
	 return NULL;
      }
      while(cnt < pg_cnt) {
	 bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1);
      }
      vaddr_start = kernel_vaddr.vaddr_start + bit_idx_start * PG_SIZE;
   } else {	     // 用户内存池	
      struct task_struct* cur = running_thread();
      bit_idx_start  = bitmap_scan(&cur->userprog_vaddr.vaddr_bitmap, pg_cnt);
      if (bit_idx_start == -1) {
	 return NULL;
      }

      while(cnt < pg_cnt) {
	 bitmap_set(&cur->userprog_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1);
      }
      vaddr_start = cur->userprog_vaddr.vaddr_start + bit_idx_start * PG_SIZE;

   /* (0xc0000000 - PG_SIZE)做为用户3级栈已经在start_process被分配 */
      ASSERT((uint32_t)vaddr_start < (0xc0000000 - PG_SIZE));
   }
   return (void*)vaddr_start;
}
Exemple #2
0
//adds a page to swap space, gets called with the physical memory position
size_t add_swap (void * addr) {
	//init swap if necessary
	if (swap == NULL)   //init the swap table
  		init_swap ();

	//lock the swap table
	lock_acquire(&swap_lock);

	//find a free entry in the bitmap table
	size_t free = bitmap_scan (swap_table, 0, 1, false);
	//if the swap table is full panic the kernel
	if (free == BITMAP_ERROR) PANIC ("Swaptable is full\n");

	int i;
	//get frame and the memory position and write it to swap
	for (i = 0; i< SECPP; i++)
		//write block to swap, free * SECPP is the correct block position and + i because a page has a different size, same for addr
		block_write (swap, free * SECPP + i, addr + BLOCK_SECTOR_SIZE * i);

	//set the corresponding entry in the swap_table to true
	bitmap_set (swap_table, free, true);

	//release the lock for the swap table
	lock_release(&swap_lock);

	return free;

}
Exemple #3
0
/* 分配一个i结点,返回i结点号 */
int32_t inode_bitmap_alloc(struct partition* part) {
   int32_t bit_idx = bitmap_scan(&part->inode_bitmap, 1);
   if (bit_idx == -1) {
      return -1;
   }
   bitmap_set(&part->inode_bitmap, bit_idx, 1);
   return bit_idx;
}
Exemple #4
0
/* 分配1个扇区,返回其扇区地址 */
int32_t block_bitmap_alloc(struct partition* part) {
   int32_t bit_idx = bitmap_scan(&part->block_bitmap, 1);
   if (bit_idx == -1) {
      return -1;
   }
   bitmap_set(&part->block_bitmap, bit_idx, 1);
   /* 和inode_bitmap_malloc不同,此处返回的不是位图索引,而是具体可用的扇区地址 */
   return (part->sb->data_start_lba + bit_idx);
} 
Exemple #5
0
/* adds a block to cache */
static size_t
cache_add (block_sector_t bid)
{
	/* lock the cache */
	lock_acquire(&cache_globallock);
	
	//bool hellYeah = bid == (unsigned) 163;

	/* lock for a free_cache_block cache block */
	size_t free_cache_block = bitmap_scan (cache_table, 0, 1, false);
	
	//if(DEBUG || hellYeah) printf("bitscan complete bla\n");

	/* if no free cache block is found, evict one and
	 * search again */
	if (free_cache_block == BITMAP_ERROR) {
		
		//if(DEBUG || hellYeah) printf("evict some\n");
		cache_evict();
		free_cache_block = bitmap_scan (cache_table, 0, 1, false);
	}

	ASSERT(free_cache_block != BITMAP_ERROR);
	//if(DEBUG || hellYeah) printf("add cache block %d\n",bid);

	/* copy block to cache */
	block_read (fs_device, bid, cache[free_cache_block]->kpage);

	/* setup cache entry */
	cache[free_cache_block]->dirty = false;
	cache[free_cache_block]->accessed = false;
	cache[free_cache_block]->bid = bid;

	/* set used bit of the cache table for this entry */
	bitmap_set (cache_table, free_cache_block, true);

	/* release the lock for the cache table */
	lock_release(&cache_globallock);

	if(CACHE_DEBUG) printf("added cache block %u for sector %u\n", (unsigned int) free_cache_block, (unsigned int) bid);
	
	return free_cache_block;
}
Exemple #6
0
size_t swap_out(void *kaddr)
{
	lock_acquire(&swap_lock);
	//size_t free_index = bitmap_scan_and_flip(swap_map,0,1,SWAP_FREE);
	size_t free_index = bitmap_scan(swap_map,0,1,SWAP_FREE);
	bitmap_flip(swap_map,free_index);
	size_t i;
	for(i = 0;i <SECTORS_PER_PAGE;i++)
	{
		block_write(swap_block,free_index*SECTORS_PER_PAGE +i,
				(uint8_t*)kaddr + i*BLOCK_SECTOR_SIZE);
	}
	lock_release(&swap_lock);

	return free_index;
}
Exemple #7
0
/* 在pf表示的虚拟内存池中申请pg_cnt个虚拟页,
 * 成功则返回虚拟页的起始地址, 失败则返回NULL */
static void* vaddr_get(enum pool_flags pf, uint32_t pg_cnt) {
   int vaddr_start = 0, bit_idx_start = -1;
   uint32_t cnt = 0;
   if (pf == PF_KERNEL) {
      bit_idx_start  = bitmap_scan(&kernel_vaddr.vaddr_bitmap, pg_cnt);
      if (bit_idx_start == -1) {
	 return NULL;
      }
      while(cnt < pg_cnt) {
	 bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1);
      }
      vaddr_start = kernel_vaddr.vaddr_start + bit_idx_start * PG_SIZE;
   } else {	
   // 用户内存池,将来实现用户进程再补充
   }
   return (void*)vaddr_start;
}
Exemple #8
0
static void
update_ct_zones(struct sset *lports, struct simap *ct_zones,
                unsigned long *ct_zone_bitmap)
{
    struct simap_node *ct_zone, *ct_zone_next;
    const char *iface_id;
    int scan_start = 1;

    /* xxx This is wasteful to assign a zone to each port--even if no
     * xxx security policy is applied. */

    /* Delete any zones that are associated with removed ports. */
    SIMAP_FOR_EACH_SAFE(ct_zone, ct_zone_next, ct_zones) {
        if (!sset_contains(lports, ct_zone->name)) {
            bitmap_set0(ct_zone_bitmap, ct_zone->data);
            simap_delete(ct_zones, ct_zone);
        }
    }

    /* Assign a unique zone id for each logical port. */
    SSET_FOR_EACH(iface_id, lports) {
        size_t zone;

        if (simap_contains(ct_zones, iface_id)) {
            continue;
        }

        /* We assume that there are 64K zones and that we own them all. */
        zone = bitmap_scan(ct_zone_bitmap, 0, scan_start, MAX_CT_ZONES + 1);
        if (zone == MAX_CT_ZONES + 1) {
            static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
            VLOG_WARN_RL(&rl, "exhausted all ct zones");
            return;
        }
        scan_start = zone + 1;

        bitmap_set1(ct_zone_bitmap, zone);
        simap_put(ct_zones, iface_id, zone);

        /* xxx We should erase any old entries for this
         * xxx zone, but we need a generic interface to the conntrack
         * xxx table. */
    }
Exemple #9
0
uint32 
bitmap_scan_and_set (struct bitmap* bmap, uint32 num)
{
    if (bmap == NULL || num == 0)
        return BITMAP_ERROR;

    uint32 idx = bitmap_scan (bmap, num);
    if (idx == BITMAP_ERROR)    return idx;

    uint32 i;
    uint32 end = idx + num;
    for (i = idx; i < end; i++)
        bitmap_set (bmap, i);

    return idx;
//
//    uint32 i;
//    for (i = 0; i < bmap->length; i++)
//    {
//        if (bmap->bits[i] != 0xFFFFFFFF)
//        {
//            sint32 j;
//            bool one = false;
//            uint32 count = 0;
//            sint32 idx = 0;
//            for (j = 31; j >= 0; j--)
//            {
//                if (!(bmap->bits[i] & (uint32) (0x1 << j)))
//                {
//                    if (!one)
//                    {
//                        idx = j;
//                        count = 0;
//                    }
//                    count++;
//                    one = true;
//                }
//                else
//                    one = false;
//
//                if (count == num)
//                    break;
//            }
//
//            ASSERT (count <= num);
//            ASSERT (idx < 32);
//            if (count == num)
//            {
//                /* We must flip NUM contiguous bits. */
//                sint32 k;
//                for (k = idx; k > (sint32) (idx - num); k--)
//                {
//                    bmap->bits[i] |= (uint32) (0x1 << k);
//                }
//
//                return i * 32 + (31 - idx);
//            }
//        }
//    }
//
//    return BITMAP_ERROR;
};