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

/* * Return an allocated lttng hashtable. */LTTNG_HIDDENstruct lttng_ht *lttng_ht_new(unsigned long size, int type){	struct lttng_ht *ht;	/* Test size */	if (!size)		size = DEFAULT_HT_SIZE;	pthread_mutex_lock(&seed_lock);	if (!seed_init) {		lttng_ht_seed = (unsigned long) time(NULL);		seed_init = true;	}	pthread_mutex_unlock(&seed_lock);	ht = zmalloc(sizeof(*ht));	if (ht == NULL) {		PERROR("zmalloc lttng_ht");		goto error;	}	ht->ht = cds_lfht_new(size, min_hash_alloc_size, max_hash_buckets_size,			CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);	/*	 * There is already an assert in the RCU hashtable code so if the ht is	 * NULL here there is a *huge* problem.	 */	assert(ht->ht);	switch (type) {	case LTTNG_HT_TYPE_STRING:		ht->match_fct = match_str;		ht->hash_fct = hash_key_str;		break;	case LTTNG_HT_TYPE_ULONG:		ht->match_fct = match_ulong;		ht->hash_fct = hash_key_ulong;		break;	case LTTNG_HT_TYPE_U64:		ht->match_fct = match_u64;		ht->hash_fct = hash_key_u64;		break;	case LTTNG_HT_TYPE_TWO_U64:		ht->match_fct = match_two_u64;		ht->hash_fct = hash_key_two_u64;		break;	default:		ERR("Unknown lttng hashtable type %d", type);		lttng_ht_destroy(ht);		goto error;	}	DBG3("Created hashtable size %lu at %p of type %d", size, ht->ht, type);	return ht;error:	return NULL;}

/* * Enable UST channel for session and domain. */int channel_ust_enable(struct ltt_ust_session *usess,		struct ltt_ust_channel *uchan){	int ret = LTTNG_OK;	assert(usess);	assert(uchan);	/* If already enabled, everything is OK */	if (uchan->enabled) {		DBG3("Channel %s already enabled. Skipping", uchan->name);		ret = LTTNG_ERR_UST_CHAN_EXIST;		goto end;	}	DBG2("Channel %s being enabled in UST domain", uchan->name);	/*	 * Enable channel for UST global domain on all applications. Ignore return	 * value here since whatever error we got, it means that the channel was	 * not created on one or many registered applications and we can not report	 * this to the user yet. However, at this stage, the channel was	 * successfully created on the session daemon side so the enable-channel	 * command is a success.	 */	(void) ust_app_enable_channel_glb(usess, uchan);	uchan->enabled = 1;	DBG2("Channel %s enabled successfully", uchan->name);end:	return ret;}

GList* DataStorage::lookup_network(const gchar *a_object_path) {	GList *item = NULL;	DBG3();	if(a_object_path == NULL) {		ERR("no object_path.");		return NULL;	}	if(m_list_networks == NULL) {		DBG2("network not found, list is empty.");		return NULL;	}	item = g_list_find_custom(m_list_networks, a_object_path, compare_object_path);	if(item != NULL) {		DBG2("network found");		return item;	}	else {		DBG2("network not found.");	}	return NULL;}

void BuzzMDKHelper::MidiControlChange(const int ctrl, const int channel, const int value ) {	DBG3("(ctrl=%d,channel=%d,value=%d)/n",ctrl,channel,value);/*	if( pInnerEx != NULL )		pInnerEx->MidiControlChange( ctrl, channel, value );*/}

/* * Send a given stream to UST tracer. * * On success return 0 else a negative value. */int ust_consumer_send_stream_to_ust(struct ust_app *app,		struct ust_app_channel *channel, struct ust_app_stream *stream){	int ret;	assert(app);	assert(stream);	assert(channel);	DBG2("UST consumer send stream to app %d", app->sock);	/* Relay stream to application. */	pthread_mutex_lock(&app->sock_lock);	ret = ustctl_send_stream_to_ust(app->sock, channel->obj, stream->obj);	pthread_mutex_unlock(&app->sock_lock);	if (ret < 0) {		if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {			ERR("ustctl send stream handle %d to app pid: %d with ret %d",					stream->obj->handle, app->pid, ret);		} else {			DBG3("UST app send stream to ust failed. Application is dead.");		}		goto error;	}	channel->handle = channel->obj->handle;error:	return ret;}

LTTNG_HIDDENint run_as_extract_elf_symbol_offset(int fd, const char* function,		uid_t uid, gid_t gid, uint64_t *offset){	struct run_as_data data;	struct run_as_ret ret;	memset(&data, 0, sizeof(data));	memset(&ret, 0, sizeof(ret));	DBG3("extract_elf_symbol_offset() on fd=%d and function=%s "		"with for uid %d and gid %d", fd, function, (int) uid, (int) gid);	data.fd = fd;	strncpy(data.u.extract_elf_symbol_offset.function, function, LTTNG_SYMBOL_NAME_LEN - 1);	data.u.extract_elf_symbol_offset.function[LTTNG_SYMBOL_NAME_LEN - 1] = '/0';	run_as(RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET, &data, &ret, uid, gid);	errno = ret._errno;	if (ret._error) {		return -1;	}	*offset = ret.u.extract_elf_symbol_offset.offset;	return 0;}

/* * Ask consumer to create a channel for a given session. * * Returns 0 on success else a negative value. */int ust_consumer_ask_channel(struct ust_app_session *ua_sess,		struct ust_app_channel *ua_chan, struct consumer_output *consumer,		struct consumer_socket *socket, struct ust_registry_session *registry){	int ret;	assert(ua_sess);	assert(ua_chan);	assert(consumer);	assert(socket);	assert(registry);	if (!consumer->enabled) {		ret = -LTTNG_ERR_NO_CONSUMER;		DBG3("Consumer is disabled");		goto error;	}	pthread_mutex_lock(socket->lock);	ret = ask_channel_creation(ua_sess, ua_chan, consumer, socket, registry);	pthread_mutex_unlock(socket->lock);	if (ret < 0) {		goto error;	}error:	return ret;}

LTTNG_HIDDENint run_as_mkdirat(int dirfd, const char *path, mode_t mode,		uid_t uid, gid_t gid){	int ret;	struct run_as_data data;	struct run_as_ret run_as_ret;	memset(&data, 0, sizeof(data));	memset(&run_as_ret, 0, sizeof(run_as_ret));	DBG3("mkdirat() recursive fd = %d%s, path = %s, mode = %d, uid = %d, gid = %d",			dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",			path, (int) mode, (int) uid, (int) gid);	ret = lttng_strncpy(data.u.mkdirat.path, path,			sizeof(data.u.mkdirat.path));	if (ret) {		ERR("Failed to copy path argument of mkdirat command");		goto error;	}	data.u.mkdirat.path[PATH_MAX - 1] = '/0';	data.u.mkdirat.mode = mode;	data.fd = dirfd;	run_as(dirfd == AT_FDCWD ? RUN_AS_MKDIR : RUN_AS_MKDIRAT,			&data, &run_as_ret, uid, gid);	errno = run_as_ret._errno;	ret = run_as_ret._errno;error:	return ret;}

gint ConnmanManager::add_service(ConnmanService *a_service) {	ConnmanService *service = NULL;	gint ret = 0;	DBG3();	if(a_service == NULL) {		ERR("no connman service '%p'", a_service);		return -1;	}	if(m_services == NULL) {		ERR("no services available.");		return -1;	}	service = lookup_service(a_service->get_object_path());	if(service != NULL) {		DBG("service '%s' already exists.", service->get_object_path());		return 0;	}	DBG("add new service '%s'.", a_service->get_object_path());	g_hash_table_insert(m_services, (gchar *)a_service->get_object_path(), a_service);	return 0;}

/* * Receive reply data on socket. This MUST be call after send_command or else * could result in unexpected behavior(s). */static int recv_reply(struct lttcomm_relayd_sock *rsock, void *data, size_t size){	int ret;	if (rsock->sock.fd < 0) {		return -ECONNRESET;	}	DBG3("Relayd waiting for reply of size %zu", size);	ret = rsock->sock.ops->recvmsg(&rsock->sock, data, size, 0);	if (ret <= 0 || ret != size) {		if (ret == 0) {			/* Orderly shutdown. */			DBG("Socket %d has performed an orderly shutdown", rsock->sock.fd);		} else {			DBG("Receiving reply failed on sock %d for size %zu with ret %d",					rsock->sock.fd, size, ret);		}		/* Always return -1 here and the caller can use errno. */		ret = -1;		goto error;	}error:	return ret;}

/* * Send data header structure to the relayd. */int relayd_send_data_hdr(struct lttcomm_relayd_sock *rsock,		struct lttcomm_relayd_data_hdr *hdr, size_t size){	int ret;	/* Code flow error. Safety net. */	assert(rsock);	assert(hdr);	if (rsock->sock.fd < 0) {		return -ECONNRESET;	}	DBG3("Relayd sending data header of size %zu", size);	/* Again, safety net */	if (size == 0) {		size = sizeof(struct lttcomm_relayd_data_hdr);	}	/* Only send data header. */	ret = rsock->sock.ops->sendmsg(&rsock->sock, hdr, size, 0);	if (ret < 0) {		ret = -errno;		goto error;	}	/*	 * The data MUST be sent right after that command for the receive on the	 * other end to match the size in the header.	 */error:	return ret;}

/* * Close relayd socket with an allocated lttcomm_relayd_sock. * * If no socket operations are found, simply return 0 meaning that everything * is fine. Without operations, the socket can not possibly be opened or used. * This is possible if the socket was allocated but not created. However, the * caller could simply use it to store a valid file descriptor for instance * passed over a Unix socket and call this to cleanup but still without a valid * ops pointer. * * Return the close returned value. On error, a negative value is usually * returned back from close(2). */int relayd_close(struct lttcomm_relayd_sock *rsock){	int ret;	/* Code flow error. Safety net. */	assert(rsock);	/* An invalid fd is fine, return success. */	if (rsock->sock.fd < 0) {		ret = 0;		goto end;	}	DBG3("Relayd closing socket %d", rsock->sock.fd);	if (rsock->sock.ops) {		ret = rsock->sock.ops->close(&rsock->sock);	} else {		/* Default call if no specific ops found. */		ret = close(rsock->sock.fd);		if (ret < 0) {			PERROR("relayd_close default close");		}	}	rsock->sock.fd = -1;end:	return ret;}

/* * Send channel previously received from the consumer to the UST tracer. * * On success return 0 else a negative value. */int ust_consumer_send_channel_to_ust(struct ust_app *app,		struct ust_app_session *ua_sess, struct ust_app_channel *channel){	int ret;	assert(app);	assert(ua_sess);	assert(channel);	assert(channel->obj);	DBG2("UST app send channel to sock %d pid %d (name: %s, key: %" PRIu64 ")",			app->sock, app->pid, channel->name, channel->tracing_channel_id);	/* Send stream to application. */	pthread_mutex_lock(&app->sock_lock);	ret = ustctl_send_channel_to_ust(app->sock, ua_sess->handle, channel->obj);	pthread_mutex_unlock(&app->sock_lock);	if (ret < 0) {		if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {			ERR("Error ustctl send channel %s to app pid: %d with ret %d",					channel->name, app->pid, ret);		} else {			DBG3("UST app send channel to ust failed. Application is dead.");		}		goto error;	}error:	return ret;}

/* * Connect to relay daemon with an allocated lttcomm_sock. */int relayd_connect(struct lttcomm_sock *sock){	/* Code flow error. Safety net. */	assert(sock);	DBG3("Relayd connect ...");	return sock->ops->connect(sock);}

void set_Arm (unsigned char mode){#ifdef CMM_ARM_EXPERIMENT	unsigned long cur_pos;	unsigned char old_mode;	unsigned char pct_deployed;	get_ArmPosition(&cur_pos, &old_mode);	if (mode == old_mode) return;	if (old_mode != ARM_STOP)	{		if (cur_pos != arm_pos)		{			pct_deployed = cur_pos / ARM_STROKE_PCT;#ifdef ARM_POS_DEBUG			DBG("Arm moved ");			if (cur_pos > arm_pos)				DBG2("+%lu", cur_pos - arm_pos);			else				DBG2("-%lu", arm_pos - cur_pos);			DBG3(" to %lu (%lu)/n", cur_pos, pct_deployed);#endif			arm_pos = cur_pos;		}	}	else	{		pct_deployed = cur_pos / ARM_STROKE_PCT;	}	if (mode != ARM_STOP) gettimestamp(&arm_start);#endif	switch (mode) {	default:	case ARM_STOP:		ARM(LAT) &= ~(ARM_UPDOWN_MASK | ARM_ONOFF_MASK);		break;	case ARM_UP:		ARM(LAT) &= ~ARM_UPDOWN_MASK;		ARM(LAT) |=  ARM_ONOFF_MASK;		break;	case ARM_DOWN:		ARM(LAT) |= ARM_UPDOWN_MASK;		ARM(LAT) |= ARM_ONOFF_MASK;		break;	}#ifdef CMM_ARM_EXPERIMENT	// % deployed in lower bits, mode in upper bits	eventlog_track(EVENTLOG_ARM, (((uint16_t)pct_deployed) << 8) | mode);#else	eventlog_track(EVENTLOG_ARM, mode);#endif}

int load_pkcs11_module(const char *module, pkcs11_handle_t **hp){  int rv;  struct stat module_stat;  CK_C_GetFunctionList C_GetFunctionList_ptr;  pkcs11_handle_t *h;  DBG1("PKCS #11 module = [%s]", module);  /* reset pkcs #11 handle */  h = (pkcs11_handle_t *)calloc(sizeof(pkcs11_handle_t), 1);  if (h == NULL) {    set_error("pkcs11_handle_t malloc failed: %s", strerror(errno));    return -1;  }  /* check module permissions */  rv = stat(module, &module_stat);  if (rv < 0) {    set_error("stat() failed: %s", strerror(errno));    free(h);    return -1;  }  DBG3("module permissions: uid = %d, gid = %d, mode = %o",      module_stat.st_uid, module_stat.st_gid, module_stat.st_mode & 0777);  if (module_stat.st_mode & S_IWGRP || module_stat.st_mode & S_IWOTH      || module_stat.st_uid != 0) {    set_error("the pkcs #11 module MUST be owned by root and MUST NOT "              "be writable by the group or others");    free(h);    return -1;  }  /* load module */  DBG1("loading module %s", module);  h->module_handle = dlopen(module, RTLD_NOW);  if (h->module_handle == NULL) {    set_error("dlopen() failed: %s", dlerror());    free(h);    return -1;  }  /* try to get the function list */  DBG("getting function list");  C_GetFunctionList_ptr = (CK_C_GetFunctionList)dlsym(h->module_handle, "C_GetFunctionList");  if (C_GetFunctionList_ptr == NULL) {    set_error("dlsym() failed: %s", dlerror());    free(h);    return -1;  }  rv = C_GetFunctionList_ptr(&h->fl);  if (rv != CKR_OK) {    set_error("C_GetFunctionList() failed: 0x%08lX", rv);    free(h);    return -1;  }  *hp = h;  return 0;}

/** * create a signed pkcs7 contentInfo object */chunk_t pkcs7_build_signedData(chunk_t data, chunk_t attributes,							   certificate_t *cert, int digest_alg,							   private_key_t *key){	contentInfo_t pkcs7Data, signedData;	chunk_t authenticatedAttributes = chunk_empty;	chunk_t encryptedDigest = chunk_empty;	chunk_t signerInfo, cInfo, signature, encoding = chunk_empty;;	signature_scheme_t scheme = signature_scheme_from_oid(digest_alg);	if (attributes.ptr)	{		if (key->sign(key, scheme, attributes, &signature))		{			encryptedDigest = asn1_wrap(ASN1_OCTET_STRING, "m", signature);			authenticatedAttributes = chunk_clone(attributes);			*authenticatedAttributes.ptr = ASN1_CONTEXT_C_0;		}	}	else if (data.ptr)	{		if (key->sign(key, scheme, data, &signature))		{			encryptedDigest = asn1_wrap(ASN1_OCTET_STRING, "m", signature);		}	}	signerInfo = asn1_wrap(ASN1_SEQUENCE, "cmmmmm"				, ASN1_INTEGER_1				, pkcs7_build_issuerAndSerialNumber(cert)				, asn1_algorithmIdentifier(digest_alg)				, authenticatedAttributes				, asn1_algorithmIdentifier(OID_RSA_ENCRYPTION)				, encryptedDigest);	pkcs7Data.type    = OID_PKCS7_DATA;	pkcs7Data.content = (data.ptr == NULL)? chunk_empty				: asn1_simple_object(ASN1_OCTET_STRING, data);	cert->get_encoding(cert, CERT_ASN1_DER, &encoding);	signedData.type = OID_PKCS7_SIGNED_DATA;	signedData.content = asn1_wrap(ASN1_SEQUENCE, "cmmmm"				, ASN1_INTEGER_1				, asn1_wrap(ASN1_SET, "m", asn1_algorithmIdentifier(digest_alg))				, pkcs7_build_contentInfo(&pkcs7Data)				, asn1_wrap(ASN1_CONTEXT_C_0, "m", encoding)				, asn1_wrap(ASN1_SET, "m", signerInfo));	cInfo = pkcs7_build_contentInfo(&signedData);	DBG3(DBG_LIB, "signedData %B", &cInfo);	free(pkcs7Data.content.ptr);	free(signedData.content.ptr);	return cInfo;}

LTTNG_HIDDENint run_as_unlink(const char *path, uid_t uid, gid_t gid){	struct run_as_data data;	DBG3("unlink() %s with for uid %d and gid %d",			path, (int) uid, (int) gid);	strncpy(data.u.unlink.path, path, PATH_MAX - 1);	data.u.unlink.path[PATH_MAX - 1] = '/0';	return run_as(RUN_AS_UNLINK, &data, uid, gid);}

LTTNG_HIDDENint run_as_rmdir_recursive(const char *path, uid_t uid, gid_t gid){	struct run_as_data data;	DBG3("rmdir_recursive() %s with for uid %d and gid %d",			path, (int) uid, (int) gid);	strncpy(data.u.rmdir_recursive.path, path, PATH_MAX - 1);	data.u.rmdir_recursive.path[PATH_MAX - 1] = '/0';	return run_as(RUN_AS_RMDIR_RECURSIVE, &data, uid, gid);}

void PdParamGetter::getParamFromPd(pd::PdBase * pd) {    //    parsedString.clear();    guiSizes.clear();    guiFiles.clear();    pulpParameterDescs.clear();    localObjectCount =0;    localParamCount = 0;    GUINumParams.clear();    GUINumObjects.clear();    t_canvas * x;// = pd_getcanvaslist();    pd->setMainContext();    bool isRoot = true;    for(x= pd_getcanvaslist(); x; x = x->gl_next) {        DBG3(x->gl_name->s_name,x->gl_env->ce_dir->s_name,x->gl_env->ce_argc);        if(isRoot) {            guiFiles.add(File(x->gl_env->ce_dir->s_name).getChildFile(x->gl_name->s_name));            PdRootName =x->gl_name->s_name;            isRoot = false;        }        //        DBG4(x->gl_screenx1,x->gl_screeny1,x->gl_screenx2,x->gl_screeny2)        int guiIdx = 0;        Rectangle<int> patchRect (x->gl_screenx2-x->gl_screenx1,x->gl_screeny2-x->gl_screeny1);        guiSizes.add(patchRect);        DBG(patchRect.toString());        int tmpCount = localParamCount;        int tmpObjCount = localObjectCount;        getFromPdCanvas(x,guiIdx);        guiIdx++;        //        if(pulpParameterDescs.size()>0){        //            float minX = std::min(std::min(minX, pulpParameterDescs[0]->getX()),pulpParameterDescs[0]->labelRect.getX()) ;        //            float minY = std::min(std::min(minY, pulpParameterDescs[0]->getY()),pulpParameterDescs[0]->labelRect.getY()) ;        //        //            for(auto & p:pulpParameterDescs){        //                minX = std::min(std::min(minX, p->getX()),p->labelRect.getX()) ;        //                minY = std::min(std::min(minY, p->getY()),p->labelRect.getY()) ;        //            }        //            for(auto & p:pulpParameterDescs){        //                p->setPosition( p->getX()-minX,p->getY()-minY);        //            }        //        }        GUINumObjects.add(localObjectCount - tmpObjCount);        GUINumParams.add(localParamCount-tmpCount);    }    pd->freeContext();}

LTTNG_HIDDENint run_as_mkdir(const char *path, mode_t mode, uid_t uid, gid_t gid){	struct run_as_data data;	DBG3("mkdir() %s with mode %d for uid %d and gid %d",			path, (int) mode, (int) uid, (int) gid);	strncpy(data.u.mkdir.path, path, PATH_MAX - 1);	data.u.mkdir.path[PATH_MAX - 1] = '/0';	data.u.mkdir.mode = mode;	return run_as(RUN_AS_MKDIR, &data, uid, gid);}

LTTNG_HIDDENint run_as_open(const char *path, int flags, mode_t mode, uid_t uid, gid_t gid){	struct run_as_data data;	DBG3("open() %s with flags %X mode %d for uid %d and gid %d",			path, flags, (int) mode, (int) uid, (int) gid);	strncpy(data.u.open.path, path, PATH_MAX - 1);	data.u.open.path[PATH_MAX - 1] = '/0';	data.u.open.flags = flags;	data.u.open.mode = mode;	return run_as(RUN_AS_OPEN, &data, uid, gid);}

/* * Send command. Fill up the header and append the data. */static int send_command(struct lttcomm_relayd_sock *rsock,		enum lttcomm_relayd_command cmd, void *data, size_t size,		int flags){	int ret;	struct lttcomm_relayd_hdr header;	char *buf;	uint64_t buf_size = sizeof(header);	if (rsock->sock.fd < 0) {		return -ECONNRESET;	}	if (data) {		buf_size += size;	}	buf = zmalloc(buf_size);	if (buf == NULL) {		PERROR("zmalloc relayd send command buf");		ret = -1;		goto alloc_error;	}	memset(&header, 0, sizeof(header));	header.cmd = htobe32(cmd);	header.data_size = htobe64(size);	/* Zeroed for now since not used. */	header.cmd_version = 0;	header.circuit_id = 0;	/* Prepare buffer to send. */	memcpy(buf, &header, sizeof(header));	if (data) {		memcpy(buf + sizeof(header), data, size);	}	ret = rsock->sock.ops->sendmsg(&rsock->sock, buf, buf_size, flags);	if (ret < 0) {		ret = -errno;		goto error;	}	DBG3("Relayd sending command %d of size %" PRIu64, cmd, buf_size);error:	free(buf);alloc_error:	return ret;}