| /* SPDX-License-Identifier: GPL-2.0-only */ |
| /* |
| * Copyright 2023 Red Hat |
| */ |
| |
| #ifndef VDO_DEDUPE_H |
| #define VDO_DEDUPE_H |
| |
| #include <linux/list.h> |
| #include <linux/timer.h> |
| |
| #include "indexer.h" |
| |
| #include "admin-state.h" |
| #include "constants.h" |
| #include "statistics.h" |
| #include "types.h" |
| #include "wait-queue.h" |
| |
| struct dedupe_context { |
| struct hash_zone *zone; |
| struct uds_request request; |
| struct list_head list_entry; |
| struct funnel_queue_entry queue_entry; |
| u64 submission_jiffies; |
| struct data_vio *requestor; |
| atomic_t state; |
| }; |
| |
| struct hash_lock; |
| |
| struct hash_zone { |
| /* Which hash zone this is */ |
| zone_count_t zone_number; |
| |
| /* The administrative state of the zone */ |
| struct admin_state state; |
| |
| /* The thread ID for this zone */ |
| thread_id_t thread_id; |
| |
| /* Mapping from record name fields to hash_locks */ |
| struct int_map *hash_lock_map; |
| |
| /* List containing all unused hash_locks */ |
| struct list_head lock_pool; |
| |
| /* |
| * Statistics shared by all hash locks in this zone. Only modified on the hash zone thread, |
| * but queried by other threads. |
| */ |
| struct hash_lock_statistics statistics; |
| |
| /* Array of all hash_locks */ |
| struct hash_lock *lock_array; |
| |
| /* These fields are used to manage the dedupe contexts */ |
| struct list_head available; |
| struct list_head pending; |
| struct funnel_queue *timed_out_complete; |
| struct timer_list timer; |
| struct vdo_completion completion; |
| unsigned int active; |
| atomic_t timer_state; |
| |
| /* The dedupe contexts for querying the index from this zone */ |
| struct dedupe_context contexts[MAXIMUM_VDO_USER_VIOS]; |
| }; |
| |
| struct hash_zones; |
| |
| struct pbn_lock * __must_check vdo_get_duplicate_lock(struct data_vio *data_vio); |
| |
| void vdo_acquire_hash_lock(struct vdo_completion *completion); |
| void vdo_continue_hash_lock(struct vdo_completion *completion); |
| void vdo_release_hash_lock(struct data_vio *data_vio); |
| void vdo_clean_failed_hash_lock(struct data_vio *data_vio); |
| void vdo_share_compressed_write_lock(struct data_vio *data_vio, |
| struct pbn_lock *pbn_lock); |
| |
| int __must_check vdo_make_hash_zones(struct vdo *vdo, struct hash_zones **zones_ptr); |
| |
| void vdo_free_hash_zones(struct hash_zones *zones); |
| |
| void vdo_drain_hash_zones(struct hash_zones *zones, struct vdo_completion *parent); |
| |
| void vdo_get_dedupe_statistics(struct hash_zones *zones, struct vdo_statistics *stats); |
| |
| struct hash_zone * __must_check vdo_select_hash_zone(struct hash_zones *zones, |
| const struct uds_record_name *name); |
| |
| void vdo_dump_hash_zones(struct hash_zones *zones); |
| |
| const char *vdo_get_dedupe_index_state_name(struct hash_zones *zones); |
| |
| u64 vdo_get_dedupe_index_timeout_count(struct hash_zones *zones); |
| |
| int vdo_message_dedupe_index(struct hash_zones *zones, const char *name); |
| |
| void vdo_set_dedupe_state_normal(struct hash_zones *zones); |
| |
| void vdo_start_dedupe_index(struct hash_zones *zones, bool create_flag); |
| |
| void vdo_resume_hash_zones(struct hash_zones *zones, struct vdo_completion *parent); |
| |
| void vdo_finish_dedupe_index(struct hash_zones *zones); |
| |
| /* Interval (in milliseconds) from submission until switching to fast path and skipping UDS. */ |
| extern unsigned int vdo_dedupe_index_timeout_interval; |
| |
| /* |
| * Minimum time interval (in milliseconds) between timer invocations to check for requests waiting |
| * for UDS that should now time out. |
| */ |
| extern unsigned int vdo_dedupe_index_min_timer_interval; |
| |
| void vdo_set_dedupe_index_timeout_interval(unsigned int value); |
| void vdo_set_dedupe_index_min_timer_interval(unsigned int value); |
| |
| #endif /* VDO_DEDUPE_H */ |