hc
2025-02-14 bbb9540dc49f70f6b703d1c8d1b85fa5f602d86e
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 1999,2000,2001,2002,2003,2004  Free Software Foundation, Inc.
 *
 * SPDX-License-Identifier:    GPL-2.0+
 */
/*
 * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 */
 
#ifndef    _SYS_ZAP_IMPL_H
#define    _SYS_ZAP_IMPL_H
 
#define    ZAP_MAGIC 0x2F52AB2ABULL
 
#define    ZAP_HASHBITS        28
#define    MZAP_ENT_LEN        64
#define    MZAP_NAME_LEN        (MZAP_ENT_LEN - 8 - 4 - 2)
#define    MZAP_MAX_BLKSHIFT    SPA_MAXBLOCKSHIFT
#define    MZAP_MAX_BLKSZ        (1 << MZAP_MAX_BLKSHIFT)
 
typedef struct mzap_ent_phys {
   uint64_t mze_value;
   uint32_t mze_cd;
   uint16_t mze_pad;    /* in case we want to chain them someday */
   char mze_name[MZAP_NAME_LEN];
} mzap_ent_phys_t;
 
typedef struct mzap_phys {
   uint64_t mz_block_type;    /* ZBT_MICRO */
   uint64_t mz_salt;
   uint64_t mz_pad[6];
   mzap_ent_phys_t mz_chunk[1];
   /* actually variable size depending on block size */
} mzap_phys_t;
 
/*
 * The (fat) zap is stored in one object. It is an array of
 * 1<<FZAP_BLOCK_SHIFT byte blocks. The layout looks like one of:
 *
 * ptrtbl fits in first block:
 *    [zap_phys_t zap_ptrtbl_shift < 6] [zap_leaf_t] ...
 *
 * ptrtbl too big for first block:
 *    [zap_phys_t zap_ptrtbl_shift >= 6] [zap_leaf_t] [ptrtbl] ...
 *
 */
 
#define    ZBT_LEAF        ((1ULL << 63) + 0)
#define    ZBT_HEADER        ((1ULL << 63) + 1)
#define    ZBT_MICRO        ((1ULL << 63) + 3)
/* any other values are ptrtbl blocks */
 
/*
 * the embedded pointer table takes up half a block:
 * block size / entry size (2^3) / 2
 */
#define    ZAP_EMBEDDED_PTRTBL_SHIFT(zap) (FZAP_BLOCK_SHIFT(zap) - 3 - 1)
 
/*
 * The embedded pointer table starts half-way through the block.  Since
 * the pointer table itself is half the block, it starts at (64-bit)
 * word number (1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)).
 */
#define    ZAP_EMBEDDED_PTRTBL_ENT(zap, idx) \
   ((uint64_t *)(zap)->zap_f.zap_phys) \
   [(idx) + (1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap))]
 
/*
 * TAKE NOTE:
 * If zap_phys_t is modified, zap_byteswap() must be modified.
 */
typedef struct zap_phys {
   uint64_t zap_block_type;    /* ZBT_HEADER */
   uint64_t zap_magic;        /* ZAP_MAGIC */
 
   struct zap_table_phys {
       uint64_t zt_blk;    /* starting block number */
       uint64_t zt_numblks;    /* number of blocks */
       uint64_t zt_shift;    /* bits to index it */
       uint64_t zt_nextblk;    /* next (larger) copy start block */
       uint64_t zt_blks_copied; /* number source blocks copied */
   } zap_ptrtbl;
 
   uint64_t zap_freeblk;        /* the next free block */
   uint64_t zap_num_leafs;        /* number of leafs */
   uint64_t zap_num_entries;    /* number of entries */
   uint64_t zap_salt;        /* salt to stir into hash function */
   uint64_t zap_normflags;        /* flags for u8_textprep_str() */
   uint64_t zap_flags;        /* zap_flag_t */
   /*
    * This structure is followed by padding, and then the embedded
    * pointer table.  The embedded pointer table takes up second
    * half of the block.  It is accessed using the
    * ZAP_EMBEDDED_PTRTBL_ENT() macro.
    */
} zap_phys_t;
 
#endif /* _SYS_ZAP_IMPL_H */