Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ea5a7a5b authored by Zhen Kong's avatar Zhen Kong
Browse files

qseecom: update on smcinvoke-aware listeners operations 



With the introduction of MinkIPC for TA-to-TA communication,
if a request for blocking a TA (on a busy listener) is received
by qseecom, it may not be originated from the last TA to which
a command (or unblock response) was sent to. So, make change
to use a session_id instead of app_id to uniquely identify this
blocked request and a new cmd ID to support this smcinvoke-aware
listener operation.

Change-Id: I362e9acfa52c055b5759c210bb881da40f4e0776
Signed-off-by: default avatarZhen Kong <zkong@codeaurora.org>
parent 212c115a

drivers/misc/qseecom.c

+97 −29
Original line number Diff line number Diff line
@@ -278,6 +278,7 @@ struct qseecom_control { 
	wait_queue_head_t app_block_wq;

	atomic_t qseecom_state;

	int is_apps_region_protected;

	bool smcinvoke_support;

};



struct qseecom_sec_buf_fd_info {
@@ -575,10 +576,12 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id, 
				desc.args[1] = req_64bit->sb_ptr;

				desc.args[2] = req_64bit->sb_len;

			}

			qseecom.smcinvoke_support = true;

			smc_id = TZ_OS_REGISTER_LISTENER_SMCINVOKE_ID;

			__qseecom_reentrancy_check_if_no_app_blocked(smc_id);

			ret = scm_call2(smc_id, &desc);

			if (ret) {

				qseecom.smcinvoke_support = false;

				smc_id = TZ_OS_REGISTER_LISTENER_ID;

				__qseecom_reentrancy_check_if_no_app_blocked(

					smc_id);
@@ -1003,10 +1006,14 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id, 
			struct qseecom_continue_blocked_request_ireq *req =

				(struct qseecom_continue_blocked_request_ireq *)

				req_buf;

			if (qseecom.smcinvoke_support)

				smc_id =

				TZ_OS_CONTINUE_BLOCKED_REQUEST_SMCINVOKE_ID;

			else

				smc_id = TZ_OS_CONTINUE_BLOCKED_REQUEST_ID;

			desc.arginfo =

				TZ_OS_CONTINUE_BLOCKED_REQUEST_ID_PARAM_ID;

			desc.args[0] = req->app_id;

			desc.args[0] = req->app_or_session_id;

			ret = scm_call2(smc_id, &desc);

			break;

		}
@@ -1836,7 +1843,7 @@ static int __qseecom_process_incomplete_cmd(struct qseecom_dev_handle *data, 
	return ret;

}



int __qseecom_process_reentrancy_blocked_on_listener(

static int __qseecom_process_blocked_on_listener_legacy(

				struct qseecom_command_scm_resp *resp,

				struct qseecom_registered_app_list *ptr_app,

				struct qseecom_dev_handle *data)
@@ -1845,9 +1852,8 @@ int __qseecom_process_reentrancy_blocked_on_listener( 
	int ret = 0;

	struct qseecom_continue_blocked_request_ireq ireq;

	struct qseecom_command_scm_resp continue_resp;

	sigset_t new_sigset, old_sigset;

	unsigned long flags;

	bool found_app = false;

	unsigned long flags;



	if (!resp || !data) {

		pr_err("invalid resp or data pointer\n");
@@ -1887,32 +1893,30 @@ int __qseecom_process_reentrancy_blocked_on_listener( 
	pr_debug("lsntr %d in_use = %d\n",

			resp->data, list_ptr->listener_in_use);

	ptr_app->blocked_on_listener_id = resp->data;



	/* sleep until listener is available */

	do {

	qseecom.app_block_ref_cnt++;

	ptr_app->app_blocked = true;

		sigfillset(&new_sigset);

		sigprocmask(SIG_SETMASK, &new_sigset, &old_sigset);

	mutex_unlock(&app_access_lock);

		do {

			if (!wait_event_freezable(

	if (wait_event_freezable(

			list_ptr->listener_block_app_wq,

			!list_ptr->listener_in_use)) {

				break;

		pr_err("Interrupted: listener_id %d, app_id %d\n",

				resp->data, ptr_app->app_id);

		ret = -ERESTARTSYS;

		goto exit;

	}

		} while (1);

	mutex_lock(&app_access_lock);

		sigprocmask(SIG_SETMASK, &old_sigset, NULL);

	ptr_app->app_blocked = false;

	qseecom.app_block_ref_cnt--;

	} while (list_ptr->listener_in_use == true);



	ptr_app->blocked_on_listener_id = 0;

	/* notify the blocked app that listener is available */

	pr_warn("Lsntr %d is available, unblock app(%d) %s in TZ\n",

		resp->data, data->client.app_id,

		data->client.app_name);

	ireq.qsee_cmd_id = QSEOS_CONTINUE_BLOCKED_REQ_COMMAND;

	ireq.app_id = data->client.app_id;

	ireq.app_or_session_id = data->client.app_id;

	ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1,

			&ireq, sizeof(ireq),

			&continue_resp, sizeof(continue_resp));
@@ -1931,6 +1935,73 @@ exit: 
	return ret;

}



static int __qseecom_process_blocked_on_listener_smcinvoke(

			struct qseecom_command_scm_resp *resp)

{

	struct qseecom_registered_listener_list *list_ptr;

	int ret = 0;

	struct qseecom_continue_blocked_request_ireq ireq;

	struct qseecom_command_scm_resp continue_resp;

	unsigned int session_id;



	if (!resp) {

		pr_err("invalid resp pointer\n");

		ret = -EINVAL;

		goto exit;

	}

	session_id = resp->resp_type;

	list_ptr = __qseecom_find_svc(resp->data);

	if (!list_ptr) {

		pr_err("Invalid listener ID\n");

		ret = -ENODATA;

		goto exit;

	}

	pr_debug("lsntr %d in_use = %d\n",

			resp->data, list_ptr->listener_in_use);

	/* sleep until listener is available */

	qseecom.app_block_ref_cnt++;

	mutex_unlock(&app_access_lock);

	if (wait_event_freezable(

			list_ptr->listener_block_app_wq,

			!list_ptr->listener_in_use)) {

		pr_err("Interrupted: listener_id %d, session_id %d\n",

				resp->data, session_id);

		ret = -ERESTARTSYS;

		goto exit;

	}

	mutex_lock(&app_access_lock);

	qseecom.app_block_ref_cnt--;



	/* notify TZ that listener is available */

	pr_warn("Lsntr %d is available, unblock session(%d) in TZ\n",

			resp->data, session_id);

	ireq.qsee_cmd_id = QSEOS_CONTINUE_BLOCKED_REQ_COMMAND;

	ireq.app_or_session_id = session_id;

	ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1,

			&ireq, sizeof(ireq),

			&continue_resp, sizeof(continue_resp));

	if (ret) {

		pr_err("scm_call for continue blocked req for session %d failed, ret %d\n",

			session_id, ret);

		goto exit;

	}

	resp->result = QSEOS_RESULT_INCOMPLETE;

exit:

	return ret;

}



static int __qseecom_process_reentrancy_blocked_on_listener(

				struct qseecom_command_scm_resp *resp,

				struct qseecom_registered_app_list *ptr_app,

				struct qseecom_dev_handle *data)

{

	if (!qseecom.smcinvoke_support)

		return __qseecom_process_blocked_on_listener_legacy(

			resp, ptr_app, data);

	else

		return __qseecom_process_blocked_on_listener_smcinvoke(

			resp);

}

static int __qseecom_reentrancy_process_incomplete_cmd(

					struct qseecom_dev_handle *data,

					struct qseecom_command_scm_resp *resp)
@@ -4697,18 +4768,15 @@ int qseecom_process_listener_from_smcinvoke(struct scm_desc *desc) 
	}



	resp.result = desc->ret[0];	/*req_cmd*/

	resp.resp_type = desc->ret[1];	/*app_id*/

	resp.resp_type = desc->ret[1]; /*incomplete:unused;blocked:session_id*/

	resp.data = desc->ret[2];	/*listener_id*/



	dummy_private_data.client.app_id = desc->ret[1];

	dummy_app_entry.app_id = desc->ret[1];



	mutex_lock(&app_access_lock);

	ret = __qseecom_process_reentrancy(&resp, &dummy_app_entry,

					&dummy_private_data);

	mutex_unlock(&app_access_lock);

	if (ret)

		pr_err("Failed to req cmd %d lsnr %d on app %d, ret = %d\n",

		pr_err("Failed on cmd %d for lsnr %d session %d, ret = %d\n",

			(int)desc->ret[0], (int)desc->ret[2],

			(int)desc->ret[1], ret);

	desc->ret[0] = resp.result;

include/soc/qcom/qseecomi.h

+4 −1
Original line number Diff line number Diff line
@@ -336,7 +336,7 @@ __packed struct qseecom_client_send_fsm_key_req { 


__packed struct qseecom_continue_blocked_request_ireq {

	uint32_t qsee_cmd_id;

	uint32_t app_id;

	uint32_t app_or_session_id; /*legacy: app_id; smcinvoke: session_id*/

};
@@ -681,6 +681,9 @@ __packed struct qseecom_continue_blocked_request_ireq { 
#define TZ_OS_CONTINUE_BLOCKED_REQUEST_ID \

	TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_LISTENER, 0x04)



#define TZ_OS_CONTINUE_BLOCKED_REQUEST_SMCINVOKE_ID \

	TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_LISTENER, 0x07)



#define TZ_OS_CONTINUE_BLOCKED_REQUEST_ID_PARAM_ID \

	TZ_SYSCALL_CREATE_PARAM_ID_1(TZ_SYSCALL_PARAM_TYPE_VAL)