1 // SPDX-License-Identifier: CDDL-1.0
2 /*
3 * This file and its contents are supplied under the terms of the
4 * Common Development and Distribution License ("CDDL"), version 1.0.
5 * You may only use this file in accordance with the terms of version
6 * 1.0 of the CDDL.
7 *
8 * A full copy of the text of the CDDL should have accompanied this
9 * source. A copy of the CDDL is also available via the Internet at
10 * https://opensource.org/license/CDDL-1.0.
11 */
12
13 /*
14 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
15 * Copyright (c) 2012, 2016 by Delphix. All rights reserved.
16 * Copyright (c) 2022 by Pawel Jakub Dawidek
17 * Copyright (c) 2023, Klara Inc.
18 */
19
20 #include <sys/zfs_context.h>
21 #include <sys/spa.h>
22 #include <sys/spa_impl.h>
23 #include <sys/ddt.h>
24 #include <sys/ddt_impl.h>
25
26 static void
ddt_stat_generate(ddt_t * ddt,const ddt_lightweight_entry_t * ddlwe,ddt_stat_t * dds)27 ddt_stat_generate(ddt_t *ddt, const ddt_lightweight_entry_t *ddlwe,
28 ddt_stat_t *dds)
29 {
30 spa_t *spa = ddt->ddt_spa;
31 uint64_t lsize = DDK_GET_LSIZE(&ddlwe->ddlwe_key);
32 uint64_t psize = DDK_GET_PSIZE(&ddlwe->ddlwe_key);
33
34 memset(dds, 0, sizeof (*dds));
35
36 for (int p = 0; p < DDT_NPHYS(ddt); p++) {
37 const ddt_univ_phys_t *ddp = &ddlwe->ddlwe_phys;
38 ddt_phys_variant_t v = DDT_PHYS_VARIANT(ddt, p);
39
40 if (ddt_phys_birth(ddp, v) == 0)
41 continue;
42
43 int ndvas = ddt_phys_dva_count(ddp, v,
44 DDK_GET_CRYPT(&ddlwe->ddlwe_key));
45 const dva_t *dvas = (ddt->ddt_flags & DDT_FLAG_FLAT) ?
46 ddp->ddp_flat.ddp_dva : ddp->ddp_trad[p].ddp_dva;
47
48 uint64_t dsize = 0;
49 for (int d = 0; d < ndvas; d++)
50 dsize += dva_get_dsize_sync(spa, &dvas[d]);
51
52 uint64_t refcnt = ddt_phys_refcnt(ddp, v);
53
54 dds->dds_blocks += 1;
55 dds->dds_lsize += lsize;
56 dds->dds_psize += psize;
57 dds->dds_dsize += dsize;
58
59 dds->dds_ref_blocks += refcnt;
60 dds->dds_ref_lsize += lsize * refcnt;
61 dds->dds_ref_psize += psize * refcnt;
62 dds->dds_ref_dsize += dsize * refcnt;
63 }
64 }
65
66 static void
ddt_stat_add(ddt_stat_t * dst,const ddt_stat_t * src)67 ddt_stat_add(ddt_stat_t *dst, const ddt_stat_t *src)
68 {
69 dst->dds_blocks += src->dds_blocks;
70 dst->dds_lsize += src->dds_lsize;
71 dst->dds_psize += src->dds_psize;
72 dst->dds_dsize += src->dds_dsize;
73 dst->dds_ref_blocks += src->dds_ref_blocks;
74 dst->dds_ref_lsize += src->dds_ref_lsize;
75 dst->dds_ref_psize += src->dds_ref_psize;
76 dst->dds_ref_dsize += src->dds_ref_dsize;
77 }
78
79 static void
ddt_stat_sub(ddt_stat_t * dst,const ddt_stat_t * src)80 ddt_stat_sub(ddt_stat_t *dst, const ddt_stat_t *src)
81 {
82 /* This caught more during development than you might expect... */
83 ASSERT3U(dst->dds_blocks, >=, src->dds_blocks);
84 ASSERT3U(dst->dds_lsize, >=, src->dds_lsize);
85 ASSERT3U(dst->dds_psize, >=, src->dds_psize);
86 ASSERT3U(dst->dds_dsize, >=, src->dds_dsize);
87 ASSERT3U(dst->dds_ref_blocks, >=, src->dds_ref_blocks);
88 ASSERT3U(dst->dds_ref_lsize, >=, src->dds_ref_lsize);
89 ASSERT3U(dst->dds_ref_psize, >=, src->dds_ref_psize);
90 ASSERT3U(dst->dds_ref_dsize, >=, src->dds_ref_dsize);
91
92 dst->dds_blocks -= src->dds_blocks;
93 dst->dds_lsize -= src->dds_lsize;
94 dst->dds_psize -= src->dds_psize;
95 dst->dds_dsize -= src->dds_dsize;
96 dst->dds_ref_blocks -= src->dds_ref_blocks;
97 dst->dds_ref_lsize -= src->dds_ref_lsize;
98 dst->dds_ref_psize -= src->dds_ref_psize;
99 dst->dds_ref_dsize -= src->dds_ref_dsize;
100 }
101
102 void
ddt_histogram_add_entry(ddt_t * ddt,ddt_histogram_t * ddh,const ddt_lightweight_entry_t * ddlwe)103 ddt_histogram_add_entry(ddt_t *ddt, ddt_histogram_t *ddh,
104 const ddt_lightweight_entry_t *ddlwe)
105 {
106 ddt_stat_t dds;
107 int bucket;
108
109 ddt_stat_generate(ddt, ddlwe, &dds);
110
111 bucket = highbit64(dds.dds_ref_blocks) - 1;
112 if (bucket < 0)
113 return;
114
115 ddt_stat_add(&ddh->ddh_stat[bucket], &dds);
116 }
117
118 void
ddt_histogram_sub_entry(ddt_t * ddt,ddt_histogram_t * ddh,const ddt_lightweight_entry_t * ddlwe)119 ddt_histogram_sub_entry(ddt_t *ddt, ddt_histogram_t *ddh,
120 const ddt_lightweight_entry_t *ddlwe)
121 {
122 ddt_stat_t dds;
123 int bucket;
124
125 ddt_stat_generate(ddt, ddlwe, &dds);
126
127 bucket = highbit64(dds.dds_ref_blocks) - 1;
128 if (bucket < 0)
129 return;
130
131 ddt_stat_sub(&ddh->ddh_stat[bucket], &dds);
132 }
133
134 void
ddt_histogram_add(ddt_histogram_t * dst,const ddt_histogram_t * src)135 ddt_histogram_add(ddt_histogram_t *dst, const ddt_histogram_t *src)
136 {
137 for (int h = 0; h < 64; h++)
138 ddt_stat_add(&dst->ddh_stat[h], &src->ddh_stat[h]);
139 }
140
141 void
ddt_histogram_total(ddt_stat_t * dds,const ddt_histogram_t * ddh)142 ddt_histogram_total(ddt_stat_t *dds, const ddt_histogram_t *ddh)
143 {
144 memset(dds, 0, sizeof (*dds));
145
146 for (int h = 0; h < 64; h++)
147 ddt_stat_add(dds, &ddh->ddh_stat[h]);
148 }
149
150 boolean_t
ddt_histogram_empty(const ddt_histogram_t * ddh)151 ddt_histogram_empty(const ddt_histogram_t *ddh)
152 {
153 for (int h = 0; h < 64; h++) {
154 const ddt_stat_t *dds = &ddh->ddh_stat[h];
155
156 if (dds->dds_blocks == 0 &&
157 dds->dds_lsize == 0 &&
158 dds->dds_psize == 0 &&
159 dds->dds_dsize == 0 &&
160 dds->dds_ref_blocks == 0 &&
161 dds->dds_ref_lsize == 0 &&
162 dds->dds_ref_psize == 0 &&
163 dds->dds_ref_dsize == 0)
164 continue;
165
166 return (B_FALSE);
167 }
168
169 return (B_TRUE);
170 }
171
172 void
ddt_get_dedup_object_stats(spa_t * spa,ddt_object_t * ddo_total)173 ddt_get_dedup_object_stats(spa_t *spa, ddt_object_t *ddo_total)
174 {
175 memset(ddo_total, 0, sizeof (*ddo_total));
176
177 for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
178 ddt_t *ddt = spa->spa_ddt[c];
179 if (!ddt)
180 continue;
181
182 for (ddt_type_t type = 0; type < DDT_TYPES; type++) {
183 for (ddt_class_t class = 0; class < DDT_CLASSES;
184 class++) {
185 dmu_object_info_t doi;
186 uint64_t cnt;
187 int err;
188
189 /*
190 * These stats were originally calculated
191 * during ddt_object_load().
192 */
193
194 err = ddt_object_info(ddt, type, class, &doi);
195 if (err != 0)
196 continue;
197
198 err = ddt_object_count(ddt, type, class, &cnt);
199 if (err != 0)
200 continue;
201
202 ddt_object_t *ddo =
203 &ddt->ddt_object_stats[type][class];
204
205 ddo->ddo_count = cnt;
206 ddo->ddo_dspace =
207 doi.doi_physical_blocks_512 << 9;
208 ddo->ddo_mspace = doi.doi_fill_count *
209 doi.doi_data_block_size;
210
211 ddo_total->ddo_count += ddo->ddo_count;
212 ddo_total->ddo_dspace += ddo->ddo_dspace;
213 ddo_total->ddo_mspace += ddo->ddo_mspace;
214 }
215 }
216
217 ddt_object_t *ddo = &ddt->ddt_log_stats;
218 ddo_total->ddo_count += ddo->ddo_count;
219 ddo_total->ddo_dspace += ddo->ddo_dspace;
220 ddo_total->ddo_mspace += ddo->ddo_mspace;
221 }
222
223 /*
224 * This returns raw counts (not averages). One of the consumers,
225 * print_dedup_stats(), historically has expected raw counts.
226 */
227
228 spa->spa_dedup_dsize = ddo_total->ddo_dspace;
229 }
230
231 uint64_t
ddt_get_ddt_dsize(spa_t * spa)232 ddt_get_ddt_dsize(spa_t *spa)
233 {
234 ddt_object_t ddo_total;
235
236 /* recalculate after each txg sync */
237 if (spa->spa_dedup_dsize == ~0ULL)
238 ddt_get_dedup_object_stats(spa, &ddo_total);
239
240 return (spa->spa_dedup_dsize);
241 }
242
243 void
ddt_get_dedup_histogram(spa_t * spa,ddt_histogram_t * ddh)244 ddt_get_dedup_histogram(spa_t *spa, ddt_histogram_t *ddh)
245 {
246 for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
247 ddt_t *ddt = spa->spa_ddt[c];
248 if (!ddt)
249 continue;
250
251 for (ddt_type_t type = 0; type < DDT_TYPES; type++) {
252 for (ddt_class_t class = 0; class < DDT_CLASSES;
253 class++) {
254 ddt_histogram_add(ddh,
255 &ddt->ddt_histogram_cache[type][class]);
256 }
257 }
258
259 ddt_histogram_add(ddh, &ddt->ddt_log_histogram);
260 }
261 }
262
263 void
ddt_get_dedup_stats(spa_t * spa,ddt_stat_t * dds_total)264 ddt_get_dedup_stats(spa_t *spa, ddt_stat_t *dds_total)
265 {
266 ddt_histogram_t *ddh_total;
267
268 ddh_total = kmem_zalloc(sizeof (ddt_histogram_t), KM_SLEEP);
269 ddt_get_dedup_histogram(spa, ddh_total);
270 ddt_histogram_total(dds_total, ddh_total);
271 kmem_free(ddh_total, sizeof (ddt_histogram_t));
272 }
273
274 uint64_t
ddt_get_dedup_dspace(spa_t * spa)275 ddt_get_dedup_dspace(spa_t *spa)
276 {
277 ddt_stat_t dds_total;
278
279 if (spa->spa_dedup_dspace != ~0ULL)
280 return (spa->spa_dedup_dspace);
281
282 memset(&dds_total, 0, sizeof (ddt_stat_t));
283
284 /* Calculate and cache the stats */
285 ddt_get_dedup_stats(spa, &dds_total);
286 spa->spa_dedup_dspace = dds_total.dds_ref_dsize - dds_total.dds_dsize;
287 return (spa->spa_dedup_dspace);
288 }
289
290 uint64_t
ddt_get_dedup_used(spa_t * spa)291 ddt_get_dedup_used(spa_t *spa)
292 {
293 ddt_stat_t dds_total = { 0 };
294
295 ddt_get_dedup_stats(spa, &dds_total);
296 return (dds_total.dds_dsize);
297 }
298
299 uint64_t
ddt_get_dedup_saved(spa_t * spa)300 ddt_get_dedup_saved(spa_t *spa)
301 {
302 return (ddt_get_dedup_dspace(spa));
303 }
304
305 uint64_t
ddt_get_pool_dedup_ratio(spa_t * spa)306 ddt_get_pool_dedup_ratio(spa_t *spa)
307 {
308 ddt_stat_t dds_total = { 0 };
309
310 ddt_get_dedup_stats(spa, &dds_total);
311 if (dds_total.dds_dsize == 0)
312 return (100);
313
314 return (dds_total.dds_ref_dsize * 100 / dds_total.dds_dsize);
315 }
316
317 int
ddt_get_pool_dedup_cached(spa_t * spa,uint64_t * psize)318 ddt_get_pool_dedup_cached(spa_t *spa, uint64_t *psize)
319 {
320 uint64_t l1sz, l1tot, l2sz, l2tot;
321 int err = 0;
322
323 l1tot = l2tot = 0;
324 *psize = 0;
325 for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
326 ddt_t *ddt = spa->spa_ddt[c];
327 if (ddt == NULL)
328 continue;
329 for (ddt_type_t type = 0; type < DDT_TYPES; type++) {
330 for (ddt_class_t class = 0; class < DDT_CLASSES;
331 class++) {
332 err = dmu_object_cached_size(ddt->ddt_os,
333 ddt->ddt_object[type][class], &l1sz, &l2sz);
334 if (err != 0)
335 return (err);
336 l1tot += l1sz;
337 l2tot += l2sz;
338 }
339 }
340 }
341
342 *psize = l1tot + l2tot;
343 return (err);
344 }
345