Merge tag 'android-8.1.0_r69' into oreo-x86

Android 8.1.0 Release 69 (5794017)

Conflicts:
	stack/btu/btu_hcif.cc
	stack/sdp/sdp_discovery.cc

diff --combined osi/src/alarm.cc
index 475719c,05fb3b4..55db644
--- 1/osi/src/alarm.cc
--- 2/osi/src/alarm.cc
+++ b/osi/src/alarm.cc
@@@ -92,7 -92,7 +92,7 @@@ struct alarm_t 
    // potentially long-running callback is executing. |alarm_cancel| uses this
    // mutex to provide a guarantee to its caller that the callback will not be
    // in progress when it returns.
-   std::recursive_mutex* callback_mutex;
+   std::shared_ptr<std::recursive_mutex> callback_mutex;
    period_ms_t creation_time;
    period_ms_t period;
    period_ms_t deadline;
@@@ -115,6 -115,12 +115,6 @@@
  int64_t TIMER_INTERVAL_FOR_WAKELOCK_IN_MS = 3000;
  static const clockid_t CLOCK_ID = CLOCK_BOOTTIME;
  
 -#if (KERNEL_MISSING_CLOCK_BOOTTIME_ALARM == TRUE)
 -static const clockid_t CLOCK_ID_ALARM = CLOCK_BOOTTIME;
 -#else
 -static const clockid_t CLOCK_ID_ALARM = CLOCK_BOOTTIME_ALARM;
 -#endif
 -
  // This mutex ensures that the |alarm_set|, |alarm_cancel|, and alarm callback
  // functions execute serially and not concurrently. As a result, this mutex
  // also protects the |alarms| list.
@@@ -175,7 -181,8 +175,8 @@@ static alarm_t* alarm_new_internal(cons
  
    alarm_t* ret = static_cast<alarm_t*>(osi_calloc(sizeof(alarm_t)));
  
-   ret->callback_mutex = new std::recursive_mutex;
+   std::shared_ptr<std::recursive_mutex> ptr(new std::recursive_mutex());
+   ret->callback_mutex = ptr;
    ret->is_periodic = is_periodic;
    ret->stats.name = osi_strdup(name);
  
@@@ -192,7 -199,7 +193,7 @@@ void alarm_free(alarm_t* alarm) 
    if (!alarm) return;
  
    alarm_cancel(alarm);
-   delete alarm->callback_mutex;
+ 
    osi_free((void*)alarm->stats.name);
    alarm->closure.~CancelableClosureInStruct();
    osi_free(alarm);
@@@ -245,13 -252,15 +246,15 @@@ void alarm_cancel(alarm_t* alarm) 
    CHECK(alarms != NULL);
    if (!alarm) return;
  
+   std::shared_ptr<std::recursive_mutex> local_mutex_ref;
    {
      std::lock_guard<std::mutex> lock(alarms_mutex);
+     local_mutex_ref = alarm->callback_mutex;
      alarm_cancel_internal(alarm);
    }
  
    // If the callback for |alarm| is in progress, wait here until it completes.
-   std::lock_guard<std::recursive_mutex> lock(*alarm->callback_mutex);
+   std::lock_guard<std::recursive_mutex> lock(*local_mutex_ref);
  }
  
  // Internal implementation of canceling an alarm.
@@@ -321,11 -330,7 +324,11 @@@ static bool lazy_initialize(void) 
    if (!timer_create_internal(CLOCK_ID, &timer)) goto error;
    timer_initialized = true;
  
 -  if (!timer_create_internal(CLOCK_ID_ALARM, &wakeup_timer)) goto error;
 +  if (!timer_create_internal(CLOCK_BOOTTIME_ALARM, &wakeup_timer)) {
 +    if (!timer_create_internal(CLOCK_BOOTTIME, &wakeup_timer)) {
 +      goto error;
 +    }
 +  }
    wakeup_timer_initialized = true;
  
    alarm_expired = semaphore_new(0);
@@@ -577,7 -582,10 +580,10 @@@ static void alarm_ready_generic(alarm_t
      alarm->queue = NULL;
    }
  
-   std::lock_guard<std::recursive_mutex> cb_lock(*alarm->callback_mutex);
+   // Increment the reference count of the mutex so it doesn't get freed
+   // before the callback gets finished executing.
+   std::shared_ptr<std::recursive_mutex> local_mutex_ref = alarm->callback_mutex;
+   std::lock_guard<std::recursive_mutex> cb_lock(*local_mutex_ref);
    lock.unlock();
  
    // Update the statistics