]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/scsi/scsi_logging.c
4 * Copyright (C) 2014 SUSE Linux Products GmbH
5 * Copyright (C) 2014 Hannes Reinecke <hare@suse.de>
7 * This file is released under the GPLv2
10 #include <linux/kernel.h>
11 #include <linux/atomic.h>
13 #include <scsi/scsi.h>
14 #include <scsi/scsi_cmnd.h>
15 #include <scsi/scsi_device.h>
16 #include <scsi/scsi_eh.h>
17 #include <scsi/scsi_dbg.h>
19 #define SCSI_LOG_SPOOLSIZE 4096
21 #if (SCSI_LOG_SPOOLSIZE / SCSI_LOG_BUFSIZE) > BITS_PER_LONG
22 #warning SCSI logging bitmask too large
26 char buffer
[SCSI_LOG_SPOOLSIZE
];
30 static DEFINE_PER_CPU(struct scsi_log_buf
, scsi_format_log
);
32 static char *scsi_log_reserve_buffer(size_t *len
)
34 struct scsi_log_buf
*buf
;
35 unsigned long map_bits
= sizeof(buf
->buffer
) / SCSI_LOG_BUFSIZE
;
36 unsigned long idx
= 0;
39 buf
= this_cpu_ptr(&scsi_format_log
);
40 idx
= find_first_zero_bit(&buf
->map
, map_bits
);
41 if (likely(idx
< map_bits
)) {
42 while (test_and_set_bit(idx
, &buf
->map
)) {
43 idx
= find_next_zero_bit(&buf
->map
, map_bits
, idx
);
48 if (WARN_ON(idx
>= map_bits
)) {
52 *len
= SCSI_LOG_BUFSIZE
;
53 return buf
->buffer
+ idx
* SCSI_LOG_BUFSIZE
;
56 static void scsi_log_release_buffer(char *bufptr
)
58 struct scsi_log_buf
*buf
;
62 buf
= this_cpu_ptr(&scsi_format_log
);
63 if (bufptr
>= buf
->buffer
&&
64 bufptr
< buf
->buffer
+ SCSI_LOG_SPOOLSIZE
) {
65 idx
= (bufptr
- buf
->buffer
) / SCSI_LOG_BUFSIZE
;
66 ret
= test_and_clear_bit(idx
, &buf
->map
);
72 static inline const char *scmd_name(const struct scsi_cmnd
*scmd
)
74 return scmd
->request
->rq_disk
?
75 scmd
->request
->rq_disk
->disk_name
: NULL
;
78 static size_t sdev_format_header(char *logbuf
, size_t logbuf_len
,
79 const char *name
, int tag
)
84 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
87 if (WARN_ON(off
>= logbuf_len
))
91 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
96 int sdev_prefix_printk(const char *level
, const struct scsi_device
*sdev
,
97 const char *name
, const char *fmt
, ...)
101 size_t off
= 0, logbuf_len
;
107 logbuf
= scsi_log_reserve_buffer(&logbuf_len
);
112 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
114 if (!WARN_ON(off
>= logbuf_len
)) {
116 off
+= vscnprintf(logbuf
+ off
, logbuf_len
- off
, fmt
, args
);
119 ret
= dev_printk(level
, &sdev
->sdev_gendev
, "%s", logbuf
);
120 scsi_log_release_buffer(logbuf
);
123 EXPORT_SYMBOL(sdev_prefix_printk
);
125 int scmd_printk(const char *level
, const struct scsi_cmnd
*scmd
,
126 const char *fmt
, ...)
130 size_t off
= 0, logbuf_len
;
133 if (!scmd
|| !scmd
->cmnd
)
136 logbuf
= scsi_log_reserve_buffer(&logbuf_len
);
139 off
= sdev_format_header(logbuf
, logbuf_len
, scmd_name(scmd
),
141 if (off
< logbuf_len
) {
143 off
+= vscnprintf(logbuf
+ off
, logbuf_len
- off
, fmt
, args
);
146 ret
= dev_printk(level
, &scmd
->device
->sdev_gendev
, "%s", logbuf
);
147 scsi_log_release_buffer(logbuf
);
150 EXPORT_SYMBOL(scmd_printk
);
152 static size_t scsi_format_opcode_name(char *buffer
, size_t buf_len
,
153 const unsigned char *cdbp
)
156 const char *cdb_name
= NULL
, *sa_name
= NULL
;
160 if (cdb0
== VARIABLE_LENGTH_CMD
) {
161 int len
= scsi_varlen_cdb_length(cdbp
);
164 off
= scnprintf(buffer
, buf_len
,
165 "short variable length command, len=%d",
169 sa
= (cdbp
[8] << 8) + cdbp
[9];
173 if (!scsi_opcode_sa_name(cdb0
, sa
, &cdb_name
, &sa_name
)) {
175 off
= scnprintf(buffer
, buf_len
, "%s", cdb_name
);
177 off
= scnprintf(buffer
, buf_len
, "opcode=0x%x", cdb0
);
178 if (WARN_ON(off
>= buf_len
))
180 if (cdb0
>= VENDOR_SPECIFIC_CDB
)
181 off
+= scnprintf(buffer
+ off
, buf_len
- off
,
183 else if (cdb0
>= 0x60 && cdb0
< 0x7e)
184 off
+= scnprintf(buffer
+ off
, buf_len
- off
,
189 off
= scnprintf(buffer
, buf_len
, "%s", sa_name
);
191 off
= scnprintf(buffer
, buf_len
, "%s, sa=0x%x",
194 off
= scnprintf(buffer
, buf_len
,
195 "opcode=0x%x, sa=0x%x", cdb0
, sa
);
197 WARN_ON(off
>= buf_len
);
201 size_t __scsi_format_command(char *logbuf
, size_t logbuf_len
,
202 const unsigned char *cdb
, size_t cdb_len
)
207 off
= scsi_format_opcode_name(logbuf
, logbuf_len
, cdb
);
208 if (off
>= logbuf_len
)
210 len
= scsi_command_size(cdb
);
213 /* print out all bytes in cdb */
214 for (k
= 0; k
< len
; ++k
) {
215 if (off
> logbuf_len
- 3)
217 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
222 EXPORT_SYMBOL(__scsi_format_command
);
224 void scsi_print_command(struct scsi_cmnd
*cmd
)
228 size_t off
, logbuf_len
;
233 logbuf
= scsi_log_reserve_buffer(&logbuf_len
);
237 off
= sdev_format_header(logbuf
, logbuf_len
,
238 scmd_name(cmd
), cmd
->request
->tag
);
239 if (off
>= logbuf_len
)
241 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
, "CDB: ");
242 if (WARN_ON(off
>= logbuf_len
))
245 off
+= scsi_format_opcode_name(logbuf
+ off
, logbuf_len
- off
,
247 if (off
>= logbuf_len
)
250 /* print out all bytes in cdb */
251 if (cmd
->cmd_len
> 16) {
252 /* Print opcode in one line and use separate lines for CDB */
253 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
, "\n");
254 dev_printk(KERN_INFO
, &cmd
->device
->sdev_gendev
, "%s", logbuf
);
255 scsi_log_release_buffer(logbuf
);
256 for (k
= 0; k
< cmd
->cmd_len
; k
+= 16) {
257 size_t linelen
= min(cmd
->cmd_len
- k
, 16);
259 logbuf
= scsi_log_reserve_buffer(&logbuf_len
);
262 off
= sdev_format_header(logbuf
, logbuf_len
,
265 if (!WARN_ON(off
> logbuf_len
- 58)) {
266 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
268 hex_dump_to_buffer(&cmd
->cmnd
[k
], linelen
,
270 logbuf_len
- off
, false);
272 dev_printk(KERN_INFO
, &cmd
->device
->sdev_gendev
, "%s",
274 scsi_log_release_buffer(logbuf
);
278 if (!WARN_ON(off
> logbuf_len
- 49)) {
279 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
, " ");
280 hex_dump_to_buffer(cmd
->cmnd
, cmd
->cmd_len
, 16, 1,
281 logbuf
+ off
, logbuf_len
- off
,
285 dev_printk(KERN_INFO
, &cmd
->device
->sdev_gendev
, "%s", logbuf
);
286 scsi_log_release_buffer(logbuf
);
288 EXPORT_SYMBOL(scsi_print_command
);
291 scsi_format_extd_sense(char *buffer
, size_t buf_len
,
292 unsigned char asc
, unsigned char ascq
)
295 const char *extd_sense_fmt
= NULL
;
296 const char *extd_sense_str
= scsi_extd_sense_format(asc
, ascq
,
299 if (extd_sense_str
) {
300 off
= scnprintf(buffer
, buf_len
, "Add. Sense: %s",
303 off
+= scnprintf(buffer
+ off
, buf_len
- off
,
304 "(%s%x)", extd_sense_fmt
, ascq
);
307 off
= scnprintf(buffer
, buf_len
, "<<vendor>>");
308 off
+= scnprintf(buffer
+ off
, buf_len
- off
,
311 off
+= scnprintf(buffer
+ off
, buf_len
- off
,
313 off
+= scnprintf(buffer
+ off
, buf_len
- off
,
320 scsi_format_sense_hdr(char *buffer
, size_t buf_len
,
321 const struct scsi_sense_hdr
*sshdr
)
323 const char *sense_txt
;
326 off
= scnprintf(buffer
, buf_len
, "Sense Key : ");
327 sense_txt
= scsi_sense_key_string(sshdr
->sense_key
);
329 off
+= scnprintf(buffer
+ off
, buf_len
- off
,
332 off
+= scnprintf(buffer
+ off
, buf_len
- off
,
333 "0x%x ", sshdr
->sense_key
);
334 off
+= scnprintf(buffer
+ off
, buf_len
- off
,
335 scsi_sense_is_deferred(sshdr
) ? "[deferred] " : "[current] ");
337 if (sshdr
->response_code
>= 0x72)
338 off
+= scnprintf(buffer
+ off
, buf_len
- off
, "[descriptor] ");
343 scsi_log_dump_sense(const struct scsi_device
*sdev
, const char *name
, int tag
,
344 const unsigned char *sense_buffer
, int sense_len
)
350 logbuf
= scsi_log_reserve_buffer(&logbuf_len
);
354 for (i
= 0; i
< sense_len
; i
+= 16) {
355 int len
= min(sense_len
- i
, 16);
358 off
= sdev_format_header(logbuf
, logbuf_len
,
360 hex_dump_to_buffer(&sense_buffer
[i
], len
, 16, 1,
361 logbuf
+ off
, logbuf_len
- off
,
363 dev_printk(KERN_INFO
, &sdev
->sdev_gendev
, "%s", logbuf
);
365 scsi_log_release_buffer(logbuf
);
369 scsi_log_print_sense_hdr(const struct scsi_device
*sdev
, const char *name
,
370 int tag
, const struct scsi_sense_hdr
*sshdr
)
373 size_t off
, logbuf_len
;
375 logbuf
= scsi_log_reserve_buffer(&logbuf_len
);
378 off
= sdev_format_header(logbuf
, logbuf_len
, name
, tag
);
379 off
+= scsi_format_sense_hdr(logbuf
+ off
, logbuf_len
- off
, sshdr
);
380 dev_printk(KERN_INFO
, &sdev
->sdev_gendev
, "%s", logbuf
);
381 scsi_log_release_buffer(logbuf
);
383 logbuf
= scsi_log_reserve_buffer(&logbuf_len
);
386 off
= sdev_format_header(logbuf
, logbuf_len
, name
, tag
);
387 off
+= scsi_format_extd_sense(logbuf
+ off
, logbuf_len
- off
,
388 sshdr
->asc
, sshdr
->ascq
);
389 dev_printk(KERN_INFO
, &sdev
->sdev_gendev
, "%s", logbuf
);
390 scsi_log_release_buffer(logbuf
);
394 scsi_log_print_sense(const struct scsi_device
*sdev
, const char *name
, int tag
,
395 const unsigned char *sense_buffer
, int sense_len
)
397 struct scsi_sense_hdr sshdr
;
399 if (scsi_normalize_sense(sense_buffer
, sense_len
, &sshdr
))
400 scsi_log_print_sense_hdr(sdev
, name
, tag
, &sshdr
);
402 scsi_log_dump_sense(sdev
, name
, tag
, sense_buffer
, sense_len
);
406 * Print normalized SCSI sense header with a prefix.
409 scsi_print_sense_hdr(const struct scsi_device
*sdev
, const char *name
,
410 const struct scsi_sense_hdr
*sshdr
)
412 scsi_log_print_sense_hdr(sdev
, name
, -1, sshdr
);
414 EXPORT_SYMBOL(scsi_print_sense_hdr
);
416 /* Normalize and print sense buffer with name prefix */
417 void __scsi_print_sense(const struct scsi_device
*sdev
, const char *name
,
418 const unsigned char *sense_buffer
, int sense_len
)
420 scsi_log_print_sense(sdev
, name
, -1, sense_buffer
, sense_len
);
422 EXPORT_SYMBOL(__scsi_print_sense
);
424 /* Normalize and print sense buffer in SCSI command */
425 void scsi_print_sense(const struct scsi_cmnd
*cmd
)
427 scsi_log_print_sense(cmd
->device
, scmd_name(cmd
), cmd
->request
->tag
,
428 cmd
->sense_buffer
, SCSI_SENSE_BUFFERSIZE
);
430 EXPORT_SYMBOL(scsi_print_sense
);
432 void scsi_print_result(const struct scsi_cmnd
*cmd
, const char *msg
,
436 size_t off
, logbuf_len
;
437 const char *mlret_string
= scsi_mlreturn_string(disposition
);
438 const char *hb_string
= scsi_hostbyte_string(cmd
->result
);
439 const char *db_string
= scsi_driverbyte_string(cmd
->result
);
441 logbuf
= scsi_log_reserve_buffer(&logbuf_len
);
445 off
= sdev_format_header(logbuf
, logbuf_len
,
446 scmd_name(cmd
), cmd
->request
->tag
);
448 if (off
>= logbuf_len
)
452 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
454 if (WARN_ON(off
>= logbuf_len
))
458 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
459 "%s ", mlret_string
);
461 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
462 "UNKNOWN(0x%02x) ", disposition
);
463 if (WARN_ON(off
>= logbuf_len
))
466 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
, "Result: ");
467 if (WARN_ON(off
>= logbuf_len
))
471 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
472 "hostbyte=%s ", hb_string
);
474 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
475 "hostbyte=0x%02x ", host_byte(cmd
->result
));
476 if (WARN_ON(off
>= logbuf_len
))
480 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
481 "driverbyte=%s", db_string
);
483 off
+= scnprintf(logbuf
+ off
, logbuf_len
- off
,
484 "driverbyte=0x%02x", driver_byte(cmd
->result
));
486 dev_printk(KERN_INFO
, &cmd
->device
->sdev_gendev
, "%s", logbuf
);
487 scsi_log_release_buffer(logbuf
);
489 EXPORT_SYMBOL(scsi_print_result
);