xref: /freebsd/sys/cam/cam_periph.c (revision 10b9d77bf1ccf2f3affafa6261692cb92cf7e992)
1 /*-
2  * Common functions for CAM "type" (peripheral) drivers.
3  *
4  * Copyright (c) 1997, 1998 Justin T. Gibbs.
5  * Copyright (c) 1997, 1998, 1999, 2000 Kenneth D. Merry.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions, and the following disclaimer,
13  *    without modification, immediately at the beginning of the file.
14  * 2. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32 
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/types.h>
36 #include <sys/malloc.h>
37 #include <sys/kernel.h>
38 #include <sys/bio.h>
39 #include <sys/lock.h>
40 #include <sys/mutex.h>
41 #include <sys/buf.h>
42 #include <sys/proc.h>
43 #include <sys/devicestat.h>
44 #include <sys/bus.h>
45 #include <vm/vm.h>
46 #include <vm/vm_extern.h>
47 
48 #include <cam/cam.h>
49 #include <cam/cam_ccb.h>
50 #include <cam/cam_queue.h>
51 #include <cam/cam_xpt_periph.h>
52 #include <cam/cam_periph.h>
53 #include <cam/cam_debug.h>
54 #include <cam/cam_sim.h>
55 
56 #include <cam/scsi/scsi_all.h>
57 #include <cam/scsi/scsi_message.h>
58 #include <cam/scsi/scsi_pass.h>
59 
60 static	u_int		camperiphnextunit(struct periph_driver *p_drv,
61 					  u_int newunit, int wired,
62 					  path_id_t pathid, target_id_t target,
63 					  lun_id_t lun);
64 static	u_int		camperiphunit(struct periph_driver *p_drv,
65 				      path_id_t pathid, target_id_t target,
66 				      lun_id_t lun);
67 static	void		camperiphdone(struct cam_periph *periph,
68 					union ccb *done_ccb);
69 static  void		camperiphfree(struct cam_periph *periph);
70 static int		camperiphscsistatuserror(union ccb *ccb,
71 						 cam_flags camflags,
72 						 u_int32_t sense_flags,
73 						 int *openings,
74 						 u_int32_t *relsim_flags,
75 						 u_int32_t *timeout,
76 						 const char **action_string);
77 static	int		camperiphscsisenseerror(union ccb *ccb,
78 					        cam_flags camflags,
79 					        u_int32_t sense_flags,
80 					        int *openings,
81 					        u_int32_t *relsim_flags,
82 					        u_int32_t *timeout,
83 					        const char **action_string);
84 
85 static int nperiph_drivers;
86 static int initialized = 0;
87 struct periph_driver **periph_drivers;
88 
89 MALLOC_DEFINE(M_CAMPERIPH, "CAM periph", "CAM peripheral buffers");
90 
91 static int periph_selto_delay = 1000;
92 TUNABLE_INT("kern.cam.periph_selto_delay", &periph_selto_delay);
93 static int periph_noresrc_delay = 500;
94 TUNABLE_INT("kern.cam.periph_noresrc_delay", &periph_noresrc_delay);
95 static int periph_busy_delay = 500;
96 TUNABLE_INT("kern.cam.periph_busy_delay", &periph_busy_delay);
97 
98 
99 void
100 periphdriver_register(void *data)
101 {
102 	struct periph_driver *drv = (struct periph_driver *)data;
103 	struct periph_driver **newdrivers, **old;
104 	int ndrivers;
105 
106 	ndrivers = nperiph_drivers + 2;
107 	newdrivers = malloc(sizeof(*newdrivers) * ndrivers, M_CAMPERIPH,
108 			    M_WAITOK);
109 	if (periph_drivers)
110 		bcopy(periph_drivers, newdrivers,
111 		      sizeof(*newdrivers) * nperiph_drivers);
112 	newdrivers[nperiph_drivers] = drv;
113 	newdrivers[nperiph_drivers + 1] = NULL;
114 	old = periph_drivers;
115 	periph_drivers = newdrivers;
116 	if (old)
117 		free(old, M_CAMPERIPH);
118 	nperiph_drivers++;
119 	/* If driver marked as early or it is late now, initialize it. */
120 	if (((drv->flags & CAM_PERIPH_DRV_EARLY) != 0 && initialized > 0) ||
121 	    initialized > 1)
122 		(*drv->init)();
123 }
124 
125 void
126 periphdriver_init(int level)
127 {
128 	int	i, early;
129 
130 	initialized = max(initialized, level);
131 	for (i = 0; periph_drivers[i] != NULL; i++) {
132 		early = (periph_drivers[i]->flags & CAM_PERIPH_DRV_EARLY) ? 1 : 2;
133 		if (early == initialized)
134 			(*periph_drivers[i]->init)();
135 	}
136 }
137 
138 cam_status
139 cam_periph_alloc(periph_ctor_t *periph_ctor,
140 		 periph_oninv_t *periph_oninvalidate,
141 		 periph_dtor_t *periph_dtor, periph_start_t *periph_start,
142 		 char *name, cam_periph_type type, struct cam_path *path,
143 		 ac_callback_t *ac_callback, ac_code code, void *arg)
144 {
145 	struct		periph_driver **p_drv;
146 	struct		cam_sim *sim;
147 	struct		cam_periph *periph;
148 	struct		cam_periph *cur_periph;
149 	path_id_t	path_id;
150 	target_id_t	target_id;
151 	lun_id_t	lun_id;
152 	cam_status	status;
153 	u_int		init_level;
154 
155 	init_level = 0;
156 	/*
157 	 * Handle Hot-Plug scenarios.  If there is already a peripheral
158 	 * of our type assigned to this path, we are likely waiting for
159 	 * final close on an old, invalidated, peripheral.  If this is
160 	 * the case, queue up a deferred call to the peripheral's async
161 	 * handler.  If it looks like a mistaken re-allocation, complain.
162 	 */
163 	if ((periph = cam_periph_find(path, name)) != NULL) {
164 
165 		if ((periph->flags & CAM_PERIPH_INVALID) != 0
166 		 && (periph->flags & CAM_PERIPH_NEW_DEV_FOUND) == 0) {
167 			periph->flags |= CAM_PERIPH_NEW_DEV_FOUND;
168 			periph->deferred_callback = ac_callback;
169 			periph->deferred_ac = code;
170 			return (CAM_REQ_INPROG);
171 		} else {
172 			printf("cam_periph_alloc: attempt to re-allocate "
173 			       "valid device %s%d rejected\n",
174 			       periph->periph_name, periph->unit_number);
175 		}
176 		return (CAM_REQ_INVALID);
177 	}
178 
179 	periph = (struct cam_periph *)malloc(sizeof(*periph), M_CAMPERIPH,
180 					     M_NOWAIT);
181 
182 	if (periph == NULL)
183 		return (CAM_RESRC_UNAVAIL);
184 
185 	init_level++;
186 
187 
188 	sim = xpt_path_sim(path);
189 	path_id = xpt_path_path_id(path);
190 	target_id = xpt_path_target_id(path);
191 	lun_id = xpt_path_lun_id(path);
192 	bzero(periph, sizeof(*periph));
193 	cam_init_pinfo(&periph->pinfo);
194 	periph->periph_start = periph_start;
195 	periph->periph_dtor = periph_dtor;
196 	periph->periph_oninval = periph_oninvalidate;
197 	periph->type = type;
198 	periph->periph_name = name;
199 	periph->immediate_priority = CAM_PRIORITY_NONE;
200 	periph->refcount = 0;
201 	periph->sim = sim;
202 	SLIST_INIT(&periph->ccb_list);
203 	status = xpt_create_path(&path, periph, path_id, target_id, lun_id);
204 	if (status != CAM_REQ_CMP)
205 		goto failure;
206 	periph->path = path;
207 
208 	xpt_lock_buses();
209 	for (p_drv = periph_drivers; *p_drv != NULL; p_drv++) {
210 		if (strcmp((*p_drv)->driver_name, name) == 0)
211 			break;
212 	}
213 	if (*p_drv == NULL) {
214 		printf("cam_periph_alloc: invalid periph name '%s'\n", name);
215 		xpt_free_path(periph->path);
216 		free(periph, M_CAMPERIPH);
217 		xpt_unlock_buses();
218 		return (CAM_REQ_INVALID);
219 	}
220 	periph->unit_number = camperiphunit(*p_drv, path_id, target_id, lun_id);
221 	cur_periph = TAILQ_FIRST(&(*p_drv)->units);
222 	while (cur_periph != NULL
223 	    && cur_periph->unit_number < periph->unit_number)
224 		cur_periph = TAILQ_NEXT(cur_periph, unit_links);
225 	if (cur_periph != NULL) {
226 		KASSERT(cur_periph->unit_number != periph->unit_number, ("duplicate units on periph list"));
227 		TAILQ_INSERT_BEFORE(cur_periph, periph, unit_links);
228 	} else {
229 		TAILQ_INSERT_TAIL(&(*p_drv)->units, periph, unit_links);
230 		(*p_drv)->generation++;
231 	}
232 	xpt_unlock_buses();
233 
234 	init_level++;
235 
236 	status = xpt_add_periph(periph);
237 	if (status != CAM_REQ_CMP)
238 		goto failure;
239 
240 	init_level++;
241 
242 	status = periph_ctor(periph, arg);
243 
244 	if (status == CAM_REQ_CMP)
245 		init_level++;
246 
247 failure:
248 	switch (init_level) {
249 	case 4:
250 		/* Initialized successfully */
251 		break;
252 	case 3:
253 		xpt_remove_periph(periph);
254 		/* FALLTHROUGH */
255 	case 2:
256 		xpt_lock_buses();
257 		TAILQ_REMOVE(&(*p_drv)->units, periph, unit_links);
258 		xpt_unlock_buses();
259 		xpt_free_path(periph->path);
260 		/* FALLTHROUGH */
261 	case 1:
262 		free(periph, M_CAMPERIPH);
263 		/* FALLTHROUGH */
264 	case 0:
265 		/* No cleanup to perform. */
266 		break;
267 	default:
268 		panic("cam_periph_alloc: Unkown init level");
269 	}
270 	return(status);
271 }
272 
273 /*
274  * Find a peripheral structure with the specified path, target, lun,
275  * and (optionally) type.  If the name is NULL, this function will return
276  * the first peripheral driver that matches the specified path.
277  */
278 struct cam_periph *
279 cam_periph_find(struct cam_path *path, char *name)
280 {
281 	struct periph_driver **p_drv;
282 	struct cam_periph *periph;
283 
284 	xpt_lock_buses();
285 	for (p_drv = periph_drivers; *p_drv != NULL; p_drv++) {
286 
287 		if (name != NULL && (strcmp((*p_drv)->driver_name, name) != 0))
288 			continue;
289 
290 		TAILQ_FOREACH(periph, &(*p_drv)->units, unit_links) {
291 			if (xpt_path_comp(periph->path, path) == 0) {
292 				xpt_unlock_buses();
293 				mtx_assert(periph->sim->mtx, MA_OWNED);
294 				return(periph);
295 			}
296 		}
297 		if (name != NULL) {
298 			xpt_unlock_buses();
299 			return(NULL);
300 		}
301 	}
302 	xpt_unlock_buses();
303 	return(NULL);
304 }
305 
306 cam_status
307 cam_periph_acquire(struct cam_periph *periph)
308 {
309 
310 	if (periph == NULL)
311 		return(CAM_REQ_CMP_ERR);
312 
313 	xpt_lock_buses();
314 	periph->refcount++;
315 	xpt_unlock_buses();
316 
317 	return(CAM_REQ_CMP);
318 }
319 
320 void
321 cam_periph_release_locked(struct cam_periph *periph)
322 {
323 
324 	if (periph == NULL)
325 		return;
326 
327 	xpt_lock_buses();
328 	if (periph->refcount != 0) {
329 		periph->refcount--;
330 	} else {
331 		xpt_print(periph->path, "%s: release %p when refcount is zero\n ", __func__, periph);
332 	}
333 	if (periph->refcount == 0
334 	    && (periph->flags & CAM_PERIPH_INVALID)) {
335 		camperiphfree(periph);
336 	}
337 	xpt_unlock_buses();
338 }
339 
340 void
341 cam_periph_release(struct cam_periph *periph)
342 {
343 	struct cam_sim *sim;
344 
345 	if (periph == NULL)
346 		return;
347 
348 	sim = periph->sim;
349 	mtx_assert(sim->mtx, MA_NOTOWNED);
350 	mtx_lock(sim->mtx);
351 	cam_periph_release_locked(periph);
352 	mtx_unlock(sim->mtx);
353 }
354 
355 int
356 cam_periph_hold(struct cam_periph *periph, int priority)
357 {
358 	int error;
359 
360 	/*
361 	 * Increment the reference count on the peripheral
362 	 * while we wait for our lock attempt to succeed
363 	 * to ensure the peripheral doesn't disappear out
364 	 * from user us while we sleep.
365 	 */
366 
367 	if (cam_periph_acquire(periph) != CAM_REQ_CMP)
368 		return (ENXIO);
369 
370 	mtx_assert(periph->sim->mtx, MA_OWNED);
371 	while ((periph->flags & CAM_PERIPH_LOCKED) != 0) {
372 		periph->flags |= CAM_PERIPH_LOCK_WANTED;
373 		if ((error = mtx_sleep(periph, periph->sim->mtx, priority,
374 		    "caplck", 0)) != 0) {
375 			cam_periph_release_locked(periph);
376 			return (error);
377 		}
378 	}
379 
380 	periph->flags |= CAM_PERIPH_LOCKED;
381 	return (0);
382 }
383 
384 void
385 cam_periph_unhold(struct cam_periph *periph)
386 {
387 
388 	mtx_assert(periph->sim->mtx, MA_OWNED);
389 
390 	periph->flags &= ~CAM_PERIPH_LOCKED;
391 	if ((periph->flags & CAM_PERIPH_LOCK_WANTED) != 0) {
392 		periph->flags &= ~CAM_PERIPH_LOCK_WANTED;
393 		wakeup(periph);
394 	}
395 
396 	cam_periph_release_locked(periph);
397 }
398 
399 /*
400  * Look for the next unit number that is not currently in use for this
401  * peripheral type starting at "newunit".  Also exclude unit numbers that
402  * are reserved by for future "hardwiring" unless we already know that this
403  * is a potential wired device.  Only assume that the device is "wired" the
404  * first time through the loop since after that we'll be looking at unit
405  * numbers that did not match a wiring entry.
406  */
407 static u_int
408 camperiphnextunit(struct periph_driver *p_drv, u_int newunit, int wired,
409 		  path_id_t pathid, target_id_t target, lun_id_t lun)
410 {
411 	struct	cam_periph *periph;
412 	char	*periph_name;
413 	int	i, val, dunit, r;
414 	const char *dname, *strval;
415 
416 	periph_name = p_drv->driver_name;
417 	for (;;newunit++) {
418 
419 		for (periph = TAILQ_FIRST(&p_drv->units);
420 		     periph != NULL && periph->unit_number != newunit;
421 		     periph = TAILQ_NEXT(periph, unit_links))
422 			;
423 
424 		if (periph != NULL && periph->unit_number == newunit) {
425 			if (wired != 0) {
426 				xpt_print(periph->path, "Duplicate Wired "
427 				    "Device entry!\n");
428 				xpt_print(periph->path, "Second device (%s "
429 				    "device at scbus%d target %d lun %d) will "
430 				    "not be wired\n", periph_name, pathid,
431 				    target, lun);
432 				wired = 0;
433 			}
434 			continue;
435 		}
436 		if (wired)
437 			break;
438 
439 		/*
440 		 * Don't match entries like "da 4" as a wired down
441 		 * device, but do match entries like "da 4 target 5"
442 		 * or even "da 4 scbus 1".
443 		 */
444 		i = 0;
445 		dname = periph_name;
446 		for (;;) {
447 			r = resource_find_dev(&i, dname, &dunit, NULL, NULL);
448 			if (r != 0)
449 				break;
450 			/* if no "target" and no specific scbus, skip */
451 			if (resource_int_value(dname, dunit, "target", &val) &&
452 			    (resource_string_value(dname, dunit, "at",&strval)||
453 			     strcmp(strval, "scbus") == 0))
454 				continue;
455 			if (newunit == dunit)
456 				break;
457 		}
458 		if (r != 0)
459 			break;
460 	}
461 	return (newunit);
462 }
463 
464 static u_int
465 camperiphunit(struct periph_driver *p_drv, path_id_t pathid,
466 	      target_id_t target, lun_id_t lun)
467 {
468 	u_int	unit;
469 	int	wired, i, val, dunit;
470 	const char *dname, *strval;
471 	char	pathbuf[32], *periph_name;
472 
473 	periph_name = p_drv->driver_name;
474 	snprintf(pathbuf, sizeof(pathbuf), "scbus%d", pathid);
475 	unit = 0;
476 	i = 0;
477 	dname = periph_name;
478 	for (wired = 0; resource_find_dev(&i, dname, &dunit, NULL, NULL) == 0;
479 	     wired = 0) {
480 		if (resource_string_value(dname, dunit, "at", &strval) == 0) {
481 			if (strcmp(strval, pathbuf) != 0)
482 				continue;
483 			wired++;
484 		}
485 		if (resource_int_value(dname, dunit, "target", &val) == 0) {
486 			if (val != target)
487 				continue;
488 			wired++;
489 		}
490 		if (resource_int_value(dname, dunit, "lun", &val) == 0) {
491 			if (val != lun)
492 				continue;
493 			wired++;
494 		}
495 		if (wired != 0) {
496 			unit = dunit;
497 			break;
498 		}
499 	}
500 
501 	/*
502 	 * Either start from 0 looking for the next unit or from
503 	 * the unit number given in the resource config.  This way,
504 	 * if we have wildcard matches, we don't return the same
505 	 * unit number twice.
506 	 */
507 	unit = camperiphnextunit(p_drv, unit, wired, pathid, target, lun);
508 
509 	return (unit);
510 }
511 
512 void
513 cam_periph_invalidate(struct cam_periph *periph)
514 {
515 
516 	/*
517 	 * We only call this routine the first time a peripheral is
518 	 * invalidated.
519 	 */
520 	if (((periph->flags & CAM_PERIPH_INVALID) == 0)
521 	 && (periph->periph_oninval != NULL))
522 		periph->periph_oninval(periph);
523 
524 	periph->flags |= CAM_PERIPH_INVALID;
525 	periph->flags &= ~CAM_PERIPH_NEW_DEV_FOUND;
526 
527 	xpt_lock_buses();
528 	if (periph->refcount == 0)
529 		camperiphfree(periph);
530 	else if (periph->refcount < 0)
531 		printf("cam_invalidate_periph: refcount < 0!!\n");
532 	xpt_unlock_buses();
533 }
534 
535 static void
536 camperiphfree(struct cam_periph *periph)
537 {
538 	struct periph_driver **p_drv;
539 
540 	for (p_drv = periph_drivers; *p_drv != NULL; p_drv++) {
541 		if (strcmp((*p_drv)->driver_name, periph->periph_name) == 0)
542 			break;
543 	}
544 	if (*p_drv == NULL) {
545 		printf("camperiphfree: attempt to free non-existant periph\n");
546 		return;
547 	}
548 
549 	TAILQ_REMOVE(&(*p_drv)->units, periph, unit_links);
550 	(*p_drv)->generation++;
551 	xpt_unlock_buses();
552 
553 	if (periph->periph_dtor != NULL)
554 		periph->periph_dtor(periph);
555 	xpt_remove_periph(periph);
556 
557 	if (periph->flags & CAM_PERIPH_NEW_DEV_FOUND) {
558 		union ccb ccb;
559 		void *arg;
560 
561 		switch (periph->deferred_ac) {
562 		case AC_FOUND_DEVICE:
563 			ccb.ccb_h.func_code = XPT_GDEV_TYPE;
564 			xpt_setup_ccb(&ccb.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
565 			xpt_action(&ccb);
566 			arg = &ccb;
567 			break;
568 		case AC_PATH_REGISTERED:
569 			ccb.ccb_h.func_code = XPT_PATH_INQ;
570 			xpt_setup_ccb(&ccb.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
571 			xpt_action(&ccb);
572 			arg = &ccb;
573 			break;
574 		default:
575 			arg = NULL;
576 			break;
577 		}
578 		periph->deferred_callback(NULL, periph->deferred_ac,
579 					  periph->path, arg);
580 	}
581 	xpt_free_path(periph->path);
582 	free(periph, M_CAMPERIPH);
583 	xpt_lock_buses();
584 }
585 
586 /*
587  * Map user virtual pointers into kernel virtual address space, so we can
588  * access the memory.  This won't work on physical pointers, for now it's
589  * up to the caller to check for that.  (XXX KDM -- should we do that here
590  * instead?)  This also only works for up to MAXPHYS memory.  Since we use
591  * buffers to map stuff in and out, we're limited to the buffer size.
592  */
593 int
594 cam_periph_mapmem(union ccb *ccb, struct cam_periph_map_info *mapinfo)
595 {
596 	int numbufs, i, j;
597 	int flags[CAM_PERIPH_MAXMAPS];
598 	u_int8_t **data_ptrs[CAM_PERIPH_MAXMAPS];
599 	u_int32_t lengths[CAM_PERIPH_MAXMAPS];
600 	u_int32_t dirs[CAM_PERIPH_MAXMAPS];
601 	/* Some controllers may not be able to handle more data. */
602 	size_t maxmap = DFLTPHYS;
603 
604 	switch(ccb->ccb_h.func_code) {
605 	case XPT_DEV_MATCH:
606 		if (ccb->cdm.match_buf_len == 0) {
607 			printf("cam_periph_mapmem: invalid match buffer "
608 			       "length 0\n");
609 			return(EINVAL);
610 		}
611 		if (ccb->cdm.pattern_buf_len > 0) {
612 			data_ptrs[0] = (u_int8_t **)&ccb->cdm.patterns;
613 			lengths[0] = ccb->cdm.pattern_buf_len;
614 			dirs[0] = CAM_DIR_OUT;
615 			data_ptrs[1] = (u_int8_t **)&ccb->cdm.matches;
616 			lengths[1] = ccb->cdm.match_buf_len;
617 			dirs[1] = CAM_DIR_IN;
618 			numbufs = 2;
619 		} else {
620 			data_ptrs[0] = (u_int8_t **)&ccb->cdm.matches;
621 			lengths[0] = ccb->cdm.match_buf_len;
622 			dirs[0] = CAM_DIR_IN;
623 			numbufs = 1;
624 		}
625 		/*
626 		 * This request will not go to the hardware, no reason
627 		 * to be so strict. vmapbuf() is able to map up to MAXPHYS.
628 		 */
629 		maxmap = MAXPHYS;
630 		break;
631 	case XPT_SCSI_IO:
632 	case XPT_CONT_TARGET_IO:
633 		if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_NONE)
634 			return(0);
635 
636 		data_ptrs[0] = &ccb->csio.data_ptr;
637 		lengths[0] = ccb->csio.dxfer_len;
638 		dirs[0] = ccb->ccb_h.flags & CAM_DIR_MASK;
639 		numbufs = 1;
640 		break;
641 	case XPT_ATA_IO:
642 		if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_NONE)
643 			return(0);
644 
645 		data_ptrs[0] = &ccb->ataio.data_ptr;
646 		lengths[0] = ccb->ataio.dxfer_len;
647 		dirs[0] = ccb->ccb_h.flags & CAM_DIR_MASK;
648 		numbufs = 1;
649 		break;
650 	case XPT_SMP_IO:
651 		data_ptrs[0] = &ccb->smpio.smp_request;
652 		lengths[0] = ccb->smpio.smp_request_len;
653 		dirs[0] = CAM_DIR_OUT;
654 		data_ptrs[1] = &ccb->smpio.smp_response;
655 		lengths[1] = ccb->smpio.smp_response_len;
656 		dirs[1] = CAM_DIR_IN;
657 		numbufs = 2;
658 		break;
659 	case XPT_GDEV_ADVINFO:
660 		if (ccb->cgdai.bufsiz == 0)
661 			return (0);
662 
663 		data_ptrs[0] = (uint8_t **)&ccb->cgdai.buf;
664 		lengths[0] = ccb->cgdai.bufsiz;
665 		dirs[0] = CAM_DIR_IN;
666 		numbufs = 1;
667 
668 		/*
669 		 * This request will not go to the hardware, no reason
670 		 * to be so strict. vmapbuf() is able to map up to MAXPHYS.
671 		 */
672 		maxmap = MAXPHYS;
673 		break;
674 	default:
675 		return(EINVAL);
676 		break; /* NOTREACHED */
677 	}
678 
679 	/*
680 	 * Check the transfer length and permissions first, so we don't
681 	 * have to unmap any previously mapped buffers.
682 	 */
683 	for (i = 0; i < numbufs; i++) {
684 
685 		flags[i] = 0;
686 
687 		/*
688 		 * The userland data pointer passed in may not be page
689 		 * aligned.  vmapbuf() truncates the address to a page
690 		 * boundary, so if the address isn't page aligned, we'll
691 		 * need enough space for the given transfer length, plus
692 		 * whatever extra space is necessary to make it to the page
693 		 * boundary.
694 		 */
695 		if ((lengths[i] +
696 		    (((vm_offset_t)(*data_ptrs[i])) & PAGE_MASK)) > maxmap){
697 			printf("cam_periph_mapmem: attempt to map %lu bytes, "
698 			       "which is greater than %lu\n",
699 			       (long)(lengths[i] +
700 			       (((vm_offset_t)(*data_ptrs[i])) & PAGE_MASK)),
701 			       (u_long)maxmap);
702 			return(E2BIG);
703 		}
704 
705 		if (dirs[i] & CAM_DIR_OUT) {
706 			flags[i] = BIO_WRITE;
707 		}
708 
709 		if (dirs[i] & CAM_DIR_IN) {
710 			flags[i] = BIO_READ;
711 		}
712 
713 	}
714 
715 	/* this keeps the current process from getting swapped */
716 	/*
717 	 * XXX KDM should I use P_NOSWAP instead?
718 	 */
719 	PHOLD(curproc);
720 
721 	for (i = 0; i < numbufs; i++) {
722 		/*
723 		 * Get the buffer.
724 		 */
725 		mapinfo->bp[i] = getpbuf(NULL);
726 
727 		/* save the buffer's data address */
728 		mapinfo->bp[i]->b_saveaddr = mapinfo->bp[i]->b_data;
729 
730 		/* put our pointer in the data slot */
731 		mapinfo->bp[i]->b_data = *data_ptrs[i];
732 
733 		/* set the transfer length, we know it's < MAXPHYS */
734 		mapinfo->bp[i]->b_bufsize = lengths[i];
735 
736 		/* set the direction */
737 		mapinfo->bp[i]->b_iocmd = flags[i];
738 
739 		/*
740 		 * Map the buffer into kernel memory.
741 		 *
742 		 * Note that useracc() alone is not a  sufficient test.
743 		 * vmapbuf() can still fail due to a smaller file mapped
744 		 * into a larger area of VM, or if userland races against
745 		 * vmapbuf() after the useracc() check.
746 		 */
747 		if (vmapbuf(mapinfo->bp[i]) < 0) {
748 			for (j = 0; j < i; ++j) {
749 				*data_ptrs[j] = mapinfo->bp[j]->b_saveaddr;
750 				vunmapbuf(mapinfo->bp[j]);
751 				relpbuf(mapinfo->bp[j], NULL);
752 			}
753 			relpbuf(mapinfo->bp[i], NULL);
754 			PRELE(curproc);
755 			return(EACCES);
756 		}
757 
758 		/* set our pointer to the new mapped area */
759 		*data_ptrs[i] = mapinfo->bp[i]->b_data;
760 
761 		mapinfo->num_bufs_used++;
762 	}
763 
764 	/*
765 	 * Now that we've gotten this far, change ownership to the kernel
766 	 * of the buffers so that we don't run afoul of returning to user
767 	 * space with locks (on the buffer) held.
768 	 */
769 	for (i = 0; i < numbufs; i++) {
770 		BUF_KERNPROC(mapinfo->bp[i]);
771 	}
772 
773 
774 	return(0);
775 }
776 
777 /*
778  * Unmap memory segments mapped into kernel virtual address space by
779  * cam_periph_mapmem().
780  */
781 void
782 cam_periph_unmapmem(union ccb *ccb, struct cam_periph_map_info *mapinfo)
783 {
784 	int numbufs, i;
785 	u_int8_t **data_ptrs[CAM_PERIPH_MAXMAPS];
786 
787 	if (mapinfo->num_bufs_used <= 0) {
788 		/* allow ourselves to be swapped once again */
789 		PRELE(curproc);
790 		return;
791 	}
792 
793 	switch (ccb->ccb_h.func_code) {
794 	case XPT_DEV_MATCH:
795 		numbufs = min(mapinfo->num_bufs_used, 2);
796 
797 		if (numbufs == 1) {
798 			data_ptrs[0] = (u_int8_t **)&ccb->cdm.matches;
799 		} else {
800 			data_ptrs[0] = (u_int8_t **)&ccb->cdm.patterns;
801 			data_ptrs[1] = (u_int8_t **)&ccb->cdm.matches;
802 		}
803 		break;
804 	case XPT_SCSI_IO:
805 	case XPT_CONT_TARGET_IO:
806 		data_ptrs[0] = &ccb->csio.data_ptr;
807 		numbufs = min(mapinfo->num_bufs_used, 1);
808 		break;
809 	case XPT_ATA_IO:
810 		data_ptrs[0] = &ccb->ataio.data_ptr;
811 		numbufs = min(mapinfo->num_bufs_used, 1);
812 		break;
813 	case XPT_SMP_IO:
814 		numbufs = min(mapinfo->num_bufs_used, 2);
815 		data_ptrs[0] = &ccb->smpio.smp_request;
816 		data_ptrs[1] = &ccb->smpio.smp_response;
817 		break;
818 	case XPT_GDEV_ADVINFO:
819 		numbufs = min(mapinfo->num_bufs_used, 1);
820 		data_ptrs[0] = (uint8_t **)&ccb->cgdai.buf;
821 		break;
822 	default:
823 		/* allow ourselves to be swapped once again */
824 		PRELE(curproc);
825 		return;
826 		break; /* NOTREACHED */
827 	}
828 
829 	for (i = 0; i < numbufs; i++) {
830 		/* Set the user's pointer back to the original value */
831 		*data_ptrs[i] = mapinfo->bp[i]->b_saveaddr;
832 
833 		/* unmap the buffer */
834 		vunmapbuf(mapinfo->bp[i]);
835 
836 		/* release the buffer */
837 		relpbuf(mapinfo->bp[i], NULL);
838 	}
839 
840 	/* allow ourselves to be swapped once again */
841 	PRELE(curproc);
842 }
843 
844 union ccb *
845 cam_periph_getccb(struct cam_periph *periph, u_int32_t priority)
846 {
847 	struct ccb_hdr *ccb_h;
848 
849 	mtx_assert(periph->sim->mtx, MA_OWNED);
850 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering cdgetccb\n"));
851 
852 	while (SLIST_FIRST(&periph->ccb_list) == NULL) {
853 		if (periph->immediate_priority > priority)
854 			periph->immediate_priority = priority;
855 		xpt_schedule(periph, priority);
856 		if ((SLIST_FIRST(&periph->ccb_list) != NULL)
857 		 && (SLIST_FIRST(&periph->ccb_list)->pinfo.priority == priority))
858 			break;
859 		mtx_assert(periph->sim->mtx, MA_OWNED);
860 		mtx_sleep(&periph->ccb_list, periph->sim->mtx, PRIBIO, "cgticb",
861 		    0);
862 	}
863 
864 	ccb_h = SLIST_FIRST(&periph->ccb_list);
865 	SLIST_REMOVE_HEAD(&periph->ccb_list, periph_links.sle);
866 	return ((union ccb *)ccb_h);
867 }
868 
869 void
870 cam_periph_ccbwait(union ccb *ccb)
871 {
872 	struct cam_sim *sim;
873 
874 	sim = xpt_path_sim(ccb->ccb_h.path);
875 	if ((ccb->ccb_h.pinfo.index != CAM_UNQUEUED_INDEX)
876 	 || ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INPROG))
877 		mtx_sleep(&ccb->ccb_h.cbfcnp, sim->mtx, PRIBIO, "cbwait", 0);
878 }
879 
880 int
881 cam_periph_ioctl(struct cam_periph *periph, u_long cmd, caddr_t addr,
882 		 int (*error_routine)(union ccb *ccb,
883 				      cam_flags camflags,
884 				      u_int32_t sense_flags))
885 {
886 	union ccb 	     *ccb;
887 	int 		     error;
888 	int		     found;
889 
890 	error = found = 0;
891 
892 	switch(cmd){
893 	case CAMGETPASSTHRU:
894 		ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
895 		xpt_setup_ccb(&ccb->ccb_h,
896 			      ccb->ccb_h.path,
897 			      CAM_PRIORITY_NORMAL);
898 		ccb->ccb_h.func_code = XPT_GDEVLIST;
899 
900 		/*
901 		 * Basically, the point of this is that we go through
902 		 * getting the list of devices, until we find a passthrough
903 		 * device.  In the current version of the CAM code, the
904 		 * only way to determine what type of device we're dealing
905 		 * with is by its name.
906 		 */
907 		while (found == 0) {
908 			ccb->cgdl.index = 0;
909 			ccb->cgdl.status = CAM_GDEVLIST_MORE_DEVS;
910 			while (ccb->cgdl.status == CAM_GDEVLIST_MORE_DEVS) {
911 
912 				/* we want the next device in the list */
913 				xpt_action(ccb);
914 				if (strncmp(ccb->cgdl.periph_name,
915 				    "pass", 4) == 0){
916 					found = 1;
917 					break;
918 				}
919 			}
920 			if ((ccb->cgdl.status == CAM_GDEVLIST_LAST_DEVICE) &&
921 			    (found == 0)) {
922 				ccb->cgdl.periph_name[0] = '\0';
923 				ccb->cgdl.unit_number = 0;
924 				break;
925 			}
926 		}
927 
928 		/* copy the result back out */
929 		bcopy(ccb, addr, sizeof(union ccb));
930 
931 		/* and release the ccb */
932 		xpt_release_ccb(ccb);
933 
934 		break;
935 	default:
936 		error = ENOTTY;
937 		break;
938 	}
939 	return(error);
940 }
941 
942 int
943 cam_periph_runccb(union ccb *ccb,
944 		  int (*error_routine)(union ccb *ccb,
945 				       cam_flags camflags,
946 				       u_int32_t sense_flags),
947 		  cam_flags camflags, u_int32_t sense_flags,
948 		  struct devstat *ds)
949 {
950 	struct cam_sim *sim;
951 	int error;
952 
953 	error = 0;
954 	sim = xpt_path_sim(ccb->ccb_h.path);
955 	mtx_assert(sim->mtx, MA_OWNED);
956 
957 	/*
958 	 * If the user has supplied a stats structure, and if we understand
959 	 * this particular type of ccb, record the transaction start.
960 	 */
961 	if ((ds != NULL) && (ccb->ccb_h.func_code == XPT_SCSI_IO ||
962 	    ccb->ccb_h.func_code == XPT_ATA_IO))
963 		devstat_start_transaction(ds, NULL);
964 
965 	xpt_action(ccb);
966 
967 	do {
968 		cam_periph_ccbwait(ccb);
969 		if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
970 			error = 0;
971 		else if (error_routine != NULL)
972 			error = (*error_routine)(ccb, camflags, sense_flags);
973 		else
974 			error = 0;
975 
976 	} while (error == ERESTART);
977 
978 	if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
979 		cam_release_devq(ccb->ccb_h.path,
980 				 /* relsim_flags */0,
981 				 /* openings */0,
982 				 /* timeout */0,
983 				 /* getcount_only */ FALSE);
984 		ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
985 	}
986 
987 	if (ds != NULL) {
988 		if (ccb->ccb_h.func_code == XPT_SCSI_IO) {
989 			devstat_end_transaction(ds,
990 					ccb->csio.dxfer_len,
991 					ccb->csio.tag_action & 0x3,
992 					((ccb->ccb_h.flags & CAM_DIR_MASK) ==
993 					CAM_DIR_NONE) ?  DEVSTAT_NO_DATA :
994 					(ccb->ccb_h.flags & CAM_DIR_OUT) ?
995 					DEVSTAT_WRITE :
996 					DEVSTAT_READ, NULL, NULL);
997 		} else if (ccb->ccb_h.func_code == XPT_ATA_IO) {
998 			devstat_end_transaction(ds,
999 					ccb->ataio.dxfer_len,
1000 					ccb->ataio.tag_action & 0x3,
1001 					((ccb->ccb_h.flags & CAM_DIR_MASK) ==
1002 					CAM_DIR_NONE) ?  DEVSTAT_NO_DATA :
1003 					(ccb->ccb_h.flags & CAM_DIR_OUT) ?
1004 					DEVSTAT_WRITE :
1005 					DEVSTAT_READ, NULL, NULL);
1006 		}
1007 	}
1008 
1009 	return(error);
1010 }
1011 
1012 void
1013 cam_freeze_devq(struct cam_path *path)
1014 {
1015 
1016 	cam_freeze_devq_arg(path, 0, 0);
1017 }
1018 
1019 void
1020 cam_freeze_devq_arg(struct cam_path *path, uint32_t flags, uint32_t arg)
1021 {
1022 	struct ccb_relsim crs;
1023 
1024 	xpt_setup_ccb(&crs.ccb_h, path, CAM_PRIORITY_NONE);
1025 	crs.ccb_h.func_code = XPT_FREEZE_QUEUE;
1026 	crs.release_flags = flags;
1027 	crs.openings = arg;
1028 	crs.release_timeout = arg;
1029 	xpt_action((union ccb *)&crs);
1030 }
1031 
1032 u_int32_t
1033 cam_release_devq(struct cam_path *path, u_int32_t relsim_flags,
1034 		 u_int32_t openings, u_int32_t arg,
1035 		 int getcount_only)
1036 {
1037 	struct ccb_relsim crs;
1038 
1039 	xpt_setup_ccb(&crs.ccb_h, path, CAM_PRIORITY_NORMAL);
1040 	crs.ccb_h.func_code = XPT_REL_SIMQ;
1041 	crs.ccb_h.flags = getcount_only ? CAM_DEV_QFREEZE : 0;
1042 	crs.release_flags = relsim_flags;
1043 	crs.openings = openings;
1044 	crs.release_timeout = arg;
1045 	xpt_action((union ccb *)&crs);
1046 	return (crs.qfrozen_cnt);
1047 }
1048 
1049 #define saved_ccb_ptr ppriv_ptr0
1050 #define recovery_depth ppriv_field1
1051 static void
1052 camperiphsensedone(struct cam_periph *periph, union ccb *done_ccb)
1053 {
1054 	union ccb      *saved_ccb = (union ccb *)done_ccb->ccb_h.saved_ccb_ptr;
1055 	cam_status	status;
1056 	int		frozen = 0;
1057 	u_int		sense_key;
1058 	int		depth = done_ccb->ccb_h.recovery_depth;
1059 
1060 	status = done_ccb->ccb_h.status;
1061 	if (status & CAM_DEV_QFRZN) {
1062 		frozen = 1;
1063 		/*
1064 		 * Clear freeze flag now for case of retry,
1065 		 * freeze will be dropped later.
1066 		 */
1067 		done_ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
1068 	}
1069 	status &= CAM_STATUS_MASK;
1070 	switch (status) {
1071 	case CAM_REQ_CMP:
1072 	{
1073 		/*
1074 		 * If we manually retrieved sense into a CCB and got
1075 		 * something other than "NO SENSE" send the updated CCB
1076 		 * back to the client via xpt_done() to be processed via
1077 		 * the error recovery code again.
1078 		 */
1079 		sense_key = saved_ccb->csio.sense_data.flags;
1080 		sense_key &= SSD_KEY;
1081 		if (sense_key != SSD_KEY_NO_SENSE) {
1082 			saved_ccb->ccb_h.status |=
1083 			    CAM_AUTOSNS_VALID;
1084 		} else {
1085 			saved_ccb->ccb_h.status &=
1086 			    ~CAM_STATUS_MASK;
1087 			saved_ccb->ccb_h.status |=
1088 			    CAM_AUTOSENSE_FAIL;
1089 		}
1090 		saved_ccb->csio.sense_resid = done_ccb->csio.resid;
1091 		bcopy(saved_ccb, done_ccb, sizeof(union ccb));
1092 		xpt_free_ccb(saved_ccb);
1093 		break;
1094 	}
1095 	default:
1096 		bcopy(saved_ccb, done_ccb, sizeof(union ccb));
1097 		xpt_free_ccb(saved_ccb);
1098 		done_ccb->ccb_h.status &= ~CAM_STATUS_MASK;
1099 		done_ccb->ccb_h.status |= CAM_AUTOSENSE_FAIL;
1100 		break;
1101 	}
1102 	periph->flags &= ~CAM_PERIPH_SENSE_INPROG;
1103 	/*
1104 	 * If it is the end of recovery, drop freeze, taken due to
1105 	 * CAM_DEV_QFREEZE flag, set on recovery request.
1106 	 */
1107 	if (depth == 0) {
1108 		cam_release_devq(done_ccb->ccb_h.path,
1109 			 /*relsim_flags*/0,
1110 			 /*openings*/0,
1111 			 /*timeout*/0,
1112 			 /*getcount_only*/0);
1113 	}
1114 	/*
1115 	 * Copy frozen flag from recovery request if it is set there
1116 	 * for some reason.
1117 	 */
1118 	if (frozen != 0)
1119 		done_ccb->ccb_h.status |= CAM_DEV_QFRZN;
1120 	(*done_ccb->ccb_h.cbfcnp)(periph, done_ccb);
1121 }
1122 
1123 static void
1124 camperiphdone(struct cam_periph *periph, union ccb *done_ccb)
1125 {
1126 	union ccb      *saved_ccb, *save_ccb;
1127 	cam_status	status;
1128 	int		frozen = 0;
1129 	struct scsi_start_stop_unit *scsi_cmd;
1130 	u_int32_t	relsim_flags, timeout;
1131 
1132 	status = done_ccb->ccb_h.status;
1133 	if (status & CAM_DEV_QFRZN) {
1134 		frozen = 1;
1135 		/*
1136 		 * Clear freeze flag now for case of retry,
1137 		 * freeze will be dropped later.
1138 		 */
1139 		done_ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
1140 	}
1141 
1142 	timeout = 0;
1143 	relsim_flags = 0;
1144 	saved_ccb = (union ccb *)done_ccb->ccb_h.saved_ccb_ptr;
1145 
1146 	switch (status & CAM_STATUS_MASK) {
1147 	case CAM_REQ_CMP:
1148 	{
1149 		/*
1150 		 * If we have successfully taken a device from the not
1151 		 * ready to ready state, re-scan the device and re-get
1152 		 * the inquiry information.  Many devices (mostly disks)
1153 		 * don't properly report their inquiry information unless
1154 		 * they are spun up.
1155 		 */
1156 		scsi_cmd = (struct scsi_start_stop_unit *)
1157 				&done_ccb->csio.cdb_io.cdb_bytes;
1158 
1159 	 	if (scsi_cmd->opcode == START_STOP_UNIT)
1160 			xpt_async(AC_INQ_CHANGED,
1161 				  done_ccb->ccb_h.path, NULL);
1162 		goto final;
1163 	}
1164 	case CAM_SCSI_STATUS_ERROR:
1165 		scsi_cmd = (struct scsi_start_stop_unit *)
1166 				&done_ccb->csio.cdb_io.cdb_bytes;
1167 		if (status & CAM_AUTOSNS_VALID) {
1168 			struct ccb_getdev cgd;
1169 			struct scsi_sense_data *sense;
1170 			int    error_code, sense_key, asc, ascq;
1171 			scsi_sense_action err_action;
1172 
1173 			sense = &done_ccb->csio.sense_data;
1174 			scsi_extract_sense(sense, &error_code,
1175 					   &sense_key, &asc, &ascq);
1176 			/*
1177 			 * Grab the inquiry data for this device.
1178 			 */
1179 			xpt_setup_ccb(&cgd.ccb_h, done_ccb->ccb_h.path,
1180 			    CAM_PRIORITY_NORMAL);
1181 			cgd.ccb_h.func_code = XPT_GDEV_TYPE;
1182 			xpt_action((union ccb *)&cgd);
1183 			err_action = scsi_error_action(&done_ccb->csio,
1184 						       &cgd.inq_data, 0);
1185 			/*
1186 	 		 * If the error is "invalid field in CDB",
1187 			 * and the load/eject flag is set, turn the
1188 			 * flag off and try again.  This is just in
1189 			 * case the drive in question barfs on the
1190 			 * load eject flag.  The CAM code should set
1191 			 * the load/eject flag by default for
1192 			 * removable media.
1193 			 */
1194 			/* XXX KDM
1195 			 * Should we check to see what the specific
1196 			 * scsi status is??  Or does it not matter
1197 			 * since we already know that there was an
1198 			 * error, and we know what the specific
1199 			 * error code was, and we know what the
1200 			 * opcode is..
1201 			 */
1202 			if ((scsi_cmd->opcode == START_STOP_UNIT) &&
1203 			    ((scsi_cmd->how & SSS_LOEJ) != 0) &&
1204 			     (asc == 0x24) && (ascq == 0x00) &&
1205 			     (done_ccb->ccb_h.retry_count > 0)) {
1206 
1207 				scsi_cmd->how &= ~SSS_LOEJ;
1208 				xpt_action(done_ccb);
1209 			} else if ((done_ccb->ccb_h.retry_count > 1)
1210 				&& ((err_action & SS_MASK) != SS_FAIL)) {
1211 
1212 				/*
1213 				 * In this case, the error recovery
1214 				 * command failed, but we've got
1215 				 * some retries left on it.  Give
1216 				 * it another try unless this is an
1217 				 * unretryable error.
1218 				 */
1219 				/* set the timeout to .5 sec */
1220 				relsim_flags =
1221 					RELSIM_RELEASE_AFTER_TIMEOUT;
1222 				timeout = 500;
1223 				xpt_action(done_ccb);
1224 				break;
1225 			} else {
1226 				/*
1227 				 * Perform the final retry with the original
1228 				 * CCB so that final error processing is
1229 				 * performed by the owner of the CCB.
1230 				 */
1231 				goto final;
1232 			}
1233 		} else {
1234 			save_ccb = xpt_alloc_ccb_nowait();
1235 			if (save_ccb == NULL)
1236 				goto final;
1237 			bcopy(done_ccb, save_ccb, sizeof(*save_ccb));
1238 			periph->flags |= CAM_PERIPH_SENSE_INPROG;
1239 			/*
1240 			 * Send a Request Sense to the device.  We
1241 			 * assume that we are in a contingent allegiance
1242 			 * condition so we do not tag this request.
1243 			 */
1244 			scsi_request_sense(&done_ccb->csio, /*retries*/1,
1245 					   camperiphsensedone,
1246 					   &save_ccb->csio.sense_data,
1247 					   save_ccb->csio.sense_len,
1248 					   CAM_TAG_ACTION_NONE,
1249 					   /*sense_len*/SSD_FULL_SIZE,
1250 					   /*timeout*/5000);
1251 			done_ccb->ccb_h.pinfo.priority--;
1252 			done_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
1253 			done_ccb->ccb_h.saved_ccb_ptr = save_ccb;
1254 			done_ccb->ccb_h.recovery_depth++;
1255 			xpt_action(done_ccb);
1256 		}
1257 		break;
1258 	default:
1259 final:
1260 		bcopy(saved_ccb, done_ccb, sizeof(*done_ccb));
1261 		xpt_free_ccb(saved_ccb);
1262 		periph->flags &= ~CAM_PERIPH_RECOVERY_INPROG;
1263 		xpt_action(done_ccb);
1264 		break;
1265 	}
1266 
1267 	/* decrement the retry count */
1268 	/*
1269 	 * XXX This isn't appropriate in all cases.  Restructure,
1270 	 *     so that the retry count is only decremented on an
1271 	 *     actual retry.  Remeber that the orignal ccb had its
1272 	 *     retry count dropped before entering recovery, so
1273 	 *     doing it again is a bug.
1274 	 */
1275 	if (done_ccb->ccb_h.retry_count > 0)
1276 		done_ccb->ccb_h.retry_count--;
1277 	/*
1278 	 * Drop freeze taken due to CAM_DEV_QFREEZE flag set on recovery
1279 	 * request.
1280 	 */
1281 	cam_release_devq(done_ccb->ccb_h.path,
1282 			 /*relsim_flags*/relsim_flags,
1283 			 /*openings*/0,
1284 			 /*timeout*/timeout,
1285 			 /*getcount_only*/0);
1286 	/* Drop freeze taken, if this recovery request got error. */
1287 	if (frozen != 0) {
1288 		cam_release_devq(done_ccb->ccb_h.path,
1289 			 /*relsim_flags*/0,
1290 			 /*openings*/0,
1291 			 /*timeout*/0,
1292 			 /*getcount_only*/0);
1293 	}
1294 }
1295 
1296 /*
1297  * Generic Async Event handler.  Peripheral drivers usually
1298  * filter out the events that require personal attention,
1299  * and leave the rest to this function.
1300  */
1301 void
1302 cam_periph_async(struct cam_periph *periph, u_int32_t code,
1303 		 struct cam_path *path, void *arg)
1304 {
1305 	switch (code) {
1306 	case AC_LOST_DEVICE:
1307 		cam_periph_invalidate(periph);
1308 		break;
1309 	default:
1310 		break;
1311 	}
1312 }
1313 
1314 void
1315 cam_periph_bus_settle(struct cam_periph *periph, u_int bus_settle)
1316 {
1317 	struct ccb_getdevstats cgds;
1318 
1319 	xpt_setup_ccb(&cgds.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1320 	cgds.ccb_h.func_code = XPT_GDEV_STATS;
1321 	xpt_action((union ccb *)&cgds);
1322 	cam_periph_freeze_after_event(periph, &cgds.last_reset, bus_settle);
1323 }
1324 
1325 void
1326 cam_periph_freeze_after_event(struct cam_periph *periph,
1327 			      struct timeval* event_time, u_int duration_ms)
1328 {
1329 	struct timeval delta;
1330 	struct timeval duration_tv;
1331 
1332 	microtime(&delta);
1333 	timevalsub(&delta, event_time);
1334 	duration_tv.tv_sec = duration_ms / 1000;
1335 	duration_tv.tv_usec = (duration_ms % 1000) * 1000;
1336 	if (timevalcmp(&delta, &duration_tv, <)) {
1337 		timevalsub(&duration_tv, &delta);
1338 
1339 		duration_ms = duration_tv.tv_sec * 1000;
1340 		duration_ms += duration_tv.tv_usec / 1000;
1341 		cam_freeze_devq(periph->path);
1342 		cam_release_devq(periph->path,
1343 				RELSIM_RELEASE_AFTER_TIMEOUT,
1344 				/*reduction*/0,
1345 				/*timeout*/duration_ms,
1346 				/*getcount_only*/0);
1347 	}
1348 
1349 }
1350 
1351 static int
1352 camperiphscsistatuserror(union ccb *ccb, cam_flags camflags,
1353 			 u_int32_t sense_flags,
1354 			 int *openings, u_int32_t *relsim_flags,
1355 			 u_int32_t *timeout, const char **action_string)
1356 {
1357 	int error;
1358 
1359 	switch (ccb->csio.scsi_status) {
1360 	case SCSI_STATUS_OK:
1361 	case SCSI_STATUS_COND_MET:
1362 	case SCSI_STATUS_INTERMED:
1363 	case SCSI_STATUS_INTERMED_COND_MET:
1364 		error = 0;
1365 		break;
1366 	case SCSI_STATUS_CMD_TERMINATED:
1367 	case SCSI_STATUS_CHECK_COND:
1368 		if (bootverbose)
1369 			xpt_print(ccb->ccb_h.path, "SCSI status error\n");
1370 		error = camperiphscsisenseerror(ccb,
1371 					        camflags,
1372 					        sense_flags,
1373 					        openings,
1374 					        relsim_flags,
1375 					        timeout,
1376 					        action_string);
1377 		break;
1378 	case SCSI_STATUS_QUEUE_FULL:
1379 	{
1380 		/* no decrement */
1381 		struct ccb_getdevstats cgds;
1382 
1383 		/*
1384 		 * First off, find out what the current
1385 		 * transaction counts are.
1386 		 */
1387 		xpt_setup_ccb(&cgds.ccb_h,
1388 			      ccb->ccb_h.path,
1389 			      CAM_PRIORITY_NORMAL);
1390 		cgds.ccb_h.func_code = XPT_GDEV_STATS;
1391 		xpt_action((union ccb *)&cgds);
1392 
1393 		/*
1394 		 * If we were the only transaction active, treat
1395 		 * the QUEUE FULL as if it were a BUSY condition.
1396 		 */
1397 		if (cgds.dev_active != 0) {
1398 			int total_openings;
1399 
1400 			/*
1401 		 	 * Reduce the number of openings to
1402 			 * be 1 less than the amount it took
1403 			 * to get a queue full bounded by the
1404 			 * minimum allowed tag count for this
1405 			 * device.
1406 		 	 */
1407 			total_openings = cgds.dev_active + cgds.dev_openings;
1408 			*openings = cgds.dev_active;
1409 			if (*openings < cgds.mintags)
1410 				*openings = cgds.mintags;
1411 			if (*openings < total_openings)
1412 				*relsim_flags = RELSIM_ADJUST_OPENINGS;
1413 			else {
1414 				/*
1415 				 * Some devices report queue full for
1416 				 * temporary resource shortages.  For
1417 				 * this reason, we allow a minimum
1418 				 * tag count to be entered via a
1419 				 * quirk entry to prevent the queue
1420 				 * count on these devices from falling
1421 				 * to a pessimisticly low value.  We
1422 				 * still wait for the next successful
1423 				 * completion, however, before queueing
1424 				 * more transactions to the device.
1425 				 */
1426 				*relsim_flags = RELSIM_RELEASE_AFTER_CMDCMPLT;
1427 			}
1428 			*timeout = 0;
1429 			error = ERESTART;
1430 			if (bootverbose) {
1431 				xpt_print(ccb->ccb_h.path, "Queue full\n");
1432 			}
1433 			break;
1434 		}
1435 		/* FALLTHROUGH */
1436 	}
1437 	case SCSI_STATUS_BUSY:
1438 		/*
1439 		 * Restart the queue after either another
1440 		 * command completes or a 1 second timeout.
1441 		 */
1442 		if (bootverbose) {
1443 			xpt_print(ccb->ccb_h.path, "Device busy\n");
1444 		}
1445 	 	if (ccb->ccb_h.retry_count > 0) {
1446 	 		ccb->ccb_h.retry_count--;
1447 			error = ERESTART;
1448 			*relsim_flags = RELSIM_RELEASE_AFTER_TIMEOUT
1449 				      | RELSIM_RELEASE_AFTER_CMDCMPLT;
1450 			*timeout = 1000;
1451 		} else {
1452 			error = EIO;
1453 		}
1454 		break;
1455 	case SCSI_STATUS_RESERV_CONFLICT:
1456 		xpt_print(ccb->ccb_h.path, "Reservation conflict\n");
1457 		error = EIO;
1458 		break;
1459 	default:
1460 		xpt_print(ccb->ccb_h.path, "SCSI status 0x%x\n",
1461 		    ccb->csio.scsi_status);
1462 		error = EIO;
1463 		break;
1464 	}
1465 	return (error);
1466 }
1467 
1468 static int
1469 camperiphscsisenseerror(union ccb *ccb, cam_flags camflags,
1470 			u_int32_t sense_flags,
1471 		       int *openings, u_int32_t *relsim_flags,
1472 		       u_int32_t *timeout, const char **action_string)
1473 {
1474 	struct cam_periph *periph;
1475 	union ccb *orig_ccb = ccb;
1476 	int error;
1477 
1478 	periph = xpt_path_periph(ccb->ccb_h.path);
1479 	if (periph->flags &
1480 	    (CAM_PERIPH_RECOVERY_INPROG | CAM_PERIPH_SENSE_INPROG)) {
1481 		/*
1482 		 * If error recovery is already in progress, don't attempt
1483 		 * to process this error, but requeue it unconditionally
1484 		 * and attempt to process it once error recovery has
1485 		 * completed.  This failed command is probably related to
1486 		 * the error that caused the currently active error recovery
1487 		 * action so our  current recovery efforts should also
1488 		 * address this command.  Be aware that the error recovery
1489 		 * code assumes that only one recovery action is in progress
1490 		 * on a particular peripheral instance at any given time
1491 		 * (e.g. only one saved CCB for error recovery) so it is
1492 		 * imperitive that we don't violate this assumption.
1493 		 */
1494 		error = ERESTART;
1495 	} else {
1496 		scsi_sense_action err_action;
1497 		struct ccb_getdev cgd;
1498 
1499 		/*
1500 		 * Grab the inquiry data for this device.
1501 		 */
1502 		xpt_setup_ccb(&cgd.ccb_h, ccb->ccb_h.path, CAM_PRIORITY_NORMAL);
1503 		cgd.ccb_h.func_code = XPT_GDEV_TYPE;
1504 		xpt_action((union ccb *)&cgd);
1505 
1506 		if ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)
1507 			err_action = scsi_error_action(&ccb->csio,
1508 						       &cgd.inq_data,
1509 						       sense_flags);
1510 		else if ((ccb->ccb_h.flags & CAM_DIS_AUTOSENSE) == 0)
1511 			err_action = SS_REQSENSE;
1512 		else
1513 			err_action = SS_RETRY|SSQ_DECREMENT_COUNT|EIO;
1514 
1515 		error = err_action & SS_ERRMASK;
1516 
1517 		/*
1518 		 * If the recovery action will consume a retry,
1519 		 * make sure we actually have retries available.
1520 		 */
1521 		if ((err_action & SSQ_DECREMENT_COUNT) != 0) {
1522 		 	if (ccb->ccb_h.retry_count > 0)
1523 		 		ccb->ccb_h.retry_count--;
1524 			else {
1525 				*action_string = "Retries exhausted";
1526 				goto sense_error_done;
1527 			}
1528 		}
1529 
1530 		if ((err_action & SS_MASK) >= SS_START) {
1531 			/*
1532 			 * Do common portions of commands that
1533 			 * use recovery CCBs.
1534 			 */
1535 			orig_ccb = xpt_alloc_ccb_nowait();
1536 			if (orig_ccb == NULL) {
1537 				*action_string = "Can't allocate recovery CCB";
1538 				goto sense_error_done;
1539 			}
1540 			/*
1541 			 * Clear freeze flag for original request here, as
1542 			 * this freeze will be dropped as part of ERESTART.
1543 			 */
1544 			ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
1545 			bcopy(ccb, orig_ccb, sizeof(*orig_ccb));
1546 		}
1547 
1548 		switch (err_action & SS_MASK) {
1549 		case SS_NOP:
1550 			*action_string = "No recovery action needed";
1551 			error = 0;
1552 			break;
1553 		case SS_RETRY:
1554 			*action_string = "Retrying command (per sense data)";
1555 			error = ERESTART;
1556 			break;
1557 		case SS_FAIL:
1558 			*action_string = "Unretryable error";
1559 			break;
1560 		case SS_START:
1561 		{
1562 			int le;
1563 
1564 			/*
1565 			 * Send a start unit command to the device, and
1566 			 * then retry the command.
1567 			 */
1568 			*action_string = "Attempting to start unit";
1569 			periph->flags |= CAM_PERIPH_RECOVERY_INPROG;
1570 
1571 			/*
1572 			 * Check for removable media and set
1573 			 * load/eject flag appropriately.
1574 			 */
1575 			if (SID_IS_REMOVABLE(&cgd.inq_data))
1576 				le = TRUE;
1577 			else
1578 				le = FALSE;
1579 
1580 			scsi_start_stop(&ccb->csio,
1581 					/*retries*/1,
1582 					camperiphdone,
1583 					MSG_SIMPLE_Q_TAG,
1584 					/*start*/TRUE,
1585 					/*load/eject*/le,
1586 					/*immediate*/FALSE,
1587 					SSD_FULL_SIZE,
1588 					/*timeout*/50000);
1589 			break;
1590 		}
1591 		case SS_TUR:
1592 		{
1593 			/*
1594 			 * Send a Test Unit Ready to the device.
1595 			 * If the 'many' flag is set, we send 120
1596 			 * test unit ready commands, one every half
1597 			 * second.  Otherwise, we just send one TUR.
1598 			 * We only want to do this if the retry
1599 			 * count has not been exhausted.
1600 			 */
1601 			int retries;
1602 
1603 			if ((err_action & SSQ_MANY) != 0) {
1604 				*action_string = "Polling device for readiness";
1605 				retries = 120;
1606 			} else {
1607 				*action_string = "Testing device for readiness";
1608 				retries = 1;
1609 			}
1610 			periph->flags |= CAM_PERIPH_RECOVERY_INPROG;
1611 			scsi_test_unit_ready(&ccb->csio,
1612 					     retries,
1613 					     camperiphdone,
1614 					     MSG_SIMPLE_Q_TAG,
1615 					     SSD_FULL_SIZE,
1616 					     /*timeout*/5000);
1617 
1618 			/*
1619 			 * Accomplish our 500ms delay by deferring
1620 			 * the release of our device queue appropriately.
1621 			 */
1622 			*relsim_flags = RELSIM_RELEASE_AFTER_TIMEOUT;
1623 			*timeout = 500;
1624 			break;
1625 		}
1626 		case SS_REQSENSE:
1627 		{
1628 			*action_string = "Requesting SCSI sense data";
1629 			periph->flags |= CAM_PERIPH_SENSE_INPROG;
1630 			/*
1631 			 * Send a Request Sense to the device.  We
1632 			 * assume that we are in a contingent allegiance
1633 			 * condition so we do not tag this request.
1634 			 */
1635 			scsi_request_sense(&ccb->csio, /*retries*/1,
1636 					   camperiphsensedone,
1637 					   &orig_ccb->csio.sense_data,
1638 					   orig_ccb->csio.sense_len,
1639 					   CAM_TAG_ACTION_NONE,
1640 					   /*sense_len*/SSD_FULL_SIZE,
1641 					   /*timeout*/5000);
1642 			break;
1643 		}
1644 		default:
1645 			panic("Unhandled error action %x", err_action);
1646 		}
1647 
1648 		if ((err_action & SS_MASK) >= SS_START) {
1649 			/*
1650 			 * Drop the priority, so that the recovery
1651 			 * CCB is the first to execute.  Freeze the queue
1652 			 * after this command is sent so that we can
1653 			 * restore the old csio and have it queued in
1654 			 * the proper order before we release normal
1655 			 * transactions to the device.
1656 			 */
1657 			ccb->ccb_h.pinfo.priority--;
1658 			ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
1659 			ccb->ccb_h.saved_ccb_ptr = orig_ccb;
1660 			ccb->ccb_h.recovery_depth = 0;
1661 			error = ERESTART;
1662 		}
1663 
1664 sense_error_done:
1665 		if ((err_action & SSQ_PRINT_SENSE) != 0
1666 		 && (ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)
1667 			cam_error_print(orig_ccb, CAM_ESF_ALL, CAM_EPF_ALL);
1668 	}
1669 	return (error);
1670 }
1671 
1672 /*
1673  * Generic error handler.  Peripheral drivers usually filter
1674  * out the errors that they handle in a unique mannor, then
1675  * call this function.
1676  */
1677 int
1678 cam_periph_error(union ccb *ccb, cam_flags camflags,
1679 		 u_int32_t sense_flags, union ccb *save_ccb)
1680 {
1681 	const char *action_string;
1682 	cam_status  status;
1683 	int	    frozen;
1684 	int	    error, printed = 0;
1685 	int         openings;
1686 	u_int32_t   relsim_flags;
1687 	u_int32_t   timeout = 0;
1688 
1689 	action_string = NULL;
1690 	status = ccb->ccb_h.status;
1691 	frozen = (status & CAM_DEV_QFRZN) != 0;
1692 	status &= CAM_STATUS_MASK;
1693 	openings = relsim_flags = 0;
1694 
1695 	switch (status) {
1696 	case CAM_REQ_CMP:
1697 		error = 0;
1698 		break;
1699 	case CAM_SCSI_STATUS_ERROR:
1700 		error = camperiphscsistatuserror(ccb,
1701 						 camflags,
1702 						 sense_flags,
1703 						 &openings,
1704 						 &relsim_flags,
1705 						 &timeout,
1706 						 &action_string);
1707 		break;
1708 	case CAM_AUTOSENSE_FAIL:
1709 		xpt_print(ccb->ccb_h.path, "AutoSense failed\n");
1710 		error = EIO;	/* we have to kill the command */
1711 		break;
1712 	case CAM_ATA_STATUS_ERROR:
1713 		if (bootverbose && printed == 0) {
1714 			xpt_print(ccb->ccb_h.path, "ATA status error\n");
1715 			cam_error_print(ccb, CAM_ESF_ALL, CAM_EPF_ALL);
1716 			printed++;
1717 		}
1718 		/* FALLTHROUGH */
1719 	case CAM_REQ_CMP_ERR:
1720 		if (bootverbose && printed == 0) {
1721 			xpt_print(ccb->ccb_h.path,
1722 			    "Request completed with CAM_REQ_CMP_ERR\n");
1723 			printed++;
1724 		}
1725 		/* FALLTHROUGH */
1726 	case CAM_CMD_TIMEOUT:
1727 		if (bootverbose && printed == 0) {
1728 			xpt_print(ccb->ccb_h.path, "Command timed out\n");
1729 			printed++;
1730 		}
1731 		/* FALLTHROUGH */
1732 	case CAM_UNEXP_BUSFREE:
1733 		if (bootverbose && printed == 0) {
1734 			xpt_print(ccb->ccb_h.path, "Unexpected Bus Free\n");
1735 			printed++;
1736 		}
1737 		/* FALLTHROUGH */
1738 	case CAM_UNCOR_PARITY:
1739 		if (bootverbose && printed == 0) {
1740 			xpt_print(ccb->ccb_h.path,
1741 			    "Uncorrected parity error\n");
1742 			printed++;
1743 		}
1744 		/* FALLTHROUGH */
1745 	case CAM_DATA_RUN_ERR:
1746 		if (bootverbose && printed == 0) {
1747 			xpt_print(ccb->ccb_h.path, "Data overrun\n");
1748 			printed++;
1749 		}
1750 		error = EIO;	/* we have to kill the command */
1751 		/* decrement the number of retries */
1752 		if (ccb->ccb_h.retry_count > 0) {
1753 			ccb->ccb_h.retry_count--;
1754 			error = ERESTART;
1755 		} else {
1756 			action_string = "Retries exhausted";
1757 			error = EIO;
1758 		}
1759 		break;
1760 	case CAM_UA_ABORT:
1761 	case CAM_UA_TERMIO:
1762 	case CAM_MSG_REJECT_REC:
1763 		/* XXX Don't know that these are correct */
1764 		error = EIO;
1765 		break;
1766 	case CAM_SEL_TIMEOUT:
1767 	{
1768 		struct cam_path *newpath;
1769 
1770 		if ((camflags & CAM_RETRY_SELTO) != 0) {
1771 			if (ccb->ccb_h.retry_count > 0) {
1772 
1773 				ccb->ccb_h.retry_count--;
1774 				error = ERESTART;
1775 				if (bootverbose && printed == 0) {
1776 					xpt_print(ccb->ccb_h.path,
1777 					    "Selection timeout\n");
1778 					printed++;
1779 				}
1780 
1781 				/*
1782 				 * Wait a bit to give the device
1783 				 * time to recover before we try again.
1784 				 */
1785 				relsim_flags = RELSIM_RELEASE_AFTER_TIMEOUT;
1786 				timeout = periph_selto_delay;
1787 				break;
1788 			}
1789 		}
1790 		error = ENXIO;
1791 		/* Should we do more if we can't create the path?? */
1792 		if (xpt_create_path(&newpath, xpt_path_periph(ccb->ccb_h.path),
1793 				    xpt_path_path_id(ccb->ccb_h.path),
1794 				    xpt_path_target_id(ccb->ccb_h.path),
1795 				    CAM_LUN_WILDCARD) != CAM_REQ_CMP)
1796 			break;
1797 
1798 		/*
1799 		 * Let peripheral drivers know that this device has gone
1800 		 * away.
1801 		 */
1802 		xpt_async(AC_LOST_DEVICE, newpath, NULL);
1803 		xpt_free_path(newpath);
1804 		break;
1805 	}
1806 	case CAM_REQ_INVALID:
1807 	case CAM_PATH_INVALID:
1808 	case CAM_DEV_NOT_THERE:
1809 	case CAM_NO_HBA:
1810 	case CAM_PROVIDE_FAIL:
1811 	case CAM_REQ_TOO_BIG:
1812 	case CAM_LUN_INVALID:
1813 	case CAM_TID_INVALID:
1814 		error = EINVAL;
1815 		break;
1816 	case CAM_SCSI_BUS_RESET:
1817 	case CAM_BDR_SENT:
1818 		/*
1819 		 * Commands that repeatedly timeout and cause these
1820 		 * kinds of error recovery actions, should return
1821 		 * CAM_CMD_TIMEOUT, which allows us to safely assume
1822 		 * that this command was an innocent bystander to
1823 		 * these events and should be unconditionally
1824 		 * retried.
1825 		 */
1826 		if (bootverbose && printed == 0) {
1827 			xpt_print_path(ccb->ccb_h.path);
1828 			if (status == CAM_BDR_SENT)
1829 				printf("Bus Device Reset sent\n");
1830 			else
1831 				printf("Bus Reset issued\n");
1832 			printed++;
1833 		}
1834 		/* FALLTHROUGH */
1835 	case CAM_REQUEUE_REQ:
1836 		/* Unconditional requeue */
1837 		error = ERESTART;
1838 		if (bootverbose && printed == 0) {
1839 			xpt_print(ccb->ccb_h.path, "Request requeued\n");
1840 			printed++;
1841 		}
1842 		break;
1843 	case CAM_RESRC_UNAVAIL:
1844 		/* Wait a bit for the resource shortage to abate. */
1845 		timeout = periph_noresrc_delay;
1846 		/* FALLTHROUGH */
1847 	case CAM_BUSY:
1848 		if (timeout == 0) {
1849 			/* Wait a bit for the busy condition to abate. */
1850 			timeout = periph_busy_delay;
1851 		}
1852 		relsim_flags = RELSIM_RELEASE_AFTER_TIMEOUT;
1853 		/* FALLTHROUGH */
1854 	default:
1855 		/* decrement the number of retries */
1856 		if (ccb->ccb_h.retry_count > 0) {
1857 			ccb->ccb_h.retry_count--;
1858 			error = ERESTART;
1859 			if (bootverbose && printed == 0) {
1860 				xpt_print(ccb->ccb_h.path, "CAM status 0x%x\n",
1861 				    status);
1862 				printed++;
1863 			}
1864 		} else {
1865 			error = EIO;
1866 			action_string = "Retries exhausted";
1867 		}
1868 		break;
1869 	}
1870 
1871 	/*
1872 	 * If we have and error and are booting verbosely, whine
1873 	 * *unless* this was a non-retryable selection timeout.
1874 	 */
1875 	if (error != 0 && bootverbose &&
1876 	    !(status == CAM_SEL_TIMEOUT && (camflags & CAM_RETRY_SELTO) == 0)) {
1877 		if (error != ERESTART) {
1878 			if (action_string == NULL)
1879 				action_string = "Unretryable error";
1880 			xpt_print(ccb->ccb_h.path, "Error %d, %s\n",
1881 			    error, action_string);
1882 		} else if (action_string != NULL)
1883 			xpt_print(ccb->ccb_h.path, "%s\n", action_string);
1884 		else
1885 			xpt_print(ccb->ccb_h.path, "Retrying command\n");
1886 	}
1887 
1888 	/* Attempt a retry */
1889 	if (error == ERESTART || error == 0) {
1890 		if (frozen != 0)
1891 			ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
1892 		if (error == ERESTART)
1893 			xpt_action(ccb);
1894 		if (frozen != 0)
1895 			cam_release_devq(ccb->ccb_h.path,
1896 					 relsim_flags,
1897 					 openings,
1898 					 timeout,
1899 					 /*getcount_only*/0);
1900 	}
1901 
1902 	return (error);
1903 }
1904