[FL-781] FURI, CLI, stdlib: stdout hooks, integration between subsystems, uniform printf usage (#311)

* FURI stdglue: stdout hooks, local and global, ISR safe printf. Uniform newlines for terminal/debug output. Power: prevent sleep while core 2 has not started.
* Furi record, stdglue: check mutex allocation
* remove unused test
* Furi stdglue: buferized output, dynamically allocated state. Furi record: dynamically allocated state. Input dump: proper line ending. Hal VCP: dynamically allocated state.
* Interrupt manager: explicitly init list.
* Makefile: cleanup rules, fix broken dfu upload. F4: add compiler stack protection options.
* BLE: call debug uart callback on transmission complete
* FreeRTOS: add configUSE_NEWLIB_REENTRANT
* API HAL Timebase: fix issue with idle thread stack corruption caused by systick interrupt. BT: cleanup debug info output. FreeRTOS: disable reentry for newlib.
* F4: update stack protection CFLAGS to match used compiller
* F4: disable compiller stack protection because of incompatibility with current compiller
* Makefile: return openocd logs to gdb
* BLE: fixed pin, moar power, ble trace info.
* Prevent sleep when connection is active
* Makefile: return serial port to upload rule, add workaround for mac os
* Furi: prevent usage of stack for cmsis functions.
* F4: add missing includes, add debugger breakpoints
* Applications: per app stack size.
* Furi: honor kernel state in stdglue
* FreeRTOS: remove unused hooks
* Cleanup and format sources

Co-authored-by: DrZlo13 <who.just.the.doctor@gmail.com>

core/furi/stdglue.c

@@ -1,12 +1,57 @@
 #include "stdglue.h"
-#include <main.h>
+#include "check.h"
+#include "memmgr.h"
 
+#include <main.h>
+#include <cmsis_os2.h>
 #include <stdio.h>
 #include <string.h>
+#include <m-dict.h>
 
 extern UART_HandleTypeDef DEBUG_UART;
 
+DICT_DEF2(
+    FuriStdglueCallbackDict,
+    uint32_t,
+    M_DEFAULT_OPLIST,
+    FuriStdglueWriteCallback,
+    M_PTR_OPLIST)
+
+typedef struct {
+    osMutexId_t mutex;
+    FuriStdglueCallbackDict_t global_outputs;
+    FuriStdglueCallbackDict_t thread_outputs;
+} FuriStdglue;
+
+static FuriStdglue* furi_stdglue = NULL;
+
 static ssize_t stdout_write(void* _cookie, const char* data, size_t size) {
+    assert(furi_stdglue);
+    osKernelState_t state = osKernelGetState();
+    osThreadId_t thread_id = osThreadGetId();
+    if(state == osKernelRunning && thread_id &&
+       osMutexAcquire(furi_stdglue->mutex, osWaitForever) == osOK) {
+        // We are in the thread context
+        // Handle global callbacks
+        FuriStdglueCallbackDict_it_t it;
+        for(FuriStdglueCallbackDict_it(it, furi_stdglue->global_outputs);
+            !FuriStdglueCallbackDict_end_p(it);
+            FuriStdglueCallbackDict_next(it)) {
+            osThreadId_t it_thread = (osThreadId_t)FuriStdglueCallbackDict_ref(it)->key;
+            FuriStdglueWriteCallback it_callback = FuriStdglueCallbackDict_ref(it)->value;
+            if(thread_id != it_thread) {
+                it_callback(_cookie, data, size);
+            }
+        }
+        // Handle thread callbacks
+        FuriStdglueWriteCallback* callback_ptr =
+            FuriStdglueCallbackDict_get(furi_stdglue->thread_outputs, (uint32_t)thread_id);
+        if(callback_ptr) {
+            (*callback_ptr)(_cookie, data, size);
+        }
+        furi_check(osMutexRelease(furi_stdglue->mutex) == osOK);
+    }
+    // Flush
     if(data == 0) {
         /*
          * This means that we should flush internal buffers.  Since we
@@ -15,13 +60,20 @@ static ssize_t stdout_write(void* _cookie, const char* data, size_t size) {
          */
         return 0;
     }
-
+    // Debug uart
     HAL_UART_Transmit(&DEBUG_UART, (uint8_t*)data, (uint16_t)size, HAL_MAX_DELAY);
-
+    // All data consumed
     return size;
 }
 
-bool furi_stdglue_init() {
+void furi_stdglue_init() {
+    furi_stdglue = furi_alloc(sizeof(FuriStdglue));
+    // Init outputs structures
+    furi_stdglue->mutex = osMutexNew(NULL);
+    furi_check(furi_stdglue->mutex);
+    FuriStdglueCallbackDict_init(furi_stdglue->global_outputs);
+    FuriStdglueCallbackDict_init(furi_stdglue->thread_outputs);
+    // Prepare and set stdout descriptor
     FILE* fp = fopencookie(
         NULL,
         "w",
@@ -31,8 +83,42 @@ bool furi_stdglue_init() {
             .seek = NULL,
             .close = NULL,
         });
-    setvbuf(fp, NULL, _IONBF, 0);
+    setvbuf(fp, NULL, _IOLBF, 0);
     stdout = fp;
-
-    return true;
+}
+
+bool furi_stdglue_set_global_stdout_callback(FuriStdglueWriteCallback callback) {
+    assert(furi_stdglue);
+    osThreadId_t thread_id = osThreadGetId();
+    if(thread_id) {
+        furi_check(osMutexAcquire(furi_stdglue->mutex, osWaitForever) == osOK);
+        if(callback) {
+            FuriStdglueCallbackDict_set_at(
+                furi_stdglue->global_outputs, (uint32_t)thread_id, callback);
+        } else {
+            FuriStdglueCallbackDict_erase(furi_stdglue->global_outputs, (uint32_t)thread_id);
+        }
+        furi_check(osMutexRelease(furi_stdglue->mutex) == osOK);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool furi_stdglue_set_thread_stdout_callback(FuriStdglueWriteCallback callback) {
+    assert(furi_stdglue);
+    osThreadId_t thread_id = osThreadGetId();
+    if(thread_id) {
+        furi_check(osMutexAcquire(furi_stdglue->mutex, osWaitForever) == osOK);
+        if(callback) {
+            FuriStdglueCallbackDict_set_at(
+                furi_stdglue->thread_outputs, (uint32_t)thread_id, callback);
+        } else {
+            FuriStdglueCallbackDict_erase(furi_stdglue->thread_outputs, (uint32_t)thread_id);
+        }
+        furi_check(osMutexRelease(furi_stdglue->mutex) == osOK);
+        return true;
+    } else {
+        return false;
+    }
 }