153 lines
4.7 KiB
C
153 lines
4.7 KiB
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 */
|