Quelle  completion.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * Copyright 2023 Red Hat
 */

#ifndef VDO_COMPLETION_H
#define VDO_COMPLETION_H

#include "permassert.h"

#include "status-codes.h"
#include "types.h"

/**
 * vdo_run_completion() - Run a completion's callback or error handler on the current thread.
 *
 * Context: This function must be called from the correct callback thread.
 */
static inline void vdo_run_completion(struct vdo_completion *completion)
{
 if ((completion->result != VDO_SUCCESS) && (completion->error_handler != NULL)) {
  completion->error_handler(completion);
  return;
 }

 completion->callback(completion);
}

void vdo_set_completion_result(struct vdo_completion *completion, int result);

void vdo_initialize_completion(struct vdo_completion *completion, struct vdo *vdo,
          enum vdo_completion_type type);

/**
 * vdo_reset_completion() - Reset a completion to a clean state, while keeping the type, vdo and
 *                          parent information.
 */
static inline void vdo_reset_completion(struct vdo_completion *completion)
{
 completion->result = VDO_SUCCESS;
 completion->complete = false;
}

void vdo_launch_completion_with_priority(struct vdo_completion *completion,
      enum vdo_completion_priority priority);

/**
 * vdo_launch_completion() - Launch a completion with default priority.
 */
static inline void vdo_launch_completion(struct vdo_completion *completion)
{
 vdo_launch_completion_with_priority(completion, VDO_WORK_Q_DEFAULT_PRIORITY);
}

/**
 * vdo_continue_completion() - Continue processing a completion.
 * @result: The current result (will not mask older errors).
 *
 * Continue processing a completion by setting the current result and calling
 * vdo_launch_completion().
 */
static inline void vdo_continue_completion(struct vdo_completion *completion, int result)
{
 vdo_set_completion_result(completion, result);
 vdo_launch_completion(completion);
}

void vdo_finish_completion(struct vdo_completion *completion);

/**
 * vdo_fail_completion() - Set the result of a completion if it does not already have an error,
 *                         then finish it.
 */
static inline void vdo_fail_completion(struct vdo_completion *completion, int result)
{
 vdo_set_completion_result(completion, result);
 vdo_finish_completion(completion);
}

/**
 * vdo_assert_completion_type() - Assert that a completion is of the correct type.
 *
 * Return: VDO_SUCCESS or an error
 */
static inline int vdo_assert_completion_type(struct vdo_completion *completion,
          enum vdo_completion_type expected)
{
 return VDO_ASSERT(expected == completion->type,
     "completion type should be %u, not %u", expected,
     completion->type);
}

static inline void vdo_set_completion_callback(struct vdo_completion *completion,
            vdo_action_fn callback,
            thread_id_t callback_thread_id)
{
 completion->callback = callback;
 completion->callback_thread_id = callback_thread_id;
}

/**
 * vdo_launch_completion_callback() - Set the callback for a completion and launch it immediately.
 */
static inline void vdo_launch_completion_callback(struct vdo_completion *completion,
        vdo_action_fn callback,
        thread_id_t callback_thread_id)
{
 vdo_set_completion_callback(completion, callback, callback_thread_id);
 vdo_launch_completion(completion);
}

/**
 * vdo_prepare_completion() - Prepare a completion for launch.
 *
 * Resets the completion, and then sets its callback, error handler, callback thread, and parent.
 */
static inline void vdo_prepare_completion(struct vdo_completion *completion,
       vdo_action_fn callback,
       vdo_action_fn error_handler,
       thread_id_t callback_thread_id, void *parent)
{
 vdo_reset_completion(completion);
 vdo_set_completion_callback(completion, callback, callback_thread_id);
 completion->error_handler = error_handler;
 completion->parent = parent;
}

/**
 * vdo_prepare_completion_for_requeue() - Prepare a completion for launch ensuring that it will
 *                                        always be requeued.
 *
 * Resets the completion, and then sets its callback, error handler, callback thread, and parent.
 */
static inline void vdo_prepare_completion_for_requeue(struct vdo_completion *completion,
            vdo_action_fn callback,
            vdo_action_fn error_handler,
            thread_id_t callback_thread_id,
            void *parent)
{
 vdo_prepare_completion(completion, callback, error_handler,
          callback_thread_id, parent);
 completion->requeue = true;
}

void vdo_enqueue_completion(struct vdo_completion *completion,
       enum vdo_completion_priority priority);


bool vdo_requeue_completion_if_needed(struct vdo_completion *completion,
          thread_id_t callback_thread_id);

#endif /* VDO_COMPLETION_H */