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