2 * Generic utility routines for the Common Access Method layer.
4 * Copyright (c) 1997 Justin T. Gibbs.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions, and the following disclaimer,
12 * without modification, immediately at the beginning of the file.
13 * 2. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * $FreeBSD: src/sys/cam/cam.c,v 1.4 2001/03/27 05:45:09 ken Exp $
30 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/sysctl.h>
44 #define kbsearch bsearch
50 #include "scsi/scsi_all.h"
54 #include <sys/libkern.h>
58 static int camstatusentrycomp(const void *key
, const void *member
);
60 const struct cam_status_entry cam_status_table
[] = {
61 { CAM_REQ_INPROG
, "CCB request is in progress" },
62 { CAM_REQ_CMP
, "CCB request completed without error" },
63 { CAM_REQ_ABORTED
, "CCB request aborted by the host" },
64 { CAM_UA_ABORT
, "Unable to abort CCB request" },
65 { CAM_REQ_CMP_ERR
, "CCB request completed with an error" },
66 { CAM_BUSY
, "CAM subsystem is busy" },
67 { CAM_REQ_INVALID
, "CCB request was invalid" },
68 { CAM_PATH_INVALID
, "Supplied Path ID is invalid" },
69 { CAM_DEV_NOT_THERE
, "Device Not Present" },
70 { CAM_UA_TERMIO
, "Unable to terminate I/O CCB request" },
71 { CAM_SEL_TIMEOUT
, "Selection Timeout" },
72 { CAM_CMD_TIMEOUT
, "Command timeout" },
73 { CAM_SCSI_STATUS_ERROR
, "SCSI Status Error" },
74 { CAM_MSG_REJECT_REC
, "Message Reject Reveived" },
75 { CAM_SCSI_BUS_RESET
, "SCSI Bus Reset Sent/Received" },
76 { CAM_UNCOR_PARITY
, "Uncorrectable parity/CRC error" },
77 { CAM_AUTOSENSE_FAIL
, "Auto-Sense Retrieval Failed" },
78 { CAM_NO_HBA
, "No HBA Detected" },
79 { CAM_DATA_RUN_ERR
, "Data Overrun error" },
80 { CAM_UNEXP_BUSFREE
, "Unexpected Bus Free" },
81 { CAM_SEQUENCE_FAIL
, "Target Bus Phase Sequence Failure" },
82 { CAM_CCB_LEN_ERR
, "CCB length supplied is inadequate" },
83 { CAM_PROVIDE_FAIL
, "Unable to provide requested capability" },
84 { CAM_BDR_SENT
, "SCSI BDR Message Sent" },
85 { CAM_REQ_TERMIO
, "CCB request terminated by the host" },
86 { CAM_UNREC_HBA_ERROR
, "Unrecoverable Host Bus Adapter Error" },
87 { CAM_REQ_TOO_BIG
, "The request was too large for this host" },
88 { CAM_REQUEUE_REQ
, "Unconditionally Re-queue Request", },
89 { CAM_IDE
, "Initiator Detected Error Message Received" },
90 { CAM_RESRC_UNAVAIL
, "Resource Unavailable" },
91 { CAM_UNACKED_EVENT
, "Unacknowledged Event by Host" },
92 { CAM_MESSAGE_RECV
, "Message Received in Host Target Mode" },
93 { CAM_INVALID_CDB
, "Invalid CDB received in Host Target Mode" },
94 { CAM_LUN_INVALID
, "Invalid Lun" },
95 { CAM_TID_INVALID
, "Invalid Target ID" },
96 { CAM_FUNC_NOTAVAIL
, "Function Not Available" },
97 { CAM_NO_NEXUS
, "Nexus Not Established" },
98 { CAM_IID_INVALID
, "Invalid Initiator ID" },
99 { CAM_CDB_RECVD
, "CDB Received" },
100 { CAM_LUN_ALRDY_ENA
, "LUN Already Enabled for Target Mode" },
101 { CAM_SCSI_BUSY
, "SCSI Bus Busy" },
104 const int num_cam_status_entries
= NELEM(cam_status_table
);
107 SYSCTL_NODE(_kern
, OID_AUTO
, cam
, CTLFLAG_RD
, 0, "CAM Subsystem");
111 cam_strvis(u_int8_t
*dst
, const u_int8_t
*src
, int srclen
, int dstlen
)
114 /* Trim leading/trailing spaces, nulls. */
115 while (srclen
> 0 && src
[0] == ' ')
118 && (src
[srclen
-1] == ' ' || src
[srclen
-1] == '\0'))
121 while (srclen
> 0 && dstlen
> 1) {
122 u_int8_t
*cur_pos
= dst
;
124 if (*src
< 0x20 || *src
>= 0x80) {
125 /* SCSI-II Specifies that these should never occur. */
126 /* non-printable character */
129 *cur_pos
++ = ((*src
& 0300) >> 6) + '0';
130 *cur_pos
++ = ((*src
& 0070) >> 3) + '0';
131 *cur_pos
++ = ((*src
& 0007) >> 0) + '0';
136 /* normal character */
141 dstlen
-= cur_pos
- dst
;
148 * Compare string with pattern, returning 0 on match.
149 * Short pattern matches trailing blanks in name,
150 * wildcard '*' in pattern matches rest of name,
151 * wildcard '?' matches a single non-space character.
154 cam_strmatch(const u_int8_t
*str
, const u_int8_t
*pattern
, int str_len
)
157 while (*pattern
!= '\0'&& str_len
> 0) {
159 if (*pattern
== '*') {
162 if ((*pattern
!= *str
)
163 && (*pattern
!= '?' || *str
== ' ')) {
170 while (str_len
> 0 && *str
++ == ' ')
177 cam_quirkmatch(caddr_t target
, caddr_t quirk_table
, int num_entries
,
178 int entry_size
, cam_quirkmatch_t
*comp_func
)
180 for (; num_entries
> 0; num_entries
--, quirk_table
+= entry_size
) {
181 if ((*comp_func
)(target
, quirk_table
) == 0)
182 return (quirk_table
);
187 const struct cam_status_entry
*
188 cam_fetch_status_entry(cam_status status
)
190 status
&= CAM_STATUS_MASK
;
191 return (kbsearch(&status
, &cam_status_table
,
192 num_cam_status_entries
,
193 sizeof(*cam_status_table
),
194 camstatusentrycomp
));
198 camstatusentrycomp(const void *key
, const void *member
)
201 const struct cam_status_entry
*table_entry
;
203 status
= *(const cam_status
*)key
;
204 table_entry
= (const struct cam_status_entry
*)member
;
206 return (status
- table_entry
->status_code
);
212 cam_error_string(union ccb
*ccb
, char *str
, int str_len
,
213 cam_error_string_flags flags
,
214 cam_error_proto_flags proto_flags
)
217 cam_error_string(struct cam_device
*device
, union ccb
*ccb
, char *str
,
218 int str_len
, cam_error_string_flags flags
,
219 cam_error_proto_flags proto_flags
)
220 #endif /* _KERNEL/!_KERNEL */
230 if (flags
== CAM_ESF_NONE
)
233 switch (ccb
->ccb_h
.func_code
) {
235 switch (proto_flags
& CAM_EPF_LEVEL_MASK
) {
240 proto_flags
|= CAM_ESF_PRINT_SENSE
;
242 case CAM_EPF_MINIMAL
:
243 proto_flags
|= CAM_ESF_PRINT_STATUS
;
252 xpt_path_string(ccb
->csio
.ccb_h
.path
, path_str
, sizeof(path_str
));
254 cam_path_string(device
, path_str
, sizeof(path_str
));
255 #endif /* _KERNEL/!_KERNEL */
257 sbuf_new(&sb
, str
, str_len
, 0);
259 if (flags
& CAM_ESF_COMMAND
) {
261 sbuf_cat(&sb
, path_str
);
263 switch (ccb
->ccb_h
.func_code
) {
266 scsi_command_string(&ccb
->csio
, &sb
);
268 scsi_command_string(device
, &ccb
->csio
, &sb
);
269 #endif /* _KERNEL/!_KERNEL */
270 sbuf_printf(&sb
, "\n");
278 if (flags
& CAM_ESF_CAM_STATUS
) {
280 const struct cam_status_entry
*entry
;
282 sbuf_cat(&sb
, path_str
);
284 status
= ccb
->ccb_h
.status
& CAM_STATUS_MASK
;
286 entry
= cam_fetch_status_entry(status
);
289 sbuf_printf(&sb
, "CAM Status: Unknown (%#x)\n",
292 sbuf_printf(&sb
, "CAM Status: %s\n",
296 if (flags
& CAM_ESF_PROTO_STATUS
) {
298 switch (ccb
->ccb_h
.func_code
) {
300 if ((ccb
->ccb_h
.status
& CAM_STATUS_MASK
) !=
301 CAM_SCSI_STATUS_ERROR
)
304 if (proto_flags
& CAM_ESF_PRINT_STATUS
) {
305 sbuf_cat(&sb
, path_str
);
307 * Print out the SCSI status byte as long as
308 * the user wants some protocol output.
310 sbuf_printf(&sb
, "SCSI Status: %s\n",
311 scsi_status_string(&ccb
->csio
));
314 if ((proto_flags
& CAM_ESF_PRINT_SENSE
)
315 && (ccb
->csio
.scsi_status
== SCSI_STATUS_CHECK_COND
)
316 && (ccb
->ccb_h
.status
& CAM_AUTOSNS_VALID
)) {
319 scsi_sense_sbuf(&ccb
->csio
, &sb
,
322 scsi_sense_sbuf(device
, &ccb
->csio
, &sb
,
324 #endif /* _KERNEL/!_KERNEL */
334 return(sbuf_data(&sb
));
340 cam_error_print(union ccb
*ccb
, cam_error_string_flags flags
,
341 cam_error_proto_flags proto_flags
)
345 kprintf("%s", cam_error_string(ccb
, str
, sizeof(str
), flags
,
352 cam_error_print(struct cam_device
*device
, union ccb
*ccb
,
353 cam_error_string_flags flags
, cam_error_proto_flags proto_flags
,
358 if ((device
== NULL
) || (ccb
== NULL
) || (ofile
== NULL
))
361 fprintf(ofile
, "%s", cam_error_string(device
, ccb
, str
, sizeof(str
),
362 flags
, proto_flags
));
365 #endif /* _KERNEL/!_KERNEL */
368 * Common calculate geometry fuction
370 * Caller should set ccg->volume_size and block_size.
371 * The extended parameter should be zero if extended translation
372 * should not be used.
375 cam_calc_geometry(struct ccb_calc_geometry
*ccg
, int extended
)
377 uint32_t size_mb
, secs_per_cylinder
;
379 if (ccg
->block_size
== 0) {
380 ccg
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
383 size_mb
= (1024L * 1024L) / ccg
->block_size
;
385 ccg
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
388 size_mb
= ccg
->volume_size
/ size_mb
;
389 if (size_mb
> 1024 && extended
) {
391 ccg
->secs_per_track
= 63;
394 ccg
->secs_per_track
= 32;
396 secs_per_cylinder
= ccg
->heads
* ccg
->secs_per_track
;
397 ccg
->cylinders
= ccg
->volume_size
/ secs_per_cylinder
;
398 ccg
->ccb_h
.status
= CAM_REQ_CMP
;