![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi.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 / drivers / block|
Return to scsi.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / block |
1.1 root 1: /*
2: * Copyright (C) 2006 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 <stdlib.h>
23: #include <string.h>
24: #include <byteswap.h>
25: #include <errno.h>
26: #include <ipxe/list.h>
27: #include <ipxe/process.h>
28: #include <ipxe/xfer.h>
29: #include <ipxe/blockdev.h>
30: #include <ipxe/scsi.h>
31:
32: /** @file
33: *
34: * SCSI block device
35: *
36: */
37:
38: /** Maximum number of command retries */
39: #define SCSICMD_MAX_RETRIES 10
40:
41: /* Error numbers generated by SCSI sense data */
42: #define EIO_NO_SENSE __einfo_error ( EINFO_EIO_NO_SENSE )
43: #define EINFO_EIO_NO_SENSE \
44: __einfo_uniqify ( EINFO_EIO, 0x00, "No sense" )
45: #define EIO_RECOVERED_ERROR __einfo_error ( EINFO_EIO_RECOVERED_ERROR )
46: #define EINFO_EIO_RECOVERED_ERROR \
47: __einfo_uniqify ( EINFO_EIO, 0x01, "Recovered error" )
48: #define EIO_NOT_READY __einfo_error ( EINFO_EIO_NOT_READY )
49: #define EINFO_EIO_NOT_READY \
50: __einfo_uniqify ( EINFO_EIO, 0x02, "Not ready" )
51: #define EIO_MEDIUM_ERROR __einfo_error ( EINFO_EIO_MEDIUM_ERROR )
52: #define EINFO_EIO_MEDIUM_ERROR \
53: __einfo_uniqify ( EINFO_EIO, 0x03, "Medium error" )
54: #define EIO_HARDWARE_ERROR __einfo_error ( EINFO_EIO_HARDWARE_ERROR )
55: #define EINFO_EIO_HARDWARE_ERROR \
56: __einfo_uniqify ( EINFO_EIO, 0x04, "Hardware error" )
57: #define EIO_ILLEGAL_REQUEST __einfo_error ( EINFO_EIO_ILLEGAL_REQUEST )
58: #define EINFO_EIO_ILLEGAL_REQUEST \
59: __einfo_uniqify ( EINFO_EIO, 0x05, "Illegal request" )
60: #define EIO_UNIT_ATTENTION __einfo_error ( EINFO_EIO_UNIT_ATTENTION )
61: #define EINFO_EIO_UNIT_ATTENTION \
62: __einfo_uniqify ( EINFO_EIO, 0x06, "Unit attention" )
63: #define EIO_DATA_PROTECT __einfo_error ( EINFO_EIO_DATA_PROTECT )
64: #define EINFO_EIO_DATA_PROTECT \
65: __einfo_uniqify ( EINFO_EIO, 0x07, "Data protect" )
66: #define EIO_BLANK_CHECK __einfo_error ( EINFO_EIO_BLANK_CHECK )
67: #define EINFO_EIO_BLANK_CHECK \
68: __einfo_uniqify ( EINFO_EIO, 0x08, "Blank check" )
69: #define EIO_VENDOR_SPECIFIC __einfo_error ( EINFO_EIO_VENDOR_SPECIFIC )
70: #define EINFO_EIO_VENDOR_SPECIFIC \
71: __einfo_uniqify ( EINFO_EIO, 0x09, "Vendor specific" )
72: #define EIO_COPY_ABORTED __einfo_error ( EINFO_EIO_COPY_ABORTED )
73: #define EINFO_EIO_COPY_ABORTED \
74: __einfo_uniqify ( EINFO_EIO, 0x0a, "Copy aborted" )
75: #define EIO_ABORTED_COMMAND __einfo_error ( EINFO_EIO_ABORTED_COMMAND )
76: #define EINFO_EIO_ABORTED_COMMAND \
77: __einfo_uniqify ( EINFO_EIO, 0x0b, "Aborted command" )
78: #define EIO_RESERVED __einfo_error ( EINFO_EIO_RESERVED )
79: #define EINFO_EIO_RESERVED \
80: __einfo_uniqify ( EINFO_EIO, 0x0c, "Reserved" )
81: #define EIO_VOLUME_OVERFLOW __einfo_error ( EINFO_EIO_VOLUME_OVERFLOW )
82: #define EINFO_EIO_VOLUME_OVERFLOW \
83: __einfo_uniqify ( EINFO_EIO, 0x0d, "Volume overflow" )
84: #define EIO_MISCOMPARE __einfo_error ( EINFO_EIO_MISCOMPARE )
85: #define EINFO_EIO_MISCOMPARE \
86: __einfo_uniqify ( EINFO_EIO, 0x0e, "Miscompare" )
87: #define EIO_COMPLETED __einfo_error ( EINFO_EIO_COMPLETED )
88: #define EINFO_EIO_COMPLETED \
89: __einfo_uniqify ( EINFO_EIO, 0x0f, "Completed" )
90: #define EIO_SENSE( key ) \
91: EUNIQ ( EIO, (key), EIO_NO_SENSE, EIO_RECOVERED_ERROR, \
92: EIO_NOT_READY, EIO_MEDIUM_ERROR, EIO_HARDWARE_ERROR, \
93: EIO_ILLEGAL_REQUEST, EIO_UNIT_ATTENTION, \
94: EIO_DATA_PROTECT, EIO_BLANK_CHECK, EIO_VENDOR_SPECIFIC, \
95: EIO_COPY_ABORTED, EIO_ABORTED_COMMAND, EIO_RESERVED, \
96: EIO_VOLUME_OVERFLOW, EIO_MISCOMPARE, EIO_COMPLETED )
97:
98: /******************************************************************************
99: *
100: * Utility functions
101: *
102: ******************************************************************************
103: */
104:
105: /**
106: * Parse SCSI LUN
107: *
108: * @v lun_string LUN string representation
109: * @v lun LUN to fill in
110: * @ret rc Return status code
111: */
112: int scsi_parse_lun ( const char *lun_string, struct scsi_lun *lun ) {
113: char *p;
114: int i;
115:
116: memset ( lun, 0, sizeof ( *lun ) );
117: if ( lun_string ) {
118: p = ( char * ) lun_string;
119: for ( i = 0 ; i < 4 ; i++ ) {
120: lun->u16[i] = htons ( strtoul ( p, &p, 16 ) );
121: if ( *p == '\0' )
122: break;
123: if ( *p != '-' )
124: return -EINVAL;
125: p++;
126: }
127: if ( *p )
128: return -EINVAL;
129: }
130:
131: return 0;
132: }
133:
134: /******************************************************************************
135: *
136: * Interface methods
137: *
138: ******************************************************************************
139: */
140:
141: /**
142: * Issue SCSI command
143: *
144: * @v control SCSI control interface
145: * @v data SCSI data interface
146: * @v command SCSI command
147: * @ret tag Command tag, or negative error
148: */
149: int scsi_command ( struct interface *control, struct interface *data,
150: struct scsi_cmd *command ) {
151: struct interface *dest;
152: scsi_command_TYPE ( void * ) *op =
153: intf_get_dest_op ( control, scsi_command, &dest );
154: void *object = intf_object ( dest );
155: int tap;
156:
157: if ( op ) {
158: tap = op ( object, data, command );
159: } else {
160: /* Default is to fail to issue the command */
161: tap = -EOPNOTSUPP;
162: }
163:
164: intf_put ( dest );
165: return tap;
166: }
167:
168: /**
169: * Report SCSI response
170: *
171: * @v interface SCSI command interface
172: * @v response SCSI response
173: */
174: void scsi_response ( struct interface *intf, struct scsi_rsp *response ) {
175: struct interface *dest;
176: scsi_response_TYPE ( void * ) *op =
177: intf_get_dest_op ( intf, scsi_response, &dest );
178: void *object = intf_object ( dest );
179:
180: if ( op ) {
181: op ( object, response );
182: } else {
183: /* Default is to ignore the response */
184: }
185:
186: intf_put ( dest );
187: }
188:
189: /******************************************************************************
190: *
191: * SCSI devices and commands
192: *
193: ******************************************************************************
194: */
195:
196: /** A SCSI device */
197: struct scsi_device {
198: /** Reference count */
199: struct refcnt refcnt;
200: /** Block control interface */
201: struct interface block;
202: /** SCSI control interface */
203: struct interface scsi;
204:
205: /** SCSI LUN */
206: struct scsi_lun lun;
207: /** Flags */
208: unsigned int flags;
209:
210: /** TEST UNIT READY interface */
211: struct interface ready;
212: /** TEST UNIT READY process */
213: struct process process;
214:
215: /** List of commands */
216: struct list_head cmds;
217: };
218:
219: /** SCSI device flags */
220: enum scsi_device_flags {
221: /** Unit is ready */
222: SCSIDEV_UNIT_READY = 0x0001,
223: };
224:
225: /** A SCSI command */
226: struct scsi_command {
227: /** Reference count */
228: struct refcnt refcnt;
229: /** SCSI device */
230: struct scsi_device *scsidev;
231: /** List of SCSI commands */
232: struct list_head list;
233:
234: /** Block data interface */
235: struct interface block;
236: /** SCSI data interface */
237: struct interface scsi;
238:
239: /** Command type */
240: struct scsi_command_type *type;
241: /** Starting logical block address */
242: uint64_t lba;
243: /** Number of blocks */
244: unsigned int count;
245: /** Data buffer */
246: userptr_t buffer;
247: /** Length of data buffer */
248: size_t len;
249: /** Command tag */
250: uint32_t tag;
251:
252: /** Retry count */
253: unsigned int retries;
254:
255: /** Private data */
256: uint8_t priv[0];
257: };
258:
259: /** A SCSI command type */
260: struct scsi_command_type {
261: /** Name */
262: const char *name;
263: /** Additional working space */
264: size_t priv_len;
265: /**
266: * Construct SCSI command IU
267: *
268: * @v scsicmd SCSI command
269: * @v command SCSI command IU
270: */
271: void ( * cmd ) ( struct scsi_command *scsicmd,
272: struct scsi_cmd *command );
273: /**
274: * Handle SCSI command completion
275: *
276: * @v scsicmd SCSI command
277: * @v rc Reason for completion
278: */
279: void ( * done ) ( struct scsi_command *scsicmd, int rc );
280: };
281:
282: /**
283: * Get reference to SCSI device
284: *
285: * @v scsidev SCSI device
286: * @ret scsidev SCSI device
287: */
288: static inline __attribute__ (( always_inline )) struct scsi_device *
289: scsidev_get ( struct scsi_device *scsidev ) {
290: ref_get ( &scsidev->refcnt );
291: return scsidev;
292: }
293:
294: /**
295: * Drop reference to SCSI device
296: *
297: * @v scsidev SCSI device
298: */
299: static inline __attribute__ (( always_inline )) void
300: scsidev_put ( struct scsi_device *scsidev ) {
301: ref_put ( &scsidev->refcnt );
302: }
303:
304: /**
305: * Get reference to SCSI command
306: *
307: * @v scsicmd SCSI command
308: * @ret scsicmd SCSI command
309: */
310: static inline __attribute__ (( always_inline )) struct scsi_command *
311: scsicmd_get ( struct scsi_command *scsicmd ) {
312: ref_get ( &scsicmd->refcnt );
313: return scsicmd;
314: }
315:
316: /**
317: * Drop reference to SCSI command
318: *
319: * @v scsicmd SCSI command
320: */
321: static inline __attribute__ (( always_inline )) void
322: scsicmd_put ( struct scsi_command *scsicmd ) {
323: ref_put ( &scsicmd->refcnt );
324: }
325:
326: /**
327: * Get SCSI command private data
328: *
329: * @v scsicmd SCSI command
330: * @ret priv Private data
331: */
332: static inline __attribute__ (( always_inline )) void *
333: scsicmd_priv ( struct scsi_command *scsicmd ) {
334: return scsicmd->priv;
335: }
336:
337: /**
338: * Free SCSI command
339: *
340: * @v refcnt Reference count
341: */
342: static void scsicmd_free ( struct refcnt *refcnt ) {
343: struct scsi_command *scsicmd =
344: container_of ( refcnt, struct scsi_command, refcnt );
345:
346: /* Remove from list of commands */
347: list_del ( &scsicmd->list );
348: scsidev_put ( scsicmd->scsidev );
349:
350: /* Free command */
351: free ( scsicmd );
352: }
353:
354: /**
355: * Close SCSI command
356: *
357: * @v scsicmd SCSI command
358: * @v rc Reason for close
359: */
360: static void scsicmd_close ( struct scsi_command *scsicmd, int rc ) {
361: struct scsi_device *scsidev = scsicmd->scsidev;
362:
363: if ( rc != 0 ) {
364: DBGC ( scsidev, "SCSI %p tag %08x closed: %s\n",
365: scsidev, scsicmd->tag, strerror ( rc ) );
366: }
367:
368: /* Shut down interfaces */
369: intf_shutdown ( &scsicmd->scsi, rc );
370: intf_shutdown ( &scsicmd->block, rc );
371: }
372:
373: /**
374: * Construct and issue SCSI command
375: *
376: * @ret rc Return status code
377: */
378: static int scsicmd_command ( struct scsi_command *scsicmd ) {
379: struct scsi_device *scsidev = scsicmd->scsidev;
380: struct scsi_cmd command;
381: int tag;
382: int rc;
383:
384: /* Construct command */
385: memset ( &command, 0, sizeof ( command ) );
386: memcpy ( &command.lun, &scsidev->lun, sizeof ( command.lun ) );
387: scsicmd->type->cmd ( scsicmd, &command );
388:
389: /* Issue command */
390: if ( ( tag = scsi_command ( &scsidev->scsi, &scsicmd->scsi,
391: &command ) ) < 0 ) {
392: rc = tag;
393: DBGC ( scsidev, "SCSI %p could not issue command: %s\n",
394: scsidev, strerror ( rc ) );
395: return rc;
396: }
397:
398: /* Record tag */
399: if ( scsicmd->tag ) {
400: DBGC ( scsidev, "SCSI %p tag %08x is now tag %08x\n",
401: scsidev, scsicmd->tag, tag );
402: }
403: scsicmd->tag = tag;
404: DBGC2 ( scsidev, "SCSI %p tag %08x %s " SCSI_CDB_FORMAT "\n",
405: scsidev, scsicmd->tag, scsicmd->type->name,
406: SCSI_CDB_DATA ( command.cdb ) );
407:
408: return 0;
409: }
410:
411: /**
412: * Handle SCSI command completion
413: *
414: * @v scsicmd SCSI command
415: * @v rc Reason for close
416: */
417: static void scsicmd_done ( struct scsi_command *scsicmd, int rc ) {
418: struct scsi_device *scsidev = scsicmd->scsidev;
419:
420: /* Restart SCSI interface */
421: intf_restart ( &scsicmd->scsi, rc );
422:
423: /* SCSI targets have an annoying habit of returning occasional
424: * pointless "error" messages such as "power-on occurred", so
425: * we have to be prepared to retry commands.
426: */
427: if ( ( rc != 0 ) && ( scsicmd->retries++ < SCSICMD_MAX_RETRIES ) ) {
428: /* Retry command */
429: DBGC ( scsidev, "SCSI %p tag %08x failed: %s\n",
430: scsidev, scsicmd->tag, strerror ( rc ) );
431: DBGC ( scsidev, "SCSI %p tag %08x retrying (retry %d)\n",
432: scsidev, scsicmd->tag, scsicmd->retries );
433: if ( ( rc = scsicmd_command ( scsicmd ) ) == 0 )
434: return;
435: }
436:
437: /* If we didn't (successfully) reissue the command, hand over
438: * to the command completion handler.
439: */
440: scsicmd->type->done ( scsicmd, rc );
441: }
442:
443: /**
444: * Handle SCSI response
445: *
446: * @v scsicmd SCSI command
447: * @v response SCSI response
448: */
449: static void scsicmd_response ( struct scsi_command *scsicmd,
450: struct scsi_rsp *response ) {
451: struct scsi_device *scsidev = scsicmd->scsidev;
452: size_t overrun;
453: size_t underrun;
454: int rc;
455:
456: if ( response->status == 0 ) {
457: scsicmd_done ( scsicmd, 0 );
458: } else {
459: DBGC ( scsidev, "SCSI %p tag %08x status %02x",
460: scsidev, scsicmd->tag, response->status );
461: if ( response->overrun > 0 ) {
462: overrun = response->overrun;
463: DBGC ( scsidev, " overrun +%zd", overrun );
464: } else if ( response->overrun < 0 ) {
465: underrun = -(response->overrun);
466: DBGC ( scsidev, " underrun -%zd", underrun );
467: }
468: DBGC ( scsidev, " sense %02x:%02x:%08x\n",
469: response->sense.code, response->sense.key,
470: ntohl ( response->sense.info ) );
471:
472: /* Construct error number from sense data */
473: rc = -EIO_SENSE ( response->sense.key & SCSI_SENSE_KEY_MASK );
474: scsicmd_done ( scsicmd, rc );
475: }
476: }
477:
478: /**
479: * Construct SCSI READ command
480: *
481: * @v scsicmd SCSI command
482: * @v command SCSI command IU
483: */
484: static void scsicmd_read_cmd ( struct scsi_command *scsicmd,
485: struct scsi_cmd *command ) {
486:
487: if ( ( scsicmd->lba + scsicmd->count ) > SCSI_MAX_BLOCK_10 ) {
488: /* Use READ (16) */
489: command->cdb.read16.opcode = SCSI_OPCODE_READ_16;
490: command->cdb.read16.lba = cpu_to_be64 ( scsicmd->lba );
491: command->cdb.read16.len = cpu_to_be32 ( scsicmd->count );
492: } else {
493: /* Use READ (10) */
494: command->cdb.read10.opcode = SCSI_OPCODE_READ_10;
495: command->cdb.read10.lba = cpu_to_be32 ( scsicmd->lba );
496: command->cdb.read10.len = cpu_to_be16 ( scsicmd->count );
497: }
498: command->data_in = scsicmd->buffer;
499: command->data_in_len = scsicmd->len;
500: }
501:
502: /** SCSI READ command type */
503: static struct scsi_command_type scsicmd_read = {
504: .name = "READ",
505: .cmd = scsicmd_read_cmd,
506: .done = scsicmd_close,
507: };
508:
509: /**
510: * Construct SCSI WRITE command
511: *
512: * @v scsicmd SCSI command
513: * @v command SCSI command IU
514: */
515: static void scsicmd_write_cmd ( struct scsi_command *scsicmd,
516: struct scsi_cmd *command ) {
517:
518: if ( ( scsicmd->lba + scsicmd->count ) > SCSI_MAX_BLOCK_10 ) {
519: /* Use WRITE (16) */
520: command->cdb.write16.opcode = SCSI_OPCODE_WRITE_16;
521: command->cdb.write16.lba = cpu_to_be64 ( scsicmd->lba );
522: command->cdb.write16.len = cpu_to_be32 ( scsicmd->count );
523: } else {
524: /* Use WRITE (10) */
525: command->cdb.write10.opcode = SCSI_OPCODE_WRITE_10;
526: command->cdb.write10.lba = cpu_to_be32 ( scsicmd->lba );
527: command->cdb.write10.len = cpu_to_be16 ( scsicmd->count );
528: }
529: command->data_out = scsicmd->buffer;
530: command->data_out_len = scsicmd->len;
531: }
532:
533: /** SCSI WRITE command type */
534: static struct scsi_command_type scsicmd_write = {
535: .name = "WRITE",
536: .cmd = scsicmd_write_cmd,
537: .done = scsicmd_close,
538: };
539:
540: /** SCSI READ CAPACITY private data */
541: struct scsi_read_capacity_private {
542: /** Use READ CAPACITY (16) */
543: int use16;
544: /** Data buffer for READ CAPACITY commands */
545: union {
546: /** Data buffer for READ CAPACITY (10) */
547: struct scsi_capacity_10 capacity10;
548: /** Data buffer for READ CAPACITY (16) */
549: struct scsi_capacity_16 capacity16;
550: } capacity;
551: };
552:
553: /**
554: * Construct SCSI READ CAPACITY command
555: *
556: * @v scsicmd SCSI command
557: * @v command SCSI command IU
558: */
559: static void scsicmd_read_capacity_cmd ( struct scsi_command *scsicmd,
560: struct scsi_cmd *command ) {
561: struct scsi_read_capacity_private *priv = scsicmd_priv ( scsicmd );
562: struct scsi_cdb_read_capacity_16 *readcap16 = &command->cdb.readcap16;
563: struct scsi_cdb_read_capacity_10 *readcap10 = &command->cdb.readcap10;
564: struct scsi_capacity_16 *capacity16 = &priv->capacity.capacity16;
565: struct scsi_capacity_10 *capacity10 = &priv->capacity.capacity10;
566:
567: if ( priv->use16 ) {
568: /* Use READ CAPACITY (16) */
569: readcap16->opcode = SCSI_OPCODE_SERVICE_ACTION_IN;
570: readcap16->service_action =
571: SCSI_SERVICE_ACTION_READ_CAPACITY_16;
572: readcap16->len = cpu_to_be32 ( sizeof ( *capacity16 ) );
573: command->data_in = virt_to_user ( capacity16 );
574: command->data_in_len = sizeof ( *capacity16 );
575: } else {
576: /* Use READ CAPACITY (10) */
577: readcap10->opcode = SCSI_OPCODE_READ_CAPACITY_10;
578: command->data_in = virt_to_user ( capacity10 );
579: command->data_in_len = sizeof ( *capacity10 );
580: }
581: }
582:
583: /**
584: * Handle SCSI READ CAPACITY command completion
585: *
586: * @v scsicmd SCSI command
587: * @v rc Reason for completion
588: */
589: static void scsicmd_read_capacity_done ( struct scsi_command *scsicmd,
590: int rc ) {
591: struct scsi_read_capacity_private *priv = scsicmd_priv ( scsicmd );
592: struct scsi_capacity_16 *capacity16 = &priv->capacity.capacity16;
593: struct scsi_capacity_10 *capacity10 = &priv->capacity.capacity10;
594: struct block_device_capacity capacity;
595:
596: /* Close if command failed */
597: if ( rc != 0 ) {
598: scsicmd_close ( scsicmd, rc );
599: return;
600: }
601:
602: /* Extract capacity */
603: if ( priv->use16 ) {
604: capacity.blocks = ( be64_to_cpu ( capacity16->lba ) + 1 );
605: capacity.blksize = be32_to_cpu ( capacity16->blksize );
606: } else {
607: capacity.blocks = ( be32_to_cpu ( capacity10->lba ) + 1 );
608: capacity.blksize = be32_to_cpu ( capacity10->blksize );
609:
610: /* If capacity range was exceeded (i.e. capacity.lba
611: * was 0xffffffff, meaning that blockdev->blocks is
612: * now zero), use READ CAPACITY (16) instead. READ
613: * CAPACITY (16) is not mandatory, so we can't just
614: * use it straight off.
615: */
616: if ( capacity.blocks == 0 ) {
617: priv->use16 = 1;
618: if ( ( rc = scsicmd_command ( scsicmd ) ) != 0 ) {
619: scsicmd_close ( scsicmd, rc );
620: return;
621: }
622: return;
623: }
624: }
625: capacity.max_count = -1U;
626:
627: /* Return capacity to caller */
628: block_capacity ( &scsicmd->block, &capacity );
629:
630: /* Close command */
631: scsicmd_close ( scsicmd, 0 );
632: }
633:
634: /** SCSI READ CAPACITY command type */
635: static struct scsi_command_type scsicmd_read_capacity = {
636: .name = "READ CAPACITY",
637: .priv_len = sizeof ( struct scsi_read_capacity_private ),
638: .cmd = scsicmd_read_capacity_cmd,
639: .done = scsicmd_read_capacity_done,
640: };
641:
642: /**
643: * Construct SCSI TEST UNIT READY command
644: *
645: * @v scsicmd SCSI command
646: * @v command SCSI command IU
647: */
648: static void scsicmd_test_unit_ready_cmd ( struct scsi_command *scsicmd __unused,
649: struct scsi_cmd *command ) {
650: struct scsi_cdb_test_unit_ready *testready = &command->cdb.testready;
651:
652: testready->opcode = SCSI_OPCODE_TEST_UNIT_READY;
653: }
654:
655: /** SCSI TEST UNIT READY command type */
656: static struct scsi_command_type scsicmd_test_unit_ready = {
657: .name = "TEST UNIT READY",
658: .cmd = scsicmd_test_unit_ready_cmd,
659: .done = scsicmd_close,
660: };
661:
662: /** SCSI command block interface operations */
663: static struct interface_operation scsicmd_block_op[] = {
664: INTF_OP ( intf_close, struct scsi_command *, scsicmd_close ),
665: };
666:
667: /** SCSI command block interface descriptor */
668: static struct interface_descriptor scsicmd_block_desc =
669: INTF_DESC_PASSTHRU ( struct scsi_command, block,
670: scsicmd_block_op, scsi );
671:
672: /** SCSI command SCSI interface operations */
673: static struct interface_operation scsicmd_scsi_op[] = {
674: INTF_OP ( intf_close, struct scsi_command *, scsicmd_done ),
675: INTF_OP ( scsi_response, struct scsi_command *, scsicmd_response ),
676: };
677:
678: /** SCSI command SCSI interface descriptor */
679: static struct interface_descriptor scsicmd_scsi_desc =
680: INTF_DESC_PASSTHRU ( struct scsi_command, scsi,
681: scsicmd_scsi_op, block );
682:
683: /**
684: * Create SCSI command
685: *
686: * @v scsidev SCSI device
687: * @v block Block data interface
688: * @v type SCSI command type
689: * @v lba Starting logical block address
690: * @v count Number of blocks to transfer
691: * @v buffer Data buffer
692: * @v len Length of data buffer
693: * @ret rc Return status code
694: */
695: static int scsidev_command ( struct scsi_device *scsidev,
696: struct interface *block,
697: struct scsi_command_type *type,
698: uint64_t lba, unsigned int count,
699: userptr_t buffer, size_t len ) {
700: struct scsi_command *scsicmd;
701: int rc;
702:
703: /* Allocate and initialise structure */
704: scsicmd = zalloc ( sizeof ( *scsicmd ) + type->priv_len );
705: if ( ! scsicmd ) {
706: rc = -ENOMEM;
707: goto err_zalloc;
708: }
709: ref_init ( &scsicmd->refcnt, scsicmd_free );
710: intf_init ( &scsicmd->block, &scsicmd_block_desc, &scsicmd->refcnt );
711: intf_init ( &scsicmd->scsi, &scsicmd_scsi_desc,
712: &scsicmd->refcnt );
713: scsicmd->scsidev = scsidev_get ( scsidev );
714: list_add ( &scsicmd->list, &scsidev->cmds );
715: scsicmd->type = type;
716: scsicmd->lba = lba;
717: scsicmd->count = count;
718: scsicmd->buffer = buffer;
719: scsicmd->len = len;
720:
721: /* Issue SCSI command */
722: if ( ( rc = scsicmd_command ( scsicmd ) ) != 0 )
723: goto err_command;
724:
725: /* Attach to parent interface, mortalise self, and return */
726: intf_plug_plug ( &scsicmd->block, block );
727: ref_put ( &scsicmd->refcnt );
728: return 0;
729:
730: err_command:
731: scsicmd_close ( scsicmd, rc );
732: ref_put ( &scsicmd->refcnt );
733: err_zalloc:
734: return rc;
735: }
736:
737: /**
738: * Issue SCSI block read
739: *
740: * @v scsidev SCSI device
741: * @v block Block data interface
742: * @v lba Starting logical block address
743: * @v count Number of blocks to transfer
744: * @v buffer Data buffer
745: * @v len Length of data buffer
746: * @ret rc Return status code
747:
748: */
749: static int scsidev_read ( struct scsi_device *scsidev,
750: struct interface *block,
751: uint64_t lba, unsigned int count,
752: userptr_t buffer, size_t len ) {
753: return scsidev_command ( scsidev, block, &scsicmd_read,
754: lba, count, buffer, len );
755: }
756:
757: /**
758: * Issue SCSI block write
759: *
760: * @v scsidev SCSI device
761: * @v block Block data interface
762: * @v lba Starting logical block address
763: * @v count Number of blocks to transfer
764: * @v buffer Data buffer
765: * @v len Length of data buffer
766: * @ret rc Return status code
767: */
768: static int scsidev_write ( struct scsi_device *scsidev,
769: struct interface *block,
770: uint64_t lba, unsigned int count,
771: userptr_t buffer, size_t len ) {
772: return scsidev_command ( scsidev, block, &scsicmd_write,
773: lba, count, buffer, len );
774: }
775:
776: /**
777: * Read SCSI device capacity
778: *
779: * @v scsidev SCSI device
780: * @v block Block data interface
781: * @ret rc Return status code
782: */
783: static int scsidev_read_capacity ( struct scsi_device *scsidev,
784: struct interface *block ) {
785: return scsidev_command ( scsidev, block, &scsicmd_read_capacity,
786: 0, 0, UNULL, 0 );
787: }
788:
789: /**
790: * Test to see if SCSI device is ready
791: *
792: * @v scsidev SCSI device
793: * @v block Block data interface
794: * @ret rc Return status code
795: */
796: static int scsidev_test_unit_ready ( struct scsi_device *scsidev,
797: struct interface *block ) {
798: return scsidev_command ( scsidev, block, &scsicmd_test_unit_ready,
799: 0, 0, UNULL, 0 );
800: }
801:
802: /**
803: * Check SCSI device flow-control window
804: *
805: * @v scsidev SCSI device
806: * @ret len Length of window
807: */
808: static size_t scsidev_window ( struct scsi_device *scsidev ) {
809:
810: /* Refuse commands until unit is confirmed ready */
811: if ( ! ( scsidev->flags & SCSIDEV_UNIT_READY ) )
812: return 0;
813:
814: return xfer_window ( &scsidev->scsi );
815: }
816:
817: /**
818: * Close SCSI device
819: *
820: * @v scsidev SCSI device
821: * @v rc Reason for close
822: */
823: static void scsidev_close ( struct scsi_device *scsidev, int rc ) {
824: struct scsi_command *scsicmd;
825: struct scsi_command *tmp;
826:
827: /* Stop process */
828: process_del ( &scsidev->process );
829:
830: /* Shut down interfaces */
831: intf_shutdown ( &scsidev->block, rc );
832: intf_shutdown ( &scsidev->scsi, rc );
833: intf_shutdown ( &scsidev->ready, rc );
834:
835: /* Shut down any remaining commands */
836: list_for_each_entry_safe ( scsicmd, tmp, &scsidev->cmds, list ) {
837: scsicmd_get ( scsicmd );
838: scsicmd_close ( scsicmd, rc );
839: scsicmd_put ( scsicmd );
840: }
841: }
842:
843: /** SCSI device block interface operations */
844: static struct interface_operation scsidev_block_op[] = {
845: INTF_OP ( xfer_window, struct scsi_device *, scsidev_window ),
846: INTF_OP ( block_read, struct scsi_device *, scsidev_read ),
847: INTF_OP ( block_write, struct scsi_device *, scsidev_write ),
848: INTF_OP ( block_read_capacity, struct scsi_device *,
849: scsidev_read_capacity ),
850: INTF_OP ( intf_close, struct scsi_device *, scsidev_close ),
851: };
852:
853: /** SCSI device block interface descriptor */
854: static struct interface_descriptor scsidev_block_desc =
855: INTF_DESC_PASSTHRU ( struct scsi_device, block,
856: scsidev_block_op, scsi );
857:
858: /**
859: * Handle SCSI TEST UNIT READY response
860: *
861: * @v scsidev SCSI device
862: * @v rc Reason for close
863: */
864: static void scsidev_ready ( struct scsi_device *scsidev, int rc ) {
865:
866: /* Shut down interface */
867: intf_shutdown ( &scsidev->ready, rc );
868:
869: /* Close device on failure */
870: if ( rc != 0 ) {
871: DBGC ( scsidev, "SCSI %p not ready: %s\n",
872: scsidev, strerror ( rc ) );
873: scsidev_close ( scsidev, rc );
874: return;
875: }
876:
877: /* Mark device as ready */
878: scsidev->flags |= SCSIDEV_UNIT_READY;
879: xfer_window_changed ( &scsidev->block );
880: DBGC ( scsidev, "SCSI %p unit is ready\n", scsidev );
881: }
882:
883: /** SCSI device TEST UNIT READY interface operations */
884: static struct interface_operation scsidev_ready_op[] = {
885: INTF_OP ( intf_close, struct scsi_device *, scsidev_ready ),
886: };
887:
888: /** SCSI device TEST UNIT READY interface descriptor */
889: static struct interface_descriptor scsidev_ready_desc =
890: INTF_DESC ( struct scsi_device, ready, scsidev_ready_op );
891:
892: /**
893: * SCSI TEST UNIT READY process
894: *
895: * @v process Process
896: */
897: static void scsidev_step ( struct process *process ) {
898: struct scsi_device *scsidev =
899: container_of ( process, struct scsi_device, process );
900: int rc;
901:
902: /* Wait until underlying SCSI device is ready */
903: if ( xfer_window ( &scsidev->scsi ) == 0 )
904: return;
905:
906: /* Stop process */
907: process_del ( &scsidev->process );
908:
909: DBGC ( scsidev, "SCSI %p waiting for unit to become ready\n",
910: scsidev );
911:
912: /* Issue TEST UNIT READY command */
913: if ( ( rc = scsidev_test_unit_ready ( scsidev, &scsidev->ready )) !=0){
914: scsidev_close ( scsidev, rc );
915: return;
916: }
917: }
918:
919: /** SCSI device SCSI interface operations */
920: static struct interface_operation scsidev_scsi_op[] = {
921: INTF_OP ( intf_close, struct scsi_device *, scsidev_close ),
922: };
923:
924: /** SCSI device SCSI interface descriptor */
925: static struct interface_descriptor scsidev_scsi_desc =
926: INTF_DESC_PASSTHRU ( struct scsi_device, scsi,
927: scsidev_scsi_op, block );
928:
929: /**
930: * Open SCSI device
931: *
932: * @v block Block control interface
933: * @v scsi SCSI control interface
934: * @v lun SCSI LUN
935: * @ret rc Return status code
936: */
937: int scsi_open ( struct interface *block, struct interface *scsi,
938: struct scsi_lun *lun ) {
939: struct scsi_device *scsidev;
940:
941: /* Allocate and initialise structure */
942: scsidev = zalloc ( sizeof ( *scsidev ) );
943: if ( ! scsidev )
944: return -ENOMEM;
945: ref_init ( &scsidev->refcnt, NULL );
946: intf_init ( &scsidev->block, &scsidev_block_desc, &scsidev->refcnt );
947: intf_init ( &scsidev->scsi, &scsidev_scsi_desc, &scsidev->refcnt );
948: intf_init ( &scsidev->ready, &scsidev_ready_desc, &scsidev->refcnt );
949: process_init ( &scsidev->process, scsidev_step, &scsidev->refcnt );
950: INIT_LIST_HEAD ( &scsidev->cmds );
951: memcpy ( &scsidev->lun, lun, sizeof ( scsidev->lun ) );
952: DBGC ( scsidev, "SCSI %p created for LUN " SCSI_LUN_FORMAT "\n",
953: scsidev, SCSI_LUN_DATA ( scsidev->lun ) );
954:
955: /* Attach to SCSI and parent interfaces, mortalise self, and return */
956: intf_plug_plug ( &scsidev->scsi, scsi );
957: intf_plug_plug ( &scsidev->block, block );
958: ref_put ( &scsidev->refcnt );
959: return 0;
960: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.