Use a mutex to protect the scheduling of tBTA_PM_TIMER (72ce32ef) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/dm/bta_dm_pm.cc

+12 −8

Original line number	Original line	Diff line number	Diff line
	@@ -67,7 +67,8 @@ static void bta_dm_pm_ssr(const RawAddress& peer_addr);
	#endif		#endif

	tBTA_DM_CONNECTED_SRVCS bta_dm_conn_srvcs;		tBTA_DM_CONNECTED_SRVCS bta_dm_conn_srvcs;
	static std::recursive_mutex pm_timer_mutex;		static std::recursive_mutex pm_timer_schedule_mutex;
			static std::recursive_mutex pm_timer_state_mutex;

	/*******************************************************************************		/*******************************************************************************
	*		*
	@@ -272,7 +273,8 @@ static void bta_dm_pm_stop_timer_by_srvc_id(const RawAddress& peer_addr,
	static void bta_dm_pm_start_timer(tBTA_PM_TIMER* p_timer, uint8_t timer_idx,		static void bta_dm_pm_start_timer(tBTA_PM_TIMER* p_timer, uint8_t timer_idx,
	period_ms_t timeout_ms, uint8_t srvc_id,		period_ms_t timeout_ms, uint8_t srvc_id,
	uint8_t pm_action) {		uint8_t pm_action) {
	std::unique_lock<std::recursive_mutex> lock(pm_timer_mutex);		std::unique_lock<std::recursive_mutex> schedule_lock(pm_timer_schedule_mutex);
			std::unique_lock<std::recursive_mutex> state_lock(pm_timer_state_mutex);
	p_timer->in_use = true;		p_timer->in_use = true;

	if (p_timer->srvc_id[timer_idx] == BTA_ID_MAX) p_timer->active++;		if (p_timer->srvc_id[timer_idx] == BTA_ID_MAX) p_timer->active++;
	@@ -281,7 +283,7 @@ static void bta_dm_pm_start_timer(tBTA_PM_TIMER* p_timer, uint8_t timer_idx,
	p_timer->pm_action[timer_idx] = pm_action;		p_timer->pm_action[timer_idx] = pm_action;

	p_timer->srvc_id[timer_idx] = srvc_id;		p_timer->srvc_id[timer_idx] = srvc_id;
	lock.unlock();		state_lock.unlock();

	alarm_set_on_queue(p_timer->timer[timer_idx], timeout_ms,		alarm_set_on_queue(p_timer->timer[timer_idx], timeout_ms,
	bta_dm_pm_timer_cback, p_timer->timer[timer_idx],		bta_dm_pm_timer_cback, p_timer->timer[timer_idx],
	@@ -302,19 +304,21 @@ static void bta_dm_pm_stop_timer_by_index(tBTA_PM_TIMER* p_timer,
	uint8_t timer_idx) {		uint8_t timer_idx) {
	if ((p_timer == NULL) \|\| (timer_idx >= BTA_DM_PM_MODE_TIMER_MAX)) return;		if ((p_timer == NULL) \|\| (timer_idx >= BTA_DM_PM_MODE_TIMER_MAX)) return;

			std::unique_lock<std::recursive_mutex> schedule_lock(pm_timer_schedule_mutex);
			std::unique_lock<std::recursive_mutex> state_lock(pm_timer_state_mutex);
	if (p_timer->srvc_id[timer_idx] == BTA_ID_MAX)		if (p_timer->srvc_id[timer_idx] == BTA_ID_MAX)
	return; /* The timer was not scheduled */		return; /* The timer was not scheduled */

	CHECK(p_timer->in_use && (p_timer->active > 0));		CHECK(p_timer->in_use && (p_timer->active > 0));

	alarm_cancel(p_timer->timer[timer_idx]);

	std::lock_guard<std::recursive_mutex> lock(pm_timer_mutex);
	p_timer->srvc_id[timer_idx] = BTA_ID_MAX;		p_timer->srvc_id[timer_idx] = BTA_ID_MAX;
	/* NOTE: pm_action[timer_idx] intentionally not reset */		/* NOTE: pm_action[timer_idx] intentionally not reset */

	p_timer->active--;		p_timer->active--;
	if (p_timer->active == 0) p_timer->in_use = false;		if (p_timer->active == 0) p_timer->in_use = false;
			state_lock.unlock();

			alarm_cancel(p_timer->timer[timer_idx]);
	}		}

	/*******************************************************************************		/*******************************************************************************
	@@ -881,7 +885,7 @@ static void bta_dm_pm_timer_cback(void* data) {
	uint8_t i, j;		uint8_t i, j;
	alarm_t* alarm = (alarm_t*)data;		alarm_t* alarm = (alarm_t*)data;

	std::unique_lock<std::recursive_mutex> lock(pm_timer_mutex);		std::unique_lock<std::recursive_mutex> state_lock(pm_timer_state_mutex);
	for (i = 0; i < BTA_DM_NUM_PM_TIMER; i++) {		for (i = 0; i < BTA_DM_NUM_PM_TIMER; i++) {
	APPL_TRACE_DEBUG("dm_pm_timer[%d] in use? %d", i,		APPL_TRACE_DEBUG("dm_pm_timer[%d] in use? %d", i,
	bta_dm_cb.pm_timer[i].in_use);		bta_dm_cb.pm_timer[i].in_use);
	@@ -899,7 +903,7 @@ static void bta_dm_pm_timer_cback(void* data) {
	if (j < BTA_DM_PM_MODE_TIMER_MAX) break;		if (j < BTA_DM_PM_MODE_TIMER_MAX) break;
	}		}
	}		}
	lock.unlock();		state_lock.unlock();

	/* no more timers */		/* no more timers */
	if (i == BTA_DM_NUM_PM_TIMER) return;		if (i == BTA_DM_NUM_PM_TIMER) return;