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 22enum 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 33enum 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 49static 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 55static 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 86static 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. */ 130int 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 */ 143void 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 */ 152static 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 */ 189static 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. */ 213void 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