source: grub-pc/trunk/fuentes/debian/grub-extras/disabled/gpxe/src/include/gpxe/srp.h @ 22

Last change on this file since 22 was 22, checked in by mabarracus, 4 years ago

updated version and apply net.ifnames=0 into debian/rules

File size: 21.4 KB
Line 
1#ifndef _GPXE_SRP_H
2#define _GPXE_SRP_H
3
4/** @file
5 *
6 * SCSI RDMA Protocol
7 *
8 */
9
10FILE_LICENCE ( BSD2 );
11
12#include <stdint.h>
13#include <byteswap.h>
14#include <gpxe/iobuf.h>
15#include <gpxe/xfer.h>
16#include <gpxe/scsi.h>
17
18/*****************************************************************************
19 *
20 * Common fields
21 *
22 *****************************************************************************
23 */
24
25/** An SRP information unit tag */
26struct srp_tag {
27        uint32_t dwords[2];
28} __attribute__ (( packed ));
29
30/** An SRP port ID */
31struct srp_port_id {
32        uint8_t bytes[16];
33} __attribute__ (( packed ));
34
35/** An SRP port ID pair */
36struct srp_port_ids {
37        /** Initiator port ID */
38        struct srp_port_id initiator;
39        /** Target port ID */
40        struct srp_port_id target;
41} __attribute__ (( packed ));
42
43/** SRP information unit common fields */
44struct srp_common {
45        /** Information unit type */
46        uint8_t type;
47        /** Reserved */
48        uint8_t reserved0[7];
49        /** Tag */
50        struct srp_tag tag;
51} __attribute__ (( packed ));
52
53/*****************************************************************************
54 *
55 * Login request
56 *
57 *****************************************************************************
58 */
59
60/** An SRP login request information unit */
61struct srp_login_req {
62        /** Information unit type
63         *
64         * This must be @c SRP_LOGIN_REQ
65         */
66        uint8_t type;
67        /** Reserved */
68        uint8_t reserved0[7];
69        /** Tag */
70        struct srp_tag tag;
71        /** Requested maximum initiator to target IU length */
72        uint32_t max_i_t_iu_len;
73        /** Reserved */
74        uint8_t reserved1[4];
75        /** Required buffer formats
76         *
77         * This is the bitwise OR of one or more @c
78         * SRP_LOGIN_REQ_FMT_XXX constants.
79         */
80        uint16_t required_buffer_formats;
81        /** Flags
82         *
83         * This is the bitwise OR of zero or more @c
84         * SRP_LOGIN_REQ_FLAG_XXX and @c SRP_LOGIN_REQ_MCA_XXX
85         * constants.
86         */
87        uint8_t flags;
88        /** Reserved */
89        uint8_t reserved2[5];
90        /** Initiator and target port identifiers */
91        struct srp_port_ids port_ids;
92} __attribute__ (( packed ));
93
94/** Type of an SRP login request */
95#define SRP_LOGIN_REQ 0x00
96
97/** Require indirect data buffer descriptor format */
98#define SRP_LOGIN_REQ_FMT_IDBD 0x04
99
100/** Require direct data buffer descriptor format */
101#define SRP_LOGIN_REQ_FMT_DDBD 0x02
102
103/** Use solicited notification for asynchronous events */
104#define SRP_LOGIN_REQ_FLAG_AESOLNT 0x40
105
106/** Use solicited notification for credit request */
107#define SRP_LOGIN_REQ_FLAG_CRSOLNT 0x20
108
109/** Use solicited notification for logouts */
110#define SRP_LOGIN_REQ_FLAG_LOSOLNT 0x10
111
112/** Multi-channel action mask */
113#define SRP_LOGIN_REQ_MCA_MASK 0x03
114
115/** Single RDMA channel operation */
116#define SRP_LOGIN_REQ_MCA_SINGLE_CHANNEL 0x00
117
118/** Multiple independent RDMA channel operation */
119#define SRP_LOGIN_REQ_MCA_MULTIPLE_CHANNELS 0x01
120
121/*****************************************************************************
122 *
123 * Login response
124 *
125 *****************************************************************************
126 */
127
128/** An SRP login response */
129struct srp_login_rsp {
130        /** Information unit type
131         *
132         * This must be @c SRP_LOGIN_RSP
133         */
134        uint8_t type;
135        /** Reserved */
136        uint8_t reserved0[3];
137        /** Request limit delta */
138        uint32_t request_limit_delta;
139        /** Tag */
140        struct srp_tag tag;
141        /** Maximum initiator to target IU length */
142        uint32_t max_i_t_iu_len;
143        /** Maximum target to initiator IU length */
144        uint32_t max_t_i_iu_len;
145        /** Supported buffer formats
146         *
147         * This is the bitwise OR of one or more @c
148         * SRP_LOGIN_RSP_FMT_XXX constants.
149         */
150        uint16_t supported_buffer_formats;
151        /** Flags
152         *
153         * This is the bitwise OR of zero or more @c
154         * SRP_LOGIN_RSP_FLAG_XXX and @c SRP_LOGIN_RSP_MCR_XXX
155         * constants.
156         */
157        uint8_t flags;
158        /** Reserved */
159        uint8_t reserved1[25];
160} __attribute__ (( packed ));
161
162/** Type of an SRP login response */
163#define SRP_LOGIN_RSP 0xc0
164
165/** Indirect data buffer descriptor format supported */
166#define SRP_LOGIN_RSP_FMT_IDBD 0x04
167
168/** Direct data buffer descriptor format supported */
169#define SRP_LOGIN_RSP_FMT_DDBD 0x02
170
171/** Solicited notification is supported */
172#define SRP_LOGIN_RSP_FLAG_SOLNTSUP 0x10
173
174/** Multi-channel result mask */
175#define SRP_LOGIN_RSP_MCR_MASK 0x03
176
177/** No existing RDMA channels were associated with the same I_T nexus */
178#define SRP_LOGIN_RSP_MCR_NO_EXISTING_CHANNELS 0x00
179
180/** One or more existing RDMA channels were terminated */
181#define SRP_LOGIN_RSP_MCR_EXISTING_CHANNELS_TERMINATED 0x01
182
183/** One or more existing RDMA channels continue to operate independently */
184#define SRP_LOGIN_RSP_MCR_EXISTING_CHANNELS_CONTINUE 0x02
185
186/*****************************************************************************
187 *
188 * Login rejection
189 *
190 *****************************************************************************
191 */
192
193/** An SRP login rejection */
194struct srp_login_rej {
195        /** Information unit type
196         *
197         * This must be @c SRP_LOGIN_REJ
198         */
199        uint8_t type;
200        /** Reserved */
201        uint8_t reserved0[3];
202        /** Reason
203         *
204         * This is a @c SRP_LOGIN_REJ_REASON_XXX constant.
205         */
206        uint32_t reason;
207        /** Tag */
208        struct srp_tag tag;
209        /** Reserved */
210        uint8_t reserved1[8];
211        /** Supported buffer formats
212         *
213         * This is the bitwise OR of one or more @c
214         * SRP_LOGIN_REJ_FMT_XXX constants.
215         */
216        uint16_t supported_buffer_formats;
217        /** Reserved */
218        uint8_t reserved2[6];
219} __attribute__ (( packed ));
220
221/** Type of an SRP login rejection */
222#define SRP_LOGIN_REJ 0xc2
223
224/** Unable to establish RDMA channel, no reason specified */
225#define SRP_LOGIN_REJ_REASON_UNKNOWN 0x00010000UL
226
227/** Insufficient RDMA channel resources */
228#define SRP_LOGIN_REJ_REASON_INSUFFICIENT_RESOURCES 0x00010001UL
229
230/** Requested maximum initiator to target IU length value too large */
231#define SRP_LOGIN_REJ_REASON_BAD_MAX_I_T_IU_LEN 0x00010002UL
232
233/** Unable to associate RDMA channel with specified I_T nexus */
234#define SRP_LOGIN_REJ_REASON_CANNOT_ASSOCIATE 0x00010003UL
235
236/** One or more requested data buffer descriptor formats are not supported */
237#define SRP_LOGIN_REJ_REASON_UNSUPPORTED_BUFFER_FORMAT 0x00010004UL
238
239/** SRP target port does not support multiple RDMA channels per I_T nexus */
240#define SRP_LOGIN_REJ_REASON_NO_MULTIPLE_CHANNELS 0x00010005UL
241
242/** RDMA channel limit reached for this initiator */
243#define SRP_LOGIN_REJ_REASON_NO_MORE_CHANNELS 0x00010006UL
244
245/** Indirect data buffer descriptor format supported */
246#define SRP_LOGIN_REJ_FMT_IDBD 0x04
247
248/** Direct data buffer descriptor format supported */
249#define SRP_LOGIN_REJ_FMT_DDBD 0x02
250
251/*****************************************************************************
252 *
253 * Initiator logout
254 *
255 *****************************************************************************
256 */
257
258/** An SRP initiator logout request */
259struct srp_i_logout {
260        /** Information unit type
261         *
262         * This must be @c SRP_I_LOGOUT
263         */
264        uint8_t type;
265        /** Reserved */
266        uint8_t reserved0[7];
267        /** Tag */
268        struct srp_tag tag;
269} __attribute__ (( packed ));
270
271/** Type of an SRP initiator logout request */
272#define SRP_I_LOGOUT 0x03
273
274/*****************************************************************************
275 *
276 * Target logout
277 *
278 *****************************************************************************
279 */
280
281/** An SRP target logout request */
282struct srp_t_logout {
283        /** Information unit type
284         *
285         * This must be @c SRP_T_LOGOUT
286         */
287        uint8_t type;
288        /** Flags
289         *
290         * This is the bitwise OR of zero or more @c
291         * SRP_T_LOGOUT_FLAG_XXX constants.
292         */
293        uint8_t flags;
294        /** Reserved */
295        uint8_t reserved0[2];
296        /** Reason
297         *
298         * This is a @c SRP_T_LOGOUT_REASON_XXX constant.
299         */
300        uint32_t reason;
301        /** Tag */
302        struct srp_tag tag;
303} __attribute__ (( packed ));
304
305/** Type of an SRP target logout request */
306#define SRP_T_LOGOUT 0x80
307
308/** The initiator specified solicited notification of logouts */
309#define SRP_T_LOGOUT_FLAG_SOLNT 0x01
310
311/** No reason specified */
312#define SRP_T_LOGOUT_REASON_UNKNOWN 0x00000000UL
313
314/** Inactive RDMA channel (reclaiming resources) */
315#define SRP_T_LOGOUT_REASON_INACTIVE 0x00000001UL
316
317/** Invalid information unit type code received by SRP target port */
318#define SRP_T_LOGOUT_REASON_INVALID_TYPE 0x00000002UL
319
320/** SRP initiator port sent response with no corresponding request */
321#define SRP_T_LOGOUT_REASON_SPURIOUS_RESPONSE 0x00000003UL
322
323/** RDMA channel disconnected due to multi-channel action code in new login */
324#define SRP_T_LOGOUT_REASON_MCA 0x00000004UL
325
326/** Unsuppported format code value specified in data-out buffer descriptor */
327#define SRP_T_LOGOUT_UNSUPPORTED_DATA_OUT_FORMAT 0x00000005UL
328
329/** Unsuppported format code value specified in data-in buffer descriptor */
330#define SRP_T_LOGOUT_UNSUPPORTED_DATA_IN_FORMAT 0x00000006UL
331
332/** Invalid length for IU type */
333#define SRP_T_LOGOUT_INVALID_IU_LEN 0x00000008UL
334
335/*****************************************************************************
336 *
337 * Task management
338 *
339 *****************************************************************************
340 */
341
342/** An SRP task management request */
343struct srp_tsk_mgmt {
344        /** Information unit type
345         *
346         * This must be @c SRP_TSK_MGMT
347         */
348        uint8_t type;
349        /** Flags
350         *
351         * This is the bitwise OR of zero or more
352         * @c SRP_TSK_MGMT_FLAG_XXX constants.
353         */
354        uint8_t flags;
355        /** Reserved */
356        uint8_t reserved0[6];
357        /** Tag */
358        struct srp_tag tag;
359        /** Reserved */
360        uint8_t reserved1[4];
361        /** Logical unit number */
362        struct scsi_lun lun;
363        /** Reserved */
364        uint8_t reserved2[2];
365        /** Task management function
366         *
367         * This is a @c SRP_TASK_MGMT_FUNC_XXX constant
368         */
369        uint8_t function;
370        /** Reserved */
371        uint8_t reserved3[1];
372        /** Tag of task to be managed */
373        struct srp_tag managed_tag;
374        /** Reserved */
375        uint8_t reserved4[8];
376} __attribute__ (( packed ));
377
378/** Type of an SRP task management request */
379#define SRP_TSK_MGMT 0x01
380
381/** Use solicited notification for unsuccessful completions */
382#define SRP_TSK_MGMT_FLAG_UCSOLNT 0x04
383
384/** Use solicited notification for successful completions */
385#define SRP_TSK_MGMT_FLAG_SCSOLNT 0x02
386
387/** The task manager shall perform an ABORT TASK function */
388#define SRP_TSK_MGMT_FUNC_ABORT_TASK 0x01
389
390/** The task manager shall perform an ABORT TASK SET function */
391#define SRP_TSK_MGMT_FUNC_ABORT_TASK_SET 0x02
392
393/** The task manager shall perform a CLEAR TASK SET function */
394#define SRP_TSK_MGMT_FUNC_CLEAR_TASK_SET 0x04
395
396/** The task manager shall perform a LOGICAL UNIT RESET function */
397#define SRP_TSK_MGMT_FUNC_LOGICAL_UNIT_RESET 0x08
398
399/** The task manager shall perform a CLEAR ACA function */
400#define SRP_TSK_MGMT_FUNC_CLEAR_ACA 0x40
401
402/*****************************************************************************
403 *
404 * SCSI command
405 *
406 *****************************************************************************
407 */
408
409/** An SRP SCSI command */
410struct srp_cmd {
411        /** Information unit type
412         *
413         * This must be @c SRP_CMD
414         */
415        uint8_t type;
416        /** Flags
417         *
418         * This is the bitwise OR of zero or more @c SRP_CMD_FLAG_XXX
419         * constants.
420         */
421        uint8_t flags;
422        /** Reserved */
423        uint8_t reserved0[3];
424        /** Data buffer descriptor formats
425         *
426         * This is the bitwise OR of one @c SRP_CMD_DO_FMT_XXX and one @c
427         * SRP_CMD_DI_FMT_XXX constant.
428         */
429        uint8_t data_buffer_formats;
430        /** Data-out buffer descriptor count */
431        uint8_t data_out_buffer_count;
432        /** Data-in buffer descriptor count */
433        uint8_t data_in_buffer_count;
434        /** Tag */
435        struct srp_tag tag;
436        /** Reserved */
437        uint8_t reserved1[4];
438        /** Logical unit number */
439        struct scsi_lun lun;
440        /** Reserved */
441        uint8_t reserved2[1];
442        /** Task attribute
443         *
444         * This is a @c SRP_CMD_TASK_ATTR_XXX constant.
445         */
446        uint8_t task_attr;
447        /** Reserved */
448        uint8_t reserved3[1];
449        /** Additional CDB length */
450        uint8_t additional_cdb_len;
451        /** Command data block */
452        union scsi_cdb cdb;
453} __attribute__ (( packed ));
454
455/** Type of an SRP SCSI command */
456#define SRP_CMD 0x02
457
458/** Use solicited notification for unsuccessful completions */
459#define SRP_CMD_FLAG_UCSOLNT 0x04
460
461/** Use solicited notification for successful completions */
462#define SRP_CMD_FLAG_SCSOLNT 0x02
463
464/** Data-out buffer format mask */
465#define SRP_CMD_DO_FMT_MASK 0xf0
466
467/** Direct data-out buffer format */
468#define SRP_CMD_DO_FMT_DIRECT 0x10
469
470/** Indirect data-out buffer format */
471#define SRP_CMD_DO_FMT_INDIRECT 0x20
472
473/** Data-in buffer format mask */
474#define SRP_CMD_DI_FMT_MASK 0x0f
475
476/** Direct data-in buffer format */
477#define SRP_CMD_DI_FMT_DIRECT 0x01
478
479/** Indirect data-in buffer format */
480#define SRP_CMD_DI_FMT_INDIRECT 0x02
481
482/** Use the rules for a simple task attribute */
483#define SRP_CMD_TASK_ATTR_SIMPLE 0x00
484
485/** Use the rules for a head of queue task attribute */
486#define SRP_CMD_TASK_ATTR_QUEUE_HEAD 0x01
487
488/** Use the rules for an ordered task attribute */
489#define SRP_CMD_TASK_ATTR_ORDERED 0x02
490
491/** Use the rules for an automatic contingent allegiance task attribute */
492#define SRP_CMD_TASK_ATTR_AUTOMATIC_CONTINGENT_ALLEGIANCE 0x08
493
494/** An SRP memory descriptor */
495struct srp_memory_descriptor {
496        /** Virtual address */
497        uint64_t address;
498        /** Memory handle */
499        uint32_t handle;
500        /** Data length */
501        uint32_t len;
502} __attribute__ (( packed ));
503
504/*****************************************************************************
505 *
506 * SCSI response
507 *
508 *****************************************************************************
509 */
510
511/** An SRP SCSI response */
512struct srp_rsp {
513        /** Information unit type
514         *
515         * This must be @c SRP_RSP
516         */
517        uint8_t type;
518        /** Flags
519         *
520         * This is the bitwise OR of zero or more @c SRP_RSP_FLAG_XXX
521         * constants.
522         */
523        uint8_t flags;
524        /** Reserved */
525        uint8_t reserved0[2];
526        /** Request limit delta */
527        uint32_t request_limit_delta;
528        /** Tag */
529        struct srp_tag tag;
530        /** Reserved */
531        uint8_t reserved1[2];
532        /** Valid fields
533         *
534         * This is the bitwise OR of zero or more @c SRP_RSP_VALID_XXX
535         * constants.
536         */
537        uint8_t valid;
538        /** Status
539         *
540         * This is the SCSI status code.
541         */
542        uint8_t status;
543        /** Data-out residual count */
544        uint32_t data_out_residual_count;
545        /** Data-in residual count */
546        uint32_t data_in_residual_count;
547        /** Sense data list length */
548        uint32_t sense_data_len;
549        /** Response data list length */
550        uint32_t response_data_len;
551} __attribute__ (( packed ));
552
553/** Type of an SRP SCSI response */
554#define SRP_RSP 0xc1
555
556/** The initiator specified solicited notification of this response */
557#define SRP_RSP_FLAG_SOLNT 0x01
558
559/** Data-in residual count field is valid and represents an underflow */
560#define SRP_RSP_VALID_DIUNDER 0x20
561
562/** Data-in residual count field is valid and represents an overflow */
563#define SRP_RSP_VALID_DIOVER 0x10
564
565/** Data-out residual count field is valid and represents an underflow */
566#define SRP_RSP_VALID_DOUNDER 0x08
567
568/** Data-out residual count field is valid and represents an overflow */
569#define SRP_RSP_VALID_DOOVER 0x04
570
571/** Sense data list length field is valid */
572#define SRP_RSP_VALID_SNSVALID 0x02
573
574/** Response data list length field is valid */
575#define SRP_RSP_VALID_RSPVALID 0x01
576
577/**
578 * Get response data portion of SCSI response
579 *
580 * @v rsp                       SCSI response
581 * @ret response_data           Response data, or NULL if not present
582 */
583static inline void * srp_rsp_response_data ( struct srp_rsp *rsp ) {
584        return ( ( rsp->valid & SRP_RSP_VALID_RSPVALID ) ?
585                 ( ( ( void * ) rsp ) + sizeof ( *rsp ) ) : NULL );
586}
587
588/**
589 * Get length of response data portion of SCSI response
590 *
591 * @v rsp                       SCSI response
592 * @ret response_data_len       Response data length
593 */
594static inline size_t srp_rsp_response_data_len ( struct srp_rsp *rsp ) {
595        return ( ( rsp->valid & SRP_RSP_VALID_RSPVALID ) ?
596                 ntohl ( rsp->response_data_len ) : 0 );
597}
598
599/**
600 * Get sense data portion of SCSI response
601 *
602 * @v rsp                       SCSI response
603 * @ret sense_data              Sense data, or NULL if not present
604 */
605static inline void * srp_rsp_sense_data ( struct srp_rsp *rsp ) {
606        return ( ( rsp->valid & SRP_RSP_VALID_SNSVALID ) ?
607                 ( ( ( void * ) rsp ) + sizeof ( *rsp ) +
608                   srp_rsp_response_data_len ( rsp ) ) : NULL );
609}
610
611/**
612 * Get length of sense data portion of SCSI response
613 *
614 * @v rsp                       SCSI response
615 * @ret sense_data_len          Sense data length
616 */
617static inline size_t srp_rsp_sense_data_len ( struct srp_rsp *rsp ) {
618        return ( ( rsp->valid & SRP_RSP_VALID_SNSVALID ) ?
619                 ntohl ( rsp->sense_data_len ) : 0 );
620}
621
622/*****************************************************************************
623 *
624 * Credit request
625 *
626 *****************************************************************************
627 */
628
629/** An SRP credit request */
630struct srp_cred_req {
631        /** Information unit type
632         *
633         * This must be @c SRP_CRED_REQ
634         */
635        uint8_t type;
636        /** Flags
637         *
638         * This is the bitwise OR of zero or more
639         * @c SRP_CRED_REQ_FLAG_XXX constants.
640         */
641        uint8_t flags;
642        /** Reserved */
643        uint8_t reserved0[2];
644        /** Request limit delta */
645        uint32_t request_limit_delta;
646        /** Tag */
647        struct srp_tag tag;
648} __attribute__ (( packed ));
649
650/** Type of an SRP credit request */
651#define SRP_CRED_REQ 0x81
652
653/** The initiator specified solicited notification of credit requests */
654#define SRP_CRED_REQ_FLAG_SOLNT 0x01
655
656/*****************************************************************************
657 *
658 * Credit response
659 *
660 *****************************************************************************
661 */
662
663/** An SRP credit response */
664struct srp_cred_rsp {
665        /** Information unit type
666         *
667         * This must be @c SRP_CRED_RSP
668         */
669        uint8_t type;
670        /** Reserved */
671        uint8_t reserved0[7];
672        /** Tag */
673        struct srp_tag tag;
674} __attribute__ (( packed ));
675
676/** Type of an SRP credit response */
677#define SRP_CRED_RSP 0x41
678
679/*****************************************************************************
680 *
681 * Asynchronous event request
682 *
683 *****************************************************************************
684 */
685
686/** An SRP asynchronous event request */
687struct srp_aer_req {
688        /** Information unit type
689         *
690         * This must be @c SRP_AER_REQ
691         */
692        uint8_t type;
693        /** Flags
694         *
695         * This is the bitwise OR of zero or more @c
696         * SRP_AER_REQ_FLAG_XXX constants.
697         */
698        uint8_t flags;
699        /** Reserved */
700        uint8_t reserved0[2];
701        /** Request limit delta */
702        uint32_t request_limit_delta;
703        /** Tag */
704        struct srp_tag tag;
705        /** Reserved */
706        uint8_t reserved1[4];
707        /** Logical unit number */
708        struct scsi_lun lun;
709        /** Sense data list length */
710        uint32_t sense_data_len;
711        /** Reserved */
712        uint8_t reserved2[4];
713} __attribute__ (( packed ));
714
715/** Type of an SRP asynchronous event request */
716#define SRP_AER_REQ 0x82
717
718/** The initiator specified solicited notification of asynchronous events */
719#define SRP_AER_REQ_FLAG_SOLNT 0x01
720
721/**
722 * Get sense data portion of asynchronous event request
723 *
724 * @v aer_req                   SRP asynchronous event request
725 * @ret sense_data              Sense data
726 */
727static inline __always_inline void *
728srp_aer_req_sense_data ( struct srp_aer_req *aer_req ) {
729        return ( ( ( void * ) aer_req ) + sizeof ( *aer_req ) );
730}
731
732/**
733 * Get length of sense data portion of asynchronous event request
734 *
735 * @v aer_req                   SRP asynchronous event request
736 * @ret sense_data_len          Sense data length
737 */
738static inline __always_inline size_t
739srp_aer_req_sense_data_len ( struct srp_aer_req *aer_req ) {
740        return ( ntohl ( aer_req->sense_data_len ) );
741}
742
743/*****************************************************************************
744 *
745 * Asynchronous event response
746 *
747 *****************************************************************************
748 */
749
750/** An SRP asynchronous event response */
751struct srp_aer_rsp {
752        /** Information unit type
753         *
754         * This must be @c SRP_AER_RSP
755         */
756        uint8_t type;
757        /** Reserved */
758        uint8_t reserved0[7];
759        /** Tag */
760        struct srp_tag tag;
761} __attribute__ (( packed ));
762
763/** Type of an SRP asynchronous event response */
764#define SRP_AER_RSP 0x42
765
766/*****************************************************************************
767 *
768 * Information units
769 *
770 *****************************************************************************
771 */
772
773/** Maximum length of any initiator-to-target IU that we will send
774 *
775 * The longest IU is a SRP_CMD with no additional CDB and two direct
776 * data buffer descriptors, which comes to 80 bytes.
777 */
778#define SRP_MAX_I_T_IU_LEN 80
779
780/*****************************************************************************
781 *
782 * SRP device
783 *
784 *****************************************************************************
785 */
786
787struct srp_device;
788
789/** An SRP transport type */
790struct srp_transport_type {
791        /** Length of transport private data */
792        size_t priv_len;
793        /** Parse root path
794         *
795         * @v srp               SRP device
796         * @v root_path         Root path
797         * @ret                 Return status code
798         */
799        int ( * parse_root_path ) ( struct srp_device *srp,
800                                    const char *root_path );
801        /** Connect SRP session
802         *
803         * @v srp               SRP device
804         * @ret rc              Return status code
805         *
806         * This method should open the underlying socket.
807         */
808        int ( * connect ) ( struct srp_device *srp );
809};
810
811/** An SRP device */
812struct srp_device {
813        /** Reference count */
814        struct refcnt refcnt;
815
816        /** Initiator and target port IDs */
817        struct srp_port_ids port_ids;
818        /** Logical unit number */
819        struct scsi_lun lun;
820        /** Memory handle */
821        uint32_t memory_handle;
822
823        /** Current state
824         *
825         * This is the bitwise-OR of zero or more @c SRP_STATE_XXX
826         * flags.
827         */
828        unsigned int state;
829        /** Retry counter */
830        unsigned int retry_count;
831        /** Current SCSI command */
832        struct scsi_command *command;
833
834        /** Underlying data transfer interface */
835        struct xfer_interface socket;
836
837        /** Transport type */
838        struct srp_transport_type *transport;
839        /** Transport private data */
840        char transport_priv[0];
841};
842
843/**
844 * Get SRP transport private data
845 *
846 * @v srp               SRP device
847 * @ret priv            SRP transport private data
848 */
849static inline __always_inline void *
850srp_transport_priv ( struct srp_device *srp ) {
851        return ( ( void * ) srp->transport_priv );
852}
853
854/** SRP state flags */
855enum srp_state {
856        /** Underlying socket is open */
857        SRP_STATE_SOCKET_OPEN = 0x0001,
858        /** Session is logged in */
859        SRP_STATE_LOGGED_IN = 0x0002,
860};
861
862/** Maximum number of SRP retry attempts */
863#define SRP_MAX_RETRIES 3
864
865extern int srp_attach ( struct scsi_device *scsi, const char *root_path );
866extern void srp_detach ( struct scsi_device *scsi );
867
868#endif /* _GPXE_SRP_H */
Note: See TracBrowser for help on using the repository browser.