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; }
void chunk_deinit() { buf_node* temp_node = buf_list_head; //create new head while (temp_node != NULL) { buf_list_head = temp_node; temp_node = temp_node->next; if (buf_list_head->buf != NULL) free_block(buf_list_head->buf, 2*CHUNK_MAX_SIZE*sizeof(char)); else chunk_error("Chunk buffer was null in a buffer list node", NULL); free_block(buf_list_head, sizeof(buf_node)); } }
static void cleanup_device_list (void) { if (dev_list) { int i; for (i = 0; dev_list[i]; i++) { free_block ((const void *) dev_list[i]->name); free_block ((const void *) dev_list[i]->model); free_block ((const void *) dev_list[i]); } } free (dev_list); dev_list = NULL; }
/* Free a chunk */ void chunk_free(chunk_ptr cp) { if (cp == NULL) return; size_t len = cp->length; size_t more_bytes = len == 0 ? 0 : WORD_BYTES * (len - 1); free_block((void *) cp, sizeof(chunk_t) + more_bytes); }
// 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); }
void delete_fncode(fncode fn) /* Effects: deletes fncode 'fn' */ { GCPOP(1); POP_LIST(fn->cstpro); free_block(fn->fnmemory); }
int valid( void *p ) { if (base) if(p>base && p<sbrk(0)) return (p == (free_block(p)) -> ptr); return (0); }
void blkdev_free_block(UID id, block_datastr *ptr) { int ret; ret = free_block(ptr); if(ret = 1) printf("block free complete\n"); else printf("[error] block free\n"); }
void free_group (group_t* group) { block_node_t* tmp = *group; while (*group != NULL) { tmp = *group; *group = tmp->next; free_block (&tmp->block); } }
void free_frame (block *base) { block *p,*q; for (p=base; p!=NULL; ) { q=p; p=q->next; free_block (q); } }
static void free_global_ops() { global_op_ptr ls = global_ops; while (ls) { global_op_ptr ele = ls; ls = ls->next; free_block(ele, sizeof(global_op_ele)); } global_ops = NULL; }
/* Called when there is no enough free memory. */ void flush_block_buffer(void) { struct block *block; while (!list_empty(&block_buffer_list)) { block = list_first_entry(&block_buffer_list, struct block, b_list); flush_block(block); free_block(block); } }
/** Trunca un fitxer a partir del byte n. * Si n_bytes = 0 alliberam tots els blocs. * @inode: el nombre d'inode. * @n_byte: el byte final del fitxer. * @return: 0 si exit. */ int truncate_file(int inode, int n_byte) { int how_many, block, f_offset, l_size; int n_block, n_bytes, n_inode; int i; emofs_inode tmp_inode; int blocks_to_truncate; read_inode(inode, &tmp_inode); if (tmp_inode.size <= n_byte) { /* Si fitxer es mes petit o del tamany a truncar * no s'ha de fer res. */ return 0; } blocks_to_truncate = (tmp_inode.size-n_byte)/BLOCK_SIZE; for(i = INDIRECT_POINTER_COUNT-1; i >= 0; i--) { if(tmp_inode.indirect_pointer[i] != NULL_POINTER) { truncate_assist(tmp_inode.indirect_pointer[i], i, \ &tmp_inode, &blocks_to_truncate); if (blocks_to_truncate > 0) { free_block(tmp_inode.indirect_pointer[i]); tmp_inode.indirect_pointer[i] = NULL_POINTER; tmp_inode.block_count--; blocks_to_truncate--; } } } for(i = DIRECT_POINTER_COUNT-1; i >= 0; i--) { /* El blocks_to_truncate > 0 no esta a la condicio * del bucle per donar suport als fitxers esparsos. */ if (blocks_to_truncate > 0 && \ tmp_inode.direct_pointer[i] != NULL_POINTER) { free_block(tmp_inode.direct_pointer[i]); tmp_inode.direct_pointer[i] = NULL_POINTER; tmp_inode.block_count--; blocks_to_truncate--; } } tmp_inode.size = n_byte; write_inode(inode, &tmp_inode); return 0; }
int deallocate(int start_addr) { int size = heap[start_addr]; int ceil_size,current; ceil_size = ceil2(size + 1); free_block(start_addr,ceil_size); merge_buddies(start_addr, ceil_size); }
void free_shadow_mgr(shadow_mgr mgr) { if (mgr->do_cudd) { Cudd_Quit(mgr->bdd_manager); } if (do_ref(mgr)) free_ref_mgr(mgr->ref_mgr); keyvalue_free(mgr->c2r_table); keyvalue_free(mgr->r2c_table); free_block((void *) mgr, sizeof(shadow_ele)); }
/* * Setup DCR with a new device. */ void setup_new_dcr_device(JCR *jcr, DCR *dcr, DEVICE *dev, BLOCKSIZES *blocksizes) { dcr->jcr = jcr; /* point back to jcr */ /* * Set device information, possibly change device */ if (dev) { /* * Set wanted blocksizes */ if (blocksizes) { dev->min_block_size = blocksizes->min_block_size; dev->max_block_size = blocksizes->max_block_size; } if (dcr->block) { free_block(dcr->block); } dcr->block = new_block(dev); if (dcr->rec) { free_record(dcr->rec); dcr->rec = NULL; } dcr->rec = new_record(); if (dcr->attached_to_dev) { detach_dcr_from_dev(dcr); } /* * Use job spoolsize prior to device spoolsize */ if (jcr && jcr->spool_size) { dcr->max_job_spool_size = jcr->spool_size; } else { dcr->max_job_spool_size = dev->device->max_job_spool_size; } dcr->device = dev->device; dcr->set_dev(dev); attach_dcr_to_dev(dcr); /* * Initialize the auto deflation/inflation which can * be disabled per DCR when we want to. e.g. when we want to * send the data as part of a replication stream in which we * don't want to first inflate the data to then again * do deflation for sending it to the other storage daemon. */ dcr->autodeflate = dcr->device->autodeflate; dcr->autoinflate = dcr->device->autoinflate; } }
/** * mm_free - Free a block previously allocated by mm_malloc or mm_realloc. * */ void mm_free(void *ptr) { TRACE(">>>Entering mm_free(ptr=0x%X)\n", (unsigned int)ptr); free_block(ptr, GET_THISSIZE(ptr)); coalesce(ptr); RUN_MM_CHECK(); TRACE("<<<---Leaving mm_free()\n"); }