dedupe.h

  1/* SPDX-License-Identifier: GPL-2.0-only */
  2/*
  3 * Copyright 2023 Red Hat
  4 */
  5
  6#ifndef VDO_DEDUPE_H
  7#define VDO_DEDUPE_H
  8
  9#include <linux/list.h>
 10#include <linux/timer.h>
 11
 12#include "indexer.h"
 13
 14#include "admin-state.h"
 15#include "constants.h"
 16#include "statistics.h"
 17#include "types.h"
 18#include "wait-queue.h"
 19
 20struct dedupe_context {
 21	struct hash_zone *zone;
 22	struct uds_request request;
 23	struct list_head list_entry;
 24	struct funnel_queue_entry queue_entry;
 25	u64 submission_jiffies;
 26	struct data_vio *requestor;
 27	atomic_t state;
 28};
 29
 30struct hash_lock;
 31
 32struct hash_zone {
 33	/* Which hash zone this is */
 34	zone_count_t zone_number;
 35
 36	/* The administrative state of the zone */
 37	struct admin_state state;
 38
 39	/* The thread ID for this zone */
 40	thread_id_t thread_id;
 41
 42	/* Mapping from record name fields to hash_locks */
 43	struct int_map *hash_lock_map;
 44
 45	/* List containing all unused hash_locks */
 46	struct list_head lock_pool;
 47
 48	/*
 49	 * Statistics shared by all hash locks in this zone. Only modified on the hash zone thread,
 50	 * but queried by other threads.
 51	 */
 52	struct hash_lock_statistics statistics;
 53
 54	/* Array of all hash_locks */
 55	struct hash_lock *lock_array;
 56
 57	/* These fields are used to manage the dedupe contexts */
 58	struct list_head available;
 59	struct list_head pending;
 60	struct funnel_queue *timed_out_complete;
 61	struct timer_list timer;
 62	struct vdo_completion completion;
 63	unsigned int active;
 64	atomic_t timer_state;
 65
 66	/* The dedupe contexts for querying the index from this zone */
 67	struct dedupe_context contexts[MAXIMUM_VDO_USER_VIOS];
 68};
 69
 70struct hash_zones;
 71
 72struct pbn_lock * __must_check vdo_get_duplicate_lock(struct data_vio *data_vio);
 73
 74void vdo_acquire_hash_lock(struct vdo_completion *completion);
 75void vdo_continue_hash_lock(struct vdo_completion *completion);
 76void vdo_release_hash_lock(struct data_vio *data_vio);
 77void vdo_clean_failed_hash_lock(struct data_vio *data_vio);
 78void vdo_share_compressed_write_lock(struct data_vio *data_vio,
 79				     struct pbn_lock *pbn_lock);
 80
 81int __must_check vdo_make_hash_zones(struct vdo *vdo, struct hash_zones **zones_ptr);
 82
 83void vdo_free_hash_zones(struct hash_zones *zones);
 84
 85void vdo_drain_hash_zones(struct hash_zones *zones, struct vdo_completion *parent);
 86
 87void vdo_get_dedupe_statistics(struct hash_zones *zones, struct vdo_statistics *stats);
 88
 89struct hash_zone * __must_check vdo_select_hash_zone(struct hash_zones *zones,
 90						     const struct uds_record_name *name);
 91
 92void vdo_dump_hash_zones(struct hash_zones *zones);
 93
 94const char *vdo_get_dedupe_index_state_name(struct hash_zones *zones);
 95
 96u64 vdo_get_dedupe_index_timeout_count(struct hash_zones *zones);
 97
 98int vdo_message_dedupe_index(struct hash_zones *zones, const char *name);
 99
100void vdo_set_dedupe_state_normal(struct hash_zones *zones);
101
102void vdo_start_dedupe_index(struct hash_zones *zones, bool create_flag);
103
104void vdo_resume_hash_zones(struct hash_zones *zones, struct vdo_completion *parent);
105
106void vdo_finish_dedupe_index(struct hash_zones *zones);
107
108/* Interval (in milliseconds) from submission until switching to fast path and skipping UDS. */
109extern unsigned int vdo_dedupe_index_timeout_interval;
110
111/*
112 * Minimum time interval (in milliseconds) between timer invocations to check for requests waiting
113 * for UDS that should now time out.
114 */
115extern unsigned int vdo_dedupe_index_min_timer_interval;
116
117void vdo_set_dedupe_index_timeout_interval(unsigned int value);
118void vdo_set_dedupe_index_min_timer_interval(unsigned int value);
119
120#endif /* VDO_DEDUPE_H */