![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fcp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net|
Return to fcp.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net |
1.1 ! root 1: /* ! 2: * Copyright (C) 2010 Michael Brown <[email protected]>. ! 3: * ! 4: * This program is free software; you can redistribute it and/or ! 5: * modify it under the terms of the GNU General Public License as ! 6: * published by the Free Software Foundation; either version 2 of the ! 7: * License, or any later version. ! 8: * ! 9: * This program is distributed in the hope that it will be useful, but ! 10: * WITHOUT ANY WARRANTY; without even the implied warranty of ! 11: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ! 12: * General Public License for more details. ! 13: * ! 14: * You should have received a copy of the GNU General Public License ! 15: * along with this program; if not, write to the Free Software ! 16: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ! 17: */ ! 18: ! 19: FILE_LICENCE ( GPL2_OR_LATER ); ! 20: ! 21: #include <stddef.h> ! 22: #include <stdint.h> ! 23: #include <stdlib.h> ! 24: #include <string.h> ! 25: #include <errno.h> ! 26: #include <stdio.h> ! 27: #include <assert.h> ! 28: #include <byteswap.h> ! 29: #include <ipxe/refcnt.h> ! 30: #include <ipxe/list.h> ! 31: #include <ipxe/interface.h> ! 32: #include <ipxe/xfer.h> ! 33: #include <ipxe/iobuf.h> ! 34: #include <ipxe/open.h> ! 35: #include <ipxe/process.h> ! 36: #include <ipxe/uri.h> ! 37: #include <ipxe/acpi.h> ! 38: #include <ipxe/scsi.h> ! 39: #include <ipxe/device.h> ! 40: #include <ipxe/edd.h> ! 41: #include <ipxe/fc.h> ! 42: #include <ipxe/fcels.h> ! 43: #include <ipxe/fcp.h> ! 44: ! 45: /** @file ! 46: * ! 47: * Fibre Channel Protocol ! 48: * ! 49: */ ! 50: ! 51: /* Disambiguate the various error causes */ ! 52: #define ERANGE_READ_DATA_ORDERING \ ! 53: __einfo_error ( EINFO_ERANGE_READ_DATA_ORDERING ) ! 54: #define EINFO_ERANGE_READ_DATA_ORDERING \ ! 55: __einfo_uniqify ( EINFO_ERANGE, 0x01, "Read data out of order" ) ! 56: #define ERANGE_READ_DATA_OVERRUN \ ! 57: __einfo_error ( EINFO_ERANGE_READ_DATA_OVERRUN ) ! 58: #define EINFO_ERANGE_READ_DATA_OVERRUN \ ! 59: __einfo_uniqify ( EINFO_ERANGE, 0x02, "Read data overrun" ) ! 60: #define ERANGE_WRITE_DATA_STUCK \ ! 61: __einfo_error ( EINFO_ERANGE_WRITE_DATA_STUCK ) ! 62: #define EINFO_ERANGE_WRITE_DATA_STUCK \ ! 63: __einfo_uniqify ( EINFO_ERANGE, 0x03, "Write data stuck" ) ! 64: #define ERANGE_WRITE_DATA_OVERRUN \ ! 65: __einfo_error ( EINFO_ERANGE_WRITE_DATA_OVERRUN ) ! 66: #define EINFO_ERANGE_WRITE_DATA_OVERRUN \ ! 67: __einfo_uniqify ( EINFO_ERANGE, 0x04, "Write data overrun" ) ! 68: #define ERANGE_DATA_UNDERRUN \ ! 69: __einfo_error ( EINFO_ERANGE_DATA_UNDERRUN ) ! 70: #define EINFO_ERANGE_DATA_UNDERRUN \ ! 71: __einfo_uniqify ( EINFO_ERANGE, 0x05, "Data underrun" ) ! 72: ! 73: /****************************************************************************** ! 74: * ! 75: * PRLI ! 76: * ! 77: ****************************************************************************** ! 78: */ ! 79: ! 80: struct fc_els_prli_descriptor fcp_prli_descriptor __fc_els_prli_descriptor; ! 81: ! 82: /** ! 83: * Transmit FCP PRLI ! 84: * ! 85: * @v els Fibre Channel ELS transaction ! 86: * @ret rc Return status code ! 87: */ ! 88: static int fcp_prli_tx ( struct fc_els *els ) { ! 89: struct fcp_prli_service_parameters param; ! 90: ! 91: /* Build service parameter page */ ! 92: memset ( ¶m, 0, sizeof ( param ) ); ! 93: param.flags = htonl ( FCP_PRLI_NO_READ_RDY | FCP_PRLI_INITIATOR ); ! 94: ! 95: return fc_els_prli_tx ( els, &fcp_prli_descriptor, ¶m ); ! 96: } ! 97: ! 98: /** ! 99: * Receive FCP PRLI ! 100: * ! 101: * @v els Fibre Channel ELS transaction ! 102: * @v frame ELS frame ! 103: * @v len Length of ELS frame ! 104: * @ret rc Return status code ! 105: */ ! 106: static int fcp_prli_rx ( struct fc_els *els, void *data, size_t len ) { ! 107: return fc_els_prli_rx ( els, &fcp_prli_descriptor, data, len ); ! 108: } ! 109: ! 110: /** ! 111: * Detect FCP PRLI ! 112: * ! 113: * @v els Fibre Channel ELS transaction ! 114: * @v data ELS frame ! 115: * @v len Length of ELS frame ! 116: * @ret rc Return status code ! 117: */ ! 118: static int fcp_prli_detect ( struct fc_els *els, const void *data, ! 119: size_t len ) { ! 120: return fc_els_prli_detect ( els, &fcp_prli_descriptor, data, len ); ! 121: } ! 122: ! 123: /** FCP PRLI ELS handler */ ! 124: struct fc_els_handler fcp_prli_handler __fc_els_handler = { ! 125: .name = "PRLI-FCP", ! 126: .tx = fcp_prli_tx, ! 127: .rx = fcp_prli_rx, ! 128: .detect = fcp_prli_detect, ! 129: }; ! 130: ! 131: /** FCP PRLI descriptor */ ! 132: struct fc_els_prli_descriptor fcp_prli_descriptor __fc_els_prli_descriptor = { ! 133: .type = FC_TYPE_FCP, ! 134: .param_len = sizeof ( struct fcp_prli_service_parameters ), ! 135: .handler = &fcp_prli_handler, ! 136: }; ! 137: ! 138: /****************************************************************************** ! 139: * ! 140: * FCP devices and commands ! 141: * ! 142: ****************************************************************************** ! 143: */ ! 144: ! 145: /** An FCP device */ ! 146: struct fcp_device { ! 147: /** Reference count */ ! 148: struct refcnt refcnt; ! 149: /** Fibre Channel upper-layer protocol */ ! 150: struct fc_ulp *ulp; ! 151: /** SCSI command issuing interface */ ! 152: struct interface scsi; ! 153: /** List of active commands */ ! 154: struct list_head fcpcmds; ! 155: ! 156: /** Fibre Channel WWN (for boot firmware table) */ ! 157: struct fc_name wwn; ! 158: /** SCSI LUN (for boot firmware table) */ ! 159: struct scsi_lun lun; ! 160: }; ! 161: ! 162: /** An FCP command */ ! 163: struct fcp_command { ! 164: /** Reference count */ ! 165: struct refcnt refcnt; ! 166: /** FCP SCSI device */ ! 167: struct fcp_device *fcpdev; ! 168: /** List of active commands */ ! 169: struct list_head list; ! 170: /** SCSI command interface */ ! 171: struct interface scsi; ! 172: /** Fibre Channel exchange interface */ ! 173: struct interface xchg; ! 174: /** Send process */ ! 175: struct process process; ! 176: /** Send current IU ! 177: * ! 178: * @v fcpcmd FCP command ! 179: * @ret rc Return status code ! 180: */ ! 181: int ( * send ) ( struct fcp_command *fcpcmd ); ! 182: /** SCSI command */ ! 183: struct scsi_cmd command; ! 184: /** Data offset within command */ ! 185: size_t offset; ! 186: /** Length of data remaining to be sent within this IU */ ! 187: size_t remaining; ! 188: /** Exchange ID */ ! 189: uint16_t xchg_id; ! 190: }; ! 191: ! 192: /** ! 193: * Get reference to FCP device ! 194: * ! 195: * @v fcpdev FCP device ! 196: * @ret fcpdev FCP device ! 197: */ ! 198: static inline __attribute__ (( always_inline )) struct fcp_device * ! 199: fcpdev_get ( struct fcp_device *fcpdev ) { ! 200: ref_get ( &fcpdev->refcnt ); ! 201: return fcpdev; ! 202: } ! 203: ! 204: /** ! 205: * Drop reference to FCP device ! 206: * ! 207: * @v fcpdev FCP device ! 208: */ ! 209: static inline __attribute__ (( always_inline )) void ! 210: fcpdev_put ( struct fcp_device *fcpdev ) { ! 211: ref_put ( &fcpdev->refcnt ); ! 212: } ! 213: ! 214: /** ! 215: * Get reference to FCP command ! 216: * ! 217: * @v fcpcmd FCP command ! 218: * @ret fcpcmd FCP command ! 219: */ ! 220: static inline __attribute__ (( always_inline )) struct fcp_command * ! 221: fcpcmd_get ( struct fcp_command *fcpcmd ) { ! 222: ref_get ( &fcpcmd->refcnt ); ! 223: return fcpcmd; ! 224: } ! 225: ! 226: /** ! 227: * Drop reference to FCP command ! 228: * ! 229: * @v fcpcmd FCP command ! 230: */ ! 231: static inline __attribute__ (( always_inline )) void ! 232: fcpcmd_put ( struct fcp_command *fcpcmd ) { ! 233: ref_put ( &fcpcmd->refcnt ); ! 234: } ! 235: ! 236: /** ! 237: * Start FCP command sending ! 238: * ! 239: * @v fcpcmd FCP command ! 240: * @v send Send method ! 241: */ ! 242: static inline __attribute__ (( always_inline )) void ! 243: fcpcmd_start_send ( struct fcp_command *fcpcmd, ! 244: int ( * send ) ( struct fcp_command *fcpcmd ) ) { ! 245: fcpcmd->send = send; ! 246: process_add ( &fcpcmd->process ); ! 247: } ! 248: ! 249: /** ! 250: * Stop FCP command sending ! 251: * ! 252: * @v fcpcmd FCP command ! 253: */ ! 254: static inline __attribute__ (( always_inline )) void ! 255: fcpcmd_stop_send ( struct fcp_command *fcpcmd ) { ! 256: process_del ( &fcpcmd->process ); ! 257: } ! 258: ! 259: /** ! 260: * Free FCP command ! 261: * ! 262: * @v refcnt Reference count ! 263: */ ! 264: static void fcpcmd_free ( struct refcnt *refcnt ) { ! 265: struct fcp_command *fcpcmd = ! 266: container_of ( refcnt, struct fcp_command, refcnt ); ! 267: ! 268: /* Remove from list of commands */ ! 269: list_del ( &fcpcmd->list ); ! 270: fcpdev_put ( fcpcmd->fcpdev ); ! 271: ! 272: /* Free command */ ! 273: free ( fcpcmd ); ! 274: } ! 275: ! 276: /** ! 277: * Close FCP command ! 278: * ! 279: * @v fcpcmd FCP command ! 280: * @v rc Reason for close ! 281: */ ! 282: static void fcpcmd_close ( struct fcp_command *fcpcmd, int rc ) { ! 283: struct fcp_device *fcpdev = fcpcmd->fcpdev; ! 284: ! 285: if ( rc != 0 ) { ! 286: DBGC ( fcpdev, "FCP %p xchg %04x closed: %s\n", ! 287: fcpdev, fcpcmd->xchg_id, strerror ( rc ) ); ! 288: } ! 289: ! 290: /* Stop sending */ ! 291: fcpcmd_stop_send ( fcpcmd ); ! 292: ! 293: /* Shut down interfaces */ ! 294: intf_shutdown ( &fcpcmd->scsi, rc ); ! 295: intf_shutdown ( &fcpcmd->xchg, rc ); ! 296: } ! 297: ! 298: /** ! 299: * Close FCP command in error ! 300: * ! 301: * @v fcpcmd FCP command ! 302: * @v rc Reason for close ! 303: */ ! 304: static void fcpcmd_close_err ( struct fcp_command *fcpcmd, int rc ) { ! 305: if ( rc == 0 ) ! 306: rc = -EPIPE; ! 307: fcpcmd_close ( fcpcmd, rc ); ! 308: } ! 309: ! 310: /** ! 311: * Send FCP command IU ! 312: * ! 313: * @v fcpcmd FCP command ! 314: * @ret rc Return status code ! 315: */ ! 316: static int fcpcmd_send_cmnd ( struct fcp_command *fcpcmd ) { ! 317: struct fcp_device *fcpdev = fcpcmd->fcpdev; ! 318: struct scsi_cmd *command = &fcpcmd->command; ! 319: struct io_buffer *iobuf; ! 320: struct fcp_cmnd *cmnd; ! 321: struct xfer_metadata meta; ! 322: int rc; ! 323: ! 324: /* Sanity check */ ! 325: if ( command->data_in_len && command->data_out_len ) { ! 326: DBGC ( fcpdev, "FCP %p xchg %04x cannot handle bidirectional " ! 327: "command\n", fcpdev, fcpcmd->xchg_id ); ! 328: return -ENOTSUP; ! 329: } ! 330: ! 331: /* Allocate I/O buffer */ ! 332: iobuf = xfer_alloc_iob ( &fcpcmd->xchg, sizeof ( *cmnd ) ); ! 333: if ( ! iobuf ) { ! 334: DBGC ( fcpdev, "FCP %p xchg %04x cannot allocate command IU\n", ! 335: fcpdev, fcpcmd->xchg_id ); ! 336: return -ENOMEM; ! 337: } ! 338: ! 339: /* Construct command IU frame */ ! 340: cmnd = iob_put ( iobuf, sizeof ( *cmnd ) ); ! 341: memset ( cmnd, 0, sizeof ( *cmnd ) ); ! 342: memcpy ( &cmnd->lun, &command->lun, sizeof ( cmnd->lun ) ); ! 343: assert ( ! ( command->data_in_len && command->data_out_len ) ); ! 344: if ( command->data_in_len ) ! 345: cmnd->dirn |= FCP_CMND_RDDATA; ! 346: if ( command->data_out_len ) ! 347: cmnd->dirn |= FCP_CMND_WRDATA; ! 348: memcpy ( &cmnd->cdb, &fcpcmd->command.cdb, sizeof ( cmnd->cdb ) ); ! 349: cmnd->len = htonl ( command->data_in_len + command->data_out_len ); ! 350: memset ( &meta, 0, sizeof ( meta ) ); ! 351: meta.flags = ( XFER_FL_CMD_STAT | XFER_FL_OVER ); ! 352: DBGC2 ( fcpdev, "FCP %p xchg %04x CMND " SCSI_CDB_FORMAT " %04x\n", ! 353: fcpdev, fcpcmd->xchg_id, SCSI_CDB_DATA ( cmnd->cdb ), ! 354: ntohl ( cmnd->len ) ); ! 355: ! 356: /* No further data to send within this IU */ ! 357: fcpcmd_stop_send ( fcpcmd ); ! 358: ! 359: /* Send command IU frame */ ! 360: if ( ( rc = xfer_deliver ( &fcpcmd->xchg, iob_disown ( iobuf ), ! 361: &meta ) ) != 0 ) { ! 362: DBGC ( fcpdev, "FCP %p xchg %04x cannot deliver command IU: " ! 363: "%s\n", fcpdev, fcpcmd->xchg_id, strerror ( rc ) ); ! 364: return rc; ! 365: } ! 366: ! 367: return 0; ! 368: } ! 369: ! 370: /** ! 371: * Handle FCP read data IU ! 372: * ! 373: * @v fcpcmd FCP command ! 374: * @v iobuf I/O buffer ! 375: * @v meta Data transfer metadata ! 376: * @ret rc Return status code ! 377: */ ! 378: static int fcpcmd_recv_rddata ( struct fcp_command *fcpcmd, ! 379: struct io_buffer *iobuf, ! 380: struct xfer_metadata *meta ) { ! 381: struct fcp_device *fcpdev = fcpcmd->fcpdev; ! 382: struct scsi_cmd *command = &fcpcmd->command; ! 383: size_t offset = meta->offset; ! 384: size_t len = iob_len ( iobuf ); ! 385: int rc; ! 386: ! 387: /* Sanity checks */ ! 388: if ( ! ( meta->flags & XFER_FL_ABS_OFFSET ) ) { ! 389: DBGC ( fcpdev, "FCP %p xchg %04x read data missing offset\n", ! 390: fcpdev, fcpcmd->xchg_id ); ! 391: rc = -ERANGE_READ_DATA_ORDERING; ! 392: goto done; ! 393: } ! 394: if ( offset != fcpcmd->offset ) { ! 395: DBGC ( fcpdev, "FCP %p xchg %04x read data out of order " ! 396: "(expected %zd, received %zd)\n", ! 397: fcpdev, fcpcmd->xchg_id, fcpcmd->offset, offset ); ! 398: rc = -ERANGE_READ_DATA_ORDERING; ! 399: goto done; ! 400: } ! 401: if ( ( offset + len ) > command->data_in_len ) { ! 402: DBGC ( fcpdev, "FCP %p xchg %04x read data overrun (max %zd, " ! 403: "received %zd)\n", fcpdev, fcpcmd->xchg_id, ! 404: command->data_in_len, ( offset + len ) ); ! 405: rc = -ERANGE_READ_DATA_OVERRUN; ! 406: goto done; ! 407: } ! 408: DBGC2 ( fcpdev, "FCP %p xchg %04x RDDATA [%08zx,%08zx)\n", ! 409: fcpdev, fcpcmd->xchg_id, offset, ( offset + len ) ); ! 410: ! 411: /* Copy to user buffer */ ! 412: copy_to_user ( command->data_in, offset, iobuf->data, len ); ! 413: fcpcmd->offset += len; ! 414: assert ( fcpcmd->offset <= command->data_in_len ); ! 415: ! 416: rc = 0; ! 417: done: ! 418: free_iob ( iobuf ); ! 419: return rc; ! 420: } ! 421: ! 422: /** ! 423: * Send FCP write data IU ! 424: * ! 425: * @v fcpcmd FCP command ! 426: * @ret rc Return status code ! 427: */ ! 428: static int fcpcmd_send_wrdata ( struct fcp_command *fcpcmd ) { ! 429: struct fcp_device *fcpdev = fcpcmd->fcpdev; ! 430: struct scsi_cmd *command = &fcpcmd->command; ! 431: struct io_buffer *iobuf; ! 432: struct xfer_metadata meta; ! 433: size_t len; ! 434: int rc; ! 435: ! 436: /* Calculate length to be sent */ ! 437: len = xfer_window ( &fcpcmd->xchg ); ! 438: if ( len > fcpcmd->remaining ) ! 439: len = fcpcmd->remaining; ! 440: ! 441: /* Sanity checks */ ! 442: if ( len == 0 ) { ! 443: DBGC ( fcpdev, "FCP %p xchg %04x write data stuck\n", ! 444: fcpdev, fcpcmd->xchg_id ); ! 445: return -ERANGE_WRITE_DATA_STUCK; ! 446: } ! 447: if ( ( fcpcmd->offset + len ) > command->data_out_len ) { ! 448: DBGC ( fcpdev, "FCP %p xchg %04x write data overrun (max %zd, " ! 449: "requested %zd)\n", fcpdev, fcpcmd->xchg_id, ! 450: command->data_out_len, ( fcpcmd->offset + len ) ); ! 451: return -ERANGE_WRITE_DATA_OVERRUN; ! 452: } ! 453: ! 454: /* Allocate I/O buffer */ ! 455: iobuf = xfer_alloc_iob ( &fcpcmd->xchg, len ); ! 456: if ( ! iobuf ) { ! 457: DBGC ( fcpdev, "FCP %p xchg %04x cannot allocate write data " ! 458: "IU for %zd bytes\n", fcpdev, fcpcmd->xchg_id, len ); ! 459: return -ENOMEM; ! 460: } ! 461: ! 462: /* Construct data IU frame */ ! 463: copy_from_user ( iob_put ( iobuf, len ), command->data_out, ! 464: fcpcmd->offset, len ); ! 465: memset ( &meta, 0, sizeof ( meta ) ); ! 466: meta.flags = ( XFER_FL_RESPONSE | XFER_FL_ABS_OFFSET ); ! 467: meta.offset = fcpcmd->offset; ! 468: DBGC2 ( fcpdev, "FCP %p xchg %04x WRDATA [%08zx,%04zx)\n", ! 469: fcpdev, fcpcmd->xchg_id, fcpcmd->offset, ! 470: ( fcpcmd->offset + iob_len ( iobuf ) ) ); ! 471: ! 472: /* Calculate amount of data remaining to be sent within this IU */ ! 473: assert ( len <= fcpcmd->remaining ); ! 474: fcpcmd->offset += len; ! 475: fcpcmd->remaining -= len; ! 476: assert ( fcpcmd->offset <= command->data_out_len ); ! 477: if ( fcpcmd->remaining == 0 ) { ! 478: fcpcmd_stop_send ( fcpcmd ); ! 479: meta.flags |= XFER_FL_OVER; ! 480: } ! 481: ! 482: /* Send data IU frame */ ! 483: if ( ( rc = xfer_deliver ( &fcpcmd->xchg, iob_disown ( iobuf ), ! 484: &meta ) ) != 0 ) { ! 485: DBGC ( fcpdev, "FCP %p xchg %04x cannot deliver write data " ! 486: "IU: %s\n", fcpdev, fcpcmd->xchg_id, strerror ( rc ) ); ! 487: return rc; ! 488: } ! 489: ! 490: return 0; ! 491: } ! 492: ! 493: /** ! 494: * Handle FCP transfer ready IU ! 495: * ! 496: * @v fcpcmd FCP command ! 497: * @v iobuf I/O buffer ! 498: * @v meta Data transfer metadata ! 499: * @ret rc Return status code ! 500: */ ! 501: static int fcpcmd_recv_xfer_rdy ( struct fcp_command *fcpcmd, ! 502: struct io_buffer *iobuf, ! 503: struct xfer_metadata *meta __unused ) { ! 504: struct fcp_device *fcpdev = fcpcmd->fcpdev; ! 505: struct fcp_xfer_rdy *xfer_rdy = iobuf->data; ! 506: int rc; ! 507: ! 508: /* Sanity checks */ ! 509: if ( iob_len ( iobuf ) != sizeof ( *xfer_rdy ) ) { ! 510: DBGC ( fcpdev, "FCP %p xchg %04x received invalid transfer " ! 511: "ready IU:\n", fcpdev, fcpcmd->xchg_id ); ! 512: DBGC_HDA ( fcpdev, 0, iobuf->data, iob_len ( iobuf ) ); ! 513: rc = -EPROTO; ! 514: goto done; ! 515: } ! 516: if ( ntohl ( xfer_rdy->offset ) != fcpcmd->offset ) { ! 517: /* We do not advertise out-of-order delivery */ ! 518: DBGC ( fcpdev, "FCP %p xchg %04x cannot support out-of-order " ! 519: "delivery (expected %zd, requested %d)\n", ! 520: fcpdev, fcpcmd->xchg_id, fcpcmd->offset, ! 521: ntohl ( xfer_rdy->offset ) ); ! 522: rc = -EPROTO; ! 523: goto done; ! 524: } ! 525: DBGC2 ( fcpdev, "FCP %p xchg %04x XFER_RDY [%08x,%08x)\n", ! 526: fcpdev, fcpcmd->xchg_id, ntohl ( xfer_rdy->offset ), ! 527: ( ntohl ( xfer_rdy->offset ) + ntohl ( xfer_rdy->len ) ) ); ! 528: ! 529: /* Start sending requested data */ ! 530: fcpcmd->remaining = ntohl ( xfer_rdy->len ); ! 531: fcpcmd_start_send ( fcpcmd, fcpcmd_send_wrdata ); ! 532: ! 533: rc = 0; ! 534: done: ! 535: free_iob ( iobuf ); ! 536: return rc; ! 537: } ! 538: ! 539: /** ! 540: * Handle FCP response IU ! 541: * ! 542: * @v fcpcmd FCP command ! 543: * @v iobuf I/O buffer ! 544: * @v meta Data transfer metadata ! 545: * @ret rc Return status code ! 546: */ ! 547: static int fcpcmd_recv_rsp ( struct fcp_command *fcpcmd, ! 548: struct io_buffer *iobuf, ! 549: struct xfer_metadata *meta __unused ) { ! 550: struct fcp_device *fcpdev = fcpcmd->fcpdev; ! 551: struct scsi_cmd *command = &fcpcmd->command; ! 552: struct fcp_rsp *rsp = iobuf->data; ! 553: struct scsi_sense *sense; ! 554: struct scsi_rsp response; ! 555: int rc; ! 556: ! 557: /* Sanity check */ ! 558: if ( ( iob_len ( iobuf ) < sizeof ( *rsp ) ) || ! 559: ( iob_len ( iobuf ) < ( sizeof ( *rsp ) + ! 560: fcp_rsp_response_data_len ( rsp ) + ! 561: fcp_rsp_sense_data_len ( rsp ) ) ) ) { ! 562: DBGC ( fcpdev, "FCP %p xchg %04x received invalid response " ! 563: "IU:\n", fcpdev, fcpcmd->xchg_id ); ! 564: DBGC_HDA ( fcpdev, 0, iobuf->data, iob_len ( iobuf ) ); ! 565: rc = -EPROTO; ! 566: goto done; ! 567: } ! 568: DBGC2 ( fcpdev, "FCP %p xchg %04x RSP stat %02x resid %08x flags %02x" ! 569: "%s%s%s%s\n", fcpdev, fcpcmd->xchg_id, rsp->status, ! 570: ntohl ( rsp->residual ), rsp->flags, ! 571: ( ( rsp->flags & FCP_RSP_RESPONSE_LEN_VALID ) ? " resp" : "" ), ! 572: ( ( rsp->flags & FCP_RSP_SENSE_LEN_VALID ) ? " sense" : "" ), ! 573: ( ( rsp->flags & FCP_RSP_RESIDUAL_OVERRUN ) ? " over" : "" ), ! 574: ( ( rsp->flags & FCP_RSP_RESIDUAL_UNDERRUN ) ? " under" : "" )); ! 575: if ( fcp_rsp_response_data ( rsp ) ) { ! 576: DBGC2 ( fcpdev, "FCP %p xchg %04x response data:\n", ! 577: fcpdev, fcpcmd->xchg_id ); ! 578: DBGC2_HDA ( fcpdev, 0, fcp_rsp_response_data ( rsp ), ! 579: fcp_rsp_response_data_len ( rsp ) ); ! 580: } ! 581: if ( fcp_rsp_sense_data ( rsp ) ) { ! 582: DBGC2 ( fcpdev, "FCP %p xchg %04x sense data:\n", ! 583: fcpdev, fcpcmd->xchg_id ); ! 584: DBGC2_HDA ( fcpdev, 0, fcp_rsp_sense_data ( rsp ), ! 585: fcp_rsp_sense_data_len ( rsp ) ); ! 586: } ! 587: ! 588: /* Check for locally-detected command underrun */ ! 589: if ( ( rsp->status == 0 ) && ! 590: ( fcpcmd->offset != ( command->data_in_len + ! 591: command->data_out_len ) ) ) { ! 592: DBGC ( fcpdev, "FCP %p xchg %04x data underrun (expected %zd, " ! 593: "got %zd)\n", fcpdev, fcpcmd->xchg_id, ! 594: ( command->data_in_len + command->data_out_len ), ! 595: fcpcmd->offset ); ! 596: rc = -ERANGE_DATA_UNDERRUN; ! 597: goto done; ! 598: } ! 599: ! 600: /* Build SCSI response */ ! 601: memset ( &response, 0, sizeof ( response ) ); ! 602: response.status = rsp->status; ! 603: if ( rsp->flags & ( FCP_RSP_RESIDUAL_OVERRUN | ! 604: FCP_RSP_RESIDUAL_UNDERRUN ) ) { ! 605: response.overrun = ntohl ( rsp->residual ); ! 606: if ( rsp->flags & FCP_RSP_RESIDUAL_UNDERRUN ) ! 607: response.overrun = -response.overrun; ! 608: } ! 609: if ( ( sense = fcp_rsp_sense_data ( rsp ) ) != NULL ) ! 610: memcpy ( &response.sense, sense, sizeof ( response.sense ) ); ! 611: ! 612: /* Free buffer before sending response, to minimise ! 613: * out-of-memory errors. ! 614: */ ! 615: free_iob ( iob_disown ( iobuf ) ); ! 616: ! 617: /* Send SCSI response */ ! 618: scsi_response ( &fcpcmd->scsi, &response ); ! 619: ! 620: /* Terminate command */ ! 621: fcpcmd_close ( fcpcmd, 0 ); ! 622: ! 623: rc = 0; ! 624: done: ! 625: free_iob ( iobuf ); ! 626: return rc; ! 627: } ! 628: ! 629: /** ! 630: * Handle unknown FCP IU ! 631: * ! 632: * @v fcpcmd FCP command ! 633: * @v iobuf I/O buffer ! 634: * @v meta Data transfer metadata ! 635: * @ret rc Return status code ! 636: */ ! 637: static int fcpcmd_recv_unknown ( struct fcp_command *fcpcmd, ! 638: struct io_buffer *iobuf, ! 639: struct xfer_metadata *meta __unused ) { ! 640: struct fcp_device *fcpdev = fcpcmd->fcpdev; ! 641: ! 642: DBGC ( fcpdev, "FCP %p xchg %04x received unknown IU:\n", ! 643: fcpdev, fcpcmd->xchg_id ); ! 644: DBGC_HDA ( fcpdev, 0, iobuf->data, iob_len ( iobuf ) ); ! 645: free_iob ( iobuf ); ! 646: return -EPROTO; ! 647: } ! 648: ! 649: /** ! 650: * Transmit FCP frame ! 651: * ! 652: * @v process FCP command process ! 653: */ ! 654: static void fcpcmd_step ( struct process *process ) { ! 655: struct fcp_command *fcpcmd = ! 656: container_of ( process, struct fcp_command, process ); ! 657: int rc; ! 658: ! 659: /* Send the current IU */ ! 660: if ( ( rc = fcpcmd->send ( fcpcmd ) ) != 0 ) { ! 661: /* Treat failure as a fatal error */ ! 662: fcpcmd_close ( fcpcmd, rc ); ! 663: } ! 664: } ! 665: ! 666: /** ! 667: * Receive FCP frame ! 668: * ! 669: * @v fcpcmd FCP command ! 670: * @v iobuf I/O buffer ! 671: * @v meta Data transfer metadata ! 672: * @ret rc Return status code ! 673: */ ! 674: static int fcpcmd_deliver ( struct fcp_command *fcpcmd, ! 675: struct io_buffer *iobuf, ! 676: struct xfer_metadata *meta ) { ! 677: int ( * fcpcmd_recv ) ( struct fcp_command *fcpcmd, ! 678: struct io_buffer *iobuf, ! 679: struct xfer_metadata *meta ); ! 680: int rc; ! 681: ! 682: /* Determine handler */ ! 683: switch ( meta->flags & ( XFER_FL_CMD_STAT | XFER_FL_RESPONSE ) ) { ! 684: case ( XFER_FL_RESPONSE ) : ! 685: fcpcmd_recv = fcpcmd_recv_rddata; ! 686: break; ! 687: case ( XFER_FL_CMD_STAT ) : ! 688: fcpcmd_recv = fcpcmd_recv_xfer_rdy; ! 689: break; ! 690: case ( XFER_FL_CMD_STAT | XFER_FL_RESPONSE ) : ! 691: fcpcmd_recv = fcpcmd_recv_rsp; ! 692: break; ! 693: default: ! 694: fcpcmd_recv = fcpcmd_recv_unknown; ! 695: break; ! 696: } ! 697: ! 698: /* Handle IU */ ! 699: if ( ( rc = fcpcmd_recv ( fcpcmd, iob_disown ( iobuf ), meta ) ) != 0 ){ ! 700: /* Treat any error as fatal to the command */ ! 701: fcpcmd_close ( fcpcmd, rc ); ! 702: } ! 703: ! 704: return rc; ! 705: } ! 706: ! 707: /** FCP command SCSI interface operations */ ! 708: static struct interface_operation fcpcmd_scsi_op[] = { ! 709: INTF_OP ( intf_close, struct fcp_command *, fcpcmd_close ), ! 710: }; ! 711: ! 712: /** FCP command SCSI interface descriptor */ ! 713: static struct interface_descriptor fcpcmd_scsi_desc = ! 714: INTF_DESC_PASSTHRU ( struct fcp_command, scsi, fcpcmd_scsi_op, xchg ); ! 715: ! 716: /** FCP command Fibre Channel exchange interface operations */ ! 717: static struct interface_operation fcpcmd_xchg_op[] = { ! 718: INTF_OP ( xfer_deliver, struct fcp_command *, fcpcmd_deliver ), ! 719: INTF_OP ( intf_close, struct fcp_command *, fcpcmd_close_err ), ! 720: }; ! 721: ! 722: /** FCP command Fibre Channel exchange interface descriptor */ ! 723: static struct interface_descriptor fcpcmd_xchg_desc = ! 724: INTF_DESC_PASSTHRU ( struct fcp_command, xchg, fcpcmd_xchg_op, scsi ); ! 725: ! 726: /** ! 727: * Issue FCP SCSI command ! 728: * ! 729: * @v fcpdev FCP device ! 730: * @v parent Parent interface ! 731: * @v command SCSI command ! 732: * @ret tag Command tag, or negative error ! 733: */ ! 734: static int fcpdev_scsi_command ( struct fcp_device *fcpdev, ! 735: struct interface *parent, ! 736: struct scsi_cmd *command ) { ! 737: struct fcp_prli_service_parameters *param = fcpdev->ulp->param; ! 738: struct fcp_command *fcpcmd; ! 739: int xchg_id; ! 740: int rc; ! 741: ! 742: /* Check link */ ! 743: if ( ( rc = fcpdev->ulp->link.rc ) != 0 ) { ! 744: DBGC ( fcpdev, "FCP %p could not issue command while link is " ! 745: "down: %s\n", fcpdev, strerror ( rc ) ); ! 746: goto err_link; ! 747: } ! 748: ! 749: /* Check target capability */ ! 750: assert ( param != NULL ); ! 751: assert ( fcpdev->ulp->param_len >= sizeof ( *param ) ); ! 752: if ( ! ( param->flags & htonl ( FCP_PRLI_TARGET ) ) ) { ! 753: DBGC ( fcpdev, "FCP %p could not issue command: not a target\n", ! 754: fcpdev ); ! 755: rc = -ENOTTY; ! 756: goto err_target; ! 757: } ! 758: ! 759: /* Allocate and initialise structure */ ! 760: fcpcmd = zalloc ( sizeof ( *fcpcmd ) ); ! 761: if ( ! fcpcmd ) { ! 762: rc = -ENOMEM; ! 763: goto err_zalloc; ! 764: } ! 765: ref_init ( &fcpcmd->refcnt, fcpcmd_free ); ! 766: intf_init ( &fcpcmd->scsi, &fcpcmd_scsi_desc, &fcpcmd->refcnt ); ! 767: intf_init ( &fcpcmd->xchg, &fcpcmd_xchg_desc, &fcpcmd->refcnt ); ! 768: process_init_stopped ( &fcpcmd->process, fcpcmd_step, &fcpcmd->refcnt ); ! 769: fcpcmd->fcpdev = fcpdev_get ( fcpdev ); ! 770: list_add ( &fcpcmd->list, &fcpdev->fcpcmds ); ! 771: memcpy ( &fcpcmd->command, command, sizeof ( fcpcmd->command ) ); ! 772: ! 773: /* Create new exchange */ ! 774: if ( ( xchg_id = fc_xchg_originate ( &fcpcmd->xchg, ! 775: fcpdev->ulp->peer->port, ! 776: &fcpdev->ulp->peer->port_id, ! 777: FC_TYPE_FCP ) ) < 0 ) { ! 778: rc = xchg_id; ! 779: DBGC ( fcpdev, "FCP %p could not create exchange: %s\n", ! 780: fcpdev, strerror ( rc ) ); ! 781: goto err_xchg_originate; ! 782: } ! 783: fcpcmd->xchg_id = xchg_id; ! 784: ! 785: /* Start sending command IU */ ! 786: fcpcmd_start_send ( fcpcmd, fcpcmd_send_cmnd ); ! 787: ! 788: /* Attach to parent interface, mortalise self, and return */ ! 789: intf_plug_plug ( &fcpcmd->scsi, parent ); ! 790: ref_put ( &fcpcmd->refcnt ); ! 791: return ( FCP_TAG_MAGIC | fcpcmd->xchg_id ); ! 792: ! 793: err_xchg_originate: ! 794: fcpcmd_close ( fcpcmd, rc ); ! 795: ref_put ( &fcpcmd->refcnt ); ! 796: err_zalloc: ! 797: err_target: ! 798: err_link: ! 799: return rc; ! 800: } ! 801: ! 802: /** ! 803: * Close FCP device ! 804: * ! 805: * @v fcpdev FCP device ! 806: * @v rc Reason for close ! 807: */ ! 808: static void fcpdev_close ( struct fcp_device *fcpdev, int rc ) { ! 809: struct fcp_command *fcpcmd; ! 810: struct fcp_command *tmp; ! 811: ! 812: DBGC ( fcpdev, "FCP %p closed: %s\n", fcpdev, strerror ( rc ) ); ! 813: ! 814: /* Shut down interfaces */ ! 815: intf_shutdown ( &fcpdev->scsi, rc ); ! 816: ! 817: /* Shut down any active commands */ ! 818: list_for_each_entry_safe ( fcpcmd, tmp, &fcpdev->fcpcmds, list ) { ! 819: fcpcmd_get ( fcpcmd ); ! 820: fcpcmd_close ( fcpcmd, rc ); ! 821: fcpcmd_put ( fcpcmd ); ! 822: } ! 823: ! 824: /* Drop reference to ULP */ ! 825: if ( fcpdev->ulp ) { ! 826: fc_ulp_decrement ( fcpdev->ulp ); ! 827: fc_ulp_put ( fcpdev->ulp ); ! 828: fcpdev->ulp = NULL; ! 829: } ! 830: } ! 831: ! 832: /** ! 833: * Check FCP device flow-control window ! 834: * ! 835: * @v fcpdev FCP device ! 836: * @ret len Length of window ! 837: */ ! 838: static size_t fcpdev_window ( struct fcp_device *fcpdev ) { ! 839: return ( fc_link_ok ( &fcpdev->ulp->link ) ? ~( ( size_t ) 0 ) : 0 ); ! 840: } ! 841: ! 842: /** ! 843: * Describe FCP device in an ACPI table ! 844: * ! 845: * @v fcpdev FCP device ! 846: * @v acpi ACPI table ! 847: * @v len Length of ACPI table ! 848: * @ret rc Return status code ! 849: */ ! 850: static int fcpdev_acpi_describe ( struct fcp_device *fcpdev, ! 851: struct acpi_description_header *acpi, ! 852: size_t len ) { ! 853: ! 854: DBGC ( fcpdev, "FCP %p cannot yet describe device in an ACPI table\n", ! 855: fcpdev ); ! 856: ( void ) acpi; ! 857: ( void ) len; ! 858: return 0; ! 859: } ! 860: ! 861: /** ! 862: * Describe FCP device using EDD ! 863: * ! 864: * @v fcpdev FCP device ! 865: * @v type EDD interface type ! 866: * @v path EDD device path ! 867: * @ret rc Return status code ! 868: */ ! 869: static int fcpdev_edd_describe ( struct fcp_device *fcpdev, ! 870: struct edd_interface_type *type, ! 871: union edd_device_path *path ) { ! 872: union { ! 873: struct fc_name fc; ! 874: uint64_t u64; ! 875: } wwn; ! 876: union { ! 877: struct scsi_lun scsi; ! 878: uint64_t u64; ! 879: } lun; ! 880: ! 881: type->type = cpu_to_le64 ( EDD_INTF_TYPE_FIBRE ); ! 882: memcpy ( &wwn.fc, &fcpdev->wwn, sizeof ( wwn.fc ) ); ! 883: path->fibre.wwn = be64_to_cpu ( wwn.u64 ); ! 884: memcpy ( &lun.scsi, &fcpdev->lun, sizeof ( lun.scsi ) ); ! 885: path->fibre.lun = be64_to_cpu ( lun.u64 ); ! 886: return 0; ! 887: } ! 888: ! 889: /** ! 890: * Identify device underlying FCP device ! 891: * ! 892: * @v fcpdev FCP device ! 893: * @ret device Underlying device ! 894: */ ! 895: static struct device * fcpdev_identify_device ( struct fcp_device *fcpdev ) { ! 896: ! 897: /* We know the underlying device only if the link is up; ! 898: * otherwise we don't have a port to examine. ! 899: */ ! 900: if ( ! fc_link_ok ( &fcpdev->ulp->link ) ) { ! 901: DBGC ( fcpdev, "FCP %p doesn't know underlying device " ! 902: "until link is up\n", fcpdev ); ! 903: return NULL; ! 904: } ! 905: ! 906: /* Hand off to port's transport interface */ ! 907: assert ( fcpdev->ulp->peer->port != NULL ); ! 908: return identify_device ( &fcpdev->ulp->peer->port->transport ); ! 909: } ! 910: ! 911: /** FCP device SCSI interface operations */ ! 912: static struct interface_operation fcpdev_scsi_op[] = { ! 913: INTF_OP ( scsi_command, struct fcp_device *, fcpdev_scsi_command ), ! 914: INTF_OP ( xfer_window, struct fcp_device *, fcpdev_window ), ! 915: INTF_OP ( intf_close, struct fcp_device *, fcpdev_close ), ! 916: INTF_OP ( acpi_describe, struct fcp_device *, fcpdev_acpi_describe ), ! 917: INTF_OP ( edd_describe, struct fcp_device *, fcpdev_edd_describe ), ! 918: INTF_OP ( identify_device, struct fcp_device *, ! 919: fcpdev_identify_device ), ! 920: }; ! 921: ! 922: /** FCP device SCSI interface descriptor */ ! 923: static struct interface_descriptor fcpdev_scsi_desc = ! 924: INTF_DESC ( struct fcp_device, scsi, fcpdev_scsi_op ); ! 925: ! 926: /** ! 927: * Open FCP device ! 928: * ! 929: * @v parent Parent interface ! 930: * @v wwn Fibre Channel WWN ! 931: * @v lun SCSI LUN ! 932: * @ret rc Return status code ! 933: */ ! 934: static int fcpdev_open ( struct interface *parent, struct fc_name *wwn, ! 935: struct scsi_lun *lun ) { ! 936: struct fc_ulp *ulp; ! 937: struct fcp_device *fcpdev; ! 938: int rc; ! 939: ! 940: /* Get Fibre Channel ULP interface */ ! 941: ulp = fc_ulp_get_wwn_type ( wwn, FC_TYPE_FCP ); ! 942: if ( ! ulp ) { ! 943: rc = -ENOMEM; ! 944: goto err_ulp_get; ! 945: } ! 946: ! 947: /* Allocate and initialise structure */ ! 948: fcpdev = zalloc ( sizeof ( *fcpdev ) ); ! 949: if ( ! fcpdev ) { ! 950: rc = -ENOMEM; ! 951: goto err_zalloc; ! 952: } ! 953: ref_init ( &fcpdev->refcnt, NULL ); ! 954: intf_init ( &fcpdev->scsi, &fcpdev_scsi_desc, &fcpdev->refcnt ); ! 955: INIT_LIST_HEAD ( &fcpdev->fcpcmds ); ! 956: fcpdev->ulp = fc_ulp_get ( ulp ); ! 957: fc_ulp_increment ( fcpdev->ulp ); ! 958: ! 959: DBGC ( fcpdev, "FCP %p opened for %s\n", fcpdev, fc_ntoa ( wwn ) ); ! 960: ! 961: /* Preserve parameters required for boot firmware table */ ! 962: memcpy ( &fcpdev->wwn, wwn, sizeof ( fcpdev->wwn ) ); ! 963: memcpy ( &fcpdev->lun, lun, sizeof ( fcpdev->lun ) ); ! 964: ! 965: /* Attach SCSI device to parent interface */ ! 966: if ( ( rc = scsi_open ( parent, &fcpdev->scsi, lun ) ) != 0 ) { ! 967: DBGC ( fcpdev, "FCP %p could not create SCSI device: %s\n", ! 968: fcpdev, strerror ( rc ) ); ! 969: goto err_scsi_open; ! 970: } ! 971: ! 972: /* Drop temporary reference to ULP */ ! 973: fc_ulp_put ( ulp ); ! 974: ! 975: /* Mortalise self and return */ ! 976: ref_put ( &fcpdev->refcnt ); ! 977: return 0; ! 978: ! 979: err_scsi_open: ! 980: fcpdev_close ( fcpdev, rc ); ! 981: ref_put ( &fcpdev->refcnt ); ! 982: err_zalloc: ! 983: fc_ulp_put ( ulp ); ! 984: err_ulp_get: ! 985: return rc; ! 986: } ! 987: ! 988: /****************************************************************************** ! 989: * ! 990: * FCP URIs ! 991: * ! 992: ****************************************************************************** ! 993: */ ! 994: ! 995: /** ! 996: * Parse FCP URI ! 997: * ! 998: * @v uri URI ! 999: * @ret wwn Fibre Channel WWN ! 1000: * @ret lun SCSI LUN ! 1001: * @ret rc Return status code ! 1002: * ! 1003: * An FCP URI has the form "fcp:<wwn>:<lun>" or "fcp://<wwn>/<lun>" ! 1004: */ ! 1005: static int fcp_parse_uri ( struct uri *uri, struct fc_name *wwn, ! 1006: struct scsi_lun *lun ) { ! 1007: char wwn_buf[ FC_NAME_STRLEN + 1 /* NUL */ ]; ! 1008: const char *wwn_text; ! 1009: const char *lun_text; ! 1010: int rc; ! 1011: ! 1012: /* Extract WWN and LUN texts from URI */ ! 1013: if ( uri->opaque ) { ! 1014: /* "fcp:<wwn>:<lun>" */ ! 1015: if ( snprintf ( wwn_buf, sizeof ( wwn_buf ), "%s", ! 1016: uri->opaque ) < ( FC_NAME_STRLEN + 1 /* : */ ) ) ! 1017: return -EINVAL; ! 1018: if ( uri->opaque[FC_NAME_STRLEN] != ':' ) ! 1019: return -EINVAL; ! 1020: wwn_text = wwn_buf; ! 1021: lun_text = &uri->opaque[FC_NAME_STRLEN + 1]; ! 1022: } else { ! 1023: /* If host exists, path must also exist */ ! 1024: if ( ! ( uri->host && uri->path ) ) ! 1025: return -EINVAL; ! 1026: if ( uri->path[0] != '/' ) ! 1027: return -EINVAL; ! 1028: wwn_text = uri->host; ! 1029: lun_text = ( uri->path + 1 ); ! 1030: } ! 1031: ! 1032: /* Parse WWN */ ! 1033: if ( ( rc = fc_aton ( wwn_text, wwn ) ) != 0 ) ! 1034: return rc; ! 1035: ! 1036: /* Parse LUN */ ! 1037: if ( ( rc = scsi_parse_lun ( lun_text, lun ) ) != 0 ) ! 1038: return rc; ! 1039: ! 1040: return 0; ! 1041: } ! 1042: ! 1043: /** ! 1044: * Open FCP URI ! 1045: * ! 1046: * @v parent Parent interface ! 1047: * @v uri URI ! 1048: * @ret rc Return status code ! 1049: */ ! 1050: static int fcp_open ( struct interface *parent, struct uri *uri ) { ! 1051: struct fc_name wwn; ! 1052: struct scsi_lun lun; ! 1053: int rc; ! 1054: ! 1055: /* Parse URI */ ! 1056: if ( ( rc = fcp_parse_uri ( uri, &wwn, &lun ) ) != 0 ) ! 1057: return rc; ! 1058: ! 1059: /* Open FCP device */ ! 1060: if ( ( rc = fcpdev_open ( parent, &wwn, &lun ) ) != 0 ) ! 1061: return rc; ! 1062: ! 1063: return 0; ! 1064: } ! 1065: ! 1066: /** FCP URI opener */ ! 1067: struct uri_opener fcp_uri_opener __uri_opener = { ! 1068: .scheme = "fcp", ! 1069: .open = fcp_open, ! 1070: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.