task.c File Reference

#include <rz_core.h>

Go to the source code of this file.

Classes
struct	oneshot_t
struct	core_task_ctx_t
struct	cmd_task_ctx_t
struct	function_task_ctx_t

Macros
#define	TASK_SIGSET_T   void *

Typedefs
typedef struct oneshot_t	OneShot
typedef struct core_task_ctx_t	CoreTaskCtx
typedef struct cmd_task_ctx_t	CmdTaskCtx
typedef struct function_task_ctx_t	FunctionTaskCtx

Functions
RZ_API void	rz_core_task_scheduler_init (RzCoreTaskScheduler *sched, RzCoreTaskContextSwitch ctx_switch, void *ctx_switch_user, RzCoreTaskBreak break_cb, void *break_cb_user)
RZ_API void	rz_core_task_scheduler_fini (RzCoreTaskScheduler *tasks)
static void	tasks_lock_block_signals (TASK_SIGSET_T *old_sigset)
static void	tasks_lock_block_signals_reset (TASK_SIGSET_T *old_sigset)
static void	tasks_lock_enter (RzCoreTaskScheduler *scheduler, TASK_SIGSET_T *old_sigset)
static void	tasks_lock_leave (RzCoreTaskScheduler *scheduler, TASK_SIGSET_T *old_sigset)
RZ_API int	rz_core_task_running_tasks_count (RzCoreTaskScheduler *scheduler)
static void	task_join (RzCoreTask *task)
RZ_API void	rz_core_task_join (RzCoreTaskScheduler *scheduler, RzCoreTask *current, int id)
static void	task_free (RzCoreTask *task)
RZ_API RzCoreTask *	rz_core_task_new (RzCoreTaskScheduler *sched, RzCoreTaskRunner runner, RzCoreTaskRunnerFree runner_free, void *runner_user)
RZ_API void	rz_core_task_incref (RzCoreTask *task)
RZ_API void	rz_core_task_decref (RzCoreTask *task)
static void	cleanup_transient (RzCoreTaskScheduler *sched, RzCoreTask *exclude)
RZ_API void	rz_core_task_schedule (RzCoreTask *current, RzTaskState next_state)
static void	task_wakeup (RzCoreTask *current)
RZ_API void	rz_core_task_yield (RzCoreTaskScheduler *scheduler)
static void	task_end (RzCoreTask *t)
static void *	task_run_thread (RzCoreTask *task)
RZ_API void	rz_core_task_enqueue (RzCoreTaskScheduler *scheduler, RzCoreTask *task)
RZ_API void	rz_core_task_enqueue_oneshot (RzCoreTaskScheduler *scheduler, RzCoreTaskOneShot func, void *user)
RZ_API int	rz_core_task_run_sync (RzCoreTaskScheduler *scheduler, RzCoreTask *task)
RZ_API void	rz_core_task_sync_begin (RzCoreTaskScheduler *scheduler)
RZ_API void	rz_core_task_sync_end (RzCoreTaskScheduler *scheduler)
RZ_API void	rz_core_task_sleep_begin (RzCoreTask *task)
RZ_API void	rz_core_task_sleep_end (RzCoreTask *task)
RZ_API RzCoreTask *	rz_core_task_self (RzCoreTaskScheduler *scheduler)
static RzCoreTask *	task_get (RzCoreTaskScheduler *scheduler, int id)
RZ_API RzCoreTask *	rz_core_task_get_incref (RzCoreTaskScheduler *scheduler, int id)
static void	task_break (RzCoreTask *task)
RZ_API void	rz_core_task_break (RzCoreTaskScheduler *scheduler, int id)
RZ_API void	rz_core_task_break_all (RzCoreTaskScheduler *scheduler)
RZ_API int	rz_core_task_del (RzCoreTaskScheduler *scheduler, int id)
static bool	core_task_ctx_init (CoreTaskCtx *ctx, RzCore *core)
static void	core_task_ctx_fini (CoreTaskCtx *ctx)
static CmdTaskCtx *	cmd_task_ctx_new (RzCore *core, const char *cmd, RzCoreCmdTaskFinished finished_cb, void *finished_cb_user)
static void	cmd_task_runner (RzCoreTaskScheduler *sched, void *user)
static void	cmd_task_free (CmdTaskCtx *ctx)
RZ_API RzCoreTask *	rz_core_cmd_task_new (RzCore *core, const char *cmd, RzCoreCmdTaskFinished finished_cb, void *finished_cb_user)
RZ_API const char *	rz_core_cmd_task_get_result (RzCoreTask *task)
static FunctionTaskCtx *	function_task_ctx_new (RzCore *core, RzCoreTaskFunction fcn, void *fcn_user)
static void	function_task_runner (RzCoreTaskScheduler *sched, void *user)
static void	function_task_free (FunctionTaskCtx *ctx)
RZ_API RzCoreTask *	rz_core_function_task_new (RzCore *core, RzCoreTaskFunction fcn, void *fcn_user)
RZ_API void *	rz_core_function_task_get_result (RzCoreTask *task)
RZ_IPI void	rz_core_task_ctx_switch (RzCoreTask *next, void *user)
RZ_IPI void	rz_core_task_break_cb (RzCoreTask *task, void *user)
RZ_API const char *	rz_core_task_status (RzCoreTask *task)
RZ_API void	rz_core_task_print (RzCore *core, RzCoreTask *task, int mode, PJ *j)
RZ_API void	rz_core_task_list (RzCore *core, int mode)
RZ_API bool	rz_core_task_is_cmd (RzCore *core, int id)
RZ_API void	rz_core_task_del_all_done (RzCore *core)

Macro Definition Documentation

TASK_SIGSET_T

#define TASK_SIGSET_T   void *

Definition at line 47 of file task.c.

Typedef Documentation

CmdTaskCtx

typedef struct cmd_task_ctx_t CmdTaskCtx

Context for (user-visible) command tasks

CoreTaskCtx

typedef struct core_task_ctx_t CoreTaskCtx

Common base for all contexts of tasks in core. Must be the first member of every task context!

FunctionTaskCtx

typedef struct function_task_ctx_t FunctionTaskCtx

Context for (user-invisible) function tasks

OneShot

typedef struct oneshot_t OneShot

Function Documentation

cleanup_transient()

static void cleanup_transient ( RzCoreTaskScheduler *  sched, RzCoreTask *  exclude  )

static

Delete all done, transient, non-current jobs that have not been deleted yet.

Definition at line 217 of file task.c.

                                                                               {
    RzCoreTask *ltask;
    RzListIter *iter;
    RzListIter *iter_tmp;
    rz_list_foreach_safe (sched->tasks, iter, iter_tmp, ltask) {
        if (ltask == exclude) {
            continue;
        }
        if (ltask->transient && ltask->state == RZ_CORE_TASK_STATE_DONE) {
            rz_list_delete(sched->tasks, iter);
        }
    }
}

References rz_list_delete(), and rz_core_tasks_t::tasks.

Referenced by rz_core_task_schedule().

cmd_task_ctx_new()

static CmdTaskCtx* cmd_task_ctx_new ( RzCore *  core, const char *  cmd, RzCoreCmdTaskFinished  finished_cb, void *  finished_cb_user  )

static

Definition at line 575 of file task.c.

                                                                                                                              {
    rz_return_val_if_fail(cmd, NULL);
    CmdTaskCtx *ctx = RZ_NEW(CmdTaskCtx);
    if (!ctx) {
        return NULL;
    }
    if (!core_task_ctx_init(&ctx->core_ctx, core)) {
        free(ctx);
        return NULL;
    }
    ctx->cmd = strdup(cmd);
    ctx->cmd_log = false;
    ctx->res = NULL;
    ctx->finished_cb = finished_cb;
    ctx->finished_cb_user = finished_cb_user;
    return ctx;
}

References cmd, core_task_ctx_init(), free(), NULL, RZ_NEW, rz_return_val_if_fail, and strdup().

Referenced by rz_core_cmd_task_new().

cmd_task_free()

static void cmd_task_free ( CmdTaskCtx *  ctx )

static

Definition at line 615 of file task.c.

                                           {
    if (!ctx) {
        return;
    }
    free(ctx->cmd);
    free(ctx->res);
    core_task_ctx_fini(&ctx->core_ctx);
    free(ctx);
}

References core_task_ctx_fini(), and free().

Referenced by rz_core_cmd_task_new().

cmd_task_runner()

static void cmd_task_runner ( RzCoreTaskScheduler *  sched, void *  user  )

static

Definition at line 593 of file task.c.

                                                                    {
    CmdTaskCtx *ctx = user;
    RzCore *core = ctx->core_ctx.core;
    RzCoreTask *task = rz_core_task_self(sched);
    char *res_str;
    if (task == sched->main_task) {
        rz_core_cmd(core, ctx->cmd, ctx->cmd_log);
        res_str = NULL;
    } else {
        res_str = rz_core_cmd_str(core, ctx->cmd);
    }
    ctx->res = res_str;
 
    if (ctx->finished_cb) {
        ctx->finished_cb(res_str, ctx->finished_cb_user);
    }
 
    if (task != sched->main_task && rz_cons_default_context_is_interactive()) {
        eprintf("\nTask %d finished\n", task->id);
    }
}

References eprintf, rz_core_tasks_t::main_task, NULL, rz_cons_default_context_is_interactive(), rz_core_cmd(), rz_core_cmd_str(), and rz_core_task_self().

Referenced by rz_core_cmd_task_get_result(), rz_core_cmd_task_new(), rz_core_task_del_all_done(), rz_core_task_is_cmd(), and rz_core_task_print().

core_task_ctx_fini()

static void core_task_ctx_fini ( CoreTaskCtx *  ctx )

static

Definition at line 556 of file task.c.

                                                 {
    if (ctx->cons_context && ctx->cons_context->break_stack) {
        rz_cons_context_break_pop(ctx->cons_context, false);
    }
    rz_cons_context_free(ctx->cons_context);
}

References rz_cons_context_break_pop(), and rz_cons_context_free().

Referenced by cmd_task_free(), and function_task_free().

core_task_ctx_init()

static bool core_task_ctx_init ( CoreTaskCtx *  ctx, RzCore *  core  )

static

Definition at line 545 of file task.c.

                                                               {
    ctx->core = core;
    ctx->cons_context = rz_cons_context_new(rz_cons_singleton()->context);
    if (!ctx->cons_context) {
        return false;
    }
    ctx->cons_context->cmd_depth = core->max_cmd_depth;
    rz_cons_context_break_push(ctx->cons_context, NULL, NULL, false);
    return true;
}

References rz_core_t::max_cmd_depth, NULL, rz_cons_context_break_push(), rz_cons_context_new(), and rz_cons_singleton().

Referenced by cmd_task_ctx_new(), and function_task_ctx_new().

function_task_ctx_new()

static FunctionTaskCtx* function_task_ctx_new ( RzCore *  core, RzCoreTaskFunction  fcn, void *  fcn_user  )

static

Definition at line 665 of file task.c.

                                                                                                    {
    FunctionTaskCtx *ctx = RZ_NEW(FunctionTaskCtx);
    if (!ctx) {
        return NULL;
    }
    if (!core_task_ctx_init(&ctx->core_ctx, core)) {
        free(ctx);
        return NULL;
    }
    ctx->fcn = fcn;
    ctx->fcn_user = fcn_user;
    ctx->res = NULL;
    return ctx;
}

References core_task_ctx_init(), free(), NULL, and RZ_NEW.

Referenced by rz_core_function_task_new().

function_task_free()

static void function_task_free ( FunctionTaskCtx *  ctx )

static

Definition at line 688 of file task.c.

                                                     {
    if (!ctx) {
        return;
    }
    core_task_ctx_fini(&ctx->core_ctx);
    free(ctx);
}

References core_task_ctx_fini(), and free().

Referenced by rz_core_function_task_new().

function_task_runner()

static void function_task_runner ( RzCoreTaskScheduler *  sched, void *  user  )

static

Definition at line 680 of file task.c.

                                                                         {
    FunctionTaskCtx *ctx = user;
    RzCore *core = ctx->core_ctx.core;
    rz_cons_push();
    ctx->res = ctx->fcn(core, ctx->fcn_user);
    rz_cons_pop();
}

References rz_cons_pop(), and rz_cons_push().

Referenced by rz_core_function_task_get_result(), and rz_core_function_task_new().

rz_core_cmd_task_get_result()

RZ_API const char* rz_core_cmd_task_get_result

(

RzCoreTask *

task

)

Get the result of the command that was run in a task created with rz_core_cmd_task_new. If the task is not a command task, returns NULL.

Definition at line 646 of file task.c.

                                                                 {
    // Check if this is really a command task
    if (!task->runner_user || task->runner != cmd_task_runner) {
        return NULL;
    }
    CmdTaskCtx *ctx = task->runner_user;
    return ctx->res;
}

References cmd_task_runner(), and NULL.

Referenced by task_output().

rz_core_cmd_task_new()

RZ_API RzCoreTask* rz_core_cmd_task_new	(	RzCore *	core,
		const char *	cmd,
		RzCoreCmdTaskFinished	finished_cb,
		void *	finished_cb_user
	)

Create a new task that runs a command and saves its result. These tasks are user-visible under the & command family.

Definition at line 629 of file task.c.

                                                                                                                                  {
    CmdTaskCtx *ctx = cmd_task_ctx_new(core, cmd, finished_cb, finished_cb_user);
    if (!ctx) {
        return NULL;
    }
    RzCoreTask *task = rz_core_task_new(&core->tasks, cmd_task_runner, (RzCoreTaskRunnerFree)cmd_task_free, ctx);
    if (!task) {
        cmd_task_free(ctx);
        return NULL;
    }
    return task;
}

References cmd, cmd_task_ctx_new(), cmd_task_free(), cmd_task_runner(), NULL, rz_core_task_new(), and rz_core_t::tasks.

Referenced by task_enqueue().

rz_core_function_task_get_result()

RZ_API void* rz_core_function_task_get_result

(

RzCoreTask *

task

)

Get the return value of the function that was run in a task created with rz_core_function_task_new. If the task is not a function task, returns NULL.

Definition at line 718 of file task.c.

                                                                {
    // Check if this is really a command task
    if (!task->runner_user || task->runner != function_task_runner) {
        return NULL;
    }
    FunctionTaskCtx *ctx = task->runner_user;
    return ctx->res;
}

References function_task_runner(), and NULL.

rz_core_function_task_new()

RZ_API RzCoreTask* rz_core_function_task_new	(	RzCore *	core,
		RzCoreTaskFunction	fcn,
		void *	fcn_user
	)

Create a new task that runs a custom function and saves its result. These tasks are not user-visible.

Definition at line 700 of file task.c.

                                                                                                   {
    FunctionTaskCtx *ctx = function_task_ctx_new(core, fcn, fcn_user);
    if (!ctx) {
        return NULL;
    }
    RzCoreTask *task = rz_core_task_new(&core->tasks, function_task_runner,
        (RzCoreTaskRunnerFree)function_task_free, ctx);
    if (!task) {
        function_task_free(ctx);
        return NULL;
    }
    return task;
}

References function_task_ctx_new(), function_task_free(), function_task_runner(), NULL, rz_core_task_new(), and rz_core_t::tasks.

rz_core_task_break()

RZ_API void rz_core_task_break	(	RzCoreTaskScheduler *	scheduler,
		int	id
	)

Definition at line 483 of file task.c.

                                                                       {
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(scheduler, &old_sigset);
    RzCoreTask *task = task_get(scheduler, id);
    if (!task || task->state == RZ_CORE_TASK_STATE_DONE) {
        tasks_lock_leave(scheduler, &old_sigset);
        return;
    }
    task_break(task);
    tasks_lock_leave(scheduler, &old_sigset);
}

References task_break(), task_get(), TASK_SIGSET_T, tasks_lock_enter(), and tasks_lock_leave().

Referenced by task_break().

rz_core_task_break_all()

RZ_API void rz_core_task_break_all

(

RzCoreTaskScheduler *

scheduler

)

Definition at line 495 of file task.c.

                                                                   {
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(scheduler, &old_sigset);
    RzCoreTask *task;
    RzListIter *iter;
    rz_list_foreach (scheduler->tasks, iter, task) {
        if (task->state != RZ_CORE_TASK_STATE_DONE) {
            task_break(task);
        }
    }
    tasks_lock_leave(scheduler, &old_sigset);
}

References task_break(), TASK_SIGSET_T, rz_core_tasks_t::tasks, tasks_lock_enter(), and tasks_lock_leave().

Referenced by rz_core_fini(), and rz_main_rizin().

rz_core_task_break_cb()

RZ_IPI void rz_core_task_break_cb	(	RzCoreTask *	task,
		void *	user
	)

Definition at line 738 of file task.c.

                                                                {
    CoreTaskCtx *ctx = task->runner_user;
    rz_cons_context_break(ctx ? ctx->cons_context : NULL);
}

References NULL, and rz_cons_context_break().

Referenced by rz_core_init().

rz_core_task_ctx_switch()

RZ_IPI void rz_core_task_ctx_switch	(	RzCoreTask *	next,
		void *	user
	)

Definition at line 727 of file task.c.

                                                                  {
    if (next->runner_user) {
        CoreTaskCtx *ctx = next->runner_user;
        if (ctx->cons_context) {
            rz_cons_context_load(ctx->cons_context);
            return;
        }
    }
    rz_cons_context_reset();
}

References rz_cons_context_load(), and rz_cons_context_reset().

Referenced by rz_core_init().

rz_core_task_decref()

RZ_API void rz_core_task_decref

(

RzCoreTask *

task

)

Definition at line 200 of file task.c.

                                                  {
    if (!task) {
        return;
    }
    TASK_SIGSET_T old_sigset;
    RzCoreTaskScheduler *sched = task->sched;
    tasks_lock_enter(sched, &old_sigset);
    task->refcount--;
    if (task->refcount <= 0) {
        task_free(task);
    }
    tasks_lock_leave(sched, &old_sigset);
}

References task_free(), TASK_SIGSET_T, tasks_lock_enter(), and tasks_lock_leave().

Referenced by rz_core_task_is_cmd(), rz_core_task_join(), rz_core_task_scheduler_init(), and task_output().

rz_core_task_del()

RZ_API int rz_core_task_del	(	RzCoreTaskScheduler *	scheduler,
		int	id
	)

Definition at line 508 of file task.c.

                                                                    {
    RzCoreTask *task;
    RzListIter *iter;
    bool ret = false;
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(scheduler, &old_sigset);
    rz_list_foreach (scheduler->tasks, iter, task) {
        if (task->id == id) {
            if (task == scheduler->main_task) {
                break;
            }
            if (task->state == RZ_CORE_TASK_STATE_DONE) {
                rz_list_delete(scheduler->tasks, iter);
            } else {
                task->transient = true;
            }
            ret = true;
            break;
        }
    }
    tasks_lock_leave(scheduler, &old_sigset);
    return ret;
}

References rz_core_tasks_t::main_task, rz_list_delete(), TASK_SIGSET_T, rz_core_tasks_t::tasks, tasks_lock_enter(), and tasks_lock_leave().

Referenced by rz_tasks_delete_handler().

rz_core_task_del_all_done()

RZ_API void rz_core_task_del_all_done

(

RzCore *

core

)

Definition at line 844 of file task.c.

                                                    {
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(&core->tasks, &old_sigset);
    RzCoreTaskScheduler *sched = &core->tasks;
    RzCoreTask *task;
    RzListIter *iter, *iter2;
    rz_list_foreach_safe (sched->tasks, iter, iter2, task) {
        if (task != sched->main_task && task->state == RZ_CORE_TASK_STATE_DONE && task->runner == cmd_task_runner) {
            rz_list_delete(sched->tasks, iter);
        }
    }
    tasks_lock_leave(&core->tasks, &old_sigset);
}

References cmd_task_runner(), rz_core_tasks_t::main_task, rz_list_delete(), TASK_SIGSET_T, rz_core_tasks_t::tasks, rz_core_t::tasks, tasks_lock_enter(), and tasks_lock_leave().

Referenced by rz_tasks_delete_all_handler().

rz_core_task_enqueue()

RZ_API void rz_core_task_enqueue	(	RzCoreTaskScheduler *	scheduler,
		RzCoreTask *	task
	)

Definition at line 374 of file task.c.

                                                                                   {
    if (!scheduler || !task) {
        return;
    }
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(scheduler, &old_sigset);
    if (!task->running_sem) {
        task->running_sem = rz_th_sem_new(1);
    }
    if (task->running_sem) {
        rz_th_sem_wait(task->running_sem);
    }
    rz_list_append(scheduler->tasks, task);
    task->thread = rz_th_new((RzThreadFunction)task_run_thread, task);
    tasks_lock_leave(scheduler, &old_sigset);
}

References rz_list_append(), rz_th_new(), rz_th_sem_new(), rz_th_sem_wait(), task_run_thread(), TASK_SIGSET_T, rz_core_tasks_t::tasks, tasks_lock_enter(), and tasks_lock_leave().

Referenced by task_enqueue().

rz_core_task_enqueue_oneshot()

RZ_API void rz_core_task_enqueue_oneshot	(	RzCoreTaskScheduler *	scheduler,
		RzCoreTaskOneShot	func,
		void *	user
	)

Definition at line 391 of file task.c.

                                                                                                             {
    if (!scheduler || !func) {
        return;
    }
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(scheduler, &old_sigset);
    if (scheduler->tasks_running == 0) {
        // nothing is running right now and no other task can be scheduled
        // while core->tasks_lock is locked => just run it
        scheduler->oneshot_running = true;
        func(user);
        scheduler->oneshot_running = false;
    } else {
        OneShot *oneshot = RZ_NEW(OneShot);
        if (oneshot) {
            oneshot->func = func;
            oneshot->user = user;
            rz_list_append(scheduler->oneshot_queue, oneshot);
            scheduler->oneshots_enqueued++;
        }
    }
    tasks_lock_leave(scheduler, &old_sigset);
}

References oneshot(), rz_core_tasks_t::oneshot_queue, rz_core_tasks_t::oneshot_running, rz_core_tasks_t::oneshots_enqueued, rz_list_append(), RZ_NEW, TASK_SIGSET_T, tasks_lock_enter(), tasks_lock_leave(), and rz_core_tasks_t::tasks_running.

Referenced by __do_panels_refreshOneShot(), agraph_refresh_oneshot(), rz_core_bind_cons(), rz_core_visual_analysis_refresh_oneshot(), and visual_refresh_oneshot().

rz_core_task_get_incref()

RZ_API RzCoreTask* rz_core_task_get_incref	(	RzCoreTaskScheduler *	scheduler,
		int	id
	)

Definition at line 461 of file task.c.

                                                                                   {
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(scheduler, &old_sigset);
    RzCoreTask *task = task_get(scheduler, id);
    if (task) {
        rz_core_task_incref(task);
    }
    tasks_lock_leave(scheduler, &old_sigset);
    return task;
}

References rz_core_task_incref(), task_get(), TASK_SIGSET_T, tasks_lock_enter(), and tasks_lock_leave().

Referenced by rz_core_task_is_cmd(), rz_core_task_join(), and task_output().

rz_core_task_incref()

RZ_API void rz_core_task_incref

(

RzCoreTask *

task

)

Definition at line 190 of file task.c.

                                                  {
    if (!task) {
        return;
    }
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(task->sched, &old_sigset);
    task->refcount++;
    tasks_lock_leave(task->sched, &old_sigset);
}

References TASK_SIGSET_T, tasks_lock_enter(), and tasks_lock_leave().

Referenced by rz_core_task_get_incref(), and rz_core_task_join().

rz_core_task_is_cmd()

RZ_API bool rz_core_task_is_cmd	(	RzCore *	core,
		int	id
	)

Definition at line 834 of file task.c.

                                                      {
    RzCoreTask *task = rz_core_task_get_incref(&core->tasks, id);
    if (!task) {
        return false;
    }
    bool r = task->runner == cmd_task_runner;
    rz_core_task_decref(task);
    return r;
}

References cmd_task_runner(), r, rz_core_task_decref(), rz_core_task_get_incref(), and rz_core_t::tasks.

Referenced by rz_tasks_delete_handler(), rz_tasks_wait_handler(), and task_break().

rz_core_task_join()

RZ_API void rz_core_task_join	(	RzCoreTaskScheduler *	scheduler,
		RzCoreTask *	current,
		int	id
	)

Definition at line 96 of file task.c.

                                                                                           {
    if (current && id == current->id) {
        return;
    }
    if (id >= 0) {
        RzCoreTask *task = rz_core_task_get_incref(scheduler, id);
        if (!task) {
            return;
        }
        if (current) {
            rz_core_task_sleep_begin(current);
        }
        task_join(task);
        if (current) {
            rz_core_task_sleep_end(current);
        }
        rz_core_task_decref(task);
    } else {
        TASK_SIGSET_T old_sigset;
        tasks_lock_enter(scheduler, &old_sigset);
        RzList *tasks = rz_list_clone(scheduler->tasks);
        RzListIter *iter;
        RzCoreTask *task;
        rz_list_foreach (tasks, iter, task) {
            if (current == task) {
                continue;
            }
            rz_core_task_incref(task);
        }
        tasks_lock_leave(scheduler, &old_sigset);
 
        rz_list_foreach (tasks, iter, task) {
            if (current == task) {
                continue;
            }
            if (current) {
                rz_core_task_sleep_begin(current);
            }
            task_join(task);
            if (current) {
                rz_core_task_sleep_end(current);
            }
            rz_core_task_decref(task);
        }
        rz_list_free(tasks);
    }
}

References rz_core_task_decref(), rz_core_task_get_incref(), rz_core_task_incref(), rz_core_task_sleep_begin(), rz_core_task_sleep_end(), rz_list_clone(), rz_list_free(), task_join(), TASK_SIGSET_T, rz_core_tasks_t::tasks, tasks_lock_enter(), and tasks_lock_leave().

Referenced by rz_core_fini(), rz_main_rizin(), and rz_tasks_wait_handler().

rz_core_task_list()

RZ_API void rz_core_task_list	(	RzCore *	core,
		int	mode
	)

Definition at line 811 of file task.c.

                                                      {
    RzListIter *iter;
    RzCoreTask *task;
    PJ *j = NULL;
    if (mode == 'j') {
        j = pj_new();
        pj_a(j);
    }
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(&core->tasks, &old_sigset);
    rz_list_foreach (core->tasks.tasks, iter, task) {
        rz_core_task_print(core, task, mode, j);
    }
    if (j) {
        pj_end(j);
        rz_cons_println(pj_string(j));
        pj_free(j);
    } else {
        rz_cons_printf("--\ntotal running: %d\n", core->tasks.tasks_running);
    }
    tasks_lock_leave(&core->tasks, &old_sigset);
}

References NULL, pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), rz_cons_printf(), rz_cons_println(), rz_core_task_print(), TASK_SIGSET_T, rz_core_tasks_t::tasks, rz_core_t::tasks, tasks_lock_enter(), tasks_lock_leave(), and rz_core_tasks_t::tasks_running.

Referenced by rz_tasks_handler().

rz_core_task_new()

RZ_API RzCoreTask* rz_core_task_new	(	RzCoreTaskScheduler *	sched,
		RzCoreTaskRunner	runner,
		RzCoreTaskRunnerFree	runner_free,
		void *	runner_user
	)

Definition at line 161 of file task.c.

                                                                                                                                              {
    RzCoreTask *task = RZ_NEW0(RzCoreTask);
    if (!task) {
        goto fail;
    }
 
    task->sched = sched;
    task->thread = NULL;
    task->running_sem = NULL;
    task->dispatched = false;
    task->dispatch_cond = rz_th_cond_new();
    task->dispatch_lock = rz_th_lock_new(false);
    if (!task->dispatch_cond || !task->dispatch_lock) {
        goto fail;
    }
    task->runner = runner;
    task->runner_free = runner_free;
    task->runner_user = runner_user;
    task->id = sched->task_id_next++;
    task->state = RZ_CORE_TASK_STATE_BEFORE_START;
    task->refcount = 1;
    task->transient = false;
    return task;
 
fail:
    task_free(task);
    return NULL;
}

References fail, NULL, RZ_NEW0, rz_th_cond_new(), rz_th_lock_new(), task_free(), and rz_core_tasks_t::task_id_next.

Referenced by rz_core_cmd_task_new(), rz_core_function_task_new(), and rz_core_task_scheduler_init().

rz_core_task_print()

RZ_API void rz_core_task_print	(	RzCore *	core,
		RzCoreTask *	task,
		int	mode,
		PJ *	j
	)

Definition at line 758 of file task.c.

                                                                                {
    rz_return_if_fail(mode != 'j' || j);
    if (task != core->tasks.main_task && task->runner != cmd_task_runner) {
        // don't print tasks that are custom function-runners, which come from internal code.
        // only main and command ones, which should be user-visible.
        return;
    }
    const char *cmd = NULL;
    if (task != core->tasks.main_task) {
        cmd = ((CmdTaskCtx *)task->runner_user)->cmd;
    }
    switch (mode) {
    case 'j': {
        pj_o(j);
        pj_ki(j, "id", task->id);
        const char *state;
        // This is NOT the same as rz_core_task_status()!
        // rz_core_task_status() is meant to be readable and may be changed.
        // These are meant to be stable for scripting.
        switch (task->state) {
        case RZ_CORE_TASK_STATE_BEFORE_START:
            state = "before_start";
            break;
        case RZ_CORE_TASK_STATE_RUNNING:
            state = "running";
            break;
        case RZ_CORE_TASK_STATE_SLEEPING:
            state = "sleeping";
            break;
        case RZ_CORE_TASK_STATE_DONE:
            state = "done";
            break;
        default:
            state = "invalid";
        }
        pj_ks(j, "state", state);
        pj_kb(j, "transient", task->transient);
        if (cmd) {
            pj_ks(j, "cmd", cmd);
        }
        pj_end(j);
        break;
    default: {
        rz_cons_printf("%3d %3s %12s  %s\n",
            task->id,
            task->transient ? "(t)" : "",
            rz_core_task_status(task),
            cmd ? cmd : "-- MAIN TASK --");
    } break;
    }
    }
}

References cmd, cmd_task_runner(), rz_core_tasks_t::main_task, NULL, pj_end(), pj_kb(), pj_ki(), pj_ks(), pj_o(), rz_cons_printf(), rz_core_task_status(), rz_return_if_fail, and rz_core_t::tasks.

Referenced by rz_core_task_list().

rz_core_task_run_sync()

RZ_API int rz_core_task_run_sync	(	RzCoreTaskScheduler *	scheduler,
		RzCoreTask *	task
	)

Definition at line 415 of file task.c.

                                                                                   {
    task->thread = NULL;
    return task_run_thread(task) != NULL;
}

References NULL, and task_run_thread().

rz_core_task_running_tasks_count()

RZ_API int rz_core_task_running_tasks_count

(

RzCoreTaskScheduler *

scheduler

)

Definition at line 71 of file task.c.

                                                                            {
    RzListIter *iter;
    RzCoreTask *task;
    int count = 0;
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(scheduler, &old_sigset);
    rz_list_foreach (scheduler->tasks, iter, task) {
        if (task != scheduler->main_task && task->state != RZ_CORE_TASK_STATE_DONE) {
            count++;
        }
    }
    tasks_lock_leave(scheduler, &old_sigset);
    return count;
}

References count, rz_core_tasks_t::main_task, TASK_SIGSET_T, rz_core_tasks_t::tasks, tasks_lock_enter(), and tasks_lock_leave().

Referenced by rz_main_rizin().

rz_core_task_schedule()

RZ_API void rz_core_task_schedule	(	RzCoreTask *	current,
		RzTaskState	next_state
	)

Definition at line 231 of file task.c.

                                                                               {
    RzCoreTaskScheduler *sched = current->sched;
    bool stop = next_state != RZ_CORE_TASK_STATE_RUNNING;
 
    if (sched->oneshot_running || (!stop && sched->tasks_running == 1 && sched->oneshots_enqueued == 0)) {
        return;
    }
 
    sched->current_task = NULL;
 
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(sched, &old_sigset);
 
    current->state = next_state;
 
    if (stop) {
        sched->tasks_running--;
    }
 
    cleanup_transient(sched, current);
 
    // oneshots always have priority.
    // if there are any queued, run them immediately.
    OneShot *oneshot;
    while ((oneshot = rz_list_pop_head(sched->oneshot_queue))) {
        sched->oneshots_enqueued--;
        sched->oneshot_running = true;
        oneshot->func(oneshot->user);
        sched->oneshot_running = false;
        free(oneshot);
    }
 
    RzCoreTask *next = rz_list_pop_head(sched->tasks_queue);
 
    if (next && !stop) {
        rz_list_append(sched->tasks_queue, current);
        rz_th_lock_enter(current->dispatch_lock);
    }
 
    tasks_lock_leave(sched, &old_sigset);
 
    if (next) {
        rz_th_lock_enter(next->dispatch_lock);
        next->dispatched = true;
        rz_th_lock_leave(next->dispatch_lock);
        rz_th_cond_signal(next->dispatch_cond);
        if (!stop) {
            while (!current->dispatched) {
                rz_th_cond_wait(current->dispatch_cond, current->dispatch_lock);
            }
            current->dispatched = false;
            rz_th_lock_leave(current->dispatch_lock);
 
            tasks_lock_enter(sched, &old_sigset);
            cleanup_transient(sched, current);
            tasks_lock_leave(sched, &old_sigset);
        }
    }
 
    if (!stop) {
        sched->current_task = current;
        if (sched->ctx_switch) {
            sched->ctx_switch(current, sched->ctx_switch_user);
        }
    }
}

References cleanup_transient(), rz_core_tasks_t::ctx_switch, rz_core_tasks_t::ctx_switch_user, rz_core_tasks_t::current_task, free(), NULL, oneshot(), rz_core_tasks_t::oneshot_queue, rz_core_tasks_t::oneshot_running, rz_core_tasks_t::oneshots_enqueued, rz_list_append(), rz_list_pop_head(), rz_th_cond_signal(), rz_th_cond_wait(), rz_th_lock_enter(), rz_th_lock_leave(), TASK_SIGSET_T, tasks_lock_enter(), tasks_lock_leave(), rz_core_tasks_t::tasks_queue, and rz_core_tasks_t::tasks_running.

Referenced by rz_core_task_sleep_begin(), rz_core_task_yield(), and task_end().

rz_core_task_scheduler_fini()

RZ_API void rz_core_task_scheduler_fini

(

RzCoreTaskScheduler *

tasks

)

Definition at line 27 of file task.c.

                                                                    {
    rz_list_free(tasks->tasks);
    rz_list_free(tasks->tasks_queue);
    rz_list_free(tasks->oneshot_queue);
    rz_th_lock_free(tasks->lock);
}

References rz_core_tasks_t::lock, rz_core_tasks_t::oneshot_queue, rz_list_free(), rz_th_lock_free(), rz_core_tasks_t::tasks, and rz_core_tasks_t::tasks_queue.

Referenced by rz_core_fini().

rz_core_task_scheduler_init()

RZ_API void rz_core_task_scheduler_init	(	RzCoreTaskScheduler *	sched,
		RzCoreTaskContextSwitch	ctx_switch,
		void *	ctx_switch_user,
		RzCoreTaskBreak	break_cb,
		void *	break_cb_user
	)

Definition at line 7 of file task.c.

                                                   {
    sched->ctx_switch = ctx_switch;
    sched->ctx_switch_user = ctx_switch_user;
    sched->break_cb = break_cb;
    sched->break_cb_user = break_cb_user;
    sched->task_id_next = 0;
    sched->tasks = rz_list_newf((RzListFree)rz_core_task_decref);
    sched->tasks_queue = rz_list_new();
    sched->oneshot_queue = rz_list_newf(free);
    sched->oneshots_enqueued = 0;
    sched->lock = rz_th_lock_new(true);
    sched->tasks_running = 0;
    sched->oneshot_running = false;
    sched->main_task = rz_core_task_new(sched, NULL, NULL, NULL);
    rz_list_append(sched->tasks, sched->main_task);
    sched->current_task = NULL;
}

References rz_core_tasks_t::break_cb, rz_core_tasks_t::break_cb_user, rz_core_tasks_t::ctx_switch, rz_core_tasks_t::ctx_switch_user, rz_core_tasks_t::current_task, free(), rz_core_tasks_t::lock, rz_core_tasks_t::main_task, NULL, rz_core_tasks_t::oneshot_queue, rz_core_tasks_t::oneshot_running, rz_core_tasks_t::oneshots_enqueued, rz_core_task_decref(), rz_core_task_new(), rz_list_append(), rz_list_new(), rz_list_newf(), rz_th_lock_new(), rz_core_tasks_t::task_id_next, rz_core_tasks_t::tasks, rz_core_tasks_t::tasks_queue, and rz_core_tasks_t::tasks_running.

Referenced by rz_core_init().

rz_core_task_self()

RZ_API RzCoreTask* rz_core_task_self

(

RzCoreTaskScheduler *

scheduler

)

Definition at line 446 of file task.c.

                                                                     {
    return scheduler->current_task ? scheduler->current_task : scheduler->main_task;
}

References rz_core_tasks_t::current_task, and rz_core_tasks_t::main_task.

Referenced by cmd_task_runner(), rz_core_sleep_begin(), and rz_core_task_yield().

rz_core_task_sleep_begin()

RZ_API void rz_core_task_sleep_begin

(

RzCoreTask *

task

)

Definition at line 438 of file task.c.

                                                       {
    rz_core_task_schedule(task, RZ_CORE_TASK_STATE_SLEEPING);
}

References rz_core_task_schedule().

Referenced by rz_core_sleep_begin(), and rz_core_task_join().

rz_core_task_sleep_end()

RZ_API void rz_core_task_sleep_end

(

RzCoreTask *

task

)

Definition at line 442 of file task.c.

                                                     {
    task_wakeup(task);
}

References task_wakeup().

Referenced by rz_core_sleep_end(), and rz_core_task_join().

rz_core_task_status()

RZ_API const char* rz_core_task_status

(

RzCoreTask *

task

)

Definition at line 743 of file task.c.

                                                         {
    switch (task->state) {
    case RZ_CORE_TASK_STATE_RUNNING:
        return "running";
    case RZ_CORE_TASK_STATE_SLEEPING:
        return "sleeping";
    case RZ_CORE_TASK_STATE_DONE:
        return "done";
    case RZ_CORE_TASK_STATE_BEFORE_START:
        return "before start";
    default:
        return "unknown";
    }
}

Referenced by rz_core_task_print().

rz_core_task_sync_begin()

RZ_API void rz_core_task_sync_begin

(

RzCoreTaskScheduler *

scheduler

)

Definition at line 421 of file task.c.

                                                                    {
    RzCoreTask *task = scheduler->main_task;
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(scheduler, &old_sigset);
    task->thread = NULL;
    task->state = RZ_CORE_TASK_STATE_BEFORE_START;
    tasks_lock_leave(scheduler, &old_sigset);
    task_wakeup(task);
}

References rz_core_tasks_t::main_task, NULL, TASK_SIGSET_T, task_wakeup(), tasks_lock_enter(), and tasks_lock_leave().

Referenced by open_core_file(), and rz_main_rizin().

rz_core_task_sync_end()

RZ_API void rz_core_task_sync_end

(

RzCoreTaskScheduler *

scheduler

)

Definition at line 432 of file task.c.

                                                                  {
    task_end(scheduler->main_task);
}

References rz_core_tasks_t::main_task, and task_end().

Referenced by open_core_file(), and rz_main_rizin().

rz_core_task_yield()

RZ_API void rz_core_task_yield

(

RzCoreTaskScheduler *

scheduler

)

Definition at line 336 of file task.c.

                                                               {
    RzCoreTask *task = rz_core_task_self(scheduler);
    if (!task) {
        return;
    }
    rz_core_task_schedule(task, RZ_CORE_TASK_STATE_RUNNING);
}

References rz_core_task_schedule(), and rz_core_task_self().

Referenced by core_perform_auto_analysis(), DEFINE_HANDLE_TS_FCN(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), rz_core_analysis_all(), rz_core_analysis_everything(), and rz_core_cmd_foreach().

task_break()

static void task_break ( RzCoreTask *  task )

static

break without locking, don't call directly and use public api instead!

Definition at line 475 of file task.c.

                                         {
    RzCoreTaskScheduler *sched = task->sched;
    task->breaked = true;
    if (sched->break_cb) {
        sched->break_cb(task, sched->break_cb_user);
    }
}

References rz_core_tasks_t::break_cb, and rz_core_tasks_t::break_cb_user.

Referenced by rz_core_task_break(), and rz_core_task_break_all().

task_end()

static void task_end ( RzCoreTask *  t )

static

Definition at line 344 of file task.c.

                                    {
    rz_core_task_schedule(t, RZ_CORE_TASK_STATE_DONE);
}

References rz_core_task_schedule().

Referenced by rz_core_task_sync_end(), and task_run_thread().

task_free()

static void task_free ( RzCoreTask *  task )

static

Definition at line 144 of file task.c.

                                        {
    if (!task) {
        return;
    }
    if (task->runner_free) {
        task->runner_free(task->runner_user);
    }
    if (task->thread) {
        rz_th_wait(task->thread);
        rz_th_free(task->thread);
    }
    rz_th_sem_free(task->running_sem);
    rz_th_cond_free(task->dispatch_cond);
    rz_th_lock_free(task->dispatch_lock);
    free(task);
}

References free(), rz_th_cond_free(), rz_th_free(), rz_th_lock_free(), rz_th_sem_free(), and rz_th_wait().

Referenced by rz_core_task_decref(), and rz_core_task_new().

task_get()

static RzCoreTask* task_get ( RzCoreTaskScheduler *  scheduler, int  id  )

static

Definition at line 450 of file task.c.

                                                                    {
    RzCoreTask *task;
    RzListIter *iter;
    rz_list_foreach (scheduler->tasks, iter, task) {
        if (task->id == id) {
            return task;
        }
    }
    return NULL;
}

References NULL, and rz_core_tasks_t::tasks.

Referenced by rz_core_task_break(), and rz_core_task_get_incref().

task_join()

static void task_join ( RzCoreTask *  task )

static

Definition at line 86 of file task.c.

                                        {
    RzThreadSemaphore *sem = task->running_sem;
    if (!sem) {
        return;
    }
 
    rz_th_sem_wait(sem);
    rz_th_sem_post(sem);
}

References rz_th_sem_post(), and rz_th_sem_wait().

Referenced by rz_core_task_join().

task_run_thread()

static void* task_run_thread ( RzCoreTask *  task )

static

Definition at line 348 of file task.c.

                                               {
    RzCoreTaskScheduler *sched = task->sched;
 
    task_wakeup(task);
 
    if (task->breaked) {
        // breaked in RZ_CORE_TASK_STATE_BEFORE_START
        goto nonstart;
    }
 
    task->runner(sched, task->runner_user);
 
    TASK_SIGSET_T old_sigset;
nonstart:
    tasks_lock_enter(sched, &old_sigset);
 
    task_end(task);
 
    if (task->running_sem) {
        rz_th_sem_post(task->running_sem);
    }
 
    tasks_lock_leave(sched, &old_sigset);
    return NULL;
}

References NULL, rz_th_sem_post(), task_end(), TASK_SIGSET_T, task_wakeup(), tasks_lock_enter(), and tasks_lock_leave().

Referenced by rz_core_task_enqueue(), and rz_core_task_run_sync().

task_wakeup()

static void task_wakeup ( RzCoreTask *  current )

static

Definition at line 298 of file task.c.

                                             {
    RzCoreTaskScheduler *sched = current->sched;
 
    TASK_SIGSET_T old_sigset;
    tasks_lock_enter(sched, &old_sigset);
 
    sched->tasks_running++;
    current->state = RZ_CORE_TASK_STATE_RUNNING;
 
    // check if there are other tasks running
    bool single = sched->tasks_running == 1 || sched->tasks_running == 0;
 
    rz_th_lock_enter(current->dispatch_lock);
 
    // if we are not the only task, we must wait until another task signals us.
 
    if (!single) {
        rz_list_append(sched->tasks_queue, current);
    }
 
    tasks_lock_leave(sched, &old_sigset);
 
    if (!single) {
        while (!current->dispatched) {
            rz_th_cond_wait(current->dispatch_cond, current->dispatch_lock);
        }
        current->dispatched = false;
    }
 
    rz_th_lock_leave(current->dispatch_lock);
 
    sched->current_task = current;
 
    if (sched->ctx_switch) {
        sched->ctx_switch(current, sched->ctx_switch_user);
    }
}

References rz_core_tasks_t::ctx_switch, rz_core_tasks_t::ctx_switch_user, rz_core_tasks_t::current_task, rz_list_append(), rz_th_cond_wait(), rz_th_lock_enter(), rz_th_lock_leave(), TASK_SIGSET_T, tasks_lock_enter(), tasks_lock_leave(), rz_core_tasks_t::tasks_queue, and rz_core_tasks_t::tasks_running.

Referenced by rz_core_task_sleep_end(), rz_core_task_sync_begin(), and task_run_thread().

tasks_lock_block_signals()

static void tasks_lock_block_signals ( TASK_SIGSET_T *  old_sigset )

static

Definition at line 48 of file task.c.

                                                                {
    (void)old_sigset;
}

Referenced by tasks_lock_enter().

tasks_lock_block_signals_reset()

static void tasks_lock_block_signals_reset ( TASK_SIGSET_T *  old_sigset )

static

Definition at line 51 of file task.c.

                                                                      {
    (void)old_sigset;
}

Referenced by tasks_lock_leave().

tasks_lock_enter()

static void tasks_lock_enter ( RzCoreTaskScheduler *  scheduler, TASK_SIGSET_T *  old_sigset  )

static

Definition at line 56 of file task.c.

                                                                                        {
    tasks_lock_block_signals(old_sigset);
    rz_th_lock_enter(scheduler->lock);
}

References rz_core_tasks_t::lock, rz_th_lock_enter(), and tasks_lock_block_signals().

Referenced by rz_core_task_break(), rz_core_task_break_all(), rz_core_task_decref(), rz_core_task_del(), rz_core_task_del_all_done(), rz_core_task_enqueue(), rz_core_task_enqueue_oneshot(), rz_core_task_get_incref(), rz_core_task_incref(), rz_core_task_join(), rz_core_task_list(), rz_core_task_running_tasks_count(), rz_core_task_schedule(), rz_core_task_sync_begin(), task_run_thread(), and task_wakeup().

tasks_lock_leave()

static void tasks_lock_leave ( RzCoreTaskScheduler *  scheduler, TASK_SIGSET_T *  old_sigset  )

static

Definition at line 61 of file task.c.

                                                                                        {
    rz_th_lock_leave(scheduler->lock);
    tasks_lock_block_signals_reset(old_sigset);
}

References rz_core_tasks_t::lock, rz_th_lock_leave(), and tasks_lock_block_signals_reset().

Referenced by rz_core_task_break(), rz_core_task_break_all(), rz_core_task_decref(), rz_core_task_del(), rz_core_task_del_all_done(), rz_core_task_enqueue(), rz_core_task_enqueue_oneshot(), rz_core_task_get_incref(), rz_core_task_incref(), rz_core_task_join(), rz_core_task_list(), rz_core_task_running_tasks_count(), rz_core_task_schedule(), rz_core_task_sync_begin(), task_run_thread(), and task_wakeup().