C++ free_block函数代码示例

bool quit_agent(int argc, char *argv[]) {
    op_ptr op = op_list;
    word_t w;
    while (op) {
	op_ptr ele = op;
	op = ele->next;
	free_block(ele, sizeof(op_ele));
    }
    if (router_fd_array)
	free_array(router_fd_array, nrouters, sizeof(int));
    /* Free any pending operations */
    chunk_ptr msg;
    keyvalue_iterstart(operator_table);
    while (keyvalue_removenext(operator_table, NULL, (word_t *) &msg)) {
	chunk_free(msg);
    }
    keyvalue_free(operator_table);
    keyvalue_iterstart(deferred_operand_table);
    while (keyvalue_removenext(deferred_operand_table, NULL, &w)) {
	operand_ptr ls = (operand_ptr) w;
	while (ls) {
	    chunk_free(ls->operand);
	    operand_ptr ele = ls;
	    ls = ls->next;
	    free_block(ele, sizeof(operand_ele));
	}
    }
    keyvalue_free(deferred_operand_table);
    chunk_deinit();
    return true;
}

void initiate_free_list() {
    free_block(0);
    uint max_inode_block = 1 + curr_superblock.isize;
    int i;
    for(i = curr_superblock.fsize - 1; i > max_inode_block; i--) {
        free_block(i);
    }
}

void* work_run(void* arg) {
    printf("create pthread %d\n", pthread_self());

    BufBlock_t* block = NULL;
    BufBlock_t* new_block = NULL;

    Reactor* reactor = (Reactor*) arg;

    while (!stop) {
        reactor->handle_events(1000);

        //将接收到的协议 串行处理
        while ((block=g_receive_queue.pop_queue()) != NULL) {
            char* send_data;
            int send_len = 0;

            int ret_code = dll.handle_process((char*)block->page_base, block->buf_head.len, &send_data, &send_len, &(block->buf_head.sk));

            new_block = alloc_block(send_len);
            new_block->buf_head = block->buf_head;
            new_block->buf_head.len = send_len;
            memcpy(new_block->page_base, send_data, send_len);

            free_block(block);
            if (send_len != 0 && g_server_conf.need_free_send_buf) {
                free(send_data);
            }

            if (ret_code == -1) { //关闭链接
                PUSH_ERRMSG(FIN_BLOCK);
            }
            else if (send_len == 0 || send_len > 8388608) { //长度不对
                LOG4CPLUS_INFO(log4cplus::Logger::getRoot(), "socket fd="<<new_block->buf_head.sk.socket<<" send too large pkg");
                PUSH_ERRMSG(CLEAR_BLOCK);
            }
            else if (send_len > 0) {
                new_block->buf_head.buf_type = DATA_BLOCK;
                if (1 == ret_code) {
                    new_block->buf_head.buf_type |= FIN_BLOCK;
                }

                if (stop) {
                    return ((void *)0);
                }

                HandlerBase* h = reactor->get_handler(new_block->buf_head.sk.socket);
                if (NULL == h) {
                    free_block(new_block);
                    continue;
                }

                if (!h->push_buf(new_block)) {
                    free_block(new_block);
                }
            }
        }
    }
}

void testsAllocationBlocks(){
    
    printf("Volume %s plein\n", (isVolFull() == 0) ? "NON ":"");
    printf("Espace restant : %d/%d (1 bloc reserve au superbloc)\n", volFreeSpace(), MBR.volumes[currentVol].size);
    
    disp_freelist();
    
    int newBlock;
    while( (newBlock = new_block()) > 0){
        printf("Allocation du bloc %04d.\n", newBlock); // pour un volume de 10 240o, on pourra allouer 39 blocs (1 bloc réservé pour superblock) 40*256o=10240o
        printf("Espace restant : %d\n\n", volFreeSpace());
    }
    printf("Allocation impossible : err %d\n", newBlock);
    printf("Espace restant : %d/%d\n", volFreeSpace(), MBR.volumes[currentVol].size);
    
    printf("Volume %splein.\n", (isVolFull() == 0) ? "NON ":"");
    
    printf("Liberation de le moitie des blocs du volume.\n");
    unsigned int i;
    for (i = 1; i < MBR.volumes[currentVol].size/2; i++) // Libération de blocs contingüs.
        free_block(i);
        
    disp_freelist();
        
    // ré-allocation de 2 blocs
    for(unsigned int i = 0;i<2 && (newBlock = new_block()) > 0;i++){
        printf("Allocation du bloc %04d.\n", newBlock);
        printf("Espace restant : %d\n\n", volFreeSpace());
    }
    
    // libération de blocs au hasard
    unsigned int blockToFree[] = { 10, 15 };
    unsigned int blockToFreeCount = 2;
    for (i = 0; i < blockToFreeCount; i++){
        printf("Liberation du bloc n %d - statut : %d\n", blockToFree[i], free_block(blockToFree[i]));
        printf("Permier bloc libre : %u\n", currentSuperblock.firstFree);
        printf("Espace restant : %d/%d\n", volFreeSpace(), MBR.volumes[currentVol].size);
        printf("Volume %s plein\n", (isVolFull() == 0) ? "NON ":"");
    }
    
    disp_freelist();
    
    // ré-allocation de 2 blocs
    for(unsigned int i = 0;i<2 && (newBlock = new_block()) > 0;i++){
        printf("Allocation du bloc %04d.\n", newBlock);
        printf("Espace restant : %d\n\n", volFreeSpace());
    }
    
    // affichage freelist
    disp_freelist();
    
    printf("Permier bloc libre : %u\n", currentSuperblock.firstFree);
    printf("Espace restant : %d/%d\n", volFreeSpace(), MBR.volumes[currentVol].size);
    printf("Volume %s plein\n", (isVolFull() == 0) ? "NON ":"");
}

void buddy_free_blob(struct chunked_blob *blob, size_t _unused)
{
	int i;
	int orders[CHUNKS_COUNT];
	value_size_to_block_sizes(blob->size, orders);

	for (i = CHUNKS_COUNT-1; i > 0; i--) {
		if (orders[i] < 0)
			continue;
		free_block(blob->other_chunks[i-1], orders[i]);
	}
	free_block(blob, orders[0]);
}

static void free_ind(int dev,int block) {
	struct buffer_head * bh;
	unsigned short * p;
	int i;
	if (!block) return;
	if ((bh=bread(dev,block))) {
		p = (unsigned short *) bh->b_data;
		for (i = 0; i < 512; i++,p++) {
			if (*p) free_block(dev,*p);
    }
		brelse(bh);
	}
	free_block(dev,block);
}

/* Deze methode zet het blok op index op vrij, indien mogelijk fuseert het
 * met omringende vrije blokken. */
void free_block(long index){
	long prev = get_prev(index);
	long next = get_next(index);
	
	if(!get_free(index)){
		/* Zet het blok op vrij. */
		set_free(index, 1);
		mem[0] -= get_length(index);
	}
	
	/* Voeg vorige blok samen met het huidige als deze vrij is als een groot
	 * vrij blok. */
	if(prev != 0 && get_free(prev)){
		set_length(prev, get_length(prev) + get_length(index) + ADMIN_SIZE);
		set_next(prev, next);
		
		if(next != 0){
			set_prev(next, prev);
		}
		
		mem[1] -= ADMIN_SIZE;
	}
	
	/* Voeg volgende blok samen met het huidige als deze vrij is als een 
	 * groot vrij blok. */
	if(next != 0 && get_free(next)){
		free_block(next);
	}
}

int i915_mem_free(struct drm_device *dev, void *data,
		  struct drm_file *file_priv)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct drm_i915_mem_free *memfree = data;
	struct mem_block *block, **heap;

	if (!dev_priv) {
		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
		return -EINVAL;
	}

	heap = get_heap(dev_priv, memfree->region);
	if (!heap || !*heap)
		return -EFAULT;

	block = find_block(*heap, memfree->region_offset);
	if (!block)
		return -EFAULT;

	if (block->file_priv != file_priv)
		return -EPERM;

	mark_block(dev, block, 0);
	free_block(block);
	return 0;
}

/*
 * Free up all aspects of the given dcr -- i.e. dechain it,
 *  release allocated memory, zap pointers, ...
 */
void free_dcr(DCR *dcr)
{
   JCR *jcr;

   P(dcr->m_mutex);
   jcr = dcr->jcr;

   locked_detach_dcr_from_dev(dcr);

   if (dcr->block) {
      free_block(dcr->block);
   }

   if (dcr->rec) {
      free_record(dcr->rec);
   }

   if (jcr && jcr->dcr == dcr) {
      jcr->dcr = NULL;
   }

   if (jcr && jcr->read_dcr == dcr) {
      jcr->read_dcr = NULL;
   }

   V(dcr->m_mutex);

   pthread_mutex_destroy(&dcr->m_mutex);
   pthread_mutex_destroy(&dcr->r_mutex);

   delete dcr;
}

/*! \brief Completely free()s a BlockHeap.  Use for cleanup.
 * \param bh Pointer to the BlockHeap to be destroyed
 * \return 0 if successful, 1 if bh == NULL
 */
int
BlockHeapDestroy(BlockHeap *bh)
{
  Block *walker = NULL, *next = NULL;

  if (bh == NULL)
    return 1;

  for (walker = bh->base; walker != NULL; walker = next)
  {
    next = walker->next;
    free_block(walker->elems, walker->alloc_size);

    if (walker != NULL)
      free(walker);
  }

  if (heap_list == bh)
    heap_list = bh->next;
  else {
    BlockHeap *prev;

    for (prev = heap_list; prev->next != bh; prev = prev->next)
      /* nothing */ ;
    prev->next = bh->next;
  }

  free(bh);
  return 0;
}

int radeon_mem_free( DRM_IOCTL_ARGS )
{
	DRM_DEVICE;
	drm_radeon_private_t *dev_priv = dev->dev_private;
	drm_radeon_mem_free_t memfree;
	struct mem_block *block, **heap;

	if ( !dev_priv ) {
		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
		return DRM_ERR(EINVAL);
	}

	DRM_COPY_FROM_USER_IOCTL( memfree, (drm_radeon_mem_free_t *)data,
				  sizeof(memfree) );

	heap = get_heap( dev_priv, memfree.region );
	if (!heap || !*heap)
		return DRM_ERR(EFAULT);
	
	block = find_block( *heap, memfree.region_offset );
	if (!block)
		return DRM_ERR(EFAULT);

	if (block->pid != DRM_CURRENTPID)
		return DRM_ERR(EPERM);

	free_block( block );	
	return 0;
}

// Remove any blocks currently used by file 'f',
// but not necessary for a file of size 'newsize'.
// For both the old and new sizes, figure out the number of blocks required,
// and then clear the blocks from new_nblocks to old_nblocks.
// If the new_nblocks is no more than NDIRECT, and the indirect block has
// been allocated (f->f_indirect != 0), then free the indirect block too.
// (Remember to clear the f->f_indirect pointer so you'll know
// whether it's valid!)
// Do not change f->f_size.
static void
file_truncate_blocks(struct File *f, off_t newsize)
{
	int r;
	uint32_t bno, old_nblocks, new_nblocks;

	// Hint: Use file_clear_block and/or free_block.
	for (old_nblocks = 0; old_nblocks < f->f_size; old_nblocks += BLKSIZE)
		;
	old_nblocks /= BLKSIZE;
	for (new_nblocks = 0; new_nblocks < newsize; new_nblocks += BLKSIZE)
		;
	new_nblocks /= BLKSIZE;
	cprintf("truncate from %d[%d] -> %d[%d].\n", f->f_size, new_nblocks, f->f_size, old_nblocks);
	for (bno = new_nblocks; bno <= old_nblocks; bno++)
		if ((r = file_clear_block(f, bno)) < 0)
			panic("file clear block error: %e\n", r);

	// Yeah, we need to clear the extra block as well
	if (new_nblocks < NDIRECT) {
		if (f->f_indirect != 0) {
			free_block(f->f_indirect);
			f->f_indirect = 0;
		}
		while (new_nblocks < NDIRECT)
			f->f_direct[new_nblocks++] = 0;
	}
}

 int StackAllocator::free_head()
 {
   int err = OB_SUCCESS;
   Block* head = NULL;
   if (NULL == allocator_)
   {
     err = OB_NOT_INIT;
   }
   else if (NULL == head_ || (top_ -= head_->pos_) < 0)
   {
     err = OB_ERR_UNEXPECTED;
   }
   else
   {
     head = head_;
     head_ = head_->next_;
   }
   if (OB_SUCCESS != err)
   {}
   else if (OB_SUCCESS != (err = free_block(head)))
   {
     TBSYS_LOG(ERROR, "free_block()=>%d", err);
   }
   return err;
 }

// Remove any blocks currently used by file 'f',
// but not necessary for a file of size 'newsize'.
// For both the old and new sizes, figure out the number of blocks required,
// and then clear the blocks from new_nblocks to old_nblocks.
// If the new_nblocks is no more than NDIRECT, and the indirect block has
// been allocated (f->f_indirect != 0), then free the indirect block too.
// (Remember to clear the f->f_indirect pointer so you'll know
// whether it's valid!)
// Do not change f->f_size.
static void
file_truncate_blocks(struct File *f, off_t newsize)
{
	int r, i;
	uint32_t old_nblocks, new_nblocks;

	// Hint: Use file_clear_block and/or free_block.
	// LAB 5: Your code here.

	if(newsize >= f->f_size)
		return;
	
	new_nblocks = newsize/BLKSIZE;
	if (newsize % BLKSIZE)
		new_nblocks++;
	
	old_nblocks = f->f_size/BLKSIZE;
	if (f->f_size % BLKSIZE)
		old_nblocks++;
	
	for(i=new_nblocks; i<old_nblocks; i++)
		if((r = file_clear_block(f, i)) < 0)
			panic("file_truncate_blocks - couldn't free blocks!");

	if(new_nblocks <= NDIRECT && old_nblocks > NDIRECT){
		free_block(f->f_indirect);				
		f->f_indirect = 0;
	}
	return;
}	

static void free_block(struct k_mem_pool *p, int level, size_t *lsizes, int bn)
{
	int i, key, lsz = lsizes[level];
	void *block = block_ptr(p, lsz, bn);

	key = irq_lock();

	set_free_bit(p, level, bn);

	if (level && partner_bits(p, level, bn) == 0xf) {
		for (i = 0; i < 4; i++) {
			int b = (bn & ~3) + i;

			clear_free_bit(p, level, b);
			if (b != bn &&
			    block_fits(p, block_ptr(p, lsz, b), lsz)) {
				sys_dlist_remove(block_ptr(p, lsz, b));
			}
		}

		irq_unlock(key);
		free_block(p, level-1, lsizes, bn / 4); /* tail recursion! */
		return;
	}

	if (block_fits(p, block, lsz)) {
		sys_dlist_append(&p->levels[level].free_list, block);
	}

	irq_unlock(key);
}