linux-imx

// SPDX-License-Identifier: GPL-2.0

#include <linux/spinlock.h>

#include <linux/task_work.h>

#include <linux/tracehook.h>

​

static struct callback_head work_exited; /* all we need is ->next == NULL */

​

/**

 * task_work_add - ask the @task to execute @work->func()

 * @task: the task which should run the callback

 * @work: the callback to run

 * @notify: send the notification if true

 *

 * Queue @work for task_work_run() below and notify the @task if @notify.

 * Fails if the @task is exiting/exited and thus it can't process this @work.

 * Otherwise @work->func() will be called when the @task returns from kernel

 * mode or exits.

 *

 * This is like the signal handler which runs in kernel mode, but it doesn't

 * try to wake up the @task.

 *

 * Note: there is no ordering guarantee on works queued here.

 *

 * RETURNS:

 * 0 if succeeds or -ESRCH.

 */

int

task_work_add(struct task_struct *task, struct callback_head *work, bool notify)

{

    struct callback_head *head;

​

    do {

        head = READ_ONCE(task->task_works);

        if (unlikely(head == &work_exited))

            return -ESRCH;

        work->next = head;

    } while (cmpxchg(&task->task_works, head, work) != head);

​

    if (notify)

        set_notify_resume(task);

    return 0;

}

​

/**

 * task_work_cancel - cancel a pending work added by task_work_add()

 * @task: the task which should execute the work

 * @func: identifies the work to remove

 *

 * Find the last queued pending work with ->func == @func and remove

 * it from queue.

 *

 * RETURNS:

 * The found work or NULL if not found.

 */

struct callback_head *

task_work_cancel(struct task_struct *task, task_work_func_t func)

{

    struct callback_head **pprev = &task->task_works;

    struct callback_head *work;

    unsigned long flags;

​

    if (likely(!task->task_works))

        return NULL;