C++ TRACE_ENTRY函数代码示例

/**
 * Check if any seamless mode is enabled.
 * Seamless is only relevant for the newer Xorg modules.
 *
 * @returns the result of the query
 * (true = seamless enabled, false = seamless not enabled)
 * @param   pScrn  Screen info pointer.
 */
Bool
vboxGuestIsSeamless(ScrnInfoPtr pScrn)
{
    VMMDevSeamlessMode mode;
    VBOXPtr pVBox = pScrn->driverPrivate;
    TRACE_ENTRY();
    if (!pVBox->useDevice)
        return FALSE;
    if (RT_FAILURE(VbglR3SeamlessGetLastEvent(&mode)))
        return FALSE;
    return (mode != VMMDev_Seamless_Disabled);
}

static int tierfs_fasync(int fd, struct file *file, int flag)
{
	int rc = 0;
	struct file *lower_file = NULL;

	TRACE_ENTRY();
	lower_file = tierfs_file_to_lower(file);
	if (lower_file->f_op && lower_file->f_op->fasync)
		rc = lower_file->f_op->fasync(fd, lower_file, flag);
	TRACE_EXIT();
	return rc;
}

static void isert_handle_wc_error(struct ib_wc *wc)
{
	struct isert_wr *wr = _u64_to_ptr(wc->wr_id);
	struct isert_cmnd *isert_pdu = wr->pdu;
	struct isert_connection *isert_conn = wr->conn;
	struct isert_buf *isert_buf = wr->buf;
	struct isert_device *isert_dev = wr->isert_dev;
	struct ib_device *ib_dev = isert_dev->ib_dev;

	TRACE_ENTRY();

	if (wc->status != IB_WC_WR_FLUSH_ERR)
		pr_err("conn:%p wr_id:0x%p status:%s vendor_err:0x%0x\n",
		       isert_conn, wr, wr_status_str(wc->status),
		       wc->vendor_err);

	switch (wr->wr_op) {
	case ISER_WR_SEND:
		if (unlikely(wr->send_wr.num_sge == 0)) /* Drain WR */
			isert_sched_conn_drained(isert_conn);
		else
			isert_pdu_err(&isert_pdu->iscsi);
		break;
	case ISER_WR_RDMA_READ:
		if (isert_buf->sg_cnt != 0) {
			ib_dma_unmap_sg(ib_dev, isert_buf->sg, isert_buf->sg_cnt,
				isert_buf->dma_dir);
			isert_buf->sg_cnt = 0;
		}
		isert_pdu_err(&isert_pdu->iscsi);
		break;
	case ISER_WR_RECV:
		/* this should be the Flush, no task has been created yet */
		break;
	case ISER_WR_RDMA_WRITE:
		if (isert_buf->sg_cnt != 0) {
			ib_dma_unmap_sg(ib_dev, isert_buf->sg, isert_buf->sg_cnt,
				isert_buf->dma_dir);
			isert_buf->sg_cnt = 0;
		}
		/* RDMA-WR and SEND response of a READ task
		   are sent together, so when receiving RDMA-WR error,
		   wait until SEND error arrives to complete the task */
		break;
	default:
		pr_err("unexpected opcode %d, wc:%p wr_id:%p conn:%p\n",
		       wr->wr_op, wc, wr, isert_conn);
		break;
	}

	TRACE_EXIT();
}

	void 
	_nasm_interface::set(
		__in const nasm_arguments &arguments
		)
	{
		TRACE_ENTRY();
		SERIALIZE_CALL_RECUR(m_interface_lock);

		nasm_interface::clear();
		m_arguments = arguments;

		TRACE_EXIT("Return Value: 0x%x", NULL);
	}

static int isert_send_locally(struct iscsi_cmnd *req, unsigned int cmd_count)
{
	int res = 0;

	TRACE_ENTRY();

	req_cmnd_pre_release(req);
	res = isert_process_all_writes(req->conn);
	cmnd_put(req);

	TRACE_EXIT_RES(res);
	return res;
}

		size_t 
		_test_suite::get_test_count(void)
		{
			size_t result;

			TRACE_ENTRY();
			SERIALIZE_CALL_RECURSIVE(m_test_suite_lock);

			result = m_test_map.size();

			TRACE_EXIT_MESSAGE("%lu", result);
			return result;
		}

		size_t 
		_lexer_base::size(void)
		{
			size_t result;

			TRACE_ENTRY();
			SERIALIZE_CALL_RECURSIVE(m_lexer_base_lock);

			result = m_raw_input.size();

			TRACE_EXIT_MESSAGE("%lu", result);
			return result;
		}

		void 
		_interpreter::clear(void)
		{
			TRACE_ENTRY();
			SERIALIZE_CALL_RECUR(m_lock);

			parser::reset();
			flush_scopes();

			// TODO: setup global scope here

			TRACE_EXIT("Return Value: 0x%x", NULL);
		}

int isert_data_out_ready(struct iscsi_cmnd *cmnd)
{
	int res = 0;

	TRACE_ENTRY();
#ifdef CONFIG_SCST_EXTRACHECKS
	cmnd->conn->rd_task = current;
#endif
	cmnd_rx_end(cmnd);

	TRACE_EXIT_RES(res);
	return res;
}

/* Unload */
void fd_ext_fini(void)
{
	TRACE_ENTRY();
	
	/* Unregister the cb */
	CHECK_FCT_DO( fd_rt_out_unregister ( rtd_hdl, NULL ), /* continue */ );
	
	/* Destroy the data */
	rtd_fini();
	
	/* Done */
	return ;
}

static int
tierfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
{
	int rc;

	TRACE_ENTRY();
	rc = filemap_write_and_wait(file->f_mapping);
	if (rc)
		return rc;

	TRACE_EXIT();
	return vfs_fsync(tierfs_file_to_lower(file), datasync);
}

		void 
		_json_token_factory::destroy(void)
		{
			TRACE_ENTRY();
			SERIALIZE_CALL_RECUR(m_lock);

			if(m_initialized) {
				clear();
				m_initialized = false;
			}

			TRACE_EXIT("Return Value: 0x%x", 0);
		}

		_json_token::_json_token(
			__in type_t type,
			__in_opt type_t subtype
			) :
				m_line(0),
				m_value(0)
		{
			TRACE_ENTRY();

			set_type(type, subtype);

			TRACE_EXIT("Return Value: 0x%x", 0);
		}

static void __exit exit_this_scst_driver(void)
{
    TRACE_ENTRY();

#ifdef SCST_REGISTER_INITIATOR_DRIVER
    scsi_unregister_module(MODULE_SCSI_HA, &driver_template);
#endif

    scst_unregister_target_template(&driver_target_template);

    TRACE_EXIT();
    return;
}

struct isert_cmnd *isert_tx_pdu_alloc(struct isert_connection *isert_conn,
				      size_t size)
{
	struct isert_cmnd *pdu = NULL;
	int err;

	TRACE_ENTRY();

	pdu = isert_pdu_alloc();
	if (unlikely(!pdu)) {
		pr_err("Failed to alloc pdu\n");
		goto out;
	}

	err = isert_alloc_for_rdma(pdu, 4, isert_conn);
	if (unlikely(err)) {
		pr_err("Failed to alloc sge and wr for tx pdu\n");
		goto out;
	}

	err = isert_buf_alloc_data_buf(isert_conn->isert_dev->ib_dev,
				       &pdu->buf, size, DMA_TO_DEVICE);
	if (unlikely(err)) {
		pr_err("Failed to alloc tx pdu buf sz:%zd\n", size);
		goto buf_alloc_failed;
	}

	err = isert_pdu_tx_buf_init(pdu, isert_conn);
	if (unlikely(err < 0)) {
		pr_err("Failed to init tx pdu wr:%p size:%zd err:%d\n",
		       &pdu->wr, size, err);
		goto buf_init_failed;
	}

	isert_tx_pdu_init(pdu, isert_conn);

	isert_pdu_set_hdr_plain(pdu);

	list_add_tail(&pdu->pool_node, &isert_conn->tx_free_list);

	goto out;

buf_init_failed:
	isert_buf_release(&pdu->buf);
buf_alloc_failed:
	isert_pdu_kfree(pdu);
	pdu = NULL;
out:
	TRACE_EXIT();
	return pdu;
}