/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or https://opensource.org/licenses/CDDL-1.0. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2016 by Delphix. All rights reserved. * Copyright (c) 2023, Klara Inc. */ #ifndef _SYS_DDT_IMPL_H #define _SYS_DDT_IMPL_H #include #include #ifdef __cplusplus extern "C" { #endif /* DDT version numbers */ #define DDT_VERSION_LEGACY (0) #define DDT_VERSION_FDT (1) /* Names of interesting objects in the DDT root dir */ #define DDT_DIR_VERSION "version" #define DDT_DIR_FLAGS "flags" /* Fill a lightweight entry from a live entry. */ #define DDT_ENTRY_TO_LIGHTWEIGHT(ddt, dde, ddlwe) do { \ memset((ddlwe), 0, sizeof (*ddlwe)); \ (ddlwe)->ddlwe_key = (dde)->dde_key; \ (ddlwe)->ddlwe_type = (dde)->dde_type; \ (ddlwe)->ddlwe_class = (dde)->dde_class; \ memcpy(&(ddlwe)->ddlwe_phys, (dde)->dde_phys, DDT_PHYS_SIZE(ddt)); \ } while (0) #define DDT_LOG_ENTRY_TO_LIGHTWEIGHT(ddt, ddle, ddlwe) do { \ memset((ddlwe), 0, sizeof (*ddlwe)); \ (ddlwe)->ddlwe_key = (ddle)->ddle_key; \ (ddlwe)->ddlwe_type = (ddle)->ddle_type; \ (ddlwe)->ddlwe_class = (ddle)->ddle_class; \ memcpy(&(ddlwe)->ddlwe_phys, (ddle)->ddle_phys, DDT_PHYS_SIZE(ddt)); \ } while (0) /* * An entry on the log tree. These are "frozen", and a record of what's in * the on-disk log. They can't be used in place, but can be "loaded" back into * the live tree. */ typedef struct { ddt_key_t ddle_key; /* ddt_log_tree key */ avl_node_t ddle_node; /* ddt_log_tree node */ ddt_type_t ddle_type; /* storage type */ ddt_class_t ddle_class; /* storage class */ /* extra allocation for flat/trad phys */ ddt_univ_phys_t ddle_phys[]; } ddt_log_entry_t; /* On-disk log record types. */ typedef enum { DLR_INVALID = 0, /* end of block marker */ DLR_ENTRY = 1, /* an entry to add or replace in the log tree */ } ddt_log_record_type_t; /* On-disk log record header. */ typedef struct { /* * dlr_info is a packed u64, use the DLR_GET/DLR_SET macros below to * access it. * * bits 0-7: record type (ddt_log_record_type_t) * bits 8-15: length of record header+payload * bits 16-47: reserved, all zero * bits 48-55: if type==DLR_ENTRY, storage type (ddt_type) * otherwise all zero * bits 56-63: if type==DLR_ENTRY, storage class (ddt_class) * otherwise all zero */ uint64_t dlr_info; uint8_t dlr_payload[]; } ddt_log_record_t; #define DLR_GET_TYPE(dlr) BF64_GET((dlr)->dlr_info, 0, 8) #define DLR_SET_TYPE(dlr, v) BF64_SET((dlr)->dlr_info, 0, 8, v) #define DLR_GET_RECLEN(dlr) BF64_GET((dlr)->dlr_info, 8, 16) #define DLR_SET_RECLEN(dlr, v) BF64_SET((dlr)->dlr_info, 8, 16, v) #define DLR_GET_ENTRY_TYPE(dlr) BF64_GET((dlr)->dlr_info, 48, 8) #define DLR_SET_ENTRY_TYPE(dlr, v) BF64_SET((dlr)->dlr_info, 48, 8, v) #define DLR_GET_ENTRY_CLASS(dlr) BF64_GET((dlr)->dlr_info, 56, 8) #define DLR_SET_ENTRY_CLASS(dlr, v) BF64_SET((dlr)->dlr_info, 56, 8, v) /* Payload for DLR_ENTRY. */ typedef struct { ddt_key_t dlre_key; ddt_univ_phys_t dlre_phys[]; } ddt_log_record_entry_t; /* Log flags (ddl_flags, dlh_flags) */ #define DDL_FLAG_FLUSHING (1 << 0) /* this log is being flushed */ #define DDL_FLAG_CHECKPOINT (1 << 1) /* header has a checkpoint */ /* On-disk log header, stored in the bonus buffer. */ typedef struct { /* * dlh_info is a packed u64, use the DLH_GET/DLH_SET macros below to * access it. * * bits 0-7: log version * bits 8-15: log flags * bits 16-63: reserved, all zero */ uint64_t dlh_info; uint64_t dlh_length; /* log size in bytes */ uint64_t dlh_first_txg; /* txg this log went active */ ddt_key_t dlh_checkpoint; /* last checkpoint */ } ddt_log_header_t; #define DLH_GET_VERSION(dlh) BF64_GET((dlh)->dlh_info, 0, 8) #define DLH_SET_VERSION(dlh, v) BF64_SET((dlh)->dlh_info, 0, 8, v) #define DLH_GET_FLAGS(dlh) BF64_GET((dlh)->dlh_info, 8, 8) #define DLH_SET_FLAGS(dlh, v) BF64_SET((dlh)->dlh_info, 8, 8, v) /* DDT log update state */ typedef struct { dmu_tx_t *dlu_tx; /* tx the update is being applied to */ dnode_t *dlu_dn; /* log object dnode */ dmu_buf_t **dlu_dbp; /* array of block buffer pointers */ int dlu_ndbp; /* number of block buffer pointers */ uint16_t dlu_reclen; /* cached length of record */ uint64_t dlu_block; /* block for next entry */ uint64_t dlu_offset; /* offset for next entry */ } ddt_log_update_t; /* * Ops vector to access a specific DDT object type. */ typedef struct { char ddt_op_name[32]; int (*ddt_op_create)(objset_t *os, uint64_t *object, dmu_tx_t *tx, boolean_t prehash); int (*ddt_op_destroy)(objset_t *os, uint64_t object, dmu_tx_t *tx); int (*ddt_op_lookup)(objset_t *os, uint64_t object, const ddt_key_t *ddk, void *phys, size_t psize); int (*ddt_op_contains)(objset_t *os, uint64_t object, const ddt_key_t *ddk); void (*ddt_op_prefetch)(objset_t *os, uint64_t object, const ddt_key_t *ddk); void (*ddt_op_prefetch_all)(objset_t *os, uint64_t object); int (*ddt_op_update)(objset_t *os, uint64_t object, const ddt_key_t *ddk, const void *phys, size_t psize, dmu_tx_t *tx); int (*ddt_op_remove)(objset_t *os, uint64_t object, const ddt_key_t *ddk, dmu_tx_t *tx); int (*ddt_op_walk)(objset_t *os, uint64_t object, uint64_t *walk, ddt_key_t *ddk, void *phys, size_t psize); int (*ddt_op_count)(objset_t *os, uint64_t object, uint64_t *count); } ddt_ops_t; extern const ddt_ops_t ddt_zap_ops; /* Dedup log API */ extern void ddt_log_begin(ddt_t *ddt, size_t nentries, dmu_tx_t *tx, ddt_log_update_t *dlu); extern void ddt_log_entry(ddt_t *ddt, ddt_lightweight_entry_t *dde, ddt_log_update_t *dlu); extern void ddt_log_commit(ddt_t *ddt, ddt_log_update_t *dlu); extern boolean_t ddt_log_take_first(ddt_t *ddt, ddt_log_t *ddl, ddt_lightweight_entry_t *ddlwe); extern boolean_t ddt_log_take_key(ddt_t *ddt, ddt_log_t *ddl, const ddt_key_t *ddk, ddt_lightweight_entry_t *ddlwe); extern void ddt_log_checkpoint(ddt_t *ddt, ddt_lightweight_entry_t *ddlwe, dmu_tx_t *tx); extern void ddt_log_truncate(ddt_t *ddt, dmu_tx_t *tx); extern boolean_t ddt_log_swap(ddt_t *ddt, dmu_tx_t *tx); extern void ddt_log_destroy(ddt_t *ddt, dmu_tx_t *tx); extern int ddt_log_load(ddt_t *ddt); extern void ddt_log_alloc(ddt_t *ddt); extern void ddt_log_free(ddt_t *ddt); extern void ddt_log_init(void); extern void ddt_log_fini(void); /* * These are only exposed so that zdb can access them. Try not to use them * outside of the DDT implementation proper, and if you do, consider moving * them up. */ /* * Enough room to expand DMU_POOL_DDT format for all possible DDT * checksum/class/type combinations. */ #define DDT_NAMELEN 32 extern uint64_t ddt_phys_total_refcnt(const ddt_t *ddt, const ddt_univ_phys_t *ddp); extern void ddt_key_fill(ddt_key_t *ddk, const blkptr_t *bp); extern void ddt_object_name(ddt_t *ddt, ddt_type_t type, ddt_class_t clazz, char *name); extern int ddt_object_walk(ddt_t *ddt, ddt_type_t type, ddt_class_t clazz, uint64_t *walk, ddt_lightweight_entry_t *ddlwe); extern int ddt_object_count(ddt_t *ddt, ddt_type_t type, ddt_class_t clazz, uint64_t *count); extern int ddt_object_info(ddt_t *ddt, ddt_type_t type, ddt_class_t clazz, dmu_object_info_t *); #ifdef __cplusplus } #endif #endif /* _SYS_DDT_H */