1 // SPDX-License-Identifier: GPL-2.0-only
5 * Copyright (C) 2014 SUSE Linux Products GmbH
6 * Copyright (C) 2014 Hannes Reinecke <hare@suse.de>
9 #include <linux/kernel.h>
10 #include <linux/atomic.h>
12 #include <scsi/scsi.h>
13 #include <scsi/scsi_cmnd.h>
14 #include <scsi/scsi_device.h>
15 #include <scsi/scsi_eh.h>
16 #include <scsi/scsi_dbg.h>
18 static char *scsi_log_reserve_buffer(size_t *len)
21 return kmalloc(*len, GFP_ATOMIC);
24 static void scsi_log_release_buffer(char *bufptr)
29 static inline const char *scmd_name(const struct scsi_cmnd *scmd)
31 struct request *rq = scsi_cmd_to_rq((struct scsi_cmnd *)scmd);
35 return rq->q->disk->disk_name;
38 static size_t sdev_format_header(char *logbuf, size_t logbuf_len,
39 const char *name, int tag)
44 off += scnprintf(logbuf + off, logbuf_len - off,
47 if (WARN_ON(off >= logbuf_len))
51 off += scnprintf(logbuf + off, logbuf_len - off,
56 void sdev_prefix_printk(const char *level, const struct scsi_device *sdev,
57 const char *name, const char *fmt, ...)
61 size_t off = 0, logbuf_len;
66 logbuf = scsi_log_reserve_buffer(&logbuf_len);
71 off += scnprintf(logbuf + off, logbuf_len - off,
73 if (!WARN_ON(off >= logbuf_len)) {
75 off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args);
78 dev_printk(level, &sdev->sdev_gendev, "%s", logbuf);
79 scsi_log_release_buffer(logbuf);
81 EXPORT_SYMBOL(sdev_prefix_printk);
83 void scmd_printk(const char *level, const struct scsi_cmnd *scmd,
88 size_t off = 0, logbuf_len;
90 if (!scmd || !scmd->cmnd)
93 logbuf = scsi_log_reserve_buffer(&logbuf_len);
96 off = sdev_format_header(logbuf, logbuf_len, scmd_name(scmd),
97 scsi_cmd_to_rq((struct scsi_cmnd *)scmd)->tag);
98 if (off < logbuf_len) {
100 off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args);
103 dev_printk(level, &scmd->device->sdev_gendev, "%s", logbuf);
104 scsi_log_release_buffer(logbuf);
106 EXPORT_SYMBOL(scmd_printk);
108 static size_t scsi_format_opcode_name(char *buffer, size_t buf_len,
109 const unsigned char *cdbp)
112 const char *cdb_name = NULL, *sa_name = NULL;
116 if (cdb0 == VARIABLE_LENGTH_CMD) {
117 int len = scsi_varlen_cdb_length(cdbp);
120 off = scnprintf(buffer, buf_len,
121 "short variable length command, len=%d",
125 sa = (cdbp[8] << 8) + cdbp[9];
129 if (!scsi_opcode_sa_name(cdb0, sa, &cdb_name, &sa_name)) {
131 off = scnprintf(buffer, buf_len, "%s", cdb_name);
133 off = scnprintf(buffer, buf_len, "opcode=0x%x", cdb0);
134 if (WARN_ON(off >= buf_len))
136 if (cdb0 >= VENDOR_SPECIFIC_CDB)
137 off += scnprintf(buffer + off, buf_len - off,
139 else if (cdb0 >= 0x60 && cdb0 < 0x7e)
140 off += scnprintf(buffer + off, buf_len - off,
145 off = scnprintf(buffer, buf_len, "%s", sa_name);
147 off = scnprintf(buffer, buf_len, "%s, sa=0x%x",
150 off = scnprintf(buffer, buf_len,
151 "opcode=0x%x, sa=0x%x", cdb0, sa);
153 WARN_ON(off >= buf_len);
157 size_t __scsi_format_command(char *logbuf, size_t logbuf_len,
158 const unsigned char *cdb, size_t cdb_len)
163 off = scsi_format_opcode_name(logbuf, logbuf_len, cdb);
164 if (off >= logbuf_len)
166 len = scsi_command_size(cdb);
169 /* print out all bytes in cdb */
170 for (k = 0; k < len; ++k) {
171 if (off > logbuf_len - 3)
173 off += scnprintf(logbuf + off, logbuf_len - off,
178 EXPORT_SYMBOL(__scsi_format_command);
180 void scsi_print_command(struct scsi_cmnd *cmd)
184 size_t off, logbuf_len;
189 logbuf = scsi_log_reserve_buffer(&logbuf_len);
193 off = sdev_format_header(logbuf, logbuf_len,
194 scmd_name(cmd), scsi_cmd_to_rq(cmd)->tag);
195 if (off >= logbuf_len)
197 off += scnprintf(logbuf + off, logbuf_len - off, "CDB: ");
198 if (WARN_ON(off >= logbuf_len))
201 off += scsi_format_opcode_name(logbuf + off, logbuf_len - off,
203 if (off >= logbuf_len)
206 /* print out all bytes in cdb */
207 if (cmd->cmd_len > 16) {
208 /* Print opcode in one line and use separate lines for CDB */
209 off += scnprintf(logbuf + off, logbuf_len - off, "\n");
210 dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf);
211 for (k = 0; k < cmd->cmd_len; k += 16) {
212 size_t linelen = min(cmd->cmd_len - k, 16);
214 off = sdev_format_header(logbuf, logbuf_len,
216 scsi_cmd_to_rq(cmd)->tag);
217 if (!WARN_ON(off > logbuf_len - 58)) {
218 off += scnprintf(logbuf + off, logbuf_len - off,
220 hex_dump_to_buffer(&cmd->cmnd[k], linelen,
222 logbuf_len - off, false);
224 dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s",
229 if (!WARN_ON(off > logbuf_len - 49)) {
230 off += scnprintf(logbuf + off, logbuf_len - off, " ");
231 hex_dump_to_buffer(cmd->cmnd, cmd->cmd_len, 16, 1,
232 logbuf + off, logbuf_len - off,
236 dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf);
238 scsi_log_release_buffer(logbuf);
240 EXPORT_SYMBOL(scsi_print_command);
243 scsi_format_extd_sense(char *buffer, size_t buf_len,
244 unsigned char asc, unsigned char ascq)
247 const char *extd_sense_fmt = NULL;
248 const char *extd_sense_str = scsi_extd_sense_format(asc, ascq,
251 if (extd_sense_str) {
252 off = scnprintf(buffer, buf_len, "Add. Sense: %s",
255 off += scnprintf(buffer + off, buf_len - off,
256 "(%s%x)", extd_sense_fmt, ascq);
259 off = scnprintf(buffer, buf_len, "<<vendor>>");
260 off += scnprintf(buffer + off, buf_len - off,
263 off += scnprintf(buffer + off, buf_len - off,
265 off += scnprintf(buffer + off, buf_len - off,
272 scsi_format_sense_hdr(char *buffer, size_t buf_len,
273 const struct scsi_sense_hdr *sshdr)
275 const char *sense_txt;
278 off = scnprintf(buffer, buf_len, "Sense Key : ");
279 sense_txt = scsi_sense_key_string(sshdr->sense_key);
281 off += scnprintf(buffer + off, buf_len - off,
284 off += scnprintf(buffer + off, buf_len - off,
285 "0x%x ", sshdr->sense_key);
286 off += scnprintf(buffer + off, buf_len - off,
287 scsi_sense_is_deferred(sshdr) ? "[deferred] " : "[current] ");
289 if (sshdr->response_code >= 0x72)
290 off += scnprintf(buffer + off, buf_len - off, "[descriptor] ");
295 scsi_log_dump_sense(const struct scsi_device *sdev, const char *name, int tag,
296 const unsigned char *sense_buffer, int sense_len)
302 logbuf = scsi_log_reserve_buffer(&logbuf_len);
306 for (i = 0; i < sense_len; i += 16) {
307 int len = min(sense_len - i, 16);
310 off = sdev_format_header(logbuf, logbuf_len,
312 hex_dump_to_buffer(&sense_buffer[i], len, 16, 1,
313 logbuf + off, logbuf_len - off,
315 dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf);
317 scsi_log_release_buffer(logbuf);
321 scsi_log_print_sense_hdr(const struct scsi_device *sdev, const char *name,
322 int tag, const struct scsi_sense_hdr *sshdr)
325 size_t off, logbuf_len;
327 logbuf = scsi_log_reserve_buffer(&logbuf_len);
330 off = sdev_format_header(logbuf, logbuf_len, name, tag);
331 off += scsi_format_sense_hdr(logbuf + off, logbuf_len - off, sshdr);
332 dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf);
333 scsi_log_release_buffer(logbuf);
335 logbuf = scsi_log_reserve_buffer(&logbuf_len);
338 off = sdev_format_header(logbuf, logbuf_len, name, tag);
339 off += scsi_format_extd_sense(logbuf + off, logbuf_len - off,
340 sshdr->asc, sshdr->ascq);
341 dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf);
342 scsi_log_release_buffer(logbuf);
346 scsi_log_print_sense(const struct scsi_device *sdev, const char *name, int tag,
347 const unsigned char *sense_buffer, int sense_len)
349 struct scsi_sense_hdr sshdr;
351 if (scsi_normalize_sense(sense_buffer, sense_len, &sshdr))
352 scsi_log_print_sense_hdr(sdev, name, tag, &sshdr);
354 scsi_log_dump_sense(sdev, name, tag, sense_buffer, sense_len);
358 * Print normalized SCSI sense header with a prefix.
361 scsi_print_sense_hdr(const struct scsi_device *sdev, const char *name,
362 const struct scsi_sense_hdr *sshdr)
364 scsi_log_print_sense_hdr(sdev, name, -1, sshdr);
366 EXPORT_SYMBOL(scsi_print_sense_hdr);
368 /* Normalize and print sense buffer with name prefix */
369 void __scsi_print_sense(const struct scsi_device *sdev, const char *name,
370 const unsigned char *sense_buffer, int sense_len)
372 scsi_log_print_sense(sdev, name, -1, sense_buffer, sense_len);
374 EXPORT_SYMBOL(__scsi_print_sense);
376 /* Normalize and print sense buffer in SCSI command */
377 void scsi_print_sense(const struct scsi_cmnd *cmd)
379 scsi_log_print_sense(cmd->device, scmd_name(cmd),
380 scsi_cmd_to_rq((struct scsi_cmnd *)cmd)->tag,
381 cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE);
383 EXPORT_SYMBOL(scsi_print_sense);
385 void scsi_print_result(const struct scsi_cmnd *cmd, const char *msg,
389 size_t off, logbuf_len;
390 const char *mlret_string = scsi_mlreturn_string(disposition);
391 const char *hb_string = scsi_hostbyte_string(cmd->result);
392 unsigned long cmd_age = (jiffies - cmd->jiffies_at_alloc) / HZ;
394 logbuf = scsi_log_reserve_buffer(&logbuf_len);
398 off = sdev_format_header(logbuf, logbuf_len, scmd_name(cmd),
399 scsi_cmd_to_rq((struct scsi_cmnd *)cmd)->tag);
401 if (off >= logbuf_len)
405 off += scnprintf(logbuf + off, logbuf_len - off,
407 if (WARN_ON(off >= logbuf_len))
411 off += scnprintf(logbuf + off, logbuf_len - off,
412 "%s ", mlret_string);
414 off += scnprintf(logbuf + off, logbuf_len - off,
415 "UNKNOWN(0x%02x) ", disposition);
416 if (WARN_ON(off >= logbuf_len))
419 off += scnprintf(logbuf + off, logbuf_len - off, "Result: ");
420 if (WARN_ON(off >= logbuf_len))
424 off += scnprintf(logbuf + off, logbuf_len - off,
425 "hostbyte=%s ", hb_string);
427 off += scnprintf(logbuf + off, logbuf_len - off,
428 "hostbyte=0x%02x ", host_byte(cmd->result));
429 if (WARN_ON(off >= logbuf_len))
432 off += scnprintf(logbuf + off, logbuf_len - off,
433 "driverbyte=DRIVER_OK ");
435 off += scnprintf(logbuf + off, logbuf_len - off,
436 "cmd_age=%lus", cmd_age);
439 dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf);
440 scsi_log_release_buffer(logbuf);
442 EXPORT_SYMBOL(scsi_print_result);