Furi: A Lot of Fixes (#3942)

- BT Service: cleanup code
- Dialog: correct release order in file browser
- Rpc: rollback to pre #3881 state
- Kernel: fix inverted behavior in furi_kernel_is_running
- Log: properly take mutex when kernel is not running
- Thread: rework tread control block scrubbing procedure, ensure that we don't do stupid things in idle task, add new priority for init task
- Timer: add control queue flush method, force flush on stop
- Furi: system init task now performs thread scrubbing
- BleGlue: add some extra checks
- FreeRTOSConfig: fix bunch of issues that were preventing configuration from being properly applied and cleanup

applications/services/bt/bt_service/bt.c

@@ -430,13 +430,11 @@ static void bt_change_profile(Bt* bt, BtMessage* message) {
             *message->profile_instance = NULL;
         }
     }
-    if(message->lock) api_lock_unlock(message->lock);
 }
 
-static void bt_close_connection(Bt* bt, BtMessage* message) {
+static void bt_close_connection(Bt* bt) {
     bt_close_rpc_connection(bt);
     furi_hal_bt_stop_advertising();
-    if(message->lock) api_lock_unlock(message->lock);
 }
 
 static void bt_apply_settings(Bt* bt) {
@@ -484,19 +482,13 @@ static void bt_load_settings(Bt* bt) {
 }
 
 static void bt_handle_get_settings(Bt* bt, BtMessage* message) {
-    furi_assert(message->lock);
     *message->data.settings = bt->bt_settings;
-    api_lock_unlock(message->lock);
 }
 
 static void bt_handle_set_settings(Bt* bt, BtMessage* message) {
-    furi_assert(message->lock);
     bt->bt_settings = *message->data.csettings;
-
     bt_apply_settings(bt);
     bt_settings_save(&bt->bt_settings);
-
-    api_lock_unlock(message->lock);
 }
 
 static void bt_handle_reload_keys_settings(Bt* bt) {
@@ -548,6 +540,12 @@ int32_t bt_srv(void* p) {
     while(1) {
         furi_check(
             furi_message_queue_get(bt->message_queue, &message, FuriWaitForever) == FuriStatusOk);
+        FURI_LOG_D(
+            TAG,
+            "call %d, lock 0x%p, result 0x%p",
+            message.type,
+            (void*)message.lock,
+            (void*)message.result);
         if(message.type == BtMessageTypeUpdateStatus) {
             // Update view ports
             bt_statusbar_update(bt);
@@ -571,7 +569,7 @@ int32_t bt_srv(void* p) {
         } else if(message.type == BtMessageTypeSetProfile) {
             bt_change_profile(bt, &message);
         } else if(message.type == BtMessageTypeDisconnect) {
-            bt_close_connection(bt, &message);
+            bt_close_connection(bt);
         } else if(message.type == BtMessageTypeForgetBondedDevices) {
             bt_keys_storage_delete(bt->keys_storage);
         } else if(message.type == BtMessageTypeGetSettings) {
@@ -581,6 +579,8 @@ int32_t bt_srv(void* p) {
         } else if(message.type == BtMessageTypeReloadKeysSettings) {
             bt_handle_reload_keys_settings(bt);
         }
+
+        if(message.lock) api_lock_unlock(message.lock);
     }
 
     return 0;

applications/services/dialogs/dialogs_module_file_browser.c

@@ -54,11 +54,14 @@ bool dialogs_app_process_module_file_browser(const DialogsAppMessageDataFileBrow
     ret = file_browser_context->result;
 
     view_holder_set_view(view_holder, NULL);
-    view_holder_free(view_holder);
     file_browser_stop(file_browser);
+
     file_browser_free(file_browser);
+    view_holder_free(view_holder);
+
     api_lock_free(file_browser_context->lock);
     free(file_browser_context);
+
     furi_record_close(RECORD_GUI);
 
     return ret;

applications/services/rpc/rpc.c

@@ -67,7 +67,7 @@ static RpcSystemCallbacks rpc_systems[] = {
 struct RpcSession {
     Rpc* rpc;
 
-    FuriThreadId thread_id;
+    FuriThread* thread;
 
     RpcHandlerDict_t handlers;
     FuriStreamBuffer* stream;
@@ -172,7 +172,7 @@ size_t rpc_session_feed(
 
     size_t bytes_sent = furi_stream_buffer_send(session->stream, encoded_bytes, size, timeout);
 
-    furi_thread_flags_set(session->thread_id, RpcEvtNewData);
+    furi_thread_flags_set(furi_thread_get_id(session->thread), RpcEvtNewData);
 
     return bytes_sent;
 }
@@ -220,7 +220,7 @@ bool rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_t count) {
                     break;
                 } else {
                     /* Save disconnect flag and continue reading buffer */
-                    furi_thread_flags_set(session->thread_id, RpcEvtDisconnect);
+                    furi_thread_flags_set(furi_thread_get_id(session->thread), RpcEvtDisconnect);
                 }
             } else if(flags & RpcEvtNewData) {
                 // Just wake thread up
@@ -347,32 +347,37 @@ static int32_t rpc_session_worker(void* context) {
     return 0;
 }
 
-static void rpc_session_thread_release_callback(
-    FuriThread* thread,
-    FuriThreadState thread_state,
-    void* context) {
-    if(thread_state == FuriThreadStateStopped) {
-        RpcSession* session = (RpcSession*)context;
+static void rpc_session_thread_pending_callback(void* context, uint32_t arg) {
+    UNUSED(arg);
+    RpcSession* session = (RpcSession*)context;
 
-        for(size_t i = 0; i < COUNT_OF(rpc_systems); ++i) {
-            if(rpc_systems[i].free) {
-                (rpc_systems[i].free)(session->system_contexts[i]);
-            }
+    for(size_t i = 0; i < COUNT_OF(rpc_systems); ++i) {
+        if(rpc_systems[i].free) {
+            (rpc_systems[i].free)(session->system_contexts[i]);
         }
-        free(session->system_contexts);
-        free(session->decoded_message);
-        RpcHandlerDict_clear(session->handlers);
-        furi_stream_buffer_free(session->stream);
+    }
+    free(session->system_contexts);
+    free(session->decoded_message);
+    RpcHandlerDict_clear(session->handlers);
+    furi_stream_buffer_free(session->stream);
 
-        furi_mutex_acquire(session->callbacks_mutex, FuriWaitForever);
-        if(session->terminated_callback) {
-            session->terminated_callback(session->context);
-        }
-        furi_mutex_release(session->callbacks_mutex);
+    furi_mutex_acquire(session->callbacks_mutex, FuriWaitForever);
+    if(session->terminated_callback) {
+        session->terminated_callback(session->context);
+    }
+    furi_mutex_release(session->callbacks_mutex);
 
-        furi_mutex_free(session->callbacks_mutex);
-        furi_thread_free(thread);
-        free(session);
+    furi_mutex_free(session->callbacks_mutex);
+    furi_thread_join(session->thread);
+    furi_thread_free(session->thread);
+    free(session);
+}
+
+static void
+    rpc_session_thread_state_callback(FuriThread* thread, FuriThreadState state, void* context) {
+    UNUSED(thread);
+    if(state == FuriThreadStateStopped) {
+        furi_timer_pending_callback(rpc_session_thread_pending_callback, context, 0);
     }
 }
 
@@ -404,14 +409,12 @@ RpcSession* rpc_session_open(Rpc* rpc, RpcOwner owner) {
     };
     rpc_add_handler(session, PB_Main_stop_session_tag, &rpc_handler);
 
-    FuriThread* thread =
-        furi_thread_alloc_ex("RpcSessionWorker", 3072, rpc_session_worker, session);
-    session->thread_id = furi_thread_get_id(thread);
+    session->thread = furi_thread_alloc_ex("RpcSessionWorker", 3072, rpc_session_worker, session);
 
-    furi_thread_set_state_context(thread, session);
-    furi_thread_set_state_callback(thread, rpc_session_thread_release_callback);
+    furi_thread_set_state_context(session->thread, session);
+    furi_thread_set_state_callback(session->thread, rpc_session_thread_state_callback);
 
-    furi_thread_start(thread);
+    furi_thread_start(session->thread);
 
     return session;
 }
@@ -423,7 +426,7 @@ void rpc_session_close(RpcSession* session) {
     rpc_session_set_send_bytes_callback(session, NULL);
     rpc_session_set_close_callback(session, NULL);
     rpc_session_set_buffer_is_empty_callback(session, NULL);
-    furi_thread_flags_set(session->thread_id, RpcEvtDisconnect);
+    furi_thread_flags_set(furi_thread_get_id(session->thread), RpcEvtDisconnect);
 }
 
 void rpc_on_system_start(void* p) {