Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright 2023 Red Hat
4 */
5
6#include "dedupe.h"
7#include "logger.h"
8#include "memory-alloc.h"
9#include "message-stats.h"
10#include "statistics.h"
11#include "thread-device.h"
12#include "vdo.h"
13
14static void write_u64(char *prefix, u64 value, char *suffix, char **buf,
15 unsigned int *maxlen)
16{
17 int count;
18
19 count = scnprintf(*buf, *maxlen, "%s%llu%s", prefix == NULL ? "" : prefix,
20 value, suffix == NULL ? "" : suffix);
21 *buf += count;
22 *maxlen -= count;
23}
24
25static void write_u32(char *prefix, u32 value, char *suffix, char **buf,
26 unsigned int *maxlen)
27{
28 int count;
29
30 count = scnprintf(*buf, *maxlen, "%s%u%s", prefix == NULL ? "" : prefix,
31 value, suffix == NULL ? "" : suffix);
32 *buf += count;
33 *maxlen -= count;
34}
35
36static void write_block_count_t(char *prefix, block_count_t value, char *suffix,
37 char **buf, unsigned int *maxlen)
38{
39 int count;
40
41 count = scnprintf(*buf, *maxlen, "%s%llu%s", prefix == NULL ? "" : prefix,
42 value, suffix == NULL ? "" : suffix);
43 *buf += count;
44 *maxlen -= count;
45}
46
47static void write_string(char *prefix, char *value, char *suffix, char **buf,
48 unsigned int *maxlen)
49{
50 int count;
51
52 count = scnprintf(*buf, *maxlen, "%s%s%s", prefix == NULL ? "" : prefix,
53 value, suffix == NULL ? "" : suffix);
54 *buf += count;
55 *maxlen -= count;
56}
57
58static void write_bool(char *prefix, bool value, char *suffix, char **buf,
59 unsigned int *maxlen)
60{
61 int count;
62
63 count = scnprintf(*buf, *maxlen, "%s%d%s", prefix == NULL ? "" : prefix,
64 value, suffix == NULL ? "" : suffix);
65 *buf += count;
66 *maxlen -= count;
67}
68
69static void write_u8(char *prefix, u8 value, char *suffix, char **buf,
70 unsigned int *maxlen)
71{
72 int count;
73
74 count = scnprintf(*buf, *maxlen, "%s%u%s", prefix == NULL ? "" : prefix,
75 value, suffix == NULL ? "" : suffix);
76 *buf += count;
77 *maxlen -= count;
78}
79
80static void write_block_allocator_statistics(char *prefix,
81 struct block_allocator_statistics *stats,
82 char *suffix, char **buf,
83 unsigned int *maxlen)
84{
85 write_string(prefix, "{ ", NULL, buf, maxlen);
86 /* The total number of slabs from which blocks may be allocated */
87 write_u64("slabCount : ", stats->slab_count, ", ", buf, maxlen);
88 /* The total number of slabs from which blocks have ever been allocated */
89 write_u64("slabsOpened : ", stats->slabs_opened, ", ", buf, maxlen);
90 /* The number of times since loading that a slab has been re-opened */
91 write_u64("slabsReopened : ", stats->slabs_reopened, ", ", buf, maxlen);
92 write_string(NULL, "}", suffix, buf, maxlen);
93}
94
95static void write_commit_statistics(char *prefix, struct commit_statistics *stats,
96 char *suffix, char **buf, unsigned int *maxlen)
97{
98 write_string(prefix, "{ ", NULL, buf, maxlen);
99 /* The total number of items on which processing has started */
100 write_u64("started : ", stats->started, ", ", buf, maxlen);
101 /* The total number of items for which a write operation has been issued */
102 write_u64("written : ", stats->written, ", ", buf, maxlen);
103 /* The total number of items for which a write operation has completed */
104 write_u64("committed : ", stats->committed, ", ", buf, maxlen);
105 write_string(NULL, "}", suffix, buf, maxlen);
106}
107
108static void write_recovery_journal_statistics(char *prefix,
109 struct recovery_journal_statistics *stats,
110 char *suffix, char **buf,
111 unsigned int *maxlen)
112{
113 write_string(prefix, "{ ", NULL, buf, maxlen);
114 /* Number of times the on-disk journal was full */
115 write_u64("diskFull : ", stats->disk_full, ", ", buf, maxlen);
116 /* Number of times the recovery journal requested slab journal commits. */
117 write_u64("slabJournalCommitsRequested : ",
118 stats->slab_journal_commits_requested, ", ", buf, maxlen);
119 /* Write/Commit totals for individual journal entries */
120 write_commit_statistics("entries : ", &stats->entries, ", ", buf, maxlen);
121 /* Write/Commit totals for journal blocks */
122 write_commit_statistics("blocks : ", &stats->blocks, ", ", buf, maxlen);
123 write_string(NULL, "}", suffix, buf, maxlen);
124}
125
126static void write_packer_statistics(char *prefix, struct packer_statistics *stats,
127 char *suffix, char **buf, unsigned int *maxlen)
128{
129 write_string(prefix, "{ ", NULL, buf, maxlen);
130 /* Number of compressed data items written since startup */
131 write_u64("compressedFragmentsWritten : ",
132 stats->compressed_fragments_written, ", ", buf, maxlen);
133 /* Number of blocks containing compressed items written since startup */
134 write_u64("compressedBlocksWritten : ",
135 stats->compressed_blocks_written, ", ", buf, maxlen);
136 /* Number of VIOs that are pending in the packer */
137 write_u64("compressedFragmentsInPacker : ",
138 stats->compressed_fragments_in_packer, ", ", buf, maxlen);
139 write_string(NULL, "}", suffix, buf, maxlen);
140}
141
142static void write_slab_journal_statistics(char *prefix,
143 struct slab_journal_statistics *stats,
144 char *suffix, char **buf, unsigned int *maxlen)
145{
146 write_string(prefix, "{ ", NULL, buf, maxlen);
147 /* Number of times the on-disk journal was full */
148 write_u64("diskFullCount : ", stats->disk_full_count, ", ", buf, maxlen);
149 /* Number of times an entry was added over the flush threshold */
150 write_u64("flushCount : ", stats->flush_count, ", ", buf, maxlen);
151 /* Number of times an entry was added over the block threshold */
152 write_u64("blockedCount : ", stats->blocked_count, ", ", buf, maxlen);
153 /* Number of times a tail block was written */
154 write_u64("blocksWritten : ", stats->blocks_written, ", ", buf, maxlen);
155 /* Number of times we had to wait for the tail to write */
156 write_u64("tailBusyCount : ", stats->tail_busy_count, ", ", buf, maxlen);
157 write_string(NULL, "}", suffix, buf, maxlen);
158}
159
160static void write_slab_summary_statistics(char *prefix,
161 struct slab_summary_statistics *stats,
162 char *suffix, char **buf, unsigned int *maxlen)
163{
164 write_string(prefix, "{ ", NULL, buf, maxlen);
165 /* Number of blocks written */
166 write_u64("blocksWritten : ", stats->blocks_written, ", ", buf, maxlen);
167 write_string(NULL, "}", suffix, buf, maxlen);
168}
169
170static void write_ref_counts_statistics(char *prefix, struct ref_counts_statistics *stats,
171 char *suffix, char **buf, unsigned int *maxlen)
172{
173 write_string(prefix, "{ ", NULL, buf, maxlen);
174 /* Number of reference blocks written */
175 write_u64("blocksWritten : ", stats->blocks_written, ", ", buf, maxlen);
176 write_string(NULL, "}", suffix, buf, maxlen);
177}
178
179static void write_block_map_statistics(char *prefix, struct block_map_statistics *stats,
180 char *suffix, char **buf, unsigned int *maxlen)
181{
182 write_string(prefix, "{ ", NULL, buf, maxlen);
183 /* number of dirty (resident) pages */
184 write_u32("dirtyPages : ", stats->dirty_pages, ", ", buf, maxlen);
185 /* number of clean (resident) pages */
186 write_u32("cleanPages : ", stats->clean_pages, ", ", buf, maxlen);
187 /* number of free pages */
188 write_u32("freePages : ", stats->free_pages, ", ", buf, maxlen);
189 /* number of pages in failed state */
190 write_u32("failedPages : ", stats->failed_pages, ", ", buf, maxlen);
191 /* number of pages incoming */
192 write_u32("incomingPages : ", stats->incoming_pages, ", ", buf, maxlen);
193 /* number of pages outgoing */
194 write_u32("outgoingPages : ", stats->outgoing_pages, ", ", buf, maxlen);
195 /* how many times free page not avail */
196 write_u32("cachePressure : ", stats->cache_pressure, ", ", buf, maxlen);
197 /* number of get_vdo_page() calls for read */
198 write_u64("readCount : ", stats->read_count, ", ", buf, maxlen);
199 /* number of get_vdo_page() calls for write */
200 write_u64("writeCount : ", stats->write_count, ", ", buf, maxlen);
201 /* number of times pages failed to read */
202 write_u64("failedReads : ", stats->failed_reads, ", ", buf, maxlen);
203 /* number of times pages failed to write */
204 write_u64("failedWrites : ", stats->failed_writes, ", ", buf, maxlen);
205 /* number of gets that are reclaimed */
206 write_u64("reclaimed : ", stats->reclaimed, ", ", buf, maxlen);
207 /* number of gets for outgoing pages */
208 write_u64("readOutgoing : ", stats->read_outgoing, ", ", buf, maxlen);
209 /* number of gets that were already there */
210 write_u64("foundInCache : ", stats->found_in_cache, ", ", buf, maxlen);
211 /* number of gets requiring discard */
212 write_u64("discardRequired : ", stats->discard_required, ", ", buf, maxlen);
213 /* number of gets enqueued for their page */
214 write_u64("waitForPage : ", stats->wait_for_page, ", ", buf, maxlen);
215 /* number of gets that have to fetch */
216 write_u64("fetchRequired : ", stats->fetch_required, ", ", buf, maxlen);
217 /* number of page fetches */
218 write_u64("pagesLoaded : ", stats->pages_loaded, ", ", buf, maxlen);
219 /* number of page saves */
220 write_u64("pagesSaved : ", stats->pages_saved, ", ", buf, maxlen);
221 /* the number of flushes issued */
222 write_u64("flushCount : ", stats->flush_count, ", ", buf, maxlen);
223 write_string(NULL, "}", suffix, buf, maxlen);
224}
225
226static void write_hash_lock_statistics(char *prefix, struct hash_lock_statistics *stats,
227 char *suffix, char **buf, unsigned int *maxlen)
228{
229 write_string(prefix, "{ ", NULL, buf, maxlen);
230 /* Number of times the UDS advice proved correct */
231 write_u64("dedupeAdviceValid : ", stats->dedupe_advice_valid, ", ", buf, maxlen);
232 /* Number of times the UDS advice proved incorrect */
233 write_u64("dedupeAdviceStale : ", stats->dedupe_advice_stale, ", ", buf, maxlen);
234 /* Number of writes with the same data as another in-flight write */
235 write_u64("concurrentDataMatches : ", stats->concurrent_data_matches,
236 ", ", buf, maxlen);
237 /* Number of writes whose hash collided with an in-flight write */
238 write_u64("concurrentHashCollisions : ",
239 stats->concurrent_hash_collisions, ", ", buf, maxlen);
240 /* Current number of dedupe queries that are in flight */
241 write_u32("currDedupeQueries : ", stats->curr_dedupe_queries, ", ", buf, maxlen);
242 write_string(NULL, "}", suffix, buf, maxlen);
243}
244
245static void write_error_statistics(char *prefix, struct error_statistics *stats,
246 char *suffix, char **buf, unsigned int *maxlen)
247{
248 write_string(prefix, "{ ", NULL, buf, maxlen);
249 /* number of times VDO got an invalid dedupe advice PBN from UDS */
250 write_u64("invalidAdvicePBNCount : ", stats->invalid_advice_pbn_count,
251 ", ", buf, maxlen);
252 /* number of times a VIO completed with a VDO_NO_SPACE error */
253 write_u64("noSpaceErrorCount : ", stats->no_space_error_count, ", ",
254 buf, maxlen);
255 /* number of times a VIO completed with a VDO_READ_ONLY error */
256 write_u64("readOnlyErrorCount : ", stats->read_only_error_count, ", ",
257 buf, maxlen);
258 write_string(NULL, "}", suffix, buf, maxlen);
259}
260
261static void write_bio_stats(char *prefix, struct bio_stats *stats, char *suffix,
262 char **buf, unsigned int *maxlen)
263{
264 write_string(prefix, "{ ", NULL, buf, maxlen);
265 /* Number of REQ_OP_READ bios */
266 write_u64("read : ", stats->read, ", ", buf, maxlen);
267 /* Number of REQ_OP_WRITE bios with data */
268 write_u64("write : ", stats->write, ", ", buf, maxlen);
269 /* Number of bios tagged with REQ_PREFLUSH and containing no data */
270 write_u64("emptyFlush : ", stats->empty_flush, ", ", buf, maxlen);
271 /* Number of REQ_OP_DISCARD bios */
272 write_u64("discard : ", stats->discard, ", ", buf, maxlen);
273 /* Number of bios tagged with REQ_PREFLUSH */
274 write_u64("flush : ", stats->flush, ", ", buf, maxlen);
275 /* Number of bios tagged with REQ_FUA */
276 write_u64("fua : ", stats->fua, ", ", buf, maxlen);
277 write_string(NULL, "}", suffix, buf, maxlen);
278}
279
280static void write_memory_usage(char *prefix, struct memory_usage *stats, char *suffix,
281 char **buf, unsigned int *maxlen)
282{
283 write_string(prefix, "{ ", NULL, buf, maxlen);
284 /* Tracked bytes currently allocated. */
285 write_u64("bytesUsed : ", stats->bytes_used, ", ", buf, maxlen);
286 /* Maximum tracked bytes allocated. */
287 write_u64("peakBytesUsed : ", stats->peak_bytes_used, ", ", buf, maxlen);
288 write_string(NULL, "}", suffix, buf, maxlen);
289}
290
291static void write_index_statistics(char *prefix, struct index_statistics *stats,
292 char *suffix, char **buf, unsigned int *maxlen)
293{
294 write_string(prefix, "{ ", NULL, buf, maxlen);
295 /* Number of records stored in the index */
296 write_u64("entriesIndexed : ", stats->entries_indexed, ", ", buf, maxlen);
297 /* Number of post calls that found an existing entry */
298 write_u64("postsFound : ", stats->posts_found, ", ", buf, maxlen);
299 /* Number of post calls that added a new entry */
300 write_u64("postsNotFound : ", stats->posts_not_found, ", ", buf, maxlen);
301 /* Number of query calls that found an existing entry */
302 write_u64("queriesFound : ", stats->queries_found, ", ", buf, maxlen);
303 /* Number of query calls that added a new entry */
304 write_u64("queriesNotFound : ", stats->queries_not_found, ", ", buf, maxlen);
305 /* Number of update calls that found an existing entry */
306 write_u64("updatesFound : ", stats->updates_found, ", ", buf, maxlen);
307 /* Number of update calls that added a new entry */
308 write_u64("updatesNotFound : ", stats->updates_not_found, ", ", buf, maxlen);
309 /* Number of entries discarded */
310 write_u64("entriesDiscarded : ", stats->entries_discarded, ", ", buf, maxlen);
311 write_string(NULL, "}", suffix, buf, maxlen);
312}
313
314static void write_vdo_statistics(char *prefix, struct vdo_statistics *stats, char *suffix,
315 char **buf, unsigned int *maxlen)
316{
317 write_string(prefix, "{ ", NULL, buf, maxlen);
318 write_u32("version : ", stats->version, ", ", buf, maxlen);
319 /* Number of blocks used for data */
320 write_u64("dataBlocksUsed : ", stats->data_blocks_used, ", ", buf, maxlen);
321 /* Number of blocks used for VDO metadata */
322 write_u64("overheadBlocksUsed : ", stats->overhead_blocks_used, ", ",
323 buf, maxlen);
324 /* Number of logical blocks that are currently mapped to physical blocks */
325 write_u64("logicalBlocksUsed : ", stats->logical_blocks_used, ", ", buf, maxlen);
326 /* number of physical blocks */
327 write_block_count_t("physicalBlocks : ", stats->physical_blocks, ", ",
328 buf, maxlen);
329 /* number of logical blocks */
330 write_block_count_t("logicalBlocks : ", stats->logical_blocks, ", ",
331 buf, maxlen);
332 /* Size of the block map page cache, in bytes */
333 write_u64("blockMapCacheSize : ", stats->block_map_cache_size, ", ",
334 buf, maxlen);
335 /* The physical block size */
336 write_u64("blockSize : ", stats->block_size, ", ", buf, maxlen);
337 /* Number of times the VDO has successfully recovered */
338 write_u64("completeRecoveries : ", stats->complete_recoveries, ", ",
339 buf, maxlen);
340 /* Number of times the VDO has recovered from read-only mode */
341 write_u64("readOnlyRecoveries : ", stats->read_only_recoveries, ", ",
342 buf, maxlen);
343 /* String describing the operating mode of the VDO */
344 write_string("mode : ", stats->mode, ", ", buf, maxlen);
345 /* Whether the VDO is in recovery mode */
346 write_bool("inRecoveryMode : ", stats->in_recovery_mode, ", ", buf, maxlen);
347 /* What percentage of recovery mode work has been completed */
348 write_u8("recoveryPercentage : ", stats->recovery_percentage, ", ", buf, maxlen);
349 /* The statistics for the compressed block packer */
350 write_packer_statistics("packer : ", &stats->packer, ", ", buf, maxlen);
351 /* Counters for events in the block allocator */
352 write_block_allocator_statistics("allocator : ", &stats->allocator,
353 ", ", buf, maxlen);
354 /* Counters for events in the recovery journal */
355 write_recovery_journal_statistics("journal : ", &stats->journal, ", ",
356 buf, maxlen);
357 /* The statistics for the slab journals */
358 write_slab_journal_statistics("slabJournal : ", &stats->slab_journal,
359 ", ", buf, maxlen);
360 /* The statistics for the slab summary */
361 write_slab_summary_statistics("slabSummary : ", &stats->slab_summary,
362 ", ", buf, maxlen);
363 /* The statistics for the reference counts */
364 write_ref_counts_statistics("refCounts : ", &stats->ref_counts, ", ",
365 buf, maxlen);
366 /* The statistics for the block map */
367 write_block_map_statistics("blockMap : ", &stats->block_map, ", ", buf, maxlen);
368 /* The dedupe statistics from hash locks */
369 write_hash_lock_statistics("hashLock : ", &stats->hash_lock, ", ", buf, maxlen);
370 /* Counts of error conditions */
371 write_error_statistics("errors : ", &stats->errors, ", ", buf, maxlen);
372 /* The VDO instance */
373 write_u32("instance : ", stats->instance, ", ", buf, maxlen);
374 /* Current number of active VIOs */
375 write_u32("currentVIOsInProgress : ", stats->current_vios_in_progress,
376 ", ", buf, maxlen);
377 /* Maximum number of active VIOs */
378 write_u32("maxVIOs : ", stats->max_vios, ", ", buf, maxlen);
379 /* Number of times the UDS index was too slow in responding */
380 write_u64("dedupeAdviceTimeouts : ", stats->dedupe_advice_timeouts,
381 ", ", buf, maxlen);
382 /* Number of flush requests submitted to the storage device */
383 write_u64("flushOut : ", stats->flush_out, ", ", buf, maxlen);
384 /* Logical block size */
385 write_u64("logicalBlockSize : ", stats->logical_block_size, ", ", buf, maxlen);
386 /* Bios submitted into VDO from above */
387 write_bio_stats("biosIn : ", &stats->bios_in, ", ", buf, maxlen);
388 write_bio_stats("biosInPartial : ", &stats->bios_in_partial, ", ", buf, maxlen);
389 /* Bios submitted onward for user data */
390 write_bio_stats("biosOut : ", &stats->bios_out, ", ", buf, maxlen);
391 /* Bios submitted onward for metadata */
392 write_bio_stats("biosMeta : ", &stats->bios_meta, ", ", buf, maxlen);
393 write_bio_stats("biosJournal : ", &stats->bios_journal, ", ", buf, maxlen);
394 write_bio_stats("biosPageCache : ", &stats->bios_page_cache, ", ", buf, maxlen);
395 write_bio_stats("biosOutCompleted : ", &stats->bios_out_completed, ", ",
396 buf, maxlen);
397 write_bio_stats("biosMetaCompleted : ", &stats->bios_meta_completed,
398 ", ", buf, maxlen);
399 write_bio_stats("biosJournalCompleted : ",
400 &stats->bios_journal_completed, ", ", buf, maxlen);
401 write_bio_stats("biosPageCacheCompleted : ",
402 &stats->bios_page_cache_completed, ", ", buf, maxlen);
403 write_bio_stats("biosAcknowledged : ", &stats->bios_acknowledged, ", ",
404 buf, maxlen);
405 write_bio_stats("biosAcknowledgedPartial : ",
406 &stats->bios_acknowledged_partial, ", ", buf, maxlen);
407 /* Current number of bios in progress */
408 write_bio_stats("biosInProgress : ", &stats->bios_in_progress, ", ",
409 buf, maxlen);
410 /* Memory usage stats. */
411 write_memory_usage("memoryUsage : ", &stats->memory_usage, ", ", buf, maxlen);
412 /* The statistics for the UDS index */
413 write_index_statistics("index : ", &stats->index, ", ", buf, maxlen);
414 write_string(NULL, "}", suffix, buf, maxlen);
415}
416
417int vdo_write_stats(struct vdo *vdo, char *buf, unsigned int maxlen)
418{
419 struct vdo_statistics *stats;
420 int result;
421
422 result = vdo_allocate(1, struct vdo_statistics, __func__, &stats);
423 if (result != VDO_SUCCESS) {
424 vdo_log_error("Cannot allocate memory to write VDO statistics");
425 return result;
426 }
427
428 vdo_fetch_statistics(vdo, stats);
429 write_vdo_statistics(NULL, stats, NULL, &buf, &maxlen);
430 vdo_free(stats);
431 return VDO_SUCCESS;
432}