1/*-
2 * Implementation of the Target Mode 'Black Hole device' for CAM.
3 *
4 * Copyright (c) 1999 Justin T. Gibbs.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
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.
15 *
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
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
| 1/*-
2 * Implementation of the Target Mode 'Black Hole device' for CAM.
3 *
4 * Copyright (c) 1999 Justin T. Gibbs.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
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.
15 *
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
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
|
30__FBSDID("$FreeBSD: head/sys/cam/scsi/scsi_targ_bh.c 201758 2010-01-07 21:01:37Z mbr $");
| 30__FBSDID("$FreeBSD: head/sys/cam/scsi/scsi_targ_bh.c 225950 2011-10-03 20:32:55Z ken $");
|
31
32#include <sys/param.h>
33#include <sys/queue.h>
34#include <sys/systm.h>
35#include <sys/kernel.h>
36#include <sys/types.h>
37#include <sys/bio.h>
38#include <sys/conf.h>
39#include <sys/devicestat.h>
40#include <sys/malloc.h>
41#include <sys/uio.h>
42
43#include <cam/cam.h>
44#include <cam/cam_ccb.h>
45#include <cam/cam_periph.h>
46#include <cam/cam_queue.h>
47#include <cam/cam_xpt_periph.h>
48#include <cam/cam_debug.h>
49#include <cam/cam_sim.h>
50
51#include <cam/scsi/scsi_all.h>
52#include <cam/scsi/scsi_message.h>
53
54MALLOC_DEFINE(M_SCSIBH, "SCSI bh", "SCSI blackhole buffers");
55
56typedef enum {
57 TARGBH_STATE_NORMAL,
58 TARGBH_STATE_EXCEPTION,
59 TARGBH_STATE_TEARDOWN
60} targbh_state;
61
62typedef enum {
63 TARGBH_FLAG_NONE = 0x00,
64 TARGBH_FLAG_LUN_ENABLED = 0x01
65} targbh_flags;
66
67typedef enum {
68 TARGBH_CCB_WORKQ,
69 TARGBH_CCB_WAITING
70} targbh_ccb_types;
71
72#define MAX_ACCEPT 8
73#define MAX_IMMEDIATE 16
74#define MAX_BUF_SIZE 256 /* Max inquiry/sense/mode page transfer */
75
76/* Offsets into our private CCB area for storing accept information */
77#define ccb_type ppriv_field0
78#define ccb_descr ppriv_ptr1
79
80/* We stick a pointer to the originating accept TIO in each continue I/O CCB */
81#define ccb_atio ppriv_ptr1
82
83TAILQ_HEAD(ccb_queue, ccb_hdr);
84
85struct targbh_softc {
86 struct ccb_queue pending_queue;
87 struct ccb_queue work_queue;
88 struct ccb_queue unknown_atio_queue;
89 struct devstat device_stats;
90 targbh_state state;
91 targbh_flags flags;
92 u_int init_level;
93 u_int inq_data_len;
94 struct ccb_accept_tio *accept_tio_list;
95 struct ccb_hdr_slist immed_notify_slist;
96};
97
98struct targbh_cmd_desc {
99 struct ccb_accept_tio* atio_link;
100 u_int data_resid; /* How much left to transfer */
101 u_int data_increment;/* Amount to send before next disconnect */
102 void* data; /* The data. Can be from backing_store or not */
103 void* backing_store;/* Backing store allocated for this descriptor*/
104 u_int max_size; /* Size of backing_store */
105 u_int32_t timeout;
106 u_int8_t status; /* Status to return to initiator */
107};
108
109static struct scsi_inquiry_data no_lun_inq_data =
110{
111 T_NODEVICE | (SID_QUAL_BAD_LU << 5), 0,
112 /* version */2, /* format version */2
113};
114
| 31
32#include <sys/param.h>
33#include <sys/queue.h>
34#include <sys/systm.h>
35#include <sys/kernel.h>
36#include <sys/types.h>
37#include <sys/bio.h>
38#include <sys/conf.h>
39#include <sys/devicestat.h>
40#include <sys/malloc.h>
41#include <sys/uio.h>
42
43#include <cam/cam.h>
44#include <cam/cam_ccb.h>
45#include <cam/cam_periph.h>
46#include <cam/cam_queue.h>
47#include <cam/cam_xpt_periph.h>
48#include <cam/cam_debug.h>
49#include <cam/cam_sim.h>
50
51#include <cam/scsi/scsi_all.h>
52#include <cam/scsi/scsi_message.h>
53
54MALLOC_DEFINE(M_SCSIBH, "SCSI bh", "SCSI blackhole buffers");
55
56typedef enum {
57 TARGBH_STATE_NORMAL,
58 TARGBH_STATE_EXCEPTION,
59 TARGBH_STATE_TEARDOWN
60} targbh_state;
61
62typedef enum {
63 TARGBH_FLAG_NONE = 0x00,
64 TARGBH_FLAG_LUN_ENABLED = 0x01
65} targbh_flags;
66
67typedef enum {
68 TARGBH_CCB_WORKQ,
69 TARGBH_CCB_WAITING
70} targbh_ccb_types;
71
72#define MAX_ACCEPT 8
73#define MAX_IMMEDIATE 16
74#define MAX_BUF_SIZE 256 /* Max inquiry/sense/mode page transfer */
75
76/* Offsets into our private CCB area for storing accept information */
77#define ccb_type ppriv_field0
78#define ccb_descr ppriv_ptr1
79
80/* We stick a pointer to the originating accept TIO in each continue I/O CCB */
81#define ccb_atio ppriv_ptr1
82
83TAILQ_HEAD(ccb_queue, ccb_hdr);
84
85struct targbh_softc {
86 struct ccb_queue pending_queue;
87 struct ccb_queue work_queue;
88 struct ccb_queue unknown_atio_queue;
89 struct devstat device_stats;
90 targbh_state state;
91 targbh_flags flags;
92 u_int init_level;
93 u_int inq_data_len;
94 struct ccb_accept_tio *accept_tio_list;
95 struct ccb_hdr_slist immed_notify_slist;
96};
97
98struct targbh_cmd_desc {
99 struct ccb_accept_tio* atio_link;
100 u_int data_resid; /* How much left to transfer */
101 u_int data_increment;/* Amount to send before next disconnect */
102 void* data; /* The data. Can be from backing_store or not */
103 void* backing_store;/* Backing store allocated for this descriptor*/
104 u_int max_size; /* Size of backing_store */
105 u_int32_t timeout;
106 u_int8_t status; /* Status to return to initiator */
107};
108
109static struct scsi_inquiry_data no_lun_inq_data =
110{
111 T_NODEVICE | (SID_QUAL_BAD_LU << 5), 0,
112 /* version */2, /* format version */2
113};
114
|
115static struct scsi_sense_data no_lun_sense_data =
| 115static struct scsi_sense_data_fixed no_lun_sense_data =
|
116{
117 SSD_CURRENT_ERROR|SSD_ERRCODE_VALID,
118 0,
119 SSD_KEY_NOT_READY,
120 { 0, 0, 0, 0 },
| 116{
117 SSD_CURRENT_ERROR|SSD_ERRCODE_VALID,
118 0,
119 SSD_KEY_NOT_READY,
120 { 0, 0, 0, 0 },
|
121 /*extra_len*/offsetof(struct scsi_sense_data, fru)
122 - offsetof(struct scsi_sense_data, extra_len),
| 121 /*extra_len*/offsetof(struct scsi_sense_data_fixed, fru)
122 - offsetof(struct scsi_sense_data_fixed, extra_len),
|
123 { 0, 0, 0, 0 },
124 /* Logical Unit Not Supported */
125 /*ASC*/0x25, /*ASCQ*/0
126};
127
| 123 { 0, 0, 0, 0 },
124 /* Logical Unit Not Supported */
125 /*ASC*/0x25, /*ASCQ*/0
126};
127
|
128static const int request_sense_size = offsetof(struct scsi_sense_data, fru);
| 128static const int request_sense_size = offsetof(struct scsi_sense_data_fixed, fru);
|
129
130static periph_init_t targbhinit;
131static void targbhasync(void *callback_arg, u_int32_t code,
132 struct cam_path *path, void *arg);
133static cam_status targbhenlun(struct cam_periph *periph);
134static cam_status targbhdislun(struct cam_periph *periph);
135static periph_ctor_t targbhctor;
136static periph_dtor_t targbhdtor;
137static periph_start_t targbhstart;
138static void targbhdone(struct cam_periph *periph,
139 union ccb *done_ccb);
140#ifdef NOTYET
141static int targbherror(union ccb *ccb, u_int32_t cam_flags,
142 u_int32_t sense_flags);
143#endif
144static struct targbh_cmd_desc* targbhallocdescr(void);
145static void targbhfreedescr(struct targbh_cmd_desc *buf);
146
147static struct periph_driver targbhdriver =
148{
149 targbhinit, "targbh",
150 TAILQ_HEAD_INITIALIZER(targbhdriver.units), /* generation */ 0
151};
152
153PERIPHDRIVER_DECLARE(targbh, targbhdriver);
154
155static void
156targbhinit(void)
157{
158 cam_status status;
159
160 /*
161 * Install a global async callback. This callback will
162 * receive async callbacks like "new path registered".
163 */
164 status = xpt_register_async(AC_PATH_REGISTERED | AC_PATH_DEREGISTERED,
165 targbhasync, NULL, NULL);
166
167 if (status != CAM_REQ_CMP) {
168 printf("targbh: Failed to attach master async callback "
169 "due to status 0x%x!\n", status);
170 }
171}
172
173static void
174targbhasync(void *callback_arg, u_int32_t code,
175 struct cam_path *path, void *arg)
176{
177 struct cam_path *new_path;
178 struct ccb_pathinq *cpi;
179 path_id_t bus_path_id;
180 cam_status status;
181
182 cpi = (struct ccb_pathinq *)arg;
183 if (code == AC_PATH_REGISTERED)
184 bus_path_id = cpi->ccb_h.path_id;
185 else
186 bus_path_id = xpt_path_path_id(path);
187 /*
188 * Allocate a peripheral instance for
189 * this target instance.
190 */
191 status = xpt_create_path(&new_path, NULL,
192 bus_path_id,
193 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD);
194 if (status != CAM_REQ_CMP) {
195 printf("targbhasync: Unable to create path "
196 "due to status 0x%x\n", status);
197 return;
198 }
199
200 switch (code) {
201 case AC_PATH_REGISTERED:
202 {
203 /* Only attach to controllers that support target mode */
204 if ((cpi->target_sprt & PIT_PROCESSOR) == 0)
205 break;
206
207 status = cam_periph_alloc(targbhctor, NULL, targbhdtor,
208 targbhstart,
209 "targbh", CAM_PERIPH_BIO,
210 new_path, targbhasync,
211 AC_PATH_REGISTERED,
212 cpi);
213 break;
214 }
215 case AC_PATH_DEREGISTERED:
216 {
217 struct cam_periph *periph;
218
219 if ((periph = cam_periph_find(new_path, "targbh")) != NULL)
220 cam_periph_invalidate(periph);
221 break;
222 }
223 default:
224 break;
225 }
226 xpt_free_path(new_path);
227}
228
229/* Attempt to enable our lun */
230static cam_status
231targbhenlun(struct cam_periph *periph)
232{
233 union ccb immed_ccb;
234 struct targbh_softc *softc;
235 cam_status status;
236 int i;
237
238 softc = (struct targbh_softc *)periph->softc;
239
240 if ((softc->flags & TARGBH_FLAG_LUN_ENABLED) != 0)
241 return (CAM_REQ_CMP);
242
243 xpt_setup_ccb(&immed_ccb.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
244 immed_ccb.ccb_h.func_code = XPT_EN_LUN;
245
246 /* Don't need support for any vendor specific commands */
247 immed_ccb.cel.grp6_len = 0;
248 immed_ccb.cel.grp7_len = 0;
249 immed_ccb.cel.enable = 1;
250 xpt_action(&immed_ccb);
251 status = immed_ccb.ccb_h.status;
252 if (status != CAM_REQ_CMP) {
253 xpt_print(periph->path,
254 "targbhenlun - Enable Lun Rejected with status 0x%x\n",
255 status);
256 return (status);
257 }
258
259 softc->flags |= TARGBH_FLAG_LUN_ENABLED;
260
261 /*
262 * Build up a buffer of accept target I/O
263 * operations for incoming selections.
264 */
265 for (i = 0; i < MAX_ACCEPT; i++) {
266 struct ccb_accept_tio *atio;
267
268 atio = (struct ccb_accept_tio*)malloc(sizeof(*atio), M_SCSIBH,
269 M_NOWAIT);
270 if (atio == NULL) {
271 status = CAM_RESRC_UNAVAIL;
272 break;
273 }
274
275 atio->ccb_h.ccb_descr = targbhallocdescr();
276
277 if (atio->ccb_h.ccb_descr == NULL) {
278 free(atio, M_SCSIBH);
279 status = CAM_RESRC_UNAVAIL;
280 break;
281 }
282
283 xpt_setup_ccb(&atio->ccb_h, periph->path, CAM_PRIORITY_NORMAL);
284 atio->ccb_h.func_code = XPT_ACCEPT_TARGET_IO;
285 atio->ccb_h.cbfcnp = targbhdone;
286 xpt_action((union ccb *)atio);
287 status = atio->ccb_h.status;
288 if (status != CAM_REQ_INPROG) {
289 targbhfreedescr(atio->ccb_h.ccb_descr);
290 free(atio, M_SCSIBH);
291 break;
292 }
293 ((struct targbh_cmd_desc*)atio->ccb_h.ccb_descr)->atio_link =
294 softc->accept_tio_list;
295 softc->accept_tio_list = atio;
296 }
297
298 if (i == 0) {
299 xpt_print(periph->path,
300 "targbhenlun - Could not allocate accept tio CCBs: status "
301 "= 0x%x\n", status);
302 targbhdislun(periph);
303 return (CAM_REQ_CMP_ERR);
304 }
305
306 /*
307 * Build up a buffer of immediate notify CCBs
308 * so the SIM can tell us of asynchronous target mode events.
309 */
310 for (i = 0; i < MAX_ACCEPT; i++) {
311 struct ccb_immed_notify *inot;
312
313 inot = (struct ccb_immed_notify*)malloc(sizeof(*inot), M_SCSIBH,
314 M_NOWAIT);
315
316 if (inot == NULL) {
317 status = CAM_RESRC_UNAVAIL;
318 break;
319 }
320
321 xpt_setup_ccb(&inot->ccb_h, periph->path, CAM_PRIORITY_NORMAL);
322 inot->ccb_h.func_code = XPT_IMMED_NOTIFY;
323 inot->ccb_h.cbfcnp = targbhdone;
324 xpt_action((union ccb *)inot);
325 status = inot->ccb_h.status;
326 if (status != CAM_REQ_INPROG) {
327 free(inot, M_SCSIBH);
328 break;
329 }
330 SLIST_INSERT_HEAD(&softc->immed_notify_slist, &inot->ccb_h,
331 periph_links.sle);
332 }
333
334 if (i == 0) {
335 xpt_print(periph->path,
336 "targbhenlun - Could not allocate immediate notify "
337 "CCBs: status = 0x%x\n", status);
338 targbhdislun(periph);
339 return (CAM_REQ_CMP_ERR);
340 }
341
342 return (CAM_REQ_CMP);
343}
344
345static cam_status
346targbhdislun(struct cam_periph *periph)
347{
348 union ccb ccb;
349 struct targbh_softc *softc;
350 struct ccb_accept_tio* atio;
351 struct ccb_hdr *ccb_h;
352
353 softc = (struct targbh_softc *)periph->softc;
354 if ((softc->flags & TARGBH_FLAG_LUN_ENABLED) == 0)
355 return CAM_REQ_CMP;
356
357 /* XXX Block for Continue I/O completion */
358
359 /* Kill off all ACCECPT and IMMEDIATE CCBs */
360 while ((atio = softc->accept_tio_list) != NULL) {
361
362 softc->accept_tio_list =
363 ((struct targbh_cmd_desc*)atio->ccb_h.ccb_descr)->atio_link;
364 xpt_setup_ccb(&ccb.cab.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
365 ccb.cab.ccb_h.func_code = XPT_ABORT;
366 ccb.cab.abort_ccb = (union ccb *)atio;
367 xpt_action(&ccb);
368 }
369
370 while ((ccb_h = SLIST_FIRST(&softc->immed_notify_slist)) != NULL) {
371 SLIST_REMOVE_HEAD(&softc->immed_notify_slist, periph_links.sle);
372 xpt_setup_ccb(&ccb.cab.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
373 ccb.cab.ccb_h.func_code = XPT_ABORT;
374 ccb.cab.abort_ccb = (union ccb *)ccb_h;
375 xpt_action(&ccb);
376 }
377
378 /*
379 * Dissable this lun.
380 */
381 xpt_setup_ccb(&ccb.cel.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
382 ccb.cel.ccb_h.func_code = XPT_EN_LUN;
383 ccb.cel.enable = 0;
384 xpt_action(&ccb);
385
386 if (ccb.cel.ccb_h.status != CAM_REQ_CMP)
387 printf("targbhdislun - Disabling lun on controller failed "
388 "with status 0x%x\n", ccb.cel.ccb_h.status);
389 else
390 softc->flags &= ~TARGBH_FLAG_LUN_ENABLED;
391 return (ccb.cel.ccb_h.status);
392}
393
394static cam_status
395targbhctor(struct cam_periph *periph, void *arg)
396{
397 struct targbh_softc *softc;
398
399 /* Allocate our per-instance private storage */
400 softc = (struct targbh_softc *)malloc(sizeof(*softc),
401 M_SCSIBH, M_NOWAIT);
402 if (softc == NULL) {
403 printf("targctor: unable to malloc softc\n");
404 return (CAM_REQ_CMP_ERR);
405 }
406
407 bzero(softc, sizeof(*softc));
408 TAILQ_INIT(&softc->pending_queue);
409 TAILQ_INIT(&softc->work_queue);
410 softc->accept_tio_list = NULL;
411 SLIST_INIT(&softc->immed_notify_slist);
412 softc->state = TARGBH_STATE_NORMAL;
413 periph->softc = softc;
414 softc->init_level++;
415
416 return (targbhenlun(periph));
417}
418
419static void
420targbhdtor(struct cam_periph *periph)
421{
422 struct targbh_softc *softc;
423
424 softc = (struct targbh_softc *)periph->softc;
425
426 softc->state = TARGBH_STATE_TEARDOWN;
427
428 targbhdislun(periph);
429
430 switch (softc->init_level) {
431 case 0:
432 panic("targdtor - impossible init level");
433 case 1:
434 /* FALLTHROUGH */
435 default:
436 /* XXX Wait for callback of targbhdislun() */
437 msleep(softc, periph->sim->mtx, PRIBIO, "targbh", hz/2);
438 free(softc, M_SCSIBH);
439 break;
440 }
441}
442
443static void
444targbhstart(struct cam_periph *periph, union ccb *start_ccb)
445{
446 struct targbh_softc *softc;
447 struct ccb_hdr *ccbh;
448 struct ccb_accept_tio *atio;
449 struct targbh_cmd_desc *desc;
450 struct ccb_scsiio *csio;
451 ccb_flags flags;
452
453 softc = (struct targbh_softc *)periph->softc;
454
455 ccbh = TAILQ_FIRST(&softc->work_queue);
456 if (periph->immediate_priority <= periph->pinfo.priority) {
457 start_ccb->ccb_h.ccb_type = TARGBH_CCB_WAITING;
458 SLIST_INSERT_HEAD(&periph->ccb_list, &start_ccb->ccb_h,
459 periph_links.sle);
460 periph->immediate_priority = CAM_PRIORITY_NONE;
461 wakeup(&periph->ccb_list);
462 } else if (ccbh == NULL) {
463 xpt_release_ccb(start_ccb);
464 } else {
465 TAILQ_REMOVE(&softc->work_queue, ccbh, periph_links.tqe);
466 TAILQ_INSERT_HEAD(&softc->pending_queue, ccbh,
467 periph_links.tqe);
468 atio = (struct ccb_accept_tio*)ccbh;
469 desc = (struct targbh_cmd_desc *)atio->ccb_h.ccb_descr;
470
471 /* Is this a tagged request? */
472 flags = atio->ccb_h.flags &
473 (CAM_DIS_DISCONNECT|CAM_TAG_ACTION_VALID|CAM_DIR_MASK);
474
475 csio = &start_ccb->csio;
476 /*
477 * If we are done with the transaction, tell the
478 * controller to send status and perform a CMD_CMPLT.
479 * If we have associated sense data, see if we can
480 * send that too.
481 */
482 if (desc->data_resid == desc->data_increment) {
483 flags |= CAM_SEND_STATUS;
484 if (atio->sense_len) {
485 csio->sense_len = atio->sense_len;
486 csio->sense_data = atio->sense_data;
487 flags |= CAM_SEND_SENSE;
488 }
489
490 }
491
492 cam_fill_ctio(csio,
493 /*retries*/2,
494 targbhdone,
495 flags,
496 (flags & CAM_TAG_ACTION_VALID)?
497 MSG_SIMPLE_Q_TAG : 0,
498 atio->tag_id,
499 atio->init_id,
500 desc->status,
501 /*data_ptr*/desc->data_increment == 0
502 ? NULL : desc->data,
503 /*dxfer_len*/desc->data_increment,
504 /*timeout*/desc->timeout);
505
506 /* Override our wildcard attachment */
507 start_ccb->ccb_h.target_id = atio->ccb_h.target_id;
508 start_ccb->ccb_h.target_lun = atio->ccb_h.target_lun;
509
510 start_ccb->ccb_h.ccb_type = TARGBH_CCB_WORKQ;
511 start_ccb->ccb_h.ccb_atio = atio;
512 CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
513 ("Sending a CTIO\n"));
514 xpt_action(start_ccb);
515 /*
516 * If the queue was frozen waiting for the response
517 * to this ATIO (for instance disconnection was disallowed),
518 * then release it now that our response has been queued.
519 */
520 if ((atio->ccb_h.status & CAM_DEV_QFRZN) != 0) {
521 cam_release_devq(periph->path,
522 /*relsim_flags*/0,
523 /*reduction*/0,
524 /*timeout*/0,
525 /*getcount_only*/0);
526 atio->ccb_h.status &= ~CAM_DEV_QFRZN;
527 }
528 ccbh = TAILQ_FIRST(&softc->work_queue);
529 }
530 if (ccbh != NULL)
531 xpt_schedule(periph, CAM_PRIORITY_NORMAL);
532}
533
534static void
535targbhdone(struct cam_periph *periph, union ccb *done_ccb)
536{
537 struct targbh_softc *softc;
538
539 softc = (struct targbh_softc *)periph->softc;
540
541 if (done_ccb->ccb_h.ccb_type == TARGBH_CCB_WAITING) {
542 /* Caller will release the CCB */
543 wakeup(&done_ccb->ccb_h.cbfcnp);
544 return;
545 }
546
547 switch (done_ccb->ccb_h.func_code) {
548 case XPT_ACCEPT_TARGET_IO:
549 {
550 struct ccb_accept_tio *atio;
551 struct targbh_cmd_desc *descr;
552 u_int8_t *cdb;
553 int priority;
554
555 atio = &done_ccb->atio;
556 descr = (struct targbh_cmd_desc*)atio->ccb_h.ccb_descr;
557 cdb = atio->cdb_io.cdb_bytes;
558 if (softc->state == TARGBH_STATE_TEARDOWN
559 || atio->ccb_h.status == CAM_REQ_ABORTED) {
560 targbhfreedescr(descr);
561 xpt_free_ccb(done_ccb);
562 return;
563 }
564
565 /*
566 * Determine the type of incoming command and
567 * setup our buffer for a response.
568 */
569 switch (cdb[0]) {
570 case INQUIRY:
571 {
572 struct scsi_inquiry *inq;
573
574 inq = (struct scsi_inquiry *)cdb;
575 CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
576 ("Saw an inquiry!\n"));
577 /*
578 * Validate the command. We don't
579 * support any VPD pages, so complain
580 * if EVPD is set.
581 */
582 if ((inq->byte2 & SI_EVPD) != 0
583 || inq->page_code != 0) {
584 atio->ccb_h.flags &= ~CAM_DIR_MASK;
585 atio->ccb_h.flags |= CAM_DIR_NONE;
586 /*
587 * This needs to have other than a
588 * no_lun_sense_data response.
589 */
| 129
130static periph_init_t targbhinit;
131static void targbhasync(void *callback_arg, u_int32_t code,
132 struct cam_path *path, void *arg);
133static cam_status targbhenlun(struct cam_periph *periph);
134static cam_status targbhdislun(struct cam_periph *periph);
135static periph_ctor_t targbhctor;
136static periph_dtor_t targbhdtor;
137static periph_start_t targbhstart;
138static void targbhdone(struct cam_periph *periph,
139 union ccb *done_ccb);
140#ifdef NOTYET
141static int targbherror(union ccb *ccb, u_int32_t cam_flags,
142 u_int32_t sense_flags);
143#endif
144static struct targbh_cmd_desc* targbhallocdescr(void);
145static void targbhfreedescr(struct targbh_cmd_desc *buf);
146
147static struct periph_driver targbhdriver =
148{
149 targbhinit, "targbh",
150 TAILQ_HEAD_INITIALIZER(targbhdriver.units), /* generation */ 0
151};
152
153PERIPHDRIVER_DECLARE(targbh, targbhdriver);
154
155static void
156targbhinit(void)
157{
158 cam_status status;
159
160 /*
161 * Install a global async callback. This callback will
162 * receive async callbacks like "new path registered".
163 */
164 status = xpt_register_async(AC_PATH_REGISTERED | AC_PATH_DEREGISTERED,
165 targbhasync, NULL, NULL);
166
167 if (status != CAM_REQ_CMP) {
168 printf("targbh: Failed to attach master async callback "
169 "due to status 0x%x!\n", status);
170 }
171}
172
173static void
174targbhasync(void *callback_arg, u_int32_t code,
175 struct cam_path *path, void *arg)
176{
177 struct cam_path *new_path;
178 struct ccb_pathinq *cpi;
179 path_id_t bus_path_id;
180 cam_status status;
181
182 cpi = (struct ccb_pathinq *)arg;
183 if (code == AC_PATH_REGISTERED)
184 bus_path_id = cpi->ccb_h.path_id;
185 else
186 bus_path_id = xpt_path_path_id(path);
187 /*
188 * Allocate a peripheral instance for
189 * this target instance.
190 */
191 status = xpt_create_path(&new_path, NULL,
192 bus_path_id,
193 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD);
194 if (status != CAM_REQ_CMP) {
195 printf("targbhasync: Unable to create path "
196 "due to status 0x%x\n", status);
197 return;
198 }
199
200 switch (code) {
201 case AC_PATH_REGISTERED:
202 {
203 /* Only attach to controllers that support target mode */
204 if ((cpi->target_sprt & PIT_PROCESSOR) == 0)
205 break;
206
207 status = cam_periph_alloc(targbhctor, NULL, targbhdtor,
208 targbhstart,
209 "targbh", CAM_PERIPH_BIO,
210 new_path, targbhasync,
211 AC_PATH_REGISTERED,
212 cpi);
213 break;
214 }
215 case AC_PATH_DEREGISTERED:
216 {
217 struct cam_periph *periph;
218
219 if ((periph = cam_periph_find(new_path, "targbh")) != NULL)
220 cam_periph_invalidate(periph);
221 break;
222 }
223 default:
224 break;
225 }
226 xpt_free_path(new_path);
227}
228
229/* Attempt to enable our lun */
230static cam_status
231targbhenlun(struct cam_periph *periph)
232{
233 union ccb immed_ccb;
234 struct targbh_softc *softc;
235 cam_status status;
236 int i;
237
238 softc = (struct targbh_softc *)periph->softc;
239
240 if ((softc->flags & TARGBH_FLAG_LUN_ENABLED) != 0)
241 return (CAM_REQ_CMP);
242
243 xpt_setup_ccb(&immed_ccb.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
244 immed_ccb.ccb_h.func_code = XPT_EN_LUN;
245
246 /* Don't need support for any vendor specific commands */
247 immed_ccb.cel.grp6_len = 0;
248 immed_ccb.cel.grp7_len = 0;
249 immed_ccb.cel.enable = 1;
250 xpt_action(&immed_ccb);
251 status = immed_ccb.ccb_h.status;
252 if (status != CAM_REQ_CMP) {
253 xpt_print(periph->path,
254 "targbhenlun - Enable Lun Rejected with status 0x%x\n",
255 status);
256 return (status);
257 }
258
259 softc->flags |= TARGBH_FLAG_LUN_ENABLED;
260
261 /*
262 * Build up a buffer of accept target I/O
263 * operations for incoming selections.
264 */
265 for (i = 0; i < MAX_ACCEPT; i++) {
266 struct ccb_accept_tio *atio;
267
268 atio = (struct ccb_accept_tio*)malloc(sizeof(*atio), M_SCSIBH,
269 M_NOWAIT);
270 if (atio == NULL) {
271 status = CAM_RESRC_UNAVAIL;
272 break;
273 }
274
275 atio->ccb_h.ccb_descr = targbhallocdescr();
276
277 if (atio->ccb_h.ccb_descr == NULL) {
278 free(atio, M_SCSIBH);
279 status = CAM_RESRC_UNAVAIL;
280 break;
281 }
282
283 xpt_setup_ccb(&atio->ccb_h, periph->path, CAM_PRIORITY_NORMAL);
284 atio->ccb_h.func_code = XPT_ACCEPT_TARGET_IO;
285 atio->ccb_h.cbfcnp = targbhdone;
286 xpt_action((union ccb *)atio);
287 status = atio->ccb_h.status;
288 if (status != CAM_REQ_INPROG) {
289 targbhfreedescr(atio->ccb_h.ccb_descr);
290 free(atio, M_SCSIBH);
291 break;
292 }
293 ((struct targbh_cmd_desc*)atio->ccb_h.ccb_descr)->atio_link =
294 softc->accept_tio_list;
295 softc->accept_tio_list = atio;
296 }
297
298 if (i == 0) {
299 xpt_print(periph->path,
300 "targbhenlun - Could not allocate accept tio CCBs: status "
301 "= 0x%x\n", status);
302 targbhdislun(periph);
303 return (CAM_REQ_CMP_ERR);
304 }
305
306 /*
307 * Build up a buffer of immediate notify CCBs
308 * so the SIM can tell us of asynchronous target mode events.
309 */
310 for (i = 0; i < MAX_ACCEPT; i++) {
311 struct ccb_immed_notify *inot;
312
313 inot = (struct ccb_immed_notify*)malloc(sizeof(*inot), M_SCSIBH,
314 M_NOWAIT);
315
316 if (inot == NULL) {
317 status = CAM_RESRC_UNAVAIL;
318 break;
319 }
320
321 xpt_setup_ccb(&inot->ccb_h, periph->path, CAM_PRIORITY_NORMAL);
322 inot->ccb_h.func_code = XPT_IMMED_NOTIFY;
323 inot->ccb_h.cbfcnp = targbhdone;
324 xpt_action((union ccb *)inot);
325 status = inot->ccb_h.status;
326 if (status != CAM_REQ_INPROG) {
327 free(inot, M_SCSIBH);
328 break;
329 }
330 SLIST_INSERT_HEAD(&softc->immed_notify_slist, &inot->ccb_h,
331 periph_links.sle);
332 }
333
334 if (i == 0) {
335 xpt_print(periph->path,
336 "targbhenlun - Could not allocate immediate notify "
337 "CCBs: status = 0x%x\n", status);
338 targbhdislun(periph);
339 return (CAM_REQ_CMP_ERR);
340 }
341
342 return (CAM_REQ_CMP);
343}
344
345static cam_status
346targbhdislun(struct cam_periph *periph)
347{
348 union ccb ccb;
349 struct targbh_softc *softc;
350 struct ccb_accept_tio* atio;
351 struct ccb_hdr *ccb_h;
352
353 softc = (struct targbh_softc *)periph->softc;
354 if ((softc->flags & TARGBH_FLAG_LUN_ENABLED) == 0)
355 return CAM_REQ_CMP;
356
357 /* XXX Block for Continue I/O completion */
358
359 /* Kill off all ACCECPT and IMMEDIATE CCBs */
360 while ((atio = softc->accept_tio_list) != NULL) {
361
362 softc->accept_tio_list =
363 ((struct targbh_cmd_desc*)atio->ccb_h.ccb_descr)->atio_link;
364 xpt_setup_ccb(&ccb.cab.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
365 ccb.cab.ccb_h.func_code = XPT_ABORT;
366 ccb.cab.abort_ccb = (union ccb *)atio;
367 xpt_action(&ccb);
368 }
369
370 while ((ccb_h = SLIST_FIRST(&softc->immed_notify_slist)) != NULL) {
371 SLIST_REMOVE_HEAD(&softc->immed_notify_slist, periph_links.sle);
372 xpt_setup_ccb(&ccb.cab.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
373 ccb.cab.ccb_h.func_code = XPT_ABORT;
374 ccb.cab.abort_ccb = (union ccb *)ccb_h;
375 xpt_action(&ccb);
376 }
377
378 /*
379 * Dissable this lun.
380 */
381 xpt_setup_ccb(&ccb.cel.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
382 ccb.cel.ccb_h.func_code = XPT_EN_LUN;
383 ccb.cel.enable = 0;
384 xpt_action(&ccb);
385
386 if (ccb.cel.ccb_h.status != CAM_REQ_CMP)
387 printf("targbhdislun - Disabling lun on controller failed "
388 "with status 0x%x\n", ccb.cel.ccb_h.status);
389 else
390 softc->flags &= ~TARGBH_FLAG_LUN_ENABLED;
391 return (ccb.cel.ccb_h.status);
392}
393
394static cam_status
395targbhctor(struct cam_periph *periph, void *arg)
396{
397 struct targbh_softc *softc;
398
399 /* Allocate our per-instance private storage */
400 softc = (struct targbh_softc *)malloc(sizeof(*softc),
401 M_SCSIBH, M_NOWAIT);
402 if (softc == NULL) {
403 printf("targctor: unable to malloc softc\n");
404 return (CAM_REQ_CMP_ERR);
405 }
406
407 bzero(softc, sizeof(*softc));
408 TAILQ_INIT(&softc->pending_queue);
409 TAILQ_INIT(&softc->work_queue);
410 softc->accept_tio_list = NULL;
411 SLIST_INIT(&softc->immed_notify_slist);
412 softc->state = TARGBH_STATE_NORMAL;
413 periph->softc = softc;
414 softc->init_level++;
415
416 return (targbhenlun(periph));
417}
418
419static void
420targbhdtor(struct cam_periph *periph)
421{
422 struct targbh_softc *softc;
423
424 softc = (struct targbh_softc *)periph->softc;
425
426 softc->state = TARGBH_STATE_TEARDOWN;
427
428 targbhdislun(periph);
429
430 switch (softc->init_level) {
431 case 0:
432 panic("targdtor - impossible init level");
433 case 1:
434 /* FALLTHROUGH */
435 default:
436 /* XXX Wait for callback of targbhdislun() */
437 msleep(softc, periph->sim->mtx, PRIBIO, "targbh", hz/2);
438 free(softc, M_SCSIBH);
439 break;
440 }
441}
442
443static void
444targbhstart(struct cam_periph *periph, union ccb *start_ccb)
445{
446 struct targbh_softc *softc;
447 struct ccb_hdr *ccbh;
448 struct ccb_accept_tio *atio;
449 struct targbh_cmd_desc *desc;
450 struct ccb_scsiio *csio;
451 ccb_flags flags;
452
453 softc = (struct targbh_softc *)periph->softc;
454
455 ccbh = TAILQ_FIRST(&softc->work_queue);
456 if (periph->immediate_priority <= periph->pinfo.priority) {
457 start_ccb->ccb_h.ccb_type = TARGBH_CCB_WAITING;
458 SLIST_INSERT_HEAD(&periph->ccb_list, &start_ccb->ccb_h,
459 periph_links.sle);
460 periph->immediate_priority = CAM_PRIORITY_NONE;
461 wakeup(&periph->ccb_list);
462 } else if (ccbh == NULL) {
463 xpt_release_ccb(start_ccb);
464 } else {
465 TAILQ_REMOVE(&softc->work_queue, ccbh, periph_links.tqe);
466 TAILQ_INSERT_HEAD(&softc->pending_queue, ccbh,
467 periph_links.tqe);
468 atio = (struct ccb_accept_tio*)ccbh;
469 desc = (struct targbh_cmd_desc *)atio->ccb_h.ccb_descr;
470
471 /* Is this a tagged request? */
472 flags = atio->ccb_h.flags &
473 (CAM_DIS_DISCONNECT|CAM_TAG_ACTION_VALID|CAM_DIR_MASK);
474
475 csio = &start_ccb->csio;
476 /*
477 * If we are done with the transaction, tell the
478 * controller to send status and perform a CMD_CMPLT.
479 * If we have associated sense data, see if we can
480 * send that too.
481 */
482 if (desc->data_resid == desc->data_increment) {
483 flags |= CAM_SEND_STATUS;
484 if (atio->sense_len) {
485 csio->sense_len = atio->sense_len;
486 csio->sense_data = atio->sense_data;
487 flags |= CAM_SEND_SENSE;
488 }
489
490 }
491
492 cam_fill_ctio(csio,
493 /*retries*/2,
494 targbhdone,
495 flags,
496 (flags & CAM_TAG_ACTION_VALID)?
497 MSG_SIMPLE_Q_TAG : 0,
498 atio->tag_id,
499 atio->init_id,
500 desc->status,
501 /*data_ptr*/desc->data_increment == 0
502 ? NULL : desc->data,
503 /*dxfer_len*/desc->data_increment,
504 /*timeout*/desc->timeout);
505
506 /* Override our wildcard attachment */
507 start_ccb->ccb_h.target_id = atio->ccb_h.target_id;
508 start_ccb->ccb_h.target_lun = atio->ccb_h.target_lun;
509
510 start_ccb->ccb_h.ccb_type = TARGBH_CCB_WORKQ;
511 start_ccb->ccb_h.ccb_atio = atio;
512 CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
513 ("Sending a CTIO\n"));
514 xpt_action(start_ccb);
515 /*
516 * If the queue was frozen waiting for the response
517 * to this ATIO (for instance disconnection was disallowed),
518 * then release it now that our response has been queued.
519 */
520 if ((atio->ccb_h.status & CAM_DEV_QFRZN) != 0) {
521 cam_release_devq(periph->path,
522 /*relsim_flags*/0,
523 /*reduction*/0,
524 /*timeout*/0,
525 /*getcount_only*/0);
526 atio->ccb_h.status &= ~CAM_DEV_QFRZN;
527 }
528 ccbh = TAILQ_FIRST(&softc->work_queue);
529 }
530 if (ccbh != NULL)
531 xpt_schedule(periph, CAM_PRIORITY_NORMAL);
532}
533
534static void
535targbhdone(struct cam_periph *periph, union ccb *done_ccb)
536{
537 struct targbh_softc *softc;
538
539 softc = (struct targbh_softc *)periph->softc;
540
541 if (done_ccb->ccb_h.ccb_type == TARGBH_CCB_WAITING) {
542 /* Caller will release the CCB */
543 wakeup(&done_ccb->ccb_h.cbfcnp);
544 return;
545 }
546
547 switch (done_ccb->ccb_h.func_code) {
548 case XPT_ACCEPT_TARGET_IO:
549 {
550 struct ccb_accept_tio *atio;
551 struct targbh_cmd_desc *descr;
552 u_int8_t *cdb;
553 int priority;
554
555 atio = &done_ccb->atio;
556 descr = (struct targbh_cmd_desc*)atio->ccb_h.ccb_descr;
557 cdb = atio->cdb_io.cdb_bytes;
558 if (softc->state == TARGBH_STATE_TEARDOWN
559 || atio->ccb_h.status == CAM_REQ_ABORTED) {
560 targbhfreedescr(descr);
561 xpt_free_ccb(done_ccb);
562 return;
563 }
564
565 /*
566 * Determine the type of incoming command and
567 * setup our buffer for a response.
568 */
569 switch (cdb[0]) {
570 case INQUIRY:
571 {
572 struct scsi_inquiry *inq;
573
574 inq = (struct scsi_inquiry *)cdb;
575 CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
576 ("Saw an inquiry!\n"));
577 /*
578 * Validate the command. We don't
579 * support any VPD pages, so complain
580 * if EVPD is set.
581 */
582 if ((inq->byte2 & SI_EVPD) != 0
583 || inq->page_code != 0) {
584 atio->ccb_h.flags &= ~CAM_DIR_MASK;
585 atio->ccb_h.flags |= CAM_DIR_NONE;
586 /*
587 * This needs to have other than a
588 * no_lun_sense_data response.
589 */
|
590 atio->sense_data = no_lun_sense_data;
| 590 bcopy(&no_lun_sense_data, &atio->sense_data,
591 min(sizeof(no_lun_sense_data),
592 sizeof(atio->sense_data)));
|
591 atio->sense_len = sizeof(no_lun_sense_data);
592 descr->data_resid = 0;
593 descr->data_increment = 0;
594 descr->status = SCSI_STATUS_CHECK_COND;
595 break;
596 }
597 /*
598 * Direction is always relative
599 * to the initator.
600 */
601 atio->ccb_h.flags &= ~CAM_DIR_MASK;
602 atio->ccb_h.flags |= CAM_DIR_IN;
603 descr->data = &no_lun_inq_data;
604 descr->data_resid = MIN(sizeof(no_lun_inq_data),
605 SCSI_CDB6_LEN(inq->length));
606 descr->data_increment = descr->data_resid;
607 descr->timeout = 5 * 1000;
608 descr->status = SCSI_STATUS_OK;
609 break;
610 }
611 case REQUEST_SENSE:
612 {
613 struct scsi_request_sense *rsense;
614
615 rsense = (struct scsi_request_sense *)cdb;
616 /* Refer to static sense data */
617 atio->ccb_h.flags &= ~CAM_DIR_MASK;
618 atio->ccb_h.flags |= CAM_DIR_IN;
619 descr->data = &no_lun_sense_data;
620 descr->data_resid = request_sense_size;
621 descr->data_resid = MIN(descr->data_resid,
622 SCSI_CDB6_LEN(rsense->length));
623 descr->data_increment = descr->data_resid;
624 descr->timeout = 5 * 1000;
625 descr->status = SCSI_STATUS_OK;
626 break;
627 }
628 default:
629 /* Constant CA, tell initiator */
630 /* Direction is always relative to the initator */
631 atio->ccb_h.flags &= ~CAM_DIR_MASK;
632 atio->ccb_h.flags |= CAM_DIR_NONE;
| 593 atio->sense_len = sizeof(no_lun_sense_data);
594 descr->data_resid = 0;
595 descr->data_increment = 0;
596 descr->status = SCSI_STATUS_CHECK_COND;
597 break;
598 }
599 /*
600 * Direction is always relative
601 * to the initator.
602 */
603 atio->ccb_h.flags &= ~CAM_DIR_MASK;
604 atio->ccb_h.flags |= CAM_DIR_IN;
605 descr->data = &no_lun_inq_data;
606 descr->data_resid = MIN(sizeof(no_lun_inq_data),
607 SCSI_CDB6_LEN(inq->length));
608 descr->data_increment = descr->data_resid;
609 descr->timeout = 5 * 1000;
610 descr->status = SCSI_STATUS_OK;
611 break;
612 }
613 case REQUEST_SENSE:
614 {
615 struct scsi_request_sense *rsense;
616
617 rsense = (struct scsi_request_sense *)cdb;
618 /* Refer to static sense data */
619 atio->ccb_h.flags &= ~CAM_DIR_MASK;
620 atio->ccb_h.flags |= CAM_DIR_IN;
621 descr->data = &no_lun_sense_data;
622 descr->data_resid = request_sense_size;
623 descr->data_resid = MIN(descr->data_resid,
624 SCSI_CDB6_LEN(rsense->length));
625 descr->data_increment = descr->data_resid;
626 descr->timeout = 5 * 1000;
627 descr->status = SCSI_STATUS_OK;
628 break;
629 }
630 default:
631 /* Constant CA, tell initiator */
632 /* Direction is always relative to the initator */
633 atio->ccb_h.flags &= ~CAM_DIR_MASK;
634 atio->ccb_h.flags |= CAM_DIR_NONE;
|
633 atio->sense_data = no_lun_sense_data;
| 635 bcopy(&no_lun_sense_data, &atio->sense_data,
636 min(sizeof(no_lun_sense_data),
637 sizeof(atio->sense_data)));
|
634 atio->sense_len = sizeof (no_lun_sense_data);
635 descr->data_resid = 0;
636 descr->data_increment = 0;
637 descr->timeout = 5 * 1000;
638 descr->status = SCSI_STATUS_CHECK_COND;
639 break;
640 }
641
642 /* Queue us up to receive a Continue Target I/O ccb. */
643 if ((atio->ccb_h.flags & CAM_DIS_DISCONNECT) != 0) {
644 TAILQ_INSERT_HEAD(&softc->work_queue, &atio->ccb_h,
645 periph_links.tqe);
646 priority = 0;
647 } else {
648 TAILQ_INSERT_TAIL(&softc->work_queue, &atio->ccb_h,
649 periph_links.tqe);
650 priority = CAM_PRIORITY_NORMAL;
651 }
652 xpt_schedule(periph, priority);
653 break;
654 }
655 case XPT_CONT_TARGET_IO:
656 {
657 struct ccb_accept_tio *atio;
658 struct targbh_cmd_desc *desc;
659
660 CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
661 ("Received completed CTIO\n"));
662 atio = (struct ccb_accept_tio*)done_ccb->ccb_h.ccb_atio;
663 desc = (struct targbh_cmd_desc *)atio->ccb_h.ccb_descr;
664
665 TAILQ_REMOVE(&softc->pending_queue, &atio->ccb_h,
666 periph_links.tqe);
667
668 /*
669 * We could check for CAM_SENT_SENSE bein set here,
670 * but since we're not maintaining any CA/UA state,
671 * there's no point.
672 */
673 atio->sense_len = 0;
674 done_ccb->ccb_h.flags &= ~CAM_SEND_SENSE;
675 done_ccb->ccb_h.status &= ~CAM_SENT_SENSE;
676
677 /*
678 * Any errors will not change the data we return,
679 * so make sure the queue is not left frozen.
680 * XXX - At some point there may be errors that
681 * leave us in a connected state with the
682 * initiator...
683 */
684 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
685 printf("Releasing Queue\n");
686 cam_release_devq(done_ccb->ccb_h.path,
687 /*relsim_flags*/0,
688 /*reduction*/0,
689 /*timeout*/0,
690 /*getcount_only*/0);
691 done_ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
692 }
693 desc->data_resid -= desc->data_increment;
694 xpt_release_ccb(done_ccb);
695 if (softc->state != TARGBH_STATE_TEARDOWN) {
696
697 /*
698 * Send the original accept TIO back to the
699 * controller to handle more work.
700 */
701 CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
702 ("Returning ATIO to target\n"));
703 /* Restore wildcards */
704 atio->ccb_h.target_id = CAM_TARGET_WILDCARD;
705 atio->ccb_h.target_lun = CAM_LUN_WILDCARD;
706 xpt_action((union ccb *)atio);
707 break;
708 } else {
709 targbhfreedescr(desc);
710 free(atio, M_SCSIBH);
711 }
712 break;
713 }
714 case XPT_IMMED_NOTIFY:
715 {
716 int frozen;
717
718 frozen = (done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0;
719 if (softc->state == TARGBH_STATE_TEARDOWN
720 || done_ccb->ccb_h.status == CAM_REQ_ABORTED) {
721 printf("Freed an immediate notify\n");
722 xpt_free_ccb(done_ccb);
723 } else {
724 /* Requeue for another immediate event */
725 xpt_action(done_ccb);
726 }
727 if (frozen != 0)
728 cam_release_devq(periph->path,
729 /*relsim_flags*/0,
730 /*opening reduction*/0,
731 /*timeout*/0,
732 /*getcount_only*/0);
733 break;
734 }
735 default:
736 panic("targbhdone: Unexpected ccb opcode");
737 break;
738 }
739}
740
741#ifdef NOTYET
742static int
743targbherror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
744{
745 return 0;
746}
747#endif
748
749static struct targbh_cmd_desc*
750targbhallocdescr()
751{
752 struct targbh_cmd_desc* descr;
753
754 /* Allocate the targbh_descr structure */
755 descr = (struct targbh_cmd_desc *)malloc(sizeof(*descr),
756 M_SCSIBH, M_NOWAIT);
757 if (descr == NULL)
758 return (NULL);
759
760 bzero(descr, sizeof(*descr));
761
762 /* Allocate buffer backing store */
763 descr->backing_store = malloc(MAX_BUF_SIZE, M_SCSIBH, M_NOWAIT);
764 if (descr->backing_store == NULL) {
765 free(descr, M_SCSIBH);
766 return (NULL);
767 }
768 descr->max_size = MAX_BUF_SIZE;
769 return (descr);
770}
771
772static void
773targbhfreedescr(struct targbh_cmd_desc *descr)
774{
775 free(descr->backing_store, M_SCSIBH);
776 free(descr, M_SCSIBH);
777}
| 638 atio->sense_len = sizeof (no_lun_sense_data);
639 descr->data_resid = 0;
640 descr->data_increment = 0;
641 descr->timeout = 5 * 1000;
642 descr->status = SCSI_STATUS_CHECK_COND;
643 break;
644 }
645
646 /* Queue us up to receive a Continue Target I/O ccb. */
647 if ((atio->ccb_h.flags & CAM_DIS_DISCONNECT) != 0) {
648 TAILQ_INSERT_HEAD(&softc->work_queue, &atio->ccb_h,
649 periph_links.tqe);
650 priority = 0;
651 } else {
652 TAILQ_INSERT_TAIL(&softc->work_queue, &atio->ccb_h,
653 periph_links.tqe);
654 priority = CAM_PRIORITY_NORMAL;
655 }
656 xpt_schedule(periph, priority);
657 break;
658 }
659 case XPT_CONT_TARGET_IO:
660 {
661 struct ccb_accept_tio *atio;
662 struct targbh_cmd_desc *desc;
663
664 CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
665 ("Received completed CTIO\n"));
666 atio = (struct ccb_accept_tio*)done_ccb->ccb_h.ccb_atio;
667 desc = (struct targbh_cmd_desc *)atio->ccb_h.ccb_descr;
668
669 TAILQ_REMOVE(&softc->pending_queue, &atio->ccb_h,
670 periph_links.tqe);
671
672 /*
673 * We could check for CAM_SENT_SENSE bein set here,
674 * but since we're not maintaining any CA/UA state,
675 * there's no point.
676 */
677 atio->sense_len = 0;
678 done_ccb->ccb_h.flags &= ~CAM_SEND_SENSE;
679 done_ccb->ccb_h.status &= ~CAM_SENT_SENSE;
680
681 /*
682 * Any errors will not change the data we return,
683 * so make sure the queue is not left frozen.
684 * XXX - At some point there may be errors that
685 * leave us in a connected state with the
686 * initiator...
687 */
688 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
689 printf("Releasing Queue\n");
690 cam_release_devq(done_ccb->ccb_h.path,
691 /*relsim_flags*/0,
692 /*reduction*/0,
693 /*timeout*/0,
694 /*getcount_only*/0);
695 done_ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
696 }
697 desc->data_resid -= desc->data_increment;
698 xpt_release_ccb(done_ccb);
699 if (softc->state != TARGBH_STATE_TEARDOWN) {
700
701 /*
702 * Send the original accept TIO back to the
703 * controller to handle more work.
704 */
705 CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
706 ("Returning ATIO to target\n"));
707 /* Restore wildcards */
708 atio->ccb_h.target_id = CAM_TARGET_WILDCARD;
709 atio->ccb_h.target_lun = CAM_LUN_WILDCARD;
710 xpt_action((union ccb *)atio);
711 break;
712 } else {
713 targbhfreedescr(desc);
714 free(atio, M_SCSIBH);
715 }
716 break;
717 }
718 case XPT_IMMED_NOTIFY:
719 {
720 int frozen;
721
722 frozen = (done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0;
723 if (softc->state == TARGBH_STATE_TEARDOWN
724 || done_ccb->ccb_h.status == CAM_REQ_ABORTED) {
725 printf("Freed an immediate notify\n");
726 xpt_free_ccb(done_ccb);
727 } else {
728 /* Requeue for another immediate event */
729 xpt_action(done_ccb);
730 }
731 if (frozen != 0)
732 cam_release_devq(periph->path,
733 /*relsim_flags*/0,
734 /*opening reduction*/0,
735 /*timeout*/0,
736 /*getcount_only*/0);
737 break;
738 }
739 default:
740 panic("targbhdone: Unexpected ccb opcode");
741 break;
742 }
743}
744
745#ifdef NOTYET
746static int
747targbherror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
748{
749 return 0;
750}
751#endif
752
753static struct targbh_cmd_desc*
754targbhallocdescr()
755{
756 struct targbh_cmd_desc* descr;
757
758 /* Allocate the targbh_descr structure */
759 descr = (struct targbh_cmd_desc *)malloc(sizeof(*descr),
760 M_SCSIBH, M_NOWAIT);
761 if (descr == NULL)
762 return (NULL);
763
764 bzero(descr, sizeof(*descr));
765
766 /* Allocate buffer backing store */
767 descr->backing_store = malloc(MAX_BUF_SIZE, M_SCSIBH, M_NOWAIT);
768 if (descr->backing_store == NULL) {
769 free(descr, M_SCSIBH);
770 return (NULL);
771 }
772 descr->max_size = MAX_BUF_SIZE;
773 return (descr);
774}
775
776static void
777targbhfreedescr(struct targbh_cmd_desc *descr)
778{
779 free(descr->backing_store, M_SCSIBH);
780 free(descr, M_SCSIBH);
781}
|