1/*-
|
2 * Copyright (c) 2005-2008 Daniel Braniss <danny@cs.huji.ac.il>
|
2 * Copyright (c) 2005-2010 Daniel Braniss <danny@cs.huji.ac.il> |
3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 */ 27/*
|
28 | $Id: iscsi_subr.c,v 1.17 2006/11/26 14:50:43 danny Exp danny $
|
28 | $Id: iscsi_subr.c 743 2009-08-08 10:54:53Z danny $ |
29 */ 30 31#include <sys/cdefs.h>
|
32__FBSDID("$FreeBSD: head/sys/dev/iscsi/initiator/iscsi_subr.c 185289 2008-11-25 07:17:11Z scottl $");
|
32__FBSDID("$FreeBSD: head/sys/dev/iscsi/initiator/iscsi_subr.c 211095 2010-08-09 12:36:36Z des $"); |
33 34#include "opt_iscsi_initiator.h" 35 36#include <sys/param.h> 37#include <sys/kernel.h> 38#include <sys/callout.h> 39#include <sys/malloc.h> 40#include <sys/mbuf.h> 41#include <sys/kthread.h> 42#include <sys/lock.h> 43#include <sys/mutex.h> 44#include <sys/uio.h> 45#include <sys/sysctl.h>
|
46#include <sys/sx.h> |
47 48#include <cam/cam.h> 49#include <cam/cam_ccb.h> 50#include <cam/cam_sim.h> 51#include <cam/cam_xpt_sim.h> 52#include <cam/cam_periph.h> 53#include <cam/scsi/scsi_message.h> 54#include <sys/eventhandler.h> 55 56#include <dev/iscsi/initiator/iscsi.h> 57#include <dev/iscsi/initiator/iscsivar.h> 58 59/* 60 | Interface to the SCSI layer 61 */ 62void 63iscsi_r2t(isc_session_t *sp, pduq_t *opq, pduq_t *pq) 64{ 65 union ccb *ccb = opq->ccb; 66 struct ccb_scsiio *csio = &ccb->csio; 67 pdu_t *opp = &opq->pdu; 68 bhs_t *bhp = &opp->ipdu.bhs; 69 r2t_t *r2t = &pq->pdu.ipdu.r2t; 70 pduq_t *wpq; 71 int error; 72 73 debug_called(8); 74 sdebug(4, "itt=%x r2tSN=%d bo=%x ddtl=%x W=%d", ntohl(r2t->itt), 75 ntohl(r2t->r2tSN), ntohl(r2t->bo), ntohl(r2t->ddtl), opp->ipdu.scsi_req.W); 76 77 switch(bhp->opcode) { 78 case ISCSI_SCSI_CMD: 79 if(opp->ipdu.scsi_req.W) { 80 data_out_t *cmd; 81 u_int ddtl = ntohl(r2t->ddtl); 82 u_int edtl = ntohl(opp->ipdu.scsi_req.edtlen); 83 u_int bleft, bs, dsn, bo; 84 caddr_t bp = csio->data_ptr; 85 86 bo = ntohl(r2t->bo); 87 bleft = ddtl; 88 89 if(sp->opt.maxXmitDataSegmentLength > 0) // danny's RFC 90 bs = MIN(sp->opt.maxXmitDataSegmentLength, ddtl); 91 else 92 bs = ddtl; 93 dsn = 0; 94 sdebug(4, "edtl=%x ddtl=%x bo=%x dsn=%x bs=%x maxX=%x", 95 edtl, ddtl, bo, dsn, bs, sp->opt.maxXmitDataSegmentLength); 96 while(bleft > 0) { 97 wpq = pdu_alloc(sp->isc, M_NOWAIT); // testing ... 98 if(wpq == NULL) { 99 sdebug(3, "itt=%x r2tSN=%d bo=%x ddtl=%x W=%d", ntohl(r2t->itt), 100 ntohl(r2t->r2tSN), ntohl(r2t->bo), ntohl(r2t->ddtl), opp->ipdu.scsi_req.W); 101 sdebug(1, "npdu_max=%d npdu_alloc=%d", sp->isc->npdu_max, sp->isc->npdu_alloc); 102 103 while((wpq = pdu_alloc(sp->isc, M_NOWAIT)) == NULL) { 104 sdebug(2, "waiting..."); 105#if __FreeBSD_version >= 700000 106 pause("isc_r2t", 5*hz); 107#else 108 tsleep(sp->isc, 0, "isc_r2t", 5*hz); 109#endif 110 } 111 } 112 cmd = &wpq->pdu.ipdu.data_out; 113 cmd->opcode = ISCSI_WRITE_DATA; 114 cmd->lun[0] = r2t->lun[0]; 115 cmd->lun[1] = r2t->lun[1]; 116 cmd->ttt = r2t->ttt; 117 cmd->itt = r2t->itt; 118 119 cmd->dsn = htonl(dsn); 120 cmd->bo = htonl(bo); 121 122 cmd->F = (bs < bleft)? 0: 1; // is this the last one? 123 bs = MIN(bs, bleft); 124 125 wpq->pdu.ds_len = bs;
|
125 wpq->pdu.ds = bp;
|
126 wpq->pdu.ds_addr = bp; |
127 128 error = isc_qout(sp, wpq); 129 sdebug(6, "bs=%x bo=%x bp=%p dsn=%x error=%d", bs, bo, bp, dsn, error); 130 if(error) 131 break; 132 bo += bs; 133 bp += bs; 134 bleft -= bs; 135 dsn++; 136 } 137 } 138 break; 139 140 default: 141 // XXX: should not happen ... 142 xdebug("huh? opcode=0x%x", bhp->opcode); 143 } 144} 145 146static int 147getSenseData(u_int status, union ccb *ccb, pduq_t *pq) 148{ 149 pdu_t *pp = &pq->pdu; 150 struct ccb_scsiio *scsi = (struct ccb_scsiio *)ccb; 151 struct scsi_sense_data *sense = &scsi->sense_data; 152 struct mbuf *m = pq->mp; 153 scsi_rsp_t *cmd = &pp->ipdu.scsi_rsp; 154 caddr_t bp; 155 int sense_len, mustfree = 0; 156 157 bp = mtod(pq->mp, caddr_t); 158 if((sense_len = scsi_2btoul(bp)) == 0) 159 return 0; 160 debug(4, "sense_len=%d", sense_len); 161 /* 162 | according to the specs, the sense data cannot 163 | be larger than 252 ... 164 */ 165 if(sense_len > m->m_len) { 166 bp = malloc(sense_len, M_ISCSI, M_WAITOK); 167 debug(3, "calling i_mbufcopy(len=%d)", sense_len); 168 i_mbufcopy(pq->mp, bp, sense_len); 169 mustfree++; 170 } 171 scsi->scsi_status = status; 172 173 bcopy(bp+2, sense, min(sense_len, scsi->sense_len)); 174 scsi->sense_resid = 0; 175 if(cmd->flag & (BIT(1)|BIT(2))) 176 scsi->sense_resid = ntohl(pp->ipdu.scsi_rsp.rcnt); 177 debug(3, "sense_len=%d rcnt=%d sense_resid=%d dsl=%d error_code=%x flags=%x", 178 sense_len, 179 ntohl(pp->ipdu.scsi_rsp.rcnt), scsi->sense_resid, 180 pp->ds_len, sense->error_code, sense->flags); 181 182 if(mustfree) 183 free(bp, M_ISCSI); 184 185 return 1; 186} 187 188/* 189 | Some information is from SAM draft. 190 */ 191static void
|
191_scsi_done(struct isc_softc *isp, u_int response, u_int status, union ccb *ccb, pduq_t *pq)
|
192_scsi_done(isc_session_t *sp, u_int response, u_int status, union ccb *ccb, pduq_t *pq) |
193{ 194 struct ccb_hdr *ccb_h = &ccb->ccb_h; 195 196 debug_called(8); 197 198 if(status || response) {
|
198 debug(3, "response=%x status=%x ccb=%p pq=%p", response, status, ccb, pq);
|
199 sdebug(3, "response=%x status=%x ccb=%p pq=%p", response, status, ccb, pq); |
200 if(pq != NULL)
|
200 debug(3, "mp=%p buf=%p len=%d", pq->mp, pq->buf, pq->len);
|
201 sdebug(3, "mp=%p buf=%p len=%d", pq->mp, pq->buf, pq->len); |
202 } 203 ccb_h->status = 0; 204 switch(response) { 205 case 0: // Command Completed at Target 206 switch(status) { 207 case 0: // Good, all is ok 208 ccb_h->status = CAM_REQ_CMP; 209 break; 210 211 case 0x02: // Check Condition 212 if((pq != NULL) && (pq->mp != NULL) && getSenseData(status, ccb, pq)) 213 ccb_h->status |= CAM_AUTOSNS_VALID; 214 215 case 0x14: // Intermediate-Condition Met 216 case 0x10: // Intermediate 217 case 0x04: // Condition Met 218 ccb_h->status |= CAM_SCSI_STATUS_ERROR; 219 break; 220 221 case 0x08: 222 ccb_h->status = CAM_BUSY; 223 break; 224 225 case 0x18: // Reservation Conflict 226 case 0x28: // Task Set Full 227 ccb_h->status = CAM_REQUEUE_REQ; 228 break; 229 default: 230 //case 0x22: // Command Terminated 231 //case 0x30: // ACA Active 232 //case 0x40: // Task Aborted 233 ccb_h->status = CAM_REQ_CMP_ERR; //CAM_REQ_ABORTED; 234 } 235 break; 236 237 default: 238 if((response >= 0x80) && (response <= 0xFF)) { 239 // Vendor specific ... 240 } 241 case 1: // target failure 242 ccb_h->status = CAM_REQ_CMP_ERR; //CAM_REQ_ABORTED; 243 break; 244 }
|
244 debug(5, "ccb_h->status=%x", ccb_h->status);
|
245 sdebug(5, "ccb_h->status=%x", ccb_h->status); |
246
|
246 XPT_DONE(isp, ccb);
|
247 XPT_DONE(sp, ccb); |
248} 249 250/* 251 | returns the lowest cmdseq that was not acked 252 */ 253int 254iscsi_requeue(isc_session_t *sp) 255{ 256 pduq_t *pq; 257 u_int i, n, last; 258 259 debug_called(8);
|
259 last = -1;
260 i = 0;
|
260 i = last = 0; |
261 sp->flags |= ISC_HOLD; 262 while((pq = i_dqueue_hld(sp)) != NULL) { 263 i++;
|
264 _scsi_done(sp->isc, 0, 0x28, pq->ccb, NULL);
265 n = ntohl(pq->pdu.ipdu.bhs.CmdSN);
266 if(last > n)
267 last = n;
268 sdebug(2, "last=%x n=%x", last, n);
|
264 if(pq->ccb != NULL) { 265 _scsi_done(sp, 0, 0x28, pq->ccb, NULL); 266 n = ntohl(pq->pdu.ipdu.bhs.CmdSN); 267 if(last==0 || (last > n)) 268 last = n; 269 sdebug(2, "last=%x n=%x", last, n); 270 } |
271 pdu_free(sp->isc, pq); 272 } 273 sp->flags &= ~ISC_HOLD; 274 return i? last: sp->sn.cmd; 275} 276 277int 278i_pdu_flush(isc_session_t *sp) 279{ 280 int n = 0; 281 pduq_t *pq; 282 283 debug_called(8); 284 while((pq = i_dqueue_rsp(sp)) != NULL) { 285 pdu_free(sp->isc, pq); 286 n++; 287 } 288 while((pq = i_dqueue_rsv(sp)) != NULL) { 289 pdu_free(sp->isc, pq); 290 n++; 291 } 292 while((pq = i_dqueue_snd(sp, -1)) != NULL) { 293 pdu_free(sp->isc, pq); 294 n++; 295 } 296 while((pq = i_dqueue_hld(sp)) != NULL) { 297 pdu_free(sp->isc, pq); 298 n++; 299 } 300 while((pq = i_dqueue_wsnd(sp)) != NULL) { 301 pdu_free(sp->isc, pq); 302 n++; 303 } 304 if(n != 0) 305 xdebug("%d pdus recovered, should have been ZERO!", n); 306 return n; 307} 308/* 309 | called from ism_destroy. 310 */ 311void 312iscsi_cleanup(isc_session_t *sp) 313{ 314 pduq_t *pq, *pqtmp; 315 316 debug_called(8); 317 318 TAILQ_FOREACH_SAFE(pq, &sp->hld, pq_link, pqtmp) { 319 sdebug(3, "hld pq=%p", pq); 320 if(pq->ccb)
|
319 _scsi_done(sp->isc, 1, 0x40, pq->ccb, NULL);
|
321 _scsi_done(sp, 1, 0x40, pq->ccb, NULL); |
322 TAILQ_REMOVE(&sp->hld, pq, pq_link);
|
323 if(pq->buf) { 324 free(pq->buf, M_ISCSIBUF); 325 pq->buf = NULL; 326 } |
327 pdu_free(sp->isc, pq); 328 } 329 while((pq = i_dqueue_snd(sp, BIT(0)|BIT(1)|BIT(2))) != NULL) { 330 sdebug(3, "pq=%p", pq); 331 if(pq->ccb)
|
326 _scsi_done(sp->isc, 1, 0x40, pq->ccb, NULL);
|
332 _scsi_done(sp, 1, 0x40, pq->ccb, NULL); 333 if(pq->buf) { 334 free(pq->buf, M_ISCSIBUF); 335 pq->buf = NULL; 336 } |
337 pdu_free(sp->isc, pq); 338 } 339 340 wakeup(&sp->rsp); 341} 342 343void 344iscsi_done(isc_session_t *sp, pduq_t *opq, pduq_t *pq) 345{ 346 pdu_t *pp = &pq->pdu; 347 scsi_rsp_t *cmd = &pp->ipdu.scsi_rsp; 348 349 debug_called(8); 350
|
341 _scsi_done(sp->isc, cmd->response, cmd->status, opq->ccb, pq);
|
351 _scsi_done(sp, cmd->response, cmd->status, opq->ccb, pq); |
352 353 pdu_free(sp->isc, opq); 354} 355 356// see RFC 3720, 10.9.1 page 146 357/* 358 | NOTE: 359 | the call to isc_stop_receiver is a kludge, 360 | instead, it should be handled by the userland controller, 361 | but that means that there should be a better way, other than 362 | sending a signal. Somehow, this packet should be supplied to 363 | the userland via read. 364 */ 365void 366iscsi_async(isc_session_t *sp, pduq_t *pq) 367{ 368 pdu_t *pp = &pq->pdu; 369 async_t *cmd = &pp->ipdu.async; 370 371 debug_called(8); 372 373 sdebug(3, "asyncevent=0x%x asyncVCode=0x%0x", cmd->asyncEvent, cmd->asyncVCode); 374 switch(cmd->asyncEvent) { 375 case 0: // check status ... 376 break; 377 378 case 1: // target request logout 379 isc_stop_receiver(sp); // XXX: temporary solution 380 break; 381 382 case 2: // target indicates it wants to drop connection 383 isc_stop_receiver(sp); // XXX: temporary solution 384 break; 385 386 case 3: // target indicates it will drop all connections. 387 isc_stop_receiver(sp); // XXX: temporary solution 388 break; 389 390 case 4: // target request parameter negotiation 391 break; 392 393 default: 394 break; 395 } 396} 397 398void 399iscsi_reject(isc_session_t *sp, pduq_t *opq, pduq_t *pq) 400{ 401 union ccb *ccb = opq->ccb; 402 //reject_t *reject = &pq->pdu.ipdu.reject; 403 404 debug_called(8); 405 //XXX: check RFC 10.17.1 (page 176) 406 ccb->ccb_h.status = CAM_REQ_ABORTED;
|
397 XPT_DONE(sp->isc, ccb);
|
407 XPT_DONE(sp, ccb); |
408 409 pdu_free(sp->isc, opq); 410} 411 412/* 413 | deal with lun 414 */ 415static int 416dwl(isc_session_t *sp, int lun, u_char *lp) 417{
|
408 int i;
409
|
418 debug_called(8);
|
411
|
419 sdebug(4, "lun=%d", lun); |
420 /* 421 | mapping LUN to iSCSI LUN 422 | check the SAM-2 specs 423 | hint: maxLUNS is a small number, cam's LUN is 32bits 424 | iSCSI is 64bits, scsi is ? 425 */ 426 // XXX: check if this will pass the endian test 427 if(lun < 256) { 428 lp[0] = 0; 429 lp[1] = lun; 430 } else 431 if(lun < 16384) { 432 lp[0] = (1 << 5) | ((lun >> 8) & 0x3f); 433 lp[1] = lun & 0xff; 434 } 435 else { 436 xdebug("lun %d: is unsupported!", lun); 437 return -1; 438 } 439
|
432 for(i = 0; i < sp->target_nluns; i++)
433 if(sp->target_lun[i] == lun)
434 return 0;
435 if(sp->target_nluns < ISCSI_MAX_LUNS)
436 sp->target_lun[sp->target_nluns++] = lun;
437
438 sdebug(3, "nluns=%d lun=%d", sp->target_nluns, lun);
439
|
440 return 0; 441} 442 443/* 444 | encapsulate the scsi command and 445 */ 446int 447scsi_encap(struct cam_sim *sim, union ccb *ccb) 448{
|
449 struct isc_softc *isp = (struct isc_softc *)cam_sim_softc(sim);
450 isc_session_t *sp;
|
449 isc_session_t *sp = cam_sim_softc(sim); |
450 struct ccb_scsiio *csio = &ccb->csio; 451 struct ccb_hdr *ccb_h = &ccb->ccb_h; 452 pduq_t *pq; 453 scsi_req_t *cmd; 454 455 debug_called(8); 456 457 debug(4, "ccb->sp=%p", ccb_h->spriv_ptr0); 458 sp = ccb_h->spriv_ptr0; 459
|
461 if((pq = pdu_alloc(isp, M_NOWAIT)) == NULL) {
|
460 if((pq = pdu_alloc(sp->isc, M_NOWAIT)) == NULL) { |
461 debug(2, "ccb->sp=%p", ccb_h->spriv_ptr0); 462 sdebug(1, "pdu_alloc failed sc->npdu_max=%d npdu_alloc=%d", 463 sp->isc->npdu_max, sp->isc->npdu_alloc); 464 while((pq = pdu_alloc(sp->isc, M_NOWAIT)) == NULL) {
|
466 sdebug(3, "waiting...");
|
465 sdebug(2, "waiting..."); |
466#if __FreeBSD_version >= 700000 467 pause("isc_encap", 5*hz); 468#else 469 tsleep(sp->isc, 0, "isc_encap", 5*hz); 470#endif 471 }
|
473#if 0
474 sdebug(3, "freezing");
475 ccb->ccb_h.status = CAM_REQUEUE_REQ;
476 ic_freeze(sp);
477 return 0;
478#endif
|
472 }
|
480
481#if 0
482 if((sp->flags & ISC_FFPHASE) == 0) {
483 ccb->ccb_h.status = CAM_DEV_NOT_THERE; // CAM_NO_NEXUS;
484 sdebug(3, "no active session with target %d", ccb_h->target_id);
485 goto bad;
486 }
487#endif
|
473 cmd = &pq->pdu.ipdu.scsi_req; 474 cmd->opcode = ISCSI_SCSI_CMD; 475 cmd->F = 1; 476 /* 477 | map tag option, default is UNTAGGED 478 */ 479 switch(csio->tag_action) { 480 case MSG_SIMPLE_Q_TAG: cmd->attr = iSCSI_TASK_SIMPLE; break;
|
496 case MSG_HEAD_OF_Q_TAG: cmd->attr = iSCSI_TASK_ORDER; break;
497 case MSG_ORDERED_Q_TAG: cmd->attr = iSCSI_TASK_HOFQ; break;
|
481 case MSG_HEAD_OF_Q_TAG: cmd->attr = iSCSI_TASK_HOFQ; break; 482 case MSG_ORDERED_Q_TAG: cmd->attr = iSCSI_TASK_ORDER; break; |
483 case MSG_ACA_TASK: cmd->attr = iSCSI_TASK_ACA; break; 484 } 485 486 dwl(sp, ccb_h->target_lun, (u_char *)&cmd->lun); 487 488 if((ccb_h->flags & CAM_CDB_POINTER) != 0) { 489 if((ccb_h->flags & CAM_CDB_PHYS) == 0) { 490 if(csio->cdb_len > 16) { 491 sdebug(3, "oversize cdb %d > 16", csio->cdb_len); 492 goto invalid; 493 } 494 } 495 else { 496 sdebug(3, "not phys"); 497 goto invalid; 498 } 499 } 500 501 if(csio->cdb_len > sizeof(cmd->cdb)) 502 xdebug("guevalt! %d > %ld", csio->cdb_len, (long)sizeof(cmd->cdb)); 503 504 memcpy(cmd->cdb, 505 ccb_h->flags & CAM_CDB_POINTER? csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes, 506 csio->cdb_len); 507 508 cmd->W = (ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT; 509 cmd->R = (ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN; 510 cmd->edtlen = htonl(csio->dxfer_len); 511 512 pq->ccb = ccb; 513 /* 514 | place it in the out queue 515 */ 516 if(isc_qout(sp, pq) == 0) 517 return 1; 518 invalid: 519 ccb->ccb_h.status = CAM_REQ_INVALID;
|
535 pdu_free(isp, pq);
|
520 pdu_free(sp->isc, pq); 521 |
522 return 0; 523} 524 525int 526scsi_decap(isc_session_t *sp, pduq_t *opq, pduq_t *pq) 527{ 528 union ccb *ccb = opq->ccb; 529 struct ccb_scsiio *csio = &ccb->csio; 530 pdu_t *opp = &opq->pdu; 531 bhs_t *bhp = &opp->ipdu.bhs; 532 533 debug_called(8); 534 sdebug(6, "pq=%p opq=%p bhp->opcode=0x%x len=%d", 535 pq, opq, bhp->opcode, pq->pdu.ds_len); 536 if(ccb == NULL) { 537 sdebug(1, "itt=0x%x pq=%p opq=%p bhp->opcode=0x%x len=%d", 538 ntohl(pq->pdu.ipdu.bhs.itt), 539 pq, opq, bhp->opcode, pq->pdu.ds_len); 540 xdebug("%d] ccb == NULL!", sp->sid); 541 return 0; 542 } 543 if(pq->pdu.ds_len != 0) { 544 switch(bhp->opcode) { 545 case ISCSI_SCSI_CMD: { 546 scsi_req_t *cmd = &opp->ipdu.scsi_req; 547 sdebug(5, "itt=0x%x opcode=%x R=%d", 548 ntohl(pq->pdu.ipdu.bhs.itt), 549 pq->pdu.ipdu.bhs.opcode, cmd->R); 550 551 switch(pq->pdu.ipdu.bhs.opcode) { 552 case ISCSI_READ_DATA: // SCSI Data in 553 { 554 caddr_t bp = NULL; // = mtod(pq->mp, caddr_t); 555 data_in_t *rcmd = &pq->pdu.ipdu.data_in; 556 557 if(cmd->R) { 558 sdebug(5, "copy to=%p from=%p l1=%d l2=%d mp@%p", 559 csio->data_ptr, bp? mtod(pq->mp, caddr_t): 0, 560 ntohl(cmd->edtlen), pq->pdu.ds_len, pq->mp); 561 if(ntohl(cmd->edtlen) >= pq->pdu.ds_len) {
|
576 int offset, len = pq->pdu.ds_len;
|
562 int offset, len = pq->pdu.ds_len; |
563 564 if(pq->mp != NULL) {
|
579 caddr_t dp;
|
565 caddr_t dp; |
566
|
581 offset = ntohl(rcmd->bo);
582 dp = csio->data_ptr + offset;
583 i_mbufcopy(pq->mp, dp, len);
|
567 offset = ntohl(rcmd->bo); 568 dp = csio->data_ptr + offset; 569 i_mbufcopy(pq->mp, dp, len); 570 } |
571 }
|
585 }
|
572 else { 573 xdebug("edtlen=%d < ds_len=%d", 574 ntohl(cmd->edtlen), pq->pdu.ds_len); 575 } 576 } 577 if(rcmd->S) { 578 /* 579 | contains also the SCSI Status 580 */
|
595 _scsi_done(sp->isc, 0, rcmd->status, opq->ccb, NULL);
|
581 _scsi_done(sp, 0, rcmd->status, opq->ccb, NULL); |
582 return 0; 583 } else 584 return 1; 585 } 586 break; 587 } 588 } 589 default: 590 sdebug(3, "opcode=%02x", bhp->opcode); 591 break; 592 } 593 } 594 /* 595 | XXX: error ... 596 */ 597 return 1; 598}
|