more work

Author: radare

doc/BGPLAN.md

@@ -0,0 +1,53 @@
+⏺ Background Task System Implementation Plan
+
+  1. Task Priority System
+
+  - Create an enum class TaskPriority with levels: Critical, High, Normal, Low
+  - Add priority to AsyncTask to allow scheduling based on importance
+  - Make analysis tasks lower priority than UI-responsive commands
+
+  2. Enhanced Task Manager
+
+  - Develop a centralized TaskManager to replace the current AsyncTaskManager
+  - Implement concurrent command queues with priority scheduling
+  - Use mutex for radare2 API access for thread safety
+  - Add task dependencies to prevent race conditions
+
+  3. Command Queue System
+
+  - Create a serialized command queue for radare2 commands
+  - Implement mutex-protected access to radare2 API
+  - Allow UI thread to post quick commands with higher priority
+
+  4. Specific Implementation for Key Features
+
+  Analysis Tasks:
+  - Move initial analysis (aa/aaa/aaaa) to background thread
+  - Add progress reporting via signals
+  - Allow task interruption with proper cleanup
+
+  Debugger Operations:
+  - Queue stepping/continuation commands
+  - Allow UI interaction during long-running debug operations
+  - Implement cancellation for breakpoint resolution
+
+  Decompilation:
+  - Run decompilers in separate threads
+  - Add caching for faster repeat access
+  - Enable result streaming for large functions
+
+  R2AI Requests:
+  - Execute network requests asynchronously
+  - Add timeout and retry handling
+  - Provide real-time progress indicators
+
+  5. UI Integration
+
+  - Add persistent task status indicator to main UI
+  - Create task queue inspector widget
+  - Implement per-task progress reporting
+  - Add notification system for task completion
+
+  This approach maintains radare2's thread safety while allowing heavy operations to run in background without freezing
+  the UI.
+

src/Iaito.pro

@@ -400,6 +400,7 @@ SOURCES += \
     widgets/ZignaturesWidget.cpp \
     common/AsyncTask.cpp \
     dialogs/AsyncTaskDialog.cpp \
+    common/UiInitTask.cpp \
     widgets/StackWidget.cpp \
     widgets/RegistersWidget.cpp \
     widgets/ThreadsWidget.cpp \
@@ -576,6 +577,7 @@ HEADERS  += \
     widgets/ZignaturesWidget.h \
     common/AsyncTask.h \
     dialogs/AsyncTaskDialog.h \
+    common/UiInitTask.h \
     widgets/StackWidget.h \
     widgets/RegistersWidget.h \
     widgets/ThreadsWidget.h \

src/common/UiInitTask.cpp

@@ -0,0 +1,24 @@
+ #include "UiInitTask.h"
+ #include "core/Iaito.h"
+ #include "core/MainWindow.h"
+ #include <QMetaObject>
+
+ UiInitTask::UiInitTask(MainWindow *main)
+     : Task(QObject::tr("UI Initialization"), TaskPriority::Low)
+     , m_main(main)
+ {
+     setCancellable(false);
+ }
+
+ void UiInitTask::run() {
+     // Load opcodes and update seek position
+     Core()->getOpcodes();
+     Core()->updateSeek();
+     // Trigger all panel refreshes
+     QMetaObject::invokeMethod(m_main, "refreshAll", Qt::QueuedConnection);
+     // Show fortune message
+     QString fortune = Core()->cmdRaw("fo");
+     if (!fortune.isEmpty()) {
+         Core()->message("\n" + fortune);
+     }
+ }

src/common/UiInitTask.h

@@ -0,0 +1,20 @@
+ #ifndef UIINITTASK_H
+ #define UIINITTASK_H
+
+ #include "common/TaskManager.h"
+ #include <QObject>
+
+ class MainWindow;
+
+ /**
+  * Background task to initialize UI data (opcodes, seek, panels) after main window shows.
+  */
+ class UiInitTask : public Task {
+     Q_OBJECT
+     MainWindow *m_main;
+ public:
+     explicit UiInitTask(MainWindow *main);
+     void run() override;
+ };
+
+ #endif // UIINITTASK_H

src/core/Iaito.cpp

@@ -151,9 +151,22 @@ static QString fromOwnedCharPtr(char *str)
     return result;
 }
 
+// Static control for core mutex locking (enabled by default)
+bool RCoreLocked::s_enabled = true;
+/** Enable or disable the global core mutex lock */
+void RCoreLocked::setEnabled(bool enabled) { s_enabled = enabled; }
+/** Check if the global core mutex lock is enabled */
+bool RCoreLocked::isEnabled() { return s_enabled; }
+
 RCoreLocked::RCoreLocked(IaitoCore *core)
     : core(core)
 {
+#if 0
+    // locking is controlled by s_enabled
+#endif
+    if (!RCoreLocked::s_enabled) {
+        return;
+    }
     core->coreMutex.lock();
 #if R2_VERSION_NUMBER < 50609
     assert(core->coreLockDepth >= 0);
@@ -169,6 +182,9 @@ RCoreLocked::RCoreLocked(IaitoCore *core)
 
 RCoreLocked::~RCoreLocked()
 {
+    if (!RCoreLocked::s_enabled) {
+        return;
+    }
     core->coreLockDepth--;
 #if R2_VERSION_NUMBER < 50609
     assert(core->coreLockDepth >= 0);
@@ -208,6 +224,13 @@ IaitoCore *IaitoCore::instance()
 {
     return uniqueInstance;
 }
+// -- Core lock control APIs -----------------------------------------------
+void IaitoCore::setCoreLockEnabled(bool enabled) {
+    RCoreLocked::setEnabled(enabled);
+}
+bool IaitoCore::isCoreLockEnabled() {
+    return RCoreLocked::isEnabled();
+}
 
 void IaitoCore::initialize(bool loadPlugins)
 {

src/core/Iaito.h

@@ -62,6 +62,16 @@ class IAITO_EXPORT IaitoCore : public QObject
     explicit IaitoCore(QObject *parent = nullptr);
     ~IaitoCore();
     static IaitoCore *instance();
+    /**
+     * @brief Enable or disable the global core mutex lock
+     * @param enabled true to enable locking, false to disable
+     */
+    static void setCoreLockEnabled(bool enabled);
+    /**
+     * @brief Check if the global core mutex lock is enabled
+     * @return true if locking is enabled, false otherwise
+     */
+    static bool isCoreLockEnabled();
 
     void initialize(bool loadPlugins = true);
     void loadIaitoRC(int n);
@@ -817,13 +827,26 @@ class IAITO_EXPORT RCoreLocked
     IaitoCore *const core;
 
 public:
+    /**
+     * Enable or disable the global core mutex lock usage.
+     * When disabled, CORE_LOCK() calls become no-ops.
+     */
+    static void setEnabled(bool enabled);
+    /**
+     * Check whether the global core mutex lock is enabled.
+     */
+    static bool isEnabled();
+    
     explicit RCoreLocked(IaitoCore *core);
     RCoreLocked(const RCoreLocked &) = delete;
     RCoreLocked &operator=(const RCoreLocked &) = delete;
     RCoreLocked(RCoreLocked &&);
     ~RCoreLocked();
     operator RCore *() const;
     RCore *operator->() const;
+private:
+    /** Internal flag to control locking behavior */
+    static bool s_enabled;
 };
 
 #if R2_VERSION_NUMBER >= 50909

src/core/MainWindow.cpp

@@ -74,6 +74,8 @@
 #include "widgets/VTablesWidget.h"
 #include "widgets/VisualNavbar.h"
 #include "widgets/ZignaturesWidget.h"
+#include "common/UiInitTask.h"
+#include "common/TaskManager.h"
 
 // Qt Headers
 #include <QActionGroup>
@@ -725,12 +727,10 @@ void MainWindow::openProject(const QString &project_name)
 
 void MainWindow::finalizeOpen()
 {
-    // These operations are quick and should be done immediately
-    core->getOpcodes();
-    core->updateSeek();
-    refreshAll();
-    // Add fortune message
-    core->message("\n" + core->cmdRaw("fo"));
+    // Schedule background UI initialization (opcodes, panels refresh, fortune)
+    // Background initialize opcodes, refresh panels, and show fortune
+    TaskManager::getInstance()->startTask(
+        Task::Ptr(new UiInitTask(this)));
 
     // hide all docks before showing window to avoid false positive for
     // refreshDeferrer

src/dialogs/InitialOptionsDialog.cpp

@@ -13,6 +13,7 @@
 #include <QFileDialog>
 #include <QFileInfo>
 #include <QSettings>
+#include <QTimer> // For scheduling main window initialization after dialog closes
 
 #include "common/AnalTask.h"
 #include "core/Iaito.h"
@@ -369,8 +370,8 @@ void InitialOptionsDialog::setupAndStartAnalysis()
     // Close the dialog now that the task is started
     done(0);
 
-    // Call finalizeOpen to set up UI before analysis is complete
-    mainWindow->finalizeOpen();
+    // Schedule main window initialization after dialog is closed
+    QTimer::singleShot(0, mainWindow, &MainWindow::finalizeOpen);
 }
 
 void InitialOptionsDialog::on_okButton_clicked()