void ui_menudestroy(ui_widget_t* widget) { ui_menudata_t* data=(ui_menudata_t*)widget->data; if(data->positions) sys_free(data->positions); sys_free(data); }
void __attribute__((destructor)) __ibprof_exit(void) { IBPROF_ERROR status = IBPROF_ERR_NONE; UNREFERENCED_PARAMETER(status); /* check if it has been activated */ if (ibprof_obj) { IBPROF_MODULE_OBJECT *temp_module_obj = NULL; int i = 0; ibprof_obj->task_obj->wall_time = ibprof_task_wall_time(ibprof_obj->task_obj->t_start); /* Dump all gathered information */ ibprof_dump(); temp_module_obj = ibprof_obj->module_array[0]; while (temp_module_obj) { if (temp_module_obj->id != IBPROF_MODULE_INVALID) { if (temp_module_obj->exit) status = temp_module_obj->exit(temp_module_obj); } temp_module_obj = ibprof_obj->module_array[++i]; } ibprof_hash_destroy(ibprof_obj->hash_obj); ibprof_task_destroy(ibprof_obj->task_obj); DELETE_CRITICAL(&(ibprof_obj->lock)); sys_free(ibprof_obj); ibprof_obj = NULL; } if (ibprof_dump_file && ibprof_dump_file != stdout && ibprof_dump_file != stderr) { struct stat statbuf; char fd_path[255]; char *filename = sys_malloc(255); size_t ret = 0; sys_sprintf(fd_path, "/proc/self/fd/%d", fileno(ibprof_dump_file)); ret = readlink(fd_path, filename, 255); if (ret > 0) { sys_fflush(ibprof_dump_file); sys_fclose(ibprof_dump_file); if (!sys_fstat(filename, &statbuf)) if (!statbuf.st_size) ret = sys_fremove(filename); } sys_free(filename); } return ; }
void chpl_comm_ofi_oob_allgather(const void* mine, void* all, size_t size) { DBG_PRINTF(DBG_OOB, "OOB allGather: %zd", size); // // PMI doesn't provide an ordered allGather, so we build one here // by concatenating the node index and the payload and using that // to scatter the unordered PMI_Allgather() results. // typedef struct { int nodeID; uint64_t info[]; } gather_t; const size_t g_size = offsetof(gather_t, info) + size; gather_t* g_mine; CHK_SYS_CALLOC_SZ(g_mine, 1, g_size); g_mine->nodeID = chpl_nodeID; memcpy(&g_mine->info, mine, size); gather_t* g_all; CHK_SYS_CALLOC_SZ(g_all, chpl_numNodes, g_size); PMI_CHK(PMI_Allgather(g_mine, g_all, g_size)); for (int g_i = 0; g_i < chpl_numNodes; g_i++) { char* g_pa = (char*) g_all + g_i * g_size; int i; memcpy(&i, g_pa + offsetof(gather_t, nodeID), sizeof(i)); char* p_a = (char*) all + i * size; memcpy(p_a, g_pa + offsetof(gather_t, info), size); } sys_free(g_all); sys_free(g_mine); }
void sys_freelist(char** list) { unsigned int i; for(i=0;list[i];i++) sys_free(list[i]); sys_free(list); }
/* 在part分区内的pdir目录内寻找名为name的文件或目录, * 找到后返回true并将其目录项存入dir_e,否则返回false */ bool search_dir_entry(struct partition* part, struct dir* pdir, \ const char* name, struct dir_entry* dir_e) { uint32_t block_cnt = 140; // 12个直接块+128个一级间接块=140块 /* 12个直接块大小+128个间接块,共560字节 */ uint32_t* all_blocks = (uint32_t*)sys_malloc(48 + 512); if (all_blocks == NULL) { printk("search_dir_entry: sys_malloc for all_blocks failed"); return false; } uint32_t block_idx = 0; while (block_idx < 12) { all_blocks[block_idx] = pdir->inode->i_sectors[block_idx]; block_idx++; } block_idx = 0; if (pdir->inode->i_sectors[12] != 0) { // 若含有一级间接块表 ide_read(part->my_disk, pdir->inode->i_sectors[12], all_blocks + 12, 1); } /* 至此,all_blocks存储的是该文件或目录的所有扇区地址 */ /* 写目录项的时候已保证目录项不跨扇区, * 这样读目录项时容易处理, 只申请容纳1个扇区的内存 */ uint8_t* buf = (uint8_t*)sys_malloc(SECTOR_SIZE); struct dir_entry* p_de = (struct dir_entry*)buf; // p_de为指向目录项的指针,值为buf起始地址 uint32_t dir_entry_size = part->sb->dir_entry_size; uint32_t dir_entry_cnt = SECTOR_SIZE / dir_entry_size; // 1扇区内可容纳的目录项个数 /* 开始在所有块中查找目录项 */ while (block_idx < block_cnt) { /* 块地址为0时表示该块中无数据,继续在其它块中找 */ if (all_blocks[block_idx] == 0) { block_idx++; continue; } ide_read(part->my_disk, all_blocks[block_idx], buf, 1); uint32_t dir_entry_idx = 0; /* 遍历扇区中所有目录项 */ while (dir_entry_idx < dir_entry_cnt) { /* 若找到了,就直接复制整个目录项 */ if (!strcmp(p_de->filename, name)) { memcpy(dir_e, p_de, dir_entry_size); sys_free(buf); sys_free(all_blocks); return true; } dir_entry_idx++; p_de++; } block_idx++; p_de = (struct dir_entry*)buf; // 此时p_de已经指向扇区内最后一个完整目录项了,需要恢复p_de指向为buf memset(buf, 0, SECTOR_SIZE); // 将buf清0,下次再用 } sys_free(buf); sys_free(all_blocks); return false; }
void hashtab_destroy(struct hashtab *h) { int i; struct hashtab_node *cur, *temp; if (!h) return; for (i = 0; i < h->size; i++) { cur = h->htable[i]; while (cur) { temp = cur; cur = cur->next; //kfree(temp); sys_free(temp); } h->htable[i] = NULL; } //kfree(h->htable); sys_free(h->htable); h->htable = NULL; //kfree(h); sys_free(h); }
void sys_onUnload() { sys_free(_ctxFile); sys_free(_glbFile); sys_free(_cfgFile); sys_free(_cfgDir); }
void main () { video_mode = 8; fps_max = 60; wait(2); bmap_zbuffer ( bmap_createblack(2048,2048,32) ); mouse_mode = 4; mouse_map = bmap_create ( "arrow_yellow.pcx" ); vec_fill ( &screen_color, 128 ); level_load ( "" ); camera->pan = -40; camera->tilt = -30; evnCameraLocate (); vec_set ( &colCameraBG, vector(150,150,150) ); camera->bg = pixel_for_vec ( &colCameraBG, 100, 8888 ); ENTITY *ent = ent_create ( CUBE_MDL, nullvector, NULL ); // Create style for the menues // CMMEMBER *myMenuStyle = cmstyle_create ( FONT *font, COLOR *colText, COLOR *colBack, COLOR *colOver ) FONT *fntTTF = font_create("Arial#16"); CMStyle *myMenuStyle01 = cmstyle_create ( fntTTF, vector(40,40,40), vector(250,250,250), vector(210,210,210) ); FONT *fntBitmap = font_create("ackfont.pcx"); CMStyle *myMenuStyle02 = cmstyle_create ( fntBitmap, vector(170,170,255), vector(30,20,0), vector(0,0,185) ); // Create a compact menu panel // PANEL *cmenu_create ( char *chrMember, var pos_x, var pos_y, var size_x, var layer, var flags, CMStyle *style ) PANEL *myMenu01 = cmenu_create ( "menu name.submenu=txtMain", 110, 20, 200, 1, SHOW, myMenuStyle01 ); PANEL *myMenu02 = cmenu_create ( "debug & statics.submenu=txtCMDebug", 500, 20, 200, 1, SHOW, myMenuStyle01 ); cmenu_modify ( myMenu02, 120, myMenuStyle02 ); bmpSky = bmap_create ( "sky_fu_256+6.tga" ); while ( !key_esc && !nExit ) { str_setchr ( strString, 1, random(32)+32 ); wait(1); } bmap_remove ( bmpSky ); bmpSky = NULL; bmap_remove ( mouse_map ); mouse_map = NULL; cmenu_remove ( myMenu01 ); sys_free ( myMenuStyle01 ); font_remove ( fntTTF ); cmenu_remove ( myMenu02 ); sys_free ( myMenuStyle02 ); font_remove ( fntBitmap ); sys_exit ( NULL ); }
void mt_destroydivider(mt_divider_t* divider) { if(divider->query) sys_free(divider->query); mt_destroynode(divider->root); sys_free(divider->root); if(divider->colliders) sys_free(divider->colliders); sys_free(divider); }
void trash_close () { TrashItem *it = itTrash->first; for ( ; it != NULL; ) { TrashItem *next = it->next; sys_free ( it->data ); sys_free ( it ); it = next; } }
/** *@brief read string in initialization file\n * retrieves a string from the specified section in an initialization file *@param section [in] name of the section containing the key name *@param key [in] name of the key pairs to value *@param value [in] pointer to the buffer that receives the retrieved string *@param size [in] size of result's buffer *@param default_value [in] default value of result *@param file [in] path of the initialization file *@return 1 : read success; \n 0 : read fail */ int read_profile_string( const char *section, const char *key,char *value, int size, const char *default_value, const char *file) { char *buf; int file_size; int sec_s,sec_e,key_s,key_e, value_s, value_e; //check parameters assert(section != NULL && strlen(section)); assert(key != NULL && strlen(key)); assert(value != NULL); assert(size > 0); assert(file !=NULL &&strlen(key)); buf = (char *)sys_malloc(MAX_FILE_SIZE); memset(buf,0,MAX_FILE_SIZE); if(!load_ini_file(file,buf,&file_size)) { if(default_value!=NULL) { strncpy(value,default_value, size); } sys_free(buf); return 0; } if(!parse_file(section,key,buf,&sec_s,&sec_e,&key_s,&key_e,&value_s,&value_e)) { if(default_value!=NULL) { strncpy(value,default_value, size); } sys_free(buf); return 0; //not find the key } else { int cpcount = value_e -value_s; if( size-1 < cpcount) { cpcount = size-1; } memset(value, 0, size); memcpy(value,buf+value_s, cpcount ); value[cpcount] = '\0'; sys_free(buf); return 1; } }
void decrRefCount(void *obj){ object *o = obj; if (o->refcount <= 0) xlog(LOG_WARN, "decrRefCount 一个对象的引用计数 <= 0\n"); if (o->refcount == 1){ sys_free(o->ptr); sys_free(o); xlog(LOG_DEBUG, "decr : 释放一个节点\n"); } else { o->refcount--; } }
static void clntudp_destroy(CLIENT *cl) { register struct cu_data *cu = (struct cu_data *) cl->cl_private; if (cu->cu_closeit) { close(cu->cu_sock); } XDR_DESTROY(&(cu->cu_outxdrs)); sys_free(cu); sys_free(cl); }
/* Free the whole list. * * This function can't fail. */ void listRelease(list *list) { unsigned int len; listNode *current, *next; current = list->head; len = list->len; while(len--) { next = current->next; if (list->free) list->free(current->value); sys_free(current); current = next; } sys_free(list); }
static void mt_destroynode(mt_dividernode_t* node) { if(node->colliders) sys_free(node->colliders); if(node->children) { int i; //Destroy children for(i=0;i<8;i++) mt_destroynode(&node->children[i]); sys_free(node->children); } }
int item_DrawTxt(const osd_item_t *item, int status) { const char *str; char *buf; size_t len; int x; int (*get_value)(void); //get string value str = (const char *) item->v; if(item->runtime & ITEM_RUNTIME_V) { get_value = (int (*)(void)) item->v; str = (const char *) get_value(); } //string width limit len = strlen(str); len = (len > item->w) ? item->w : len; buf = sys_malloc(len + 1); strncpy(buf, str, len); buf[len] = 0; //align x = item->x; x += (item->option & ITEM_ALIGN_MIDDLE) ? (item->w - len) >> 1 : 0; x += (item->option & ITEM_ALIGN_RIGHT) ? (item->w - len) : 0; //output to lcd osd_eng_puts(x, item->y, buf); sys_free(buf); return 0; }
void uart_disable(UART_CLASS port) { if (port < UARTS_COUNT) { //disable interrupts NVIC_DisableIRQ(UART_IRQ_VECTORS[port]); //disable core USART[port]->CR1 &= ~USART_CR1_UE; //power down if (port == UART_1 || port == UART_6) RCC->APB2ENR &= ~RCC_UART[port]; else RCC->APB1ENR &= ~RCC_UART[port]; //disable pins if ((USART_TX_DISABLE_MASK & (1 << port)) == 0) gpio_disable_pin(UART_TX_PINS[port]); if ((USART_RX_DISABLE_MASK & (1 << port)) == 0) gpio_disable_pin(UART_RX_PINS[port]); #if (USART_REMAP_MASK) if ((1 << port) & USART_REMAP_MASK) afio_unmap(); #endif //USART_REMAP_MASK sys_free(_uart_handlers[port]); _uart_handlers[port] = NULL; } else error_dev(ERROR_DEVICE_INDEX_OUT_OF_RANGE, DEV_UART, port); }
void dbg_reply_get_thread_list(struct dbg_context* dbg, const dbg_threadid_t* threads, size_t len) { assert(DREQ_GET_THREAD_LIST == dbg->req.type); if (0 == len) { write_packet(dbg, "l"); } else { size_t maxlen = 1/*m char*/ + (2 * sizeof(pid_t) + 1/*,*/) * len + 1/*\0*/; char* str = sys_malloc(maxlen); int i, offset = 0; str[offset++] = 'm'; for (i = 0; i < len; ++i) { offset += snprintf(&str[offset], maxlen - offset, "%02x,", threads[i]); } /* Overwrite the trailing ',' */ str[offset - 1] = '\0'; write_packet(dbg, str); sys_free((void**)&str); } consume_request(dbg); }
void task1(void) { static void* ptr[100]; int ix; int count; for ( count=20; 0 < count; count-- ) { for (ix=0; ix<100; ix++) { ptr[ix] = sys_malloc_align(128, 8); //ptr[ix] = sys_malloc(128); lprintf("malloc1(8)[%d]=%08X\n", ix, ptr[ix]); if ( ptr[ix] ) { memset(ptr[ix], 0x11, 128); } task_tsleep(1); } for (ix=0; ix<100; ix++) { if ( ptr[ix] ) { lprintf("free1[%d]=%08X\n", ix, ptr[ix]); sys_free(ptr[ix]); } task_tsleep(1); } dump_space(); } task_sleep(); }
static void tun_stop(ErlDrvData data) { struct tun_state *state = (struct tun_state *)data; set_input(state, 0); close(state->fd); sys_free(state); }
void task2(void) { static void* ptr[100]; int ix; int count; for ( count=20; 0 < count; count-- ) { for (ix=0; ix<100; ix++) { ptr[ix] = sys_malloc_align(256, 16); //ptr[ix] = sys_malloc(256); lprintf("malloc2(16)[%d]=%08X\n", ix, ptr[ix]); if ( ptr[ix] ) { memset(ptr[ix], 0x44, 256); } task_tsleep(2); } for (ix=0; ix<100; ix++) { if ( ptr[ix] ) { lprintf("free2[%d]=%08X\n", ix, ptr[ix]); sys_free(ptr[ix]); } task_tsleep(2); } dump_space(); } task_sleep(); }
/** ** sys_mkpath - ensure all directories in path exist ** Algorithm takes the pessimistic view and works top-down to ensure ** each directory in path exists, rather than optimistically creating ** the last element and working backwards. */ int sys_mkpath(const char *path, mode_t mode) { char *pp; char *sp; int status; char *copypath = sys_malloc(strlen(path) + 1); strcpy(copypath,path); status = 0; pp = copypath; while (status == 0 && (sp = strchr(pp, '/')) != 0) { if (sp != pp) { /* Neither root nor double slash in path */ *sp = '\0'; status = sys_mkdir(copypath, mode); *sp = '/'; } pp = sp + 1; } sys_free((void**)©path); assert(status == 0); return status; }
static void s1_ready_async(ErlDrvData drv_data, ErlDrvThreadData thread_data) { descriptor_t *desc = (descriptor_t *) drv_data; callstate_t *c = (callstate_t *) thread_data; int bytes, offset, i; char *p = NULL; unsigned long index = 0; edtk_debug("%s: cmd = %d", __FUNCTION__, c->cmd); if (c == NULL) { edtk_debug("%s: c == NULL", __FUNCTION__); return; } switch (c->cmd) { case S1_NULL: reply_ok(desc); break; case S1_OPEN: if (! c->o.__expect) { reply_error(desc, c->o.__expect_errval); break; } if (find_unused_fd_index(desc, &index) < 0) { reply_error(desc, ENOMEM); } else { desc->valmap_fd[index] = c->o.ret_int; reply_ok_valmap(desc, am_valmap_fd, index); } break; case S1_GETFD: reply_ok_num(desc, c->o.ret_int); break; case S1_SENDFD: if (c->o.__expect) { reply_ok_num(desc, c->o.ret_int_t); } else { reply_error(desc, c->o.__expect_errval); } break; case S1_RECEIVEFD: if (c->o.__expect) { reply_ok_num(desc, c->o.ret_int_t); } else { reply_error(desc, c->o.__expect_errval); } break; case S1_CLOSE: if (! c->o.__expect) { reply_error(desc, c->o.__expect_errval); break; } cleanup_valmap_fd_index(desc, c->i.__valmap_fd_index, 0); reply_ok_num(desc, c->o.ret_int); break; default: edtk_debug("%s: bogus command, should never happen", __FUNCTION__); break; } sys_free(c); }
struct hashtab *hashtab_create(uint32 (*hash_value)(struct hashtab *h, const void *key, int len), uint32 (*hash_key)(struct hashtab *h, const void *key, int len), int (*keycmp)(struct hashtab *h, const void *key1, const void *key2), int size) { struct hashtab *p; int i; //p = kzalloc(sizeof(*p), GFP_KERNEL); p = (struct hashtab*)sys_malloc(sizeof(*p)); if (p == NULL) return p; p->size = size; p->nel = 0; p->hash_value = hash_value; p->hash_key = hash_key; p->keycmp = keycmp; p->htable = (struct hashtab_node **)sys_malloc(sizeof(*(p->htable)) * size);//kmalloc(sizeof(*(p->htable)) * size, GFP_KERNEL); if (p->htable == NULL) { //kfree(p); sys_free(p); return NULL; } for (i = 0; i < size; i++) p->htable[i] = NULL; return p; }
void task3(void) { static void* ptr[100]; int ix; int count; for ( count=20; 0 < count; count-- ) { for (ix=0; ix<100; ix++) { ptr[ix] = sys_malloc_align(512, 64); //ptr[ix] = sys_malloc(512); lprintf("malloc3(64)[%d]=%08X\n", ix, ptr[ix]); if ( ptr[ix] ) { memset(ptr[ix], 0x77, 512); } task_tsleep(3); } for (ix=0; ix<100; ix++) { if ( ptr[ix] ) { lprintf("free3[%d]=%08X\n", ix, ptr[ix]); sys_free(ptr[ix]); } task_tsleep(3); } dump_space(); } task_sleep(); }
int main(int argc, const char **argv) { printf("Running all tests...\n\n"); int err; if ((err = setjmp(G_err))) { printf("ERROR: %d\n",err); } else { def_sys(); //**** core tests testDef(); testTree(); testMTree(); testStream(); testLabel(); testSemtrex(); testReceptor(); testProcess(); testScape(); testVMHost(); testAccumulator(); //***** examples testProfileExample(); testHTTPExample(); sys_free(); report_tests(); } pthread_exit(NULL); // return 0; }
static void resizeTable(int direction) { memTableEntry** newMemTable = NULL; int newHashSizeIndex, newHashSize, newHashValue; int i; memTableEntry* me; memTableEntry* next; newHashSizeIndex = hashSizeIndex + direction; newHashSize = hashSizes[newHashSizeIndex]; newMemTable = sys_calloc(newHashSize, sizeof(memTableEntry*)); for (i = 0; i < hashSize; i++) { for (me = memTable[i]; me != NULL; me = next) { next = me->nextInBucket; newHashValue = hash(me->memAlloc, newHashSize); me->nextInBucket = newMemTable[newHashValue]; newMemTable[newHashValue] = me; } } sys_free(memTable); memTable = newMemTable; hashSize = newHashSize; hashSizeIndex = newHashSizeIndex; }
__attribute__ ((visibility("default"))) void free(void* mem) { if (mem != NULL) num_alloc--; sys_free(mem); }
char* read_child_str(pid_t pid, long int addr) { char *tmp, *str; int i, idx = 0; int buffer_size = 256; str = sys_malloc(buffer_size); while (1) { if (idx + READ_SIZE >= buffer_size) { buffer_size *= 2; str = realloc(str, buffer_size); } tmp = read_child_data_tid(pid, READ_SIZE, addr + idx); memcpy(str + idx, tmp, READ_SIZE); sys_free((void**) &tmp); for (i = 0; i < READ_SIZE; i++) { if (str[idx + i] == '\0') { return str; } } idx += READ_SIZE; }assert(1==0); return 0; }
static void __config_exit( void ) { if (osh_config.exec_mode.log_file_name) { sys_free(osh_config.exec_mode.log_file_name); } }