1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright 2023 Red Hat
4 */
5
6 #include "dump.h"
7
8 #include <linux/module.h>
9
10 #include "memory-alloc.h"
11 #include "string-utils.h"
12
13 #include "constants.h"
14 #include "data-vio.h"
15 #include "dedupe.h"
16 #include "funnel-workqueue.h"
17 #include "io-submitter.h"
18 #include "logger.h"
19 #include "types.h"
20 #include "vdo.h"
21
22 enum dump_options {
23 /* Work queues */
24 SHOW_QUEUES,
25 /* Memory pools */
26 SHOW_VIO_POOL,
27 /* Others */
28 SHOW_VDO_STATUS,
29 /* This one means an option overrides the "default" choices, instead of altering them. */
30 SKIP_DEFAULT
31 };
32
33 enum dump_option_flags {
34 /* Work queues */
35 FLAG_SHOW_QUEUES = (1 << SHOW_QUEUES),
36 /* Memory pools */
37 FLAG_SHOW_VIO_POOL = (1 << SHOW_VIO_POOL),
38 /* Others */
39 FLAG_SHOW_VDO_STATUS = (1 << SHOW_VDO_STATUS),
40 /* Special */
41 FLAG_SKIP_DEFAULT = (1 << SKIP_DEFAULT)
42 };
43
44 #define FLAGS_ALL_POOLS (FLAG_SHOW_VIO_POOL)
45 #define DEFAULT_DUMP_FLAGS (FLAG_SHOW_QUEUES | FLAG_SHOW_VDO_STATUS)
46 /* Another static buffer... log10(256) = 2.408+, round up: */
47 #define DIGITS_PER_U64 (1 + sizeof(u64) * 2409 / 1000)
48
is_arg_string(const char * arg,const char * this_option)49 static inline bool is_arg_string(const char *arg, const char *this_option)
50 {
51 /* convention seems to be case-independent options */
52 return strncasecmp(arg, this_option, strlen(this_option)) == 0;
53 }
54
do_dump(struct vdo * vdo,unsigned int dump_options_requested,const char * why)55 static void do_dump(struct vdo *vdo, unsigned int dump_options_requested,
56 const char *why)
57 {
58 u32 active, maximum;
59 s64 outstanding;
60
61 vdo_log_info("%s dump triggered via %s", VDO_LOGGING_MODULE_NAME, why);
62 active = get_data_vio_pool_active_requests(vdo->data_vio_pool);
63 maximum = get_data_vio_pool_maximum_requests(vdo->data_vio_pool);
64 outstanding = (atomic64_read(&vdo->stats.bios_submitted) -
65 atomic64_read(&vdo->stats.bios_completed));
66 vdo_log_info("%u device requests outstanding (max %u), %lld bio requests outstanding, device '%s'",
67 active, maximum, outstanding,
68 vdo_get_device_name(vdo->device_config->owning_target));
69 if (((dump_options_requested & FLAG_SHOW_QUEUES) != 0) && (vdo->threads != NULL)) {
70 thread_id_t id;
71
72 for (id = 0; id < vdo->thread_config.thread_count; id++)
73 vdo_dump_work_queue(vdo->threads[id].queue);
74 }
75
76 vdo_dump_hash_zones(vdo->hash_zones);
77 dump_data_vio_pool(vdo->data_vio_pool,
78 (dump_options_requested & FLAG_SHOW_VIO_POOL) != 0);
79 if ((dump_options_requested & FLAG_SHOW_VDO_STATUS) != 0)
80 vdo_dump_status(vdo);
81
82 vdo_report_memory_usage();
83 vdo_log_info("end of %s dump", VDO_LOGGING_MODULE_NAME);
84 }
85
parse_dump_options(unsigned int argc,char * const * argv,unsigned int * dump_options_requested_ptr)86 static int parse_dump_options(unsigned int argc, char *const *argv,
87 unsigned int *dump_options_requested_ptr)
88 {
89 unsigned int dump_options_requested = 0;
90
91 static const struct {
92 const char *name;
93 unsigned int flags;
94 } option_names[] = {
95 { "viopool", FLAG_SKIP_DEFAULT | FLAG_SHOW_VIO_POOL },
96 { "vdo", FLAG_SKIP_DEFAULT | FLAG_SHOW_VDO_STATUS },
97 { "pools", FLAG_SKIP_DEFAULT | FLAGS_ALL_POOLS },
98 { "queues", FLAG_SKIP_DEFAULT | FLAG_SHOW_QUEUES },
99 { "threads", FLAG_SKIP_DEFAULT | FLAG_SHOW_QUEUES },
100 { "default", FLAG_SKIP_DEFAULT | DEFAULT_DUMP_FLAGS },
101 { "all", ~0 },
102 };
103
104 bool options_okay = true;
105 unsigned int i;
106
107 for (i = 1; i < argc; i++) {
108 unsigned int j;
109
110 for (j = 0; j < ARRAY_SIZE(option_names); j++) {
111 if (is_arg_string(argv[i], option_names[j].name)) {
112 dump_options_requested |= option_names[j].flags;
113 break;
114 }
115 }
116 if (j == ARRAY_SIZE(option_names)) {
117 vdo_log_warning("dump option name '%s' unknown", argv[i]);
118 options_okay = false;
119 }
120 }
121 if (!options_okay)
122 return -EINVAL;
123 if ((dump_options_requested & FLAG_SKIP_DEFAULT) == 0)
124 dump_options_requested |= DEFAULT_DUMP_FLAGS;
125 *dump_options_requested_ptr = dump_options_requested;
126 return 0;
127 }
128
129 /* Dump as specified by zero or more string arguments. */
vdo_dump(struct vdo * vdo,unsigned int argc,char * const * argv,const char * why)130 int vdo_dump(struct vdo *vdo, unsigned int argc, char *const *argv, const char *why)
131 {
132 unsigned int dump_options_requested = 0;
133 int result = parse_dump_options(argc, argv, &dump_options_requested);
134
135 if (result != 0)
136 return result;
137
138 do_dump(vdo, dump_options_requested, why);
139 return 0;
140 }
141
142 /* Dump everything we know how to dump */
vdo_dump_all(struct vdo * vdo,const char * why)143 void vdo_dump_all(struct vdo *vdo, const char *why)
144 {
145 do_dump(vdo, ~0, why);
146 }
147
148 /*
149 * Dump out the data_vio waiters on a waitq.
150 * wait_on should be the label to print for queue (e.g. logical or physical)
151 */
dump_vio_waiters(struct vdo_wait_queue * waitq,char * wait_on)152 static void dump_vio_waiters(struct vdo_wait_queue *waitq, char *wait_on)
153 {
154 struct vdo_waiter *waiter, *first = vdo_waitq_get_first_waiter(waitq);
155 struct data_vio *data_vio;
156
157 if (first == NULL)
158 return;
159
160 data_vio = vdo_waiter_as_data_vio(first);
161
162 vdo_log_info(" %s is locked. Waited on by: vio %px pbn %llu lbn %llu d-pbn %llu lastOp %s",
163 wait_on, data_vio, data_vio->allocation.pbn, data_vio->logical.lbn,
164 data_vio->duplicate.pbn, get_data_vio_operation_name(data_vio));
165
166 for (waiter = first->next_waiter; waiter != first; waiter = waiter->next_waiter) {
167 data_vio = vdo_waiter_as_data_vio(waiter);
168 vdo_log_info(" ... and : vio %px pbn %llu lbn %llu d-pbn %llu lastOp %s",
169 data_vio, data_vio->allocation.pbn, data_vio->logical.lbn,
170 data_vio->duplicate.pbn,
171 get_data_vio_operation_name(data_vio));
172 }
173 }
174
175 /*
176 * Encode various attributes of a data_vio as a string of one-character flags. This encoding is for
177 * logging brevity:
178 *
179 * R => vio completion result not VDO_SUCCESS
180 * W => vio is on a waitq
181 * D => vio is a duplicate
182 * p => vio is a partial block operation
183 * z => vio is a zero block
184 * d => vio is a discard
185 *
186 * The common case of no flags set will result in an empty, null-terminated buffer. If any flags
187 * are encoded, the first character in the string will be a space character.
188 */
encode_vio_dump_flags(struct data_vio * data_vio,char buffer[8])189 static void encode_vio_dump_flags(struct data_vio *data_vio, char buffer[8])
190 {
191 char *p_flag = buffer;
192 *p_flag++ = ' ';
193 if (data_vio->vio.completion.result != VDO_SUCCESS)
194 *p_flag++ = 'R';
195 if (data_vio->waiter.next_waiter != NULL)
196 *p_flag++ = 'W';
197 if (data_vio->is_duplicate)
198 *p_flag++ = 'D';
199 if (data_vio->is_partial)
200 *p_flag++ = 'p';
201 if (data_vio->is_zero)
202 *p_flag++ = 'z';
203 if (data_vio->remaining_discard > 0)
204 *p_flag++ = 'd';
205 if (p_flag == &buffer[1]) {
206 /* No flags, so remove the blank space. */
207 p_flag = buffer;
208 }
209 *p_flag = '\0';
210 }
211
212 /* Implements buffer_dump_function. */
dump_data_vio(void * data)213 void dump_data_vio(void *data)
214 {
215 struct data_vio *data_vio = data;
216
217 /*
218 * This just needs to be big enough to hold a queue (thread) name and a function name (plus
219 * a separator character and NUL). The latter is limited only by taste.
220 *
221 * In making this static, we're assuming only one "dump" will run at a time. If more than
222 * one does run, the log output will be garbled anyway.
223 */
224 static char vio_completion_dump_buffer[100 + MAX_VDO_WORK_QUEUE_NAME_LEN];
225 static char vio_block_number_dump_buffer[sizeof("P L D") + 3 * DIGITS_PER_U64];
226 static char vio_flush_generation_buffer[sizeof(" FG") + DIGITS_PER_U64];
227 static char flags_dump_buffer[8];
228
229 /*
230 * We're likely to be logging a couple thousand of these lines, and in some circumstances
231 * syslogd may have trouble keeping up, so keep it BRIEF rather than user-friendly.
232 */
233 vdo_dump_completion_to_buffer(&data_vio->vio.completion,
234 vio_completion_dump_buffer,
235 sizeof(vio_completion_dump_buffer));
236 if (data_vio->is_duplicate) {
237 snprintf(vio_block_number_dump_buffer,
238 sizeof(vio_block_number_dump_buffer), "P%llu L%llu D%llu",
239 data_vio->allocation.pbn, data_vio->logical.lbn,
240 data_vio->duplicate.pbn);
241 } else if (data_vio_has_allocation(data_vio)) {
242 snprintf(vio_block_number_dump_buffer,
243 sizeof(vio_block_number_dump_buffer), "P%llu L%llu",
244 data_vio->allocation.pbn, data_vio->logical.lbn);
245 } else {
246 snprintf(vio_block_number_dump_buffer,
247 sizeof(vio_block_number_dump_buffer), "L%llu",
248 data_vio->logical.lbn);
249 }
250
251 if (data_vio->flush_generation != 0) {
252 snprintf(vio_flush_generation_buffer,
253 sizeof(vio_flush_generation_buffer), " FG%llu",
254 data_vio->flush_generation);
255 } else {
256 vio_flush_generation_buffer[0] = 0;
257 }
258
259 encode_vio_dump_flags(data_vio, flags_dump_buffer);
260
261 vdo_log_info(" vio %px %s%s %s %s%s", data_vio,
262 vio_block_number_dump_buffer,
263 vio_flush_generation_buffer,
264 get_data_vio_operation_name(data_vio),
265 vio_completion_dump_buffer,
266 flags_dump_buffer);
267 /*
268 * might want info on: wantUDSAnswer / operation / status
269 * might want info on: bio / bios_merged
270 */
271
272 dump_vio_waiters(&data_vio->logical.waiters, "lbn");
273
274 /* might want to dump more info from vio here */
275 }
276