linux/drivers/md/dm-vdo/data-vio.h

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

#ifndef DATA_VIO_H
#define DATA_VIO_H

#include <linux/atomic.h>
#include <linux/bio.h>
#include <linux/list.h>

#include "permassert.h"

#include "indexer.h"

#include "block-map.h"
#include "completion.h"
#include "constants.h"
#include "dedupe.h"
#include "encodings.h"
#include "logical-zone.h"
#include "physical-zone.h"
#include "types.h"
#include "vdo.h"
#include "vio.h"
#include "wait-queue.h"

/* Codes for describing the last asynchronous operation performed on a vio. */
enum async_operation_number { … } __packed;

struct lbn_lock { … };

/* A position in the arboreal block map at a specific level. */
struct block_map_tree_slot { … };

/* Fields for using the arboreal block map. */
struct tree_lock { … };

struct zoned_pbn { … };

/*
 * Where a data_vio is on the compression path; advance_compression_stage() depends on the order of
 * this enum.
 */
enum data_vio_compression_stage { … };

struct data_vio_compression_status { … };

struct compression_state { … };

/* Fields supporting allocation of data blocks. */
struct allocation { … };

struct reference_updater { … };

/* A vio for processing user data requests. */
struct data_vio { … };

static inline struct data_vio *vio_as_data_vio(struct vio *vio)
{ … }

static inline struct data_vio *as_data_vio(struct vdo_completion *completion)
{ … }

static inline struct data_vio *vdo_waiter_as_data_vio(struct vdo_waiter *waiter)
{ … }

static inline struct data_vio *data_vio_from_reference_updater(struct reference_updater *updater)
{ … }

static inline bool data_vio_has_flush_generation_lock(struct data_vio *data_vio)
{ … }

static inline struct vdo *vdo_from_data_vio(struct data_vio *data_vio)
{ … }

static inline bool data_vio_has_allocation(struct data_vio *data_vio)
{ … }

struct data_vio_compression_status __must_check
advance_data_vio_compression_stage(struct data_vio *data_vio);
struct data_vio_compression_status __must_check
get_data_vio_compression_status(struct data_vio *data_vio);
bool cancel_data_vio_compression(struct data_vio *data_vio);

struct data_vio_pool;

int make_data_vio_pool(struct vdo *vdo, data_vio_count_t pool_size,
		       data_vio_count_t discard_limit, struct data_vio_pool **pool_ptr);
void free_data_vio_pool(struct data_vio_pool *pool);
void vdo_launch_bio(struct data_vio_pool *pool, struct bio *bio);
void drain_data_vio_pool(struct data_vio_pool *pool, struct vdo_completion *completion);
void resume_data_vio_pool(struct data_vio_pool *pool, struct vdo_completion *completion);

void dump_data_vio_pool(struct data_vio_pool *pool, bool dump_vios);
data_vio_count_t get_data_vio_pool_active_discards(struct data_vio_pool *pool);
data_vio_count_t get_data_vio_pool_discard_limit(struct data_vio_pool *pool);
data_vio_count_t get_data_vio_pool_maximum_discards(struct data_vio_pool *pool);
int __must_check set_data_vio_pool_discard_limit(struct data_vio_pool *pool,
						 data_vio_count_t limit);
data_vio_count_t get_data_vio_pool_active_requests(struct data_vio_pool *pool);
data_vio_count_t get_data_vio_pool_request_limit(struct data_vio_pool *pool);
data_vio_count_t get_data_vio_pool_maximum_requests(struct data_vio_pool *pool);

void complete_data_vio(struct vdo_completion *completion);
void handle_data_vio_error(struct vdo_completion *completion);

static inline void continue_data_vio(struct data_vio *data_vio)
{ … }

/**
 * continue_data_vio_with_error() - Set an error code and then continue processing a data_vio.
 *
 * This will not mask older errors. This function can be called with a success code, but it is more
 * efficient to call continue_data_vio() if the caller knows the result was a success.
 */
static inline void continue_data_vio_with_error(struct data_vio *data_vio, int result)
{ … }

const char * __must_check get_data_vio_operation_name(struct data_vio *data_vio);

static inline void assert_data_vio_in_hash_zone(struct data_vio *data_vio)
{ … }

static inline void set_data_vio_hash_zone_callback(struct data_vio *data_vio,
						   vdo_action_fn callback)
{ … }

/**
 * launch_data_vio_hash_zone_callback() - Set a callback as a hash zone operation and invoke it
 *					  immediately.
 */
static inline void launch_data_vio_hash_zone_callback(struct data_vio *data_vio,
						      vdo_action_fn callback)
{ … }

static inline void assert_data_vio_in_logical_zone(struct data_vio *data_vio)
{ … }

static inline void set_data_vio_logical_callback(struct data_vio *data_vio,
						 vdo_action_fn callback)
{ … }

/**
 * launch_data_vio_logical_callback() - Set a callback as a logical block operation and invoke it
 *					immediately.
 */
static inline void launch_data_vio_logical_callback(struct data_vio *data_vio,
						    vdo_action_fn callback)
{ … }

static inline void assert_data_vio_in_allocated_zone(struct data_vio *data_vio)
{ … }

static inline void set_data_vio_allocated_zone_callback(struct data_vio *data_vio,
							vdo_action_fn callback)
{ … }

/**
 * launch_data_vio_allocated_zone_callback() - Set a callback as a physical block operation in a
 *					       data_vio's allocated zone and queue the data_vio and
 *					       invoke it immediately.
 */
static inline void launch_data_vio_allocated_zone_callback(struct data_vio *data_vio,
							   vdo_action_fn callback)
{ … }

static inline void assert_data_vio_in_duplicate_zone(struct data_vio *data_vio)
{ … }

static inline void set_data_vio_duplicate_zone_callback(struct data_vio *data_vio,
							vdo_action_fn callback)
{ … }

/**
 * launch_data_vio_duplicate_zone_callback() - Set a callback as a physical block operation in a
 *					       data_vio's duplicate zone and queue the data_vio and
 *					       invoke it immediately.
 */
static inline void launch_data_vio_duplicate_zone_callback(struct data_vio *data_vio,
							   vdo_action_fn callback)
{ … }

static inline void assert_data_vio_in_mapped_zone(struct data_vio *data_vio)
{ … }

static inline void set_data_vio_mapped_zone_callback(struct data_vio *data_vio,
						     vdo_action_fn callback)
{ … }

static inline void assert_data_vio_in_new_mapped_zone(struct data_vio *data_vio)
{ … }

static inline void set_data_vio_new_mapped_zone_callback(struct data_vio *data_vio,
							 vdo_action_fn callback)
{ … }

static inline void assert_data_vio_in_journal_zone(struct data_vio *data_vio)
{ … }

static inline void set_data_vio_journal_callback(struct data_vio *data_vio,
						 vdo_action_fn callback)
{ … }

/**
 * launch_data_vio_journal_callback() - Set a callback as a journal operation and invoke it
 *					immediately.
 */
static inline void launch_data_vio_journal_callback(struct data_vio *data_vio,
						    vdo_action_fn callback)
{ … }

static inline void assert_data_vio_in_packer_zone(struct data_vio *data_vio)
{ … }

static inline void set_data_vio_packer_callback(struct data_vio *data_vio,
						vdo_action_fn callback)
{ … }

/**
 * launch_data_vio_packer_callback() - Set a callback as a packer operation and invoke it
 *				       immediately.
 */
static inline void launch_data_vio_packer_callback(struct data_vio *data_vio,
						   vdo_action_fn callback)
{ … }

static inline void assert_data_vio_on_cpu_thread(struct data_vio *data_vio)
{ … }

static inline void set_data_vio_cpu_callback(struct data_vio *data_vio,
					     vdo_action_fn callback)
{ … }

/**
 * launch_data_vio_cpu_callback() - Set a callback to run on the CPU queues and invoke it
 *				    immediately.
 */
static inline void launch_data_vio_cpu_callback(struct data_vio *data_vio,
						vdo_action_fn callback,
						enum vdo_completion_priority priority)
{ … }

static inline void set_data_vio_bio_zone_callback(struct data_vio *data_vio,
						  vdo_action_fn callback)
{ … }

/**
 * launch_data_vio_bio_zone_callback() - Set a callback as a bio zone operation and invoke it
 *					 immediately.
 */
static inline void launch_data_vio_bio_zone_callback(struct data_vio *data_vio,
						     vdo_action_fn callback)
{ … }

/**
 * launch_data_vio_on_bio_ack_queue() - If the vdo uses a bio_ack queue, set a callback to run on
 *					it and invoke it immediately, otherwise, just run the
 *					callback on the current thread.
 */
static inline void launch_data_vio_on_bio_ack_queue(struct data_vio *data_vio,
						    vdo_action_fn callback)
{ … }

void data_vio_allocate_data_block(struct data_vio *data_vio,
				  enum pbn_lock_type write_lock_type,
				  vdo_action_fn callback, vdo_action_fn error_handler);

void release_data_vio_allocation_lock(struct data_vio *data_vio, bool reset);

int __must_check uncompress_data_vio(struct data_vio *data_vio,
				     enum block_mapping_state mapping_state,
				     char *buffer);

void update_metadata_for_data_vio_write(struct data_vio *data_vio,
					struct pbn_lock *lock);
void write_data_vio(struct data_vio *data_vio);
void launch_compress_data_vio(struct data_vio *data_vio);
void continue_data_vio_with_block_map_slot(struct vdo_completion *completion);

#endif /* DATA_VIO_H */