自学教程：C++ sys_malloc函数代码示例

list *listInsertNode(list *list, listNode *old_node, void *value, int after) {    listNode *node;    if ((node = sys_malloc(sizeof(*node))) == NULL)        return NULL;    node->value = value;    if (after) {        node->prev = old_node;        node->next = old_node->next;        if (list->tail == old_node) {            list->tail = node;        }    } else {        node->next = old_node;        node->prev = old_node->prev;        if (list->head == old_node) {            list->head = node;        }    }    if (node->prev != NULL) {        node->prev->next = node;    }    if (node->next != NULL) {        node->next->prev = node;    }    list->len++;    return list;}

/**** 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**)&copypath);    assert(status == 0);    return status;}

//----------------------------------------------------------------------------// EXTERNAL FUNCTIONS//----------------------------------------------------------------------------// Allocate continuous space to context, stack and local variables.DvmState *mem_allocate(dvm_state_t* dvm_st, uint8_t capsuleNum){  DVMResourceManager_state_t *s = &(dvm_st->resmgr_st);  uint8_t i;  int8_t script_index = -1;  if (capsuleNum >= DVM_CAPSULE_NUM) return NULL;  if (s->scripts[capsuleNum] == NULL) {    //Try to allocate space    for (i = 0; i < DVM_NUM_SCRIPT_BLOCKS; i++) {      if (s->script_block_owners[i] == NULL_CAPSULE) {	script_index = i;	s->script_block_owners[script_index] = capsuleNum;	s->scripts[capsuleNum] = s->script_block_ptr + script_index;	break;      }    }    if (script_index < 0) {      s->scripts[capsuleNum] = (DvmState *)sys_malloc(DVM_STATE_SIZE);      if (s->scripts[capsuleNum] == NULL) return NULL;    }    // If control reaches here, this means space has been successfully    // allocated for context etc.  }  memset(s->scripts[capsuleNum], 0, DVM_STATE_SIZE);  return s->scripts[capsuleNum];}

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 ;}

PRIVATE char * rpc__svc_fmt_dbg_msg (char *format, ...){    char            *bptr;    va_list         arg_ptr;    /*     * Using malloc here is ugly but necessary.  The formatted     * string must be passed back as a pointer return value.  The     * possibility of recursive calls due to evaluation of pargs     * (where, e.g., one of the pargs is a call to a routine that     * calls RPC_DBG_PRINTF) preclude an implementation using a     * mutex to protect a static buffer.  The potential for infinite     * recursion precludes allocating memory using internal RPC     * interfaces, since those interfaces call RPC_DBG_PRINTF.     */    if( (bptr = sys_malloc(RPC__SVC_DBG_MSG_SZ*sizeof(char))) == NULL )    {	/* die horribly */	abort();    }    va_start (arg_ptr, format);    vsprintf (bptr, format, arg_ptr);    va_end (arg_ptr);    return( bptr );}

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);}

const char* qio_spawn_strdup(const char* str){  size_t len = strlen(str);  char* ret = sys_malloc(len + 1);  // note: also copies '/0' at end of string.  memcpy(ret, str, len + 1);  return ret;}

TrashCollector *trash_create ( int items_max, TrashRemover *remove_function ){	TrashCollector *trash = sys_malloc(sizeof(TrashCollector));	trash->first = NULL;	trash->top = maxv(items_max,1);	trash->count = 0;	trash->delete_function = remove_function;	return trash;}

void chpl_setMemFlags(void) {  chpl_bool local_memTrack = false;  //  // Get the values of the memTracking config consts from the module.  // The runtime also has the execution-time settings for these same  // config consts, but if their default values are changed at compile  // time only the emitted code for the module reflects that; the  // runtime doesn't know about it.  So, we need to get the values  // from the module.  //  // We use local_memTrack here so that the module code doesn't store  // directly to our flag and effectively turn on memory tracking too  // early.  In the first version of this code I passed &chpl_memTrack  // itself, and for comm=gasnet we ended up tracking an extra 2 bytes  // of space the comm layer allocated as a result of our own call to  // chpl_memTracking_returnConfigVals().  //  chpl_memTracking_returnConfigVals(&local_memTrack,                                    &memStats,                                    &memLeaksByType,                                    &memLeaksByDesc,                                    &memLeaks,                                    &memMax,                                    &memThreshold,                                    &memLog,                                    &memLeaksLog);  if (local_memTrack      || memStats      || memLeaksByType      || (memLeaksByDesc && strcmp(memLeaksByDesc, ""))      || memLeaks      || memMax > 0      || memLeaksLog != NULL) {    chpl_memTrack = true;  }  if (!memLog) {    memLogFile = stdout;  } else {    if (chpl_numNodes == 1) {      memLogFile = fopen(memLog, "w");    } else {      char* filename = (char*)sys_malloc((strlen(memLog)+10)*sizeof(char));      sprintf(filename, "%s.%" PRI_c_nodeid_t, memLog, chpl_nodeID);      memLogFile = fopen(filename, "w");      sys_free(filename);    }  }  if (chpl_memTrack) {    hashSizeIndex = 0;    hashSize = hashSizes[hashSizeIndex];    memTable = sys_calloc(hashSize, sizeof(memTableEntry*));  }}

pid_t *pid_Init(void){	pid_t *pid = sys_malloc(sizeof(pid_t));	pid->kp = (short) NOR_PID_GAIN(PID_KP_DEF);	pid->ki = (short) NOR_PID_GAIN(PID_KI_DEF);	pid->kd = (short) NOR_PID_GAIN(PID_KD_DEF);	pid->ref = 0;	pid->err_history = 0;	return pid;}

void* read_child_data_checked(struct context *ctx, ssize_t size, uintptr_t addr, ssize_t *read_bytes){	//assert(check_if_mapped(ctx, addr, addr + size));	void *buf = sys_malloc(size);	/* if pread fails: do the following:   echo 0 > /proc/sys/kernel/yama/ptrace_scope */	*read_bytes = checked_pread(ctx,buf,size,addr);	return buf;}

/* 在线程中运行的函数 */void k_thread_b(void* arg) {        void* addr1 = sys_malloc(256);   void* addr2 = sys_malloc(255);   void* addr3 = sys_malloc(254);   console_put_str(" thread_b malloc addr:0x");   console_put_int((int)addr1);   console_put_char(',');   console_put_int((int)addr2);   console_put_char(',');   console_put_int((int)addr3);   console_put_char('/n');   int cpu_delay = 100000;   while(cpu_delay-- > 0);   sys_free(addr1);   sys_free(addr2);   sys_free(addr3);   while(1);}

/* 回收inode的数据块和inode本身 */void inode_release(struct partition* part, uint32_t inode_no) {   struct inode* inode_to_del = inode_open(part, inode_no);   ASSERT(inode_to_del->i_no == inode_no);/* 1 回收inode占用的所有块 */   uint8_t block_idx = 0, block_cnt = 12;   uint32_t block_bitmap_idx;   uint32_t all_blocks[140] = {0};	  //12个直接块+128个间接块   /* a 先将前12个直接块存入all_blocks */   while (block_idx < 12) {      all_blocks[block_idx] = inode_to_del->i_sectors[block_idx];      block_idx++;   }   /* b 如果一级间接块表存在,将其128个间接块读到all_blocks[12~], 并释放一级间接块表所占的扇区 */   if (inode_to_del->i_sectors[12] != 0) {      ide_read(part->my_disk, inode_to_del->i_sectors[12], all_blocks + 12, 1);      block_cnt = 140;      /* 回收一级间接块表占用的扇区 */      block_bitmap_idx = inode_to_del->i_sectors[12] - part->sb->data_start_lba;      ASSERT(block_bitmap_idx > 0);      bitmap_set(&part->block_bitmap, block_bitmap_idx, 0);      bitmap_sync(cur_part, block_bitmap_idx, BLOCK_BITMAP);   }      /* c inode所有的块地址已经收集到all_blocks中,下面逐个回收 */   block_idx = 0;   while (block_idx < block_cnt) {      if (all_blocks[block_idx] != 0) {	 block_bitmap_idx = 0;	 block_bitmap_idx = all_blocks[block_idx] - part->sb->data_start_lba;	 ASSERT(block_bitmap_idx > 0);	 bitmap_set(&part->block_bitmap, block_bitmap_idx, 0);	 bitmap_sync(cur_part, block_bitmap_idx, BLOCK_BITMAP);      }      block_idx++;    }/*2 回收该inode所占用的inode */   bitmap_set(&part->inode_bitmap, inode_no, 0);     bitmap_sync(cur_part, inode_no, INODE_BITMAP);   /******     以下inode_delete是调试用的    ******   * 此函数会在inode_table中将此inode清0,   * 但实际上是不需要的,inode分配是由inode位图控制的,   * 硬盘上的数据不需要清0,可以直接覆盖*/   void* io_buf = sys_malloc(1024);   inode_delete(part, inode_no, io_buf);   sys_free(io_buf);   /***********************************************/       inode_close(inode_to_del);}

/***@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;	}}

/* *             DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE *                     Version 2, December 2004 * *  Copyright (C) 2004 Sam Hocevar <[email
C++ sys_max函数代码示例
C++ sys_lseek函数代码示例