![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fc.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 fc.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 <stdlib.h>
23: #include <string.h>
24: #include <stdio.h>
25: #include <errno.h>
26: #include <assert.h>
27: #include <byteswap.h>
28: #include <ipxe/refcnt.h>
29: #include <ipxe/list.h>
30: #include <ipxe/tables.h>
31: #include <ipxe/timer.h>
32: #include <ipxe/retry.h>
33: #include <ipxe/interface.h>
34: #include <ipxe/xfer.h>
35: #include <ipxe/iobuf.h>
36: #include <ipxe/fc.h>
37: #include <ipxe/fcels.h>
38: #include <ipxe/fcns.h>
39:
40: /** @file
41: *
42: * Fibre Channel
43: *
44: */
45:
46: /** List of Fibre Channel ports */
47: LIST_HEAD ( fc_ports );
48:
49: /** List of Fibre Channel peers */
50: LIST_HEAD ( fc_peers );
51:
52: /******************************************************************************
53: *
54: * Well-known addresses
55: *
56: ******************************************************************************
57: */
58:
59: /** Unassigned port ID */
60: struct fc_port_id fc_empty_port_id = { .bytes = { 0x00, 0x00, 0x00 } };
61:
62: /** F_Port contoller port ID */
63: struct fc_port_id fc_f_port_id = { .bytes = { 0xff, 0xff, 0xfe } };
64:
65: /** Generic services port ID */
66: struct fc_port_id fc_gs_port_id = { .bytes = { 0xff, 0xff, 0xfc } };
67:
68: /** Point-to-point low port ID */
69: struct fc_port_id fc_ptp_low_port_id = { .bytes = { 0x01, 0x01, 0x01 } };
70:
71: /** Point-to-point high port ID */
72: struct fc_port_id fc_ptp_high_port_id = { .bytes = { 0x01, 0x01, 0x02 } };
73:
74: /******************************************************************************
75: *
76: * Utility functions
77: *
78: ******************************************************************************
79: */
80:
81: /**
82: * Format Fibre Channel port ID
83: *
84: * @v id Fibre Channel port ID
85: * @ret id_text Port ID text
86: */
87: const char * fc_id_ntoa ( const struct fc_port_id *id ) {
88: static char id_text[ FC_PORT_ID_STRLEN + 1 /* NUL */ ];
89:
90: snprintf ( id_text, sizeof ( id_text ), "%02x.%02x.%02x",
91: id->bytes[0], id->bytes[1], id->bytes[2] );
92: return id_text;
93: }
94:
95: /**
96: * Parse Fibre Channel port ID
97: *
98: * @v id_text Port ID text
99: * @ret id Fibre Channel port ID
100: * @ret rc Return status code
101: */
102: int fc_id_aton ( const char *id_text, struct fc_port_id *id ) {
103: char *ptr = ( ( char * ) id_text );
104: unsigned int i = 0;
105:
106: while ( 1 ) {
107: id->bytes[i++] = strtoul ( ptr, &ptr, 16 );
108: if ( i == sizeof ( id->bytes ) )
109: return ( ( *ptr == '\0' ) ? 0 : -EINVAL );
110: if ( *ptr != '.' )
111: return -EINVAL;
112: ptr++;
113: }
114: }
115:
116: /**
117: * Format Fibre Channel WWN
118: *
119: * @v wwn Fibre Channel WWN
120: * @ret wwn_text WWN text
121: */
122: const char * fc_ntoa ( const struct fc_name *wwn ) {
123: static char wwn_text[ FC_NAME_STRLEN + 1 /* NUL */ ];
124:
125: snprintf ( wwn_text, sizeof ( wwn_text ),
126: "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
127: wwn->bytes[0], wwn->bytes[1], wwn->bytes[2], wwn->bytes[3],
128: wwn->bytes[4], wwn->bytes[5], wwn->bytes[6], wwn->bytes[7] );
129: return wwn_text;
130: }
131:
132: /**
133: * Parse Fibre Channel WWN
134: *
135: * @v wwn_text WWN text
136: * @ret wwn Fibre Channel WWN
137: * @ret rc Return status code
138: */
139: int fc_aton ( const char *wwn_text, struct fc_name *wwn ) {
140: char *ptr = ( ( char * ) wwn_text );
141: unsigned int i = 0;
142:
143: while ( 1 ) {
144: wwn->bytes[i++] = strtoul ( ptr, &ptr, 16 );
145: if ( i == sizeof ( wwn->bytes ) )
146: return ( ( *ptr == '\0' ) ? 0 : -EINVAL );
147: if ( *ptr != ':' )
148: return -EINVAL;
149: ptr++;
150: }
151: }
152:
153: /**
154: * Fill Fibre Channel socket address
155: *
156: * @v sa_fc Fibre Channel socket address to fill in
157: * @v id Fibre Channel port ID
158: * @ret sa Socket address
159: */
160: struct sockaddr * fc_fill_sockaddr ( struct sockaddr_fc *sa_fc,
161: struct fc_port_id *id ) {
162: union {
163: struct sockaddr sa;
164: struct sockaddr_fc fc;
165: } *u = container_of ( sa_fc, typeof ( *u ), fc );
166:
167: memset ( sa_fc, 0, sizeof ( *sa_fc ) );
168: sa_fc->sfc_family = AF_FC;
169: memcpy ( &sa_fc->sfc_port_id, id, sizeof ( sa_fc->sfc_port_id ) );
170: return &u->sa;
171: }
172:
173: /******************************************************************************
174: *
175: * Fibre Channel link state
176: *
177: ******************************************************************************
178: */
179:
180: /** Default link status code */
181: #define EUNKNOWN_LINK_STATUS __einfo_error ( EINFO_EUNKNOWN_LINK_STATUS )
182: #define EINFO_EUNKNOWN_LINK_STATUS \
183: __einfo_uniqify ( EINFO_EINPROGRESS, 0x01, "Unknown" )
184:
185: /**
186: * Mark Fibre Channel link as up
187: *
188: * @v link Fibre Channel link state monitor
189: */
190: static void fc_link_up ( struct fc_link_state *link ) {
191:
192: /* Stop retry timer */
193: stop_timer ( &link->timer );
194:
195: /* Record link state */
196: link->rc = 0;
197: }
198:
199: /**
200: * Mark Fibre Channel link as down
201: *
202: * @v link Fibre Channel link state monitor
203: * @v rc Link state
204: */
205: static void fc_link_err ( struct fc_link_state *link, int rc ) {
206:
207: /* Record link state */
208: if ( rc == 0 )
209: rc = -EUNKNOWN_LINK_STATUS;
210: link->rc = rc;
211:
212: /* Schedule another link examination */
213: start_timer_fixed ( &link->timer, FC_LINK_RETRY_DELAY );
214: }
215:
216: /**
217: * Examine Fibre Channel link state
218: *
219: * @v link Fibre Channel link state monitor
220: */
221: static void fc_link_examine ( struct fc_link_state *link ) {
222:
223: link->examine ( link );
224: }
225:
226: /**
227: * Handle Fibre Channel link retry timer expiry
228: */
229: static void fc_link_expired ( struct retry_timer *timer, int over __unused ) {
230: struct fc_link_state *link =
231: container_of ( timer, struct fc_link_state, timer );
232:
233: /* Schedule another link examination */
234: start_timer_fixed ( &link->timer, FC_LINK_RETRY_DELAY );
235:
236: /* Examine link */
237: fc_link_examine ( link );
238: }
239:
240: /**
241: * Initialise Fibre Channel link state monitor
242: *
243: * @v link Fibre Channel link state monitor
244: * @v examine Examine link state method
245: * @v refcnt Reference counter
246: */
247: static void fc_link_init ( struct fc_link_state *link,
248: void ( * examine ) ( struct fc_link_state *link ),
249: struct refcnt *refcnt ) {
250:
251: link->rc = -EUNKNOWN_LINK_STATUS;
252: timer_init ( &link->timer, fc_link_expired, refcnt );
253: link->examine = examine;
254: }
255:
256: /**
257: * Start monitoring Fibre Channel link state
258: *
259: * @v link Fibre Channel link state monitor
260: */
261: static void fc_link_start ( struct fc_link_state *link ) {
262: start_timer_nodelay ( &link->timer );
263: }
264:
265: /**
266: * Stop monitoring Fibre Channel link state
267: *
268: * @v link Fibre Channel link state monitor
269: */
270: static void fc_link_stop ( struct fc_link_state *link ) {
271: stop_timer ( &link->timer );
272: }
273:
274: /******************************************************************************
275: *
276: * Fibre Channel exchanges
277: *
278: ******************************************************************************
279: */
280:
281: /** A Fibre Channel exchange */
282: struct fc_exchange {
283: /** Reference count */
284: struct refcnt refcnt;
285: /** Fibre Channel port */
286: struct fc_port *port;
287: /** List of active exchanges within this port */
288: struct list_head list;
289:
290: /** Peer port ID */
291: struct fc_port_id peer_port_id;
292: /** Data structure type */
293: unsigned int type;
294: /** Flags */
295: unsigned int flags;
296: /** Local exchange ID */
297: uint16_t xchg_id;
298: /** Peer exchange ID */
299: uint16_t peer_xchg_id;
300: /** Active sequence ID */
301: uint8_t seq_id;
302: /** Active sequence count */
303: uint16_t seq_cnt;
304:
305: /** Timeout timer */
306: struct retry_timer timer;
307:
308: /** Upper-layer protocol interface */
309: struct interface ulp;
310: };
311:
312: /** Fibre Channel exchange flags */
313: enum fc_exchange_flags {
314: /** We are the exchange originator */
315: FC_XCHG_ORIGINATOR = 0x0001,
316: /** We have the sequence initiative */
317: FC_XCHG_SEQ_INITIATIVE = 0x0002,
318: /** This is the first sequence of the exchange */
319: FC_XCHG_SEQ_FIRST = 0x0004,
320: };
321:
322: /** Fibre Channel timeout */
323: #define FC_TIMEOUT ( 1 * TICKS_PER_SEC )
324:
325: /**
326: * Create local Fibre Channel exchange identifier
327: *
328: * @ret xchg_id Local exchange ID
329: */
330: static unsigned int fc_new_xchg_id ( void ) {
331: static uint16_t next_id = 0x0000;
332:
333: /* We must avoid using FC_RX_ID_UNKNOWN (0xffff) */
334: next_id += 2;
335: return next_id;
336: }
337:
338: /**
339: * Create local Fibre Channel sequence identifier
340: *
341: * @ret seq_id Local sequence identifier
342: */
343: static unsigned int fc_new_seq_id ( void ) {
344: static uint8_t seq_id = 0x00;
345:
346: return (++seq_id);
347: }
348:
349: /**
350: * Free Fibre Channel exchange
351: *
352: * @v refcnt Reference count
353: */
354: static void fc_xchg_free ( struct refcnt *refcnt ) {
355: struct fc_exchange *xchg =
356: container_of ( refcnt, struct fc_exchange, refcnt );
357:
358: assert ( ! timer_running ( &xchg->timer ) );
359: assert ( list_empty ( &xchg->list ) );
360:
361: fc_port_put ( xchg->port );
362: free ( xchg );
363: }
364:
365: /**
366: * Close Fibre Channel exchange
367: *
368: * @v xchg Fibre Channel exchange
369: * @v rc Reason for close
370: */
371: static void fc_xchg_close ( struct fc_exchange *xchg, int rc ) {
372: struct fc_port *port = xchg->port;
373:
374: if ( rc != 0 ) {
375: DBGC2 ( port, "FCXCHG %s/%04x closed: %s\n",
376: port->name, xchg->xchg_id, strerror ( rc ) );
377: }
378:
379: /* Stop timer */
380: stop_timer ( &xchg->timer );
381:
382: /* If list still holds a reference, remove from list of open
383: * exchanges and drop list's reference.
384: */
385: if ( ! list_empty ( &xchg->list ) ) {
386: list_del ( &xchg->list );
387: INIT_LIST_HEAD ( &xchg->list );
388: ref_put ( &xchg->refcnt );
389: }
390:
391: /* Shutdown interfaces */
392: intf_shutdown ( &xchg->ulp, rc );
393: }
394:
395: /**
396: * Handle exchange timeout
397: *
398: * @v timer Timeout timer
399: * @v over Failure indicator
400: */
401: static void fc_xchg_expired ( struct retry_timer *timer, int over __unused ) {
402: struct fc_exchange *xchg =
403: container_of ( timer, struct fc_exchange, timer );
404: struct fc_port *port = xchg->port;
405:
406: DBGC ( port, "FCXCHG %s/%04x timed out\n", port->name, xchg->xchg_id );
407:
408: /* Terminate the exchange */
409: fc_xchg_close ( xchg, -ETIMEDOUT );
410: }
411:
412: /**
413: * Check Fibre Channel exchange window
414: *
415: * @v xchg Fibre Channel exchange
416: * @ret len Length opf window
417: */
418: static size_t fc_xchg_window ( struct fc_exchange *xchg __unused ) {
419:
420: /* We don't currently store the path MTU */
421: return FC_LOGIN_DEFAULT_MTU;
422: }
423:
424: /**
425: * Allocate Fibre Channel I/O buffer
426: *
427: * @v xchg Fibre Channel exchange
428: * @v len Payload length
429: * @ret iobuf I/O buffer, or NULL
430: */
431: static struct io_buffer * fc_xchg_alloc_iob ( struct fc_exchange *xchg,
432: size_t len ) {
433: struct fc_port *port = xchg->port;
434: struct io_buffer *iobuf;
435:
436: iobuf = xfer_alloc_iob ( &port->transport,
437: ( sizeof ( struct fc_frame_header ) + len ) );
438: if ( iobuf ) {
439: iob_reserve ( iobuf, sizeof ( struct fc_frame_header ) );
440: }
441: return iobuf;
442: }
443:
444: /**
445: * Transmit data as part of a Fibre Channel exchange
446: *
447: * @v xchg Fibre Channel exchange
448: * @v iobuf I/O buffer
449: * @v meta Data transfer metadata
450: * @ret rc Return status code
451: */
452: static int fc_xchg_tx ( struct fc_exchange *xchg, struct io_buffer *iobuf,
453: struct xfer_metadata *meta ) {
454: struct fc_port *port = xchg->port;
455: struct sockaddr_fc *dest = ( ( struct sockaddr_fc * ) meta->dest );
456: struct fc_frame_header *fchdr;
457: unsigned int r_ctl;
458: unsigned int f_ctl_es;
459: int rc;
460:
461: /* Sanity checks */
462: if ( ! ( xchg->flags & FC_XCHG_SEQ_INITIATIVE ) ) {
463: DBGC ( port, "FCXCHG %s/%04x cannot transmit while not "
464: "holding sequence initiative\n",
465: port->name, xchg->xchg_id );
466: rc = -EBUSY;
467: goto done;
468: }
469:
470: /* Calculate routing control */
471: switch ( xchg->type ) {
472: case FC_TYPE_ELS:
473: r_ctl = FC_R_CTL_ELS;
474: if ( meta->flags & XFER_FL_RESPONSE ) {
475: r_ctl |= FC_R_CTL_SOL_CTRL;
476: } else {
477: r_ctl |= FC_R_CTL_UNSOL_CTRL;
478: }
479: break;
480: case FC_TYPE_CT:
481: r_ctl = FC_R_CTL_DATA;
482: if ( meta->flags & XFER_FL_RESPONSE ) {
483: r_ctl |= FC_R_CTL_SOL_CTRL;
484: } else {
485: r_ctl |= FC_R_CTL_UNSOL_CTRL;
486: }
487: break;
488: default:
489: r_ctl = FC_R_CTL_DATA;
490: switch ( meta->flags &
491: ( XFER_FL_CMD_STAT | XFER_FL_RESPONSE ) ) {
492: case ( XFER_FL_CMD_STAT | XFER_FL_RESPONSE ):
493: r_ctl |= FC_R_CTL_CMD_STAT;
494: break;
495: case ( XFER_FL_CMD_STAT ):
496: r_ctl |= FC_R_CTL_UNSOL_CMD;
497: break;
498: case ( XFER_FL_RESPONSE ):
499: r_ctl |= FC_R_CTL_SOL_DATA;
500: break;
501: default:
502: r_ctl |= FC_R_CTL_UNSOL_DATA;
503: break;
504: }
505: break;
506: }
507:
508: /* Calculate exchange and sequence control */
509: f_ctl_es = 0;
510: if ( ! ( xchg->flags & FC_XCHG_ORIGINATOR ) )
511: f_ctl_es |= FC_F_CTL_ES_RESPONDER;
512: if ( xchg->flags & FC_XCHG_SEQ_FIRST )
513: f_ctl_es |= FC_F_CTL_ES_FIRST;
514: if ( meta->flags & XFER_FL_OUT )
515: f_ctl_es |= ( FC_F_CTL_ES_END | FC_F_CTL_ES_LAST );
516: if ( meta->flags & XFER_FL_OVER )
517: f_ctl_es |= ( FC_F_CTL_ES_END | FC_F_CTL_ES_TRANSFER );
518:
519: /* Create frame header */
520: fchdr = iob_push ( iobuf, sizeof ( *fchdr ) );
521: memset ( fchdr, 0, sizeof ( *fchdr ) );
522: fchdr->r_ctl = r_ctl;
523: memcpy ( &fchdr->d_id,
524: ( dest ? &dest->sfc_port_id : &xchg->peer_port_id ),
525: sizeof ( fchdr->d_id ) );
526: memcpy ( &fchdr->s_id, &port->port_id, sizeof ( fchdr->s_id ) );
527: fchdr->type = xchg->type;
528: fchdr->f_ctl_es = f_ctl_es;
529: fchdr->seq_id = xchg->seq_id;
530: fchdr->seq_cnt = htons ( xchg->seq_cnt++ );
531: fchdr->ox_id = htons ( ( xchg->flags & FC_XCHG_ORIGINATOR ) ?
532: xchg->xchg_id : xchg->peer_xchg_id );
533: fchdr->rx_id = htons ( ( xchg->flags & FC_XCHG_ORIGINATOR ) ?
534: xchg->peer_xchg_id : xchg->xchg_id );
535: if ( meta->flags & XFER_FL_ABS_OFFSET ) {
536: fchdr->f_ctl_misc |= FC_F_CTL_MISC_REL_OFF;
537: fchdr->parameter = htonl ( meta->offset );
538: }
539:
540: /* Relinquish sequence initiative if applicable */
541: if ( meta->flags & XFER_FL_OVER ) {
542: xchg->flags &= ~( FC_XCHG_SEQ_INITIATIVE | FC_XCHG_SEQ_FIRST );
543: xchg->seq_cnt = 0;
544: }
545:
546: /* Reset timeout */
547: start_timer_fixed ( &xchg->timer, FC_TIMEOUT );
548:
549: /* Deliver frame */
550: if ( ( rc = xfer_deliver_iob ( &port->transport,
551: iob_disown ( iobuf ) ) ) != 0 ) {
552: DBGC ( port, "FCXCHG %s/%04x cannot transmit: %s\n",
553: port->name, xchg->xchg_id, strerror ( rc ) );
554: goto done;
555: }
556:
557: done:
558: free_iob ( iobuf );
559: return rc;
560: }
561:
562: /** Mapping from Fibre Channel routing control information to xfer metadata */
563: static const uint8_t fc_r_ctl_info_meta_flags[ FC_R_CTL_INFO_MASK + 1 ] = {
564: [FC_R_CTL_UNCAT] = ( 0 ),
565: [FC_R_CTL_SOL_DATA] = ( XFER_FL_RESPONSE ),
566: [FC_R_CTL_UNSOL_CTRL] = ( XFER_FL_CMD_STAT ),
567: [FC_R_CTL_SOL_CTRL] = ( XFER_FL_CMD_STAT ),
568: [FC_R_CTL_UNSOL_DATA] = ( 0 ),
569: [FC_R_CTL_DATA_DESC] = ( XFER_FL_CMD_STAT ),
570: [FC_R_CTL_UNSOL_CMD] = ( XFER_FL_CMD_STAT ),
571: [FC_R_CTL_CMD_STAT] = ( XFER_FL_CMD_STAT | XFER_FL_RESPONSE ),
572: };
573:
574: /**
575: * Receive data as part of a Fibre Channel exchange
576: *
577: * @v xchg Fibre Channel exchange
578: * @v iobuf I/O buffer
579: * @v meta Data transfer metadata
580: * @ret rc Return status code
581: */
582: static int fc_xchg_rx ( struct fc_exchange *xchg, struct io_buffer *iobuf,
583: struct xfer_metadata *meta __unused ) {
584: struct fc_port *port = xchg->port;
585: struct fc_frame_header *fchdr = iobuf->data;
586: struct xfer_metadata fc_meta;
587: struct sockaddr_fc src;
588: struct sockaddr_fc dest;
589: int rc;
590:
591: /* Record peer exchange ID */
592: xchg->peer_xchg_id =
593: ntohs ( ( fchdr->f_ctl_es & FC_F_CTL_ES_RESPONDER ) ?
594: fchdr->rx_id : fchdr->ox_id );
595:
596: /* Sequence checks */
597: if ( xchg->flags & FC_XCHG_SEQ_INITIATIVE ) {
598: DBGC ( port, "FCXCHG %s/%04x received frame while holding "
599: "sequence initiative\n", port->name, xchg->xchg_id );
600: rc = -EBUSY;
601: goto done;
602: }
603: if ( ntohs ( fchdr->seq_cnt ) != xchg->seq_cnt ) {
604: DBGC ( port, "FCXCHG %s/%04x received out-of-order frame %d "
605: "(expected %d)\n", port->name, xchg->xchg_id,
606: ntohs ( fchdr->seq_cnt ), xchg->seq_cnt );
607: rc = -EPIPE;
608: goto done;
609: }
610: if ( xchg->seq_cnt == 0 )
611: xchg->seq_id = fchdr->seq_id;
612: xchg->seq_cnt++;
613: if ( fchdr->seq_id != xchg->seq_id ) {
614: DBGC ( port, "FCXCHG %s/%04x received frame for incorrect "
615: "sequence %02x (expected %02x)\n", port->name,
616: xchg->xchg_id, fchdr->seq_id, xchg->seq_id );
617: rc = -EPIPE;
618: goto done;
619: }
620:
621: /* Check for end of sequence and transfer of sequence initiative */
622: if ( fchdr->f_ctl_es & FC_F_CTL_ES_END ) {
623: xchg->seq_cnt = 0;
624: if ( fchdr->f_ctl_es & FC_F_CTL_ES_TRANSFER ) {
625: xchg->flags |= FC_XCHG_SEQ_INITIATIVE;
626: xchg->seq_id = fc_new_seq_id();
627: }
628: }
629:
630: /* Construct metadata */
631: memset ( &fc_meta, 0, sizeof ( fc_meta ) );
632: fc_meta.flags =
633: fc_r_ctl_info_meta_flags[ fchdr->r_ctl & FC_R_CTL_INFO_MASK ];
634: if ( fchdr->f_ctl_es & FC_F_CTL_ES_TRANSFER ) {
635: fc_meta.flags |= XFER_FL_OVER;
636: }
637: if ( ( fchdr->f_ctl_es & FC_F_CTL_ES_LAST ) &&
638: ( fchdr->f_ctl_es & FC_F_CTL_ES_END ) ) {
639: fc_meta.flags |= XFER_FL_OUT;
640: }
641: if ( fchdr->f_ctl_misc & FC_F_CTL_MISC_REL_OFF ) {
642: fc_meta.flags |= XFER_FL_ABS_OFFSET;
643: fc_meta.offset = ntohl ( fchdr->parameter );
644: }
645: fc_meta.src = fc_fill_sockaddr ( &src, &fchdr->s_id );
646: fc_meta.dest = fc_fill_sockaddr ( &dest, &fchdr->d_id );
647:
648: /* Reset timeout */
649: start_timer_fixed ( &xchg->timer, FC_TIMEOUT );
650:
651: /* Deliver via exchange's ULP interface */
652: iob_pull ( iobuf, sizeof ( *fchdr ) );
653: if ( ( rc = xfer_deliver ( &xchg->ulp, iob_disown ( iobuf ),
654: &fc_meta ) ) != 0 ) {
655: DBGC ( port, "FCXCHG %s/%04x cannot deliver frame: %s\n",
656: port->name, xchg->xchg_id, strerror ( rc ) );
657: goto done;
658: }
659:
660: /* Close exchange if applicable */
661: if ( ( fchdr->f_ctl_es & FC_F_CTL_ES_LAST ) &&
662: ( fchdr->f_ctl_es & FC_F_CTL_ES_END ) ) {
663: fc_xchg_close ( xchg, 0 );
664: }
665:
666: done:
667: free_iob ( iobuf );
668: return rc;
669: }
670:
671: /** Fibre Channel exchange ULP interface operations */
672: static struct interface_operation fc_xchg_ulp_op[] = {
673: INTF_OP ( xfer_deliver, struct fc_exchange *, fc_xchg_tx ),
674: INTF_OP ( xfer_alloc_iob, struct fc_exchange *, fc_xchg_alloc_iob ),
675: INTF_OP ( xfer_window, struct fc_exchange *, fc_xchg_window ),
676: INTF_OP ( intf_close, struct fc_exchange *, fc_xchg_close ),
677: };
678:
679: /** Fibre Channel exchange ULP interface descriptor */
680: static struct interface_descriptor fc_xchg_ulp_desc =
681: INTF_DESC ( struct fc_exchange, ulp, fc_xchg_ulp_op );
682:
683: /**
684: * Create new Fibre Channel exchange
685: *
686: * @v port Fibre Channel port
687: * @v peer_port_id Peer port ID
688: * @ret xchg Exchange, or NULL
689: */
690: static struct fc_exchange * fc_xchg_create ( struct fc_port *port,
691: struct fc_port_id *peer_port_id,
692: unsigned int type ) {
693: struct fc_exchange *xchg;
694:
695: /* Allocate and initialise structure */
696: xchg = zalloc ( sizeof ( *xchg ) );
697: if ( ! xchg )
698: return NULL;
699: ref_init ( &xchg->refcnt, fc_xchg_free );
700: intf_init ( &xchg->ulp, &fc_xchg_ulp_desc, &xchg->refcnt );
701: timer_init ( &xchg->timer, fc_xchg_expired, &xchg->refcnt );
702: xchg->port = fc_port_get ( port );
703: memcpy ( &xchg->peer_port_id, peer_port_id,
704: sizeof ( xchg->peer_port_id ) );
705: xchg->type = type;
706: xchg->xchg_id = fc_new_xchg_id();
707: xchg->peer_xchg_id = FC_RX_ID_UNKNOWN;
708: xchg->seq_id = fc_new_seq_id();
709:
710: /* Transfer reference to list of exchanges and return */
711: list_add ( &xchg->list, &port->xchgs );
712: return xchg;
713: }
714:
715: /**
716: * Originate a new Fibre Channel exchange
717: *
718: * @v parent Interface to which to attach
719: * @v port Fibre Channel port
720: * @v peer_port_id Peer port ID
721: * @ret xchg_id Exchange ID, or negative error
722: */
723: int fc_xchg_originate ( struct interface *parent, struct fc_port *port,
724: struct fc_port_id *peer_port_id, unsigned int type ) {
725: struct fc_exchange *xchg;
726:
727: /* Allocate and initialise structure */
728: xchg = fc_xchg_create ( port, peer_port_id, type );
729: if ( ! xchg )
730: return -ENOMEM;
731: xchg->flags = ( FC_XCHG_ORIGINATOR | FC_XCHG_SEQ_INITIATIVE |
732: FC_XCHG_SEQ_FIRST );
733:
734: DBGC2 ( port, "FCXCHG %s/%04x originating to %s (type %02x)\n",
735: port->name, xchg->xchg_id, fc_id_ntoa ( &xchg->peer_port_id ),
736: xchg->type );
737:
738: /* Attach to parent interface and return */
739: intf_plug_plug ( &xchg->ulp, parent );
740: return xchg->xchg_id;
741: }
742:
743: /**
744: * Open a new responder Fibre Channel exchange
745: *
746: * @v port Fibre Channel port
747: * @v fchdr Fibre Channel frame header
748: * @ret xchg Fibre Channel exchange, or NULL
749: */
750: static struct fc_exchange * fc_xchg_respond ( struct fc_port *port,
751: struct fc_frame_header *fchdr ) {
752: struct fc_exchange *xchg;
753: struct fc_responder *responder;
754: unsigned int type = fchdr->type;
755: int rc;
756:
757: /* Allocate and initialise structure */
758: xchg = fc_xchg_create ( port, &fchdr->s_id, type );
759: if ( ! xchg )
760: return NULL;
761: xchg->seq_id = fchdr->seq_id;
762:
763: DBGC2 ( port, "FCXCHG %s/%04x responding to %s xchg %04x (type "
764: "%02x)\n", port->name, xchg->xchg_id,
765: fc_id_ntoa ( &xchg->peer_port_id ),
766: ntohs ( fchdr->ox_id ), xchg->type );
767:
768: /* Find a responder, if any */
769: for_each_table_entry ( responder, FC_RESPONDERS ) {
770: if ( responder->type == type ) {
771: if ( ( rc = responder->respond ( &xchg->ulp, port,
772: &fchdr->d_id,
773: &fchdr->s_id ) ) !=0 ){
774: DBGC ( port, "FCXCHG %s/%04x could not "
775: "respond: %s\n", port->name,
776: xchg->xchg_id, strerror ( rc ) );
777: }
778: }
779: break;
780: }
781:
782: /* We may or may not have a ULP attached at this point, but
783: * the exchange does exist.
784: */
785: return xchg;
786: }
787:
788: /******************************************************************************
789: *
790: * Fibre Channel ports
791: *
792: ******************************************************************************
793: */
794:
795: /**
796: * Close Fibre Channel port
797: *
798: * @v port Fibre Channel port
799: * @v rc Reason for close
800: */
801: static void fc_port_close ( struct fc_port *port, int rc ) {
802: struct fc_exchange *xchg;
803: struct fc_exchange *tmp;
804:
805: DBGC ( port, "FCPORT %s closed\n", port->name );
806:
807: /* Log out port, if necessary */
808: if ( fc_link_ok ( &port->link ) )
809: fc_port_logout ( port, rc );
810:
811: /* Stop link monitor */
812: fc_link_stop ( &port->link );
813:
814: /* Shut down interfaces */
815: intf_shutdown ( &port->transport, rc );
816: intf_shutdown ( &port->flogi, rc );
817: intf_shutdown ( &port->ns_plogi, rc );
818:
819: /* Shut down any remaining exchanges */
820: list_for_each_entry_safe ( xchg, tmp, &port->xchgs, list )
821: fc_xchg_close ( xchg, rc );
822:
823: /* Remove from list of ports */
824: list_del ( &port->list );
825: INIT_LIST_HEAD ( &port->list );
826: }
827:
828: /**
829: * Identify Fibre Channel exchange by local exchange ID
830: *
831: * @v port Fibre Channel port
832: * @v xchg_id Local exchange ID
833: * @ret xchg Fibre Channel exchange, or NULL
834: */
835: static struct fc_exchange * fc_port_demux ( struct fc_port *port,
836: unsigned int xchg_id ) {
837: struct fc_exchange *xchg;
838:
839: list_for_each_entry ( xchg, &port->xchgs, list ) {
840: if ( xchg->xchg_id == xchg_id )
841: return xchg;
842: }
843: return NULL;
844: }
845:
846: /**
847: * Handle received frame from Fibre Channel port
848: *
849: * @v port Fibre Channel port
850: * @v iobuf I/O buffer
851: * @v meta Data transfer metadata
852: * @ret rc Return status code
853: */
854: static int fc_port_deliver ( struct fc_port *port, struct io_buffer *iobuf,
855: struct xfer_metadata *meta ) {
856: struct fc_frame_header *fchdr = iobuf->data;
857: unsigned int xchg_id;
858: struct fc_exchange *xchg;
859: int rc;
860:
861: /* Sanity check */
862: if ( iob_len ( iobuf ) < sizeof ( *fchdr ) ) {
863: DBGC ( port, "FCPORT %s received underlength frame (%zd "
864: "bytes)\n", port->name, iob_len ( iobuf ) );
865: rc = -EINVAL;
866: goto err_sanity;
867: }
868:
869: /* Verify local port ID */
870: if ( ( memcmp ( &fchdr->d_id, &port->port_id,
871: sizeof ( fchdr->d_id ) ) != 0 ) &&
872: ( memcmp ( &fchdr->d_id, &fc_f_port_id,
873: sizeof ( fchdr->d_id ) ) != 0 ) &&
874: ( memcmp ( &port->port_id, &fc_empty_port_id,
875: sizeof ( port->port_id ) ) != 0 ) ) {
876: DBGC ( port, "FCPORT %s received frame for incorrect port ID "
877: "%s\n", port->name, fc_id_ntoa ( &fchdr->d_id ) );
878: rc = -ENOTCONN;
879: goto err_port_id;
880: }
881:
882: /* Demultiplex amongst active exchanges */
883: xchg_id = ntohs ( ( fchdr->f_ctl_es & FC_F_CTL_ES_RESPONDER ) ?
884: fchdr->ox_id : fchdr->rx_id );
885: xchg = fc_port_demux ( port, xchg_id );
886:
887: /* If we have no active exchange and this frame starts a new
888: * exchange, try to create a new responder exchange
889: */
890: if ( ( fchdr->f_ctl_es & FC_F_CTL_ES_FIRST ) &&
891: ( fchdr->seq_cnt == 0 ) ) {
892:
893: /* Create new exchange */
894: xchg = fc_xchg_respond ( port, fchdr );
895: if ( ! xchg ) {
896: DBGC ( port, "FCPORT %s cannot create new exchange\n",
897: port->name );
898: rc = -ENOMEM;
899: goto err_respond;
900: }
901: }
902:
903: /* Fail if no exchange exists */
904: if ( ! xchg ) {
905: DBGC ( port, "FCPORT %s xchg %04x unknown\n",
906: port->name, xchg_id );
907: rc = -ENOTCONN;
908: goto err_no_xchg;
909: }
910:
911: /* Pass received frame to exchange */
912: ref_get ( &xchg->refcnt );
913: if ( ( rc = fc_xchg_rx ( xchg, iob_disown ( iobuf ), meta ) ) != 0 )
914: goto err_xchg_rx;
915:
916: err_xchg_rx:
917: ref_put ( &xchg->refcnt );
918: err_no_xchg:
919: err_respond:
920: err_port_id:
921: err_sanity:
922: free_iob ( iobuf );
923: return rc;
924: }
925:
926: /**
927: * Log in Fibre Channel port
928: *
929: * @v port Fibre Channel port
930: * @v port_id Local port ID
931: * @v link_node_wwn Link node name
932: * @v link_port_wwn Link port name
933: * @v has_fabric Link is to a fabric
934: * @ret rc Return status code
935: */
936: int fc_port_login ( struct fc_port *port, struct fc_port_id *port_id,
937: const struct fc_name *link_node_wwn,
938: const struct fc_name *link_port_wwn, int has_fabric ) {
939: struct fc_peer *peer;
940: struct fc_peer *tmp;
941: int rc;
942:
943: /* Perform implicit logout if logged in and details differ */
944: if ( fc_link_ok ( &port->link ) &&
945: ( ( ( !! ( port->flags & FC_PORT_HAS_FABRIC ) ) !=
946: ( !! has_fabric ) ) ||
947: ( memcmp ( &port->link_node_wwn, link_node_wwn,
948: sizeof ( port->link_node_wwn ) ) != 0 ) ||
949: ( memcmp ( &port->link_port_wwn, link_port_wwn,
950: sizeof ( port->link_port_wwn ) ) != 0 ) ||
951: ( has_fabric &&
952: ( memcmp ( &port->port_id, port_id,
953: sizeof ( port->port_id ) ) != 0 ) ) ) ) {
954: fc_port_logout ( port, 0 );
955: }
956:
957: /* Log in, if applicable */
958: if ( ! fc_link_ok ( &port->link ) ) {
959:
960: /* Record link port name */
961: memcpy ( &port->link_node_wwn, link_node_wwn,
962: sizeof ( port->link_node_wwn ) );
963: memcpy ( &port->link_port_wwn, link_port_wwn,
964: sizeof ( port->link_port_wwn ) );
965: DBGC ( port, "FCPORT %s logged in to %s",
966: port->name, fc_ntoa ( &port->link_node_wwn ) );
967: DBGC ( port, " port %s\n", fc_ntoa ( &port->link_port_wwn ) );
968:
969: /* Calculate local (and possibly remote) port IDs */
970: if ( has_fabric ) {
971: port->flags |= FC_PORT_HAS_FABRIC;
972: memcpy ( &port->port_id, port_id,
973: sizeof ( port->port_id ) );
974: } else {
975: port->flags &= ~FC_PORT_HAS_FABRIC;
976: if ( memcmp ( &port->port_wwn, link_port_wwn,
977: sizeof ( port->port_wwn ) ) > 0 ) {
978: memcpy ( &port->port_id, &fc_ptp_high_port_id,
979: sizeof ( port->port_id ) );
980: memcpy ( &port->ptp_link_port_id,
981: &fc_ptp_low_port_id,
982: sizeof ( port->ptp_link_port_id ) );
983: } else {
984: memcpy ( &port->port_id, &fc_ptp_low_port_id,
985: sizeof ( port->port_id ) );
986: memcpy ( &port->ptp_link_port_id,
987: &fc_ptp_high_port_id,
988: sizeof ( port->ptp_link_port_id ) );
989: }
990: }
991: DBGC ( port, "FCPORT %s logged in via a %s, with local ID "
992: "%s\n", port->name,
993: ( ( port->flags & FC_PORT_HAS_FABRIC ) ?
994: "fabric" : "point-to-point link" ),
995: fc_id_ntoa ( &port->port_id ) );
996: }
997:
998: /* Log in to name server, if attached to a fabric */
999: if ( has_fabric && ! ( port->flags & FC_PORT_HAS_NS ) ) {
1000:
1001: DBGC ( port, "FCPORT %s attempting login to name server\n",
1002: port->name );
1003:
1004: intf_restart ( &port->ns_plogi, -ECANCELED );
1005: if ( ( rc = fc_els_plogi ( &port->ns_plogi, port,
1006: &fc_gs_port_id ) ) != 0 ) {
1007: DBGC ( port, "FCPORT %s could not initiate name "
1008: "server PLOGI: %s\n",
1009: port->name, strerror ( rc ) );
1010: fc_port_logout ( port, rc );
1011: return rc;
1012: }
1013: }
1014:
1015: /* Record login */
1016: fc_link_up ( &port->link );
1017:
1018: /* Notify peers of link state change */
1019: list_for_each_entry_safe ( peer, tmp, &fc_peers, list ) {
1020: fc_peer_get ( peer );
1021: fc_link_examine ( &peer->link );
1022: fc_peer_put ( peer );
1023: }
1024:
1025: return 0;
1026: }
1027:
1028: /**
1029: * Log out Fibre Channel port
1030: *
1031: * @v port Fibre Channel port
1032: * @v rc Reason for logout
1033: */
1034: void fc_port_logout ( struct fc_port *port, int rc ) {
1035: struct fc_peer *peer;
1036: struct fc_peer *tmp;
1037:
1038: DBGC ( port, "FCPORT %s logged out: %s\n",
1039: port->name, strerror ( rc ) );
1040:
1041: /* Erase port details */
1042: memset ( &port->port_id, 0, sizeof ( port->port_id ) );
1043: port->flags = 0;
1044:
1045: /* Record logout */
1046: fc_link_err ( &port->link, rc );
1047:
1048: /* Notify peers of link state change */
1049: list_for_each_entry_safe ( peer, tmp, &fc_peers, list ) {
1050: fc_peer_get ( peer );
1051: fc_link_examine ( &peer->link );
1052: fc_peer_put ( peer );
1053: }
1054: }
1055:
1056: /**
1057: * Handle FLOGI completion
1058: *
1059: * @v port Fibre Channel port
1060: * @v rc Reason for completion
1061: */
1062: static void fc_port_flogi_done ( struct fc_port *port, int rc ) {
1063:
1064: intf_restart ( &port->flogi, rc );
1065:
1066: if ( rc != 0 )
1067: fc_port_logout ( port, rc );
1068: }
1069:
1070: /**
1071: * Handle name server PLOGI completion
1072: *
1073: * @v port Fibre Channel port
1074: * @v rc Reason for completion
1075: */
1076: static void fc_port_ns_plogi_done ( struct fc_port *port, int rc ) {
1077:
1078: intf_restart ( &port->ns_plogi, rc );
1079:
1080: if ( rc == 0 ) {
1081: port->flags |= FC_PORT_HAS_NS;
1082: DBGC ( port, "FCPORT %s logged in to name server\n",
1083: port->name );
1084: } else {
1085: DBGC ( port, "FCPORT %s could not log in to name server: %s\n",
1086: port->name, strerror ( rc ) );
1087: /* Absence of a name server is not a fatal error */
1088: }
1089: }
1090:
1091: /**
1092: * Examine Fibre Channel port link state
1093: *
1094: * @ link Fibre Channel link state monitor
1095: */
1096: static void fc_port_examine ( struct fc_link_state *link ) {
1097: struct fc_port *port = container_of ( link, struct fc_port, link );
1098: int rc;
1099:
1100: /* Do nothing if already logged in */
1101: if ( fc_link_ok ( &port->link ) )
1102: return;
1103:
1104: DBGC ( port, "FCPORT %s attempting login\n", port->name );
1105:
1106: /* Try to create FLOGI ELS */
1107: intf_restart ( &port->flogi, -ECANCELED );
1108: if ( ( rc = fc_els_flogi ( &port->flogi, port ) ) != 0 ) {
1109: DBGC ( port, "FCPORT %s could not initiate FLOGI: %s\n",
1110: port->name, strerror ( rc ) );
1111: fc_port_logout ( port, rc );
1112: return;
1113: }
1114: }
1115:
1116: /**
1117: * Handle change of flow control window
1118: *
1119: * @v port Fibre Channel port
1120: */
1121: static void fc_port_window_changed ( struct fc_port *port ) {
1122: size_t window;
1123:
1124: /* Check if transport layer is ready */
1125: window = xfer_window ( &port->transport );
1126: if ( window > 0 ) {
1127:
1128: /* Transport layer is ready. Start login if the link
1129: * is not already up.
1130: */
1131: if ( ! fc_link_ok ( &port->link ) )
1132: fc_link_start ( &port->link );
1133:
1134: } else {
1135:
1136: /* Transport layer is not ready. Log out port and
1137: * wait for transport layer before attempting log in
1138: * again.
1139: */
1140: fc_port_logout ( port, -ENOTCONN );
1141: fc_link_stop ( &port->link );
1142: }
1143: }
1144:
1145: /** Fibre Channel port transport interface operations */
1146: static struct interface_operation fc_port_transport_op[] = {
1147: INTF_OP ( xfer_deliver, struct fc_port *, fc_port_deliver ),
1148: INTF_OP ( xfer_window_changed, struct fc_port *,
1149: fc_port_window_changed ),
1150: INTF_OP ( intf_close, struct fc_port *, fc_port_close ),
1151: };
1152:
1153: /** Fibre Channel port transport interface descriptor */
1154: static struct interface_descriptor fc_port_transport_desc =
1155: INTF_DESC ( struct fc_port, transport, fc_port_transport_op );
1156:
1157: /** Fibre Channel port FLOGI interface operations */
1158: static struct interface_operation fc_port_flogi_op[] = {
1159: INTF_OP ( intf_close, struct fc_port *, fc_port_flogi_done ),
1160: };
1161:
1162: /** Fibre Channel port FLOGI interface descriptor */
1163: static struct interface_descriptor fc_port_flogi_desc =
1164: INTF_DESC ( struct fc_port, flogi, fc_port_flogi_op );
1165:
1166: /** Fibre Channel port name server PLOGI interface operations */
1167: static struct interface_operation fc_port_ns_plogi_op[] = {
1168: INTF_OP ( intf_close, struct fc_port *, fc_port_ns_plogi_done ),
1169: };
1170:
1171: /** Fibre Channel port name server PLOGI interface descriptor */
1172: static struct interface_descriptor fc_port_ns_plogi_desc =
1173: INTF_DESC ( struct fc_port, ns_plogi, fc_port_ns_plogi_op );
1174:
1175: /**
1176: * Create Fibre Channel port
1177: *
1178: * @v transport Transport interface
1179: * @v node Fibre Channel node name
1180: * @v port Fibre Channel port name
1181: * @v name Symbolic port name
1182: * @ret rc Return status code
1183: */
1184: int fc_port_open ( struct interface *transport, const struct fc_name *node_wwn,
1185: const struct fc_name *port_wwn, const char *name ) {
1186: struct fc_port *port;
1187:
1188: /* Allocate and initialise structure */
1189: port = zalloc ( sizeof ( *port ) );
1190: if ( ! port )
1191: return -ENOMEM;
1192: ref_init ( &port->refcnt, NULL );
1193: intf_init ( &port->transport, &fc_port_transport_desc, &port->refcnt );
1194: fc_link_init ( &port->link, fc_port_examine, &port->refcnt );
1195: intf_init ( &port->flogi, &fc_port_flogi_desc, &port->refcnt );
1196: intf_init ( &port->ns_plogi, &fc_port_ns_plogi_desc, &port->refcnt );
1197: list_add_tail ( &port->list, &fc_ports );
1198: INIT_LIST_HEAD ( &port->xchgs );
1199: memcpy ( &port->node_wwn, node_wwn, sizeof ( port->node_wwn ) );
1200: memcpy ( &port->port_wwn, port_wwn, sizeof ( port->port_wwn ) );
1201: snprintf ( port->name, sizeof ( port->name ), "%s", name );
1202:
1203: DBGC ( port, "FCPORT %s opened as %s",
1204: port->name, fc_ntoa ( &port->node_wwn ) );
1205: DBGC ( port, " port %s\n", fc_ntoa ( &port->port_wwn ) );
1206:
1207: /* Attach to transport layer, mortalise self, and return */
1208: intf_plug_plug ( &port->transport, transport );
1209: ref_put ( &port->refcnt );
1210: return 0;
1211: }
1212:
1213: /**
1214: * Find Fibre Channel port by name
1215: *
1216: * @v name Fibre Channel port name
1217: * @ret port Fibre Channel port, or NULL
1218: */
1219: struct fc_port * fc_port_find ( const char *name ) {
1220: struct fc_port *port;
1221:
1222: list_for_each_entry ( port, &fc_ports, list ) {
1223: if ( strcmp ( name, port->name ) == 0 )
1224: return port;
1225: }
1226: return NULL;
1227: }
1228:
1229: /******************************************************************************
1230: *
1231: * Fibre Channel peers
1232: *
1233: ******************************************************************************
1234: */
1235:
1236: /**
1237: * Close Fibre Channel peer
1238: *
1239: * @v peer Fibre Channel peer
1240: * @v rc Reason for close
1241: */
1242: static void fc_peer_close ( struct fc_peer *peer, int rc ) {
1243:
1244: DBGC ( peer, "FCPEER %s closed: %s\n",
1245: fc_ntoa ( &peer->port_wwn ) , strerror ( rc ) );
1246:
1247: /* Sanity check */
1248: assert ( list_empty ( &peer->ulps ) );
1249:
1250: /* Stop link timer */
1251: fc_link_stop ( &peer->link );
1252:
1253: /* Shut down interfaces */
1254: intf_shutdown ( &peer->plogi, rc );
1255:
1256: /* Remove from list of peers */
1257: list_del ( &peer->list );
1258: INIT_LIST_HEAD ( &peer->list );
1259: }
1260:
1261: /**
1262: * Increment Fibre Channel peer active usage count
1263: *
1264: * @v peer Fibre Channel peer
1265: */
1266: static void fc_peer_increment ( struct fc_peer *peer ) {
1267:
1268: /* Increment our usage count */
1269: peer->usage++;
1270: }
1271:
1272: /**
1273: * Decrement Fibre Channel peer active usage count
1274: *
1275: * @v peer Fibre Channel peer
1276: */
1277: static void fc_peer_decrement ( struct fc_peer *peer ) {
1278:
1279: /* Sanity check */
1280: assert ( peer->usage > 0 );
1281:
1282: /* Decrement our usage count and log out if we reach zero */
1283: if ( --(peer->usage) == 0 )
1284: fc_peer_logout ( peer, 0 );
1285: }
1286:
1287: /**
1288: * Log in Fibre Channel peer
1289: *
1290: * @v peer Fibre Channel peer
1291: * @v port Fibre Channel port
1292: * @v port_id Port ID
1293: * @ret rc Return status code
1294: */
1295: int fc_peer_login ( struct fc_peer *peer, struct fc_port *port,
1296: struct fc_port_id *port_id ) {
1297: struct fc_ulp *ulp;
1298: struct fc_ulp *tmp;
1299:
1300: /* Perform implicit logout if logged in and details differ */
1301: if ( fc_link_ok ( &peer->link ) &&
1302: ( ( peer->port != port ) ||
1303: ( memcmp ( &peer->port_id, port_id,
1304: sizeof ( peer->port_id ) ) !=0 ) ) ) {
1305: fc_peer_logout ( peer, 0 );
1306: }
1307:
1308: /* Log in, if applicable */
1309: if ( ! fc_link_ok ( &peer->link ) ) {
1310:
1311: /* Record peer details */
1312: assert ( peer->port == NULL );
1313: peer->port = fc_port_get ( port );
1314: memcpy ( &peer->port_id, port_id, sizeof ( peer->port_id ) );
1315: DBGC ( peer, "FCPEER %s logged in via %s as %s\n",
1316: fc_ntoa ( &peer->port_wwn ), peer->port->name,
1317: fc_id_ntoa ( &peer->port_id ) );
1318:
1319: /* Add login reference */
1320: fc_peer_get ( peer );
1321: }
1322:
1323: /* Record login */
1324: fc_link_up ( &peer->link );
1325:
1326: /* Notify ULPs of link state change */
1327: list_for_each_entry_safe ( ulp, tmp, &peer->ulps, list ) {
1328: fc_ulp_get ( ulp );
1329: fc_link_examine ( &ulp->link );
1330: fc_ulp_put ( ulp );
1331: }
1332:
1333: return 0;
1334: }
1335:
1336: /**
1337: * Log out Fibre Channel peer
1338: *
1339: * @v peer Fibre Channel peer
1340: * @v rc Reason for logout
1341: */
1342: void fc_peer_logout ( struct fc_peer *peer, int rc ) {
1343: struct fc_ulp *ulp;
1344: struct fc_ulp *tmp;
1345:
1346: DBGC ( peer, "FCPEER %s logged out: %s\n",
1347: fc_ntoa ( &peer->port_wwn ), strerror ( rc ) );
1348:
1349: /* Drop login reference, if applicable */
1350: if ( fc_link_ok ( &peer->link ) )
1351: fc_peer_put ( peer );
1352:
1353: /* Erase peer details */
1354: fc_port_put ( peer->port );
1355: peer->port = NULL;
1356:
1357: /* Record logout */
1358: fc_link_err ( &peer->link, rc );
1359:
1360: /* Notify ULPs of link state change */
1361: list_for_each_entry_safe ( ulp, tmp, &peer->ulps, list ) {
1362: fc_ulp_get ( ulp );
1363: fc_link_examine ( &ulp->link );
1364: fc_ulp_put ( ulp );
1365: }
1366:
1367: /* Close peer if there are no active users */
1368: if ( peer->usage == 0 )
1369: fc_peer_close ( peer, rc );
1370: }
1371:
1372: /**
1373: * Handle PLOGI completion
1374: *
1375: * @v peer Fibre Channel peer
1376: * @v rc Reason for completion
1377: */
1378: static void fc_peer_plogi_done ( struct fc_peer *peer, int rc ) {
1379:
1380: intf_restart ( &peer->plogi, rc );
1381:
1382: if ( rc != 0 )
1383: fc_peer_logout ( peer, rc );
1384: }
1385:
1386: /**
1387: * Initiate PLOGI
1388: *
1389: * @v peer Fibre Channel peer
1390: * @v port Fibre Channel port
1391: * @v peer_port_id Peer port ID
1392: * @ret rc Return status code
1393: */
1394: static int fc_peer_plogi ( struct fc_peer *peer, struct fc_port *port,
1395: struct fc_port_id *peer_port_id ) {
1396: int rc;
1397:
1398: /* Try to create PLOGI ELS */
1399: intf_restart ( &peer->plogi, -ECANCELED );
1400: if ( ( rc = fc_els_plogi ( &peer->plogi, port, peer_port_id ) ) != 0 ) {
1401: DBGC ( peer, "FCPEER %s could not initiate PLOGI: %s\n",
1402: fc_ntoa ( &peer->port_wwn ), strerror ( rc ) );
1403: fc_peer_logout ( peer, rc );
1404: return rc;
1405: }
1406:
1407: return 0;
1408: }
1409:
1410: /**
1411: * Examine Fibre Channel peer link state
1412: *
1413: * @ link Fibre Channel link state monitor
1414: */
1415: static void fc_peer_examine ( struct fc_link_state *link ) {
1416: struct fc_peer *peer = container_of ( link, struct fc_peer, link );
1417: struct fc_port *port;
1418: int rc;
1419:
1420: /* Check to see if underlying port link has gone down */
1421: if ( peer->port && ( ! fc_link_ok ( &peer->port->link ) ) ) {
1422: fc_peer_logout ( peer, -ENOTCONN );
1423: return;
1424: }
1425:
1426: /* Do nothing if already logged in */
1427: if ( fc_link_ok ( &peer->link ) )
1428: return;
1429:
1430: DBGC ( peer, "FCPEER %s attempting login\n",
1431: fc_ntoa ( &peer->port_wwn ) );
1432:
1433: /* Sanity check */
1434: assert ( peer->port == NULL );
1435:
1436: /* First, look for a port with the peer attached via a
1437: * point-to-point link.
1438: */
1439: list_for_each_entry ( port, &fc_ports, list ) {
1440: if ( fc_link_ok ( &port->link ) &&
1441: ( ! ( port->flags & FC_PORT_HAS_FABRIC ) ) &&
1442: ( memcmp ( &peer->port_wwn, &port->link_port_wwn,
1443: sizeof ( peer->port_wwn ) ) == 0 ) ) {
1444: /* Use this peer port ID, and stop looking */
1445: fc_peer_plogi ( peer, port, &port->ptp_link_port_id );
1446: return;
1447: }
1448: }
1449:
1450: /* If the peer is not directly attached, try initiating a name
1451: * server lookup on any suitable ports.
1452: */
1453: list_for_each_entry ( port, &fc_ports, list ) {
1454: if ( fc_link_ok ( &port->link ) &&
1455: ( port->flags & FC_PORT_HAS_FABRIC ) &&
1456: ( port->flags & FC_PORT_HAS_NS ) ) {
1457: if ( ( rc = fc_ns_query ( peer, port,
1458: fc_peer_plogi ) ) != 0 ) {
1459: DBGC ( peer, "FCPEER %s could not attempt "
1460: "name server lookup on %s: %s\n",
1461: fc_ntoa ( &peer->port_wwn ), port->name,
1462: strerror ( rc ) );
1463: /* Non-fatal */
1464: }
1465: }
1466: }
1467: }
1468:
1469: /** Fibre Channel peer PLOGI interface operations */
1470: static struct interface_operation fc_peer_plogi_op[] = {
1471: INTF_OP ( intf_close, struct fc_peer *, fc_peer_plogi_done ),
1472: };
1473:
1474: /** Fibre Channel peer PLOGI interface descriptor */
1475: static struct interface_descriptor fc_peer_plogi_desc =
1476: INTF_DESC ( struct fc_peer, plogi, fc_peer_plogi_op );
1477:
1478: /**
1479: * Create Fibre Channel peer
1480: *
1481: * @v port_wwn Node name
1482: * @ret peer Fibre Channel peer, or NULL
1483: */
1484: static struct fc_peer * fc_peer_create ( const struct fc_name *port_wwn ) {
1485: struct fc_peer *peer;
1486:
1487: /* Allocate and initialise structure */
1488: peer = zalloc ( sizeof ( *peer ) );
1489: if ( ! peer )
1490: return NULL;
1491: ref_init ( &peer->refcnt, NULL );
1492: fc_link_init ( &peer->link, fc_peer_examine, &peer->refcnt );
1493: intf_init ( &peer->plogi, &fc_peer_plogi_desc, &peer->refcnt );
1494: list_add_tail ( &peer->list, &fc_peers );
1495: memcpy ( &peer->port_wwn, port_wwn, sizeof ( peer->port_wwn ) );
1496: INIT_LIST_HEAD ( &peer->ulps );
1497:
1498: /* Start link monitor */
1499: fc_link_start ( &peer->link );
1500:
1501: DBGC ( peer, "FCPEER %s created\n", fc_ntoa ( &peer->port_wwn ) );
1502: return peer;
1503: }
1504:
1505: /**
1506: * Get Fibre Channel peer by node name
1507: *
1508: * @v port_wwn Node name
1509: * @ret peer Fibre Channel peer, or NULL
1510: */
1511: struct fc_peer * fc_peer_get_wwn ( const struct fc_name *port_wwn ) {
1512: struct fc_peer *peer;
1513:
1514: /* Look for an existing peer */
1515: list_for_each_entry ( peer, &fc_peers, list ) {
1516: if ( memcmp ( &peer->port_wwn, port_wwn,
1517: sizeof ( peer->port_wwn ) ) == 0 )
1518: return fc_peer_get ( peer );
1519: }
1520:
1521: /* Create a new peer */
1522: peer = fc_peer_create ( port_wwn );
1523: if ( ! peer )
1524: return NULL;
1525:
1526: return peer;
1527: }
1528:
1529: /**
1530: * Get Fibre Channel peer by port ID
1531: *
1532: * @v port Fibre Channel port
1533: * @v peer_port_id Peer port ID
1534: * @ret peer Fibre Channel peer, or NULL
1535: */
1536: struct fc_peer * fc_peer_get_port_id ( struct fc_port *port,
1537: const struct fc_port_id *peer_port_id ){
1538: struct fc_peer *peer;
1539:
1540: /* Look for an existing peer */
1541: list_for_each_entry ( peer, &fc_peers, list ) {
1542: if ( ( peer->port == port ) &&
1543: ( memcmp ( &peer->port_id, peer_port_id,
1544: sizeof ( peer->port_id ) ) == 0 ) )
1545: return fc_peer_get ( peer );
1546: }
1547:
1548: /* Cannot create a new peer, since we have no port name to use */
1549: return NULL;
1550: }
1551:
1552: /******************************************************************************
1553: *
1554: * Fibre Channel upper-layer protocols
1555: *
1556: ******************************************************************************
1557: */
1558:
1559: /**
1560: * Free Fibre Channel upper-layer protocol
1561: *
1562: * @v refcnt Reference count
1563: */
1564: static void fc_ulp_free ( struct refcnt *refcnt ) {
1565: struct fc_ulp *ulp = container_of ( refcnt, struct fc_ulp, refcnt );
1566:
1567: fc_peer_put ( ulp->peer );
1568: free ( ulp );
1569: }
1570:
1571: /**
1572: * Close Fibre Channel upper-layer protocol
1573: *
1574: * @v ulp Fibre Channel upper-layer protocol
1575: * @v rc Reason for close
1576: */
1577: static void fc_ulp_close ( struct fc_ulp *ulp, int rc ) {
1578:
1579: DBGC ( ulp, "FCULP %s/%02x closed: %s\n",
1580: fc_ntoa ( &ulp->peer->port_wwn ), ulp->type, strerror ( rc ) );
1581:
1582: /* Sanity check */
1583: assert ( ulp->usage == 0 );
1584:
1585: /* Stop link monitor */
1586: fc_link_stop ( &ulp->link );
1587:
1588: /* Shut down interfaces */
1589: intf_shutdown ( &ulp->prli, rc );
1590:
1591: /* Remove from list of ULPs */
1592: list_del ( &ulp->list );
1593: INIT_LIST_HEAD ( &ulp->list );
1594: }
1595:
1596: /**
1597: * Increment Fibre Channel upper-layer protocol active usage count
1598: *
1599: * @v ulp Fibre Channel ulp
1600: */
1601: void fc_ulp_increment ( struct fc_ulp *ulp ) {
1602:
1603: /* Increment peer's usage count */
1604: fc_peer_increment ( ulp->peer );
1605:
1606: /* Increment our usage count */
1607: ulp->usage++;
1608: }
1609:
1610: /**
1611: * Decrement Fibre Channel upper-layer protocol active usage count
1612: *
1613: * @v ulp Fibre Channel ulp
1614: */
1615: void fc_ulp_decrement ( struct fc_ulp *ulp ) {
1616:
1617: /* Sanity check */
1618: assert ( ulp->usage > 0 );
1619:
1620: /* Decrement our usage count and log out if we reach zero */
1621: if ( --(ulp->usage) == 0 )
1622: fc_ulp_logout ( ulp, 0 );
1623:
1624: /* Decrement our peer's usage count */
1625: fc_peer_decrement ( ulp->peer );
1626: }
1627:
1628: /**
1629: * Log in Fibre Channel upper-layer protocol
1630: *
1631: * @v ulp Fibre Channel upper-layer protocol
1632: * @v param Service parameters
1633: * @v param_len Length of service parameters
1634: * @v originated Login was originated by us
1635: * @ret rc Return status code
1636: */
1637: int fc_ulp_login ( struct fc_ulp *ulp, const void *param, size_t param_len,
1638: int originated ) {
1639:
1640: /* Perform implicit logout if logged in and service parameters differ */
1641: if ( fc_link_ok ( &ulp->link ) &&
1642: ( ( ulp->param_len != param_len ) ||
1643: ( memcmp ( ulp->param, param, ulp->param_len ) != 0 ) ) ) {
1644: fc_ulp_logout ( ulp, 0 );
1645: }
1646:
1647: /* Log in, if applicable */
1648: if ( ! fc_link_ok ( &ulp->link ) ) {
1649:
1650: /* Record service parameters */
1651: assert ( ulp->param == NULL );
1652: assert ( ulp->param_len == 0 );
1653: ulp->param = malloc ( param_len );
1654: if ( ! ulp->param ) {
1655: DBGC ( ulp, "FCULP %s/%02x could not record "
1656: "parameters\n",
1657: fc_ntoa ( &ulp->peer->port_wwn ), ulp->type );
1658: return -ENOMEM;
1659: }
1660: memcpy ( ulp->param, param, param_len );
1661: ulp->param_len = param_len;
1662: DBGC ( ulp, "FCULP %s/%02x logged in with parameters:\n",
1663: fc_ntoa ( &ulp->peer->port_wwn ), ulp->type );
1664: DBGC_HDA ( ulp, 0, ulp->param, ulp->param_len );
1665:
1666: /* Add login reference */
1667: fc_ulp_get ( ulp );
1668: }
1669:
1670: /* Record login */
1671: fc_link_up ( &ulp->link );
1672:
1673: /* Work around a bug in some versions of the Linux Fibre
1674: * Channel stack, which fail to fully initialise image pairs
1675: * established via a PRLI originated by the Linux stack
1676: * itself.
1677: */
1678: if ( originated )
1679: ulp->flags |= FC_ULP_ORIGINATED_LOGIN_OK;
1680: if ( ! ( ulp->flags & FC_ULP_ORIGINATED_LOGIN_OK ) ) {
1681: DBGC ( ulp, "FCULP %s/%02x sending extra PRLI to work around "
1682: "Linux bug\n",
1683: fc_ntoa ( &ulp->peer->port_wwn ), ulp->type );
1684: fc_link_start ( &ulp->link );
1685: }
1686:
1687: return 0;
1688: }
1689:
1690: /**
1691: * Log out Fibre Channel upper-layer protocol
1692: *
1693: * @v ulp Fibre Channel upper-layer protocol
1694: * @v rc Reason for logout
1695: */
1696: void fc_ulp_logout ( struct fc_ulp *ulp, int rc ) {
1697:
1698: DBGC ( ulp, "FCULP %s/%02x logged out: %s\n",
1699: fc_ntoa ( &ulp->peer->port_wwn ), ulp->type, strerror ( rc ) );
1700:
1701: /* Drop login reference, if applicable */
1702: if ( fc_link_ok ( &ulp->link ) )
1703: fc_ulp_put ( ulp );
1704:
1705: /* Discard service parameters */
1706: free ( ulp->param );
1707: ulp->param = NULL;
1708: ulp->param_len = 0;
1709: ulp->flags = 0;
1710:
1711: /* Record logout */
1712: fc_link_err ( &ulp->link, rc );
1713:
1714: /* Close ULP if there are no clients attached */
1715: if ( ulp->usage == 0 )
1716: fc_ulp_close ( ulp, rc );
1717: }
1718:
1719: /**
1720: * Handle PRLI completion
1721: *
1722: * @v ulp Fibre Channel upper-layer protocol
1723: * @v rc Reason for completion
1724: */
1725: static void fc_ulp_prli_done ( struct fc_ulp *ulp, int rc ) {
1726:
1727: intf_restart ( &ulp->prli, rc );
1728:
1729: if ( rc != 0 )
1730: fc_ulp_logout ( ulp, rc );
1731: }
1732:
1733: /**
1734: * Examine Fibre Channel upper-layer protocol link state
1735: *
1736: * @ link Fibre Channel link state monitor
1737: */
1738: static void fc_ulp_examine ( struct fc_link_state *link ) {
1739: struct fc_ulp *ulp = container_of ( link, struct fc_ulp, link );
1740: int rc;
1741:
1742: /* Check to see if underlying peer link has gone down */
1743: if ( ! fc_link_ok ( &ulp->peer->link ) ) {
1744: fc_ulp_logout ( ulp, -ENOTCONN );
1745: return;
1746: }
1747:
1748: /* Do nothing if already logged in */
1749: if ( fc_link_ok ( &ulp->link ) &&
1750: ( ulp->flags & FC_ULP_ORIGINATED_LOGIN_OK ) )
1751: return;
1752:
1753: DBGC ( ulp, "FCULP %s/%02x attempting login\n",
1754: fc_ntoa ( &ulp->peer->port_wwn ), ulp->type );
1755:
1756: /* Try to create PRLI ELS */
1757: intf_restart ( &ulp->prli, -ECANCELED );
1758: if ( ( rc = fc_els_prli ( &ulp->prli, ulp->peer->port,
1759: &ulp->peer->port_id, ulp->type ) ) != 0 ) {
1760: DBGC ( ulp, "FCULP %s/%02x could not initiate PRLI: %s\n",
1761: fc_ntoa ( &ulp->peer->port_wwn ), ulp->type,
1762: strerror ( rc ) );
1763: fc_ulp_logout ( ulp, rc );
1764: return;
1765: }
1766: }
1767:
1768: /** Fibre Channel upper-layer protocol PRLI interface operations */
1769: static struct interface_operation fc_ulp_prli_op[] = {
1770: INTF_OP ( intf_close, struct fc_ulp *, fc_ulp_prli_done ),
1771: };
1772:
1773: /** Fibre Channel upper-layer protocol PRLI interface descriptor */
1774: static struct interface_descriptor fc_ulp_prli_desc =
1775: INTF_DESC ( struct fc_ulp, prli, fc_ulp_prli_op );
1776:
1777: /**
1778: * Create Fibre Channel upper-layer protocl
1779: *
1780: * @v peer Fibre Channel peer
1781: * @v type Type
1782: * @ret ulp Fibre Channel upper-layer protocol, or NULL
1783: */
1784: static struct fc_ulp * fc_ulp_create ( struct fc_peer *peer,
1785: unsigned int type ) {
1786: struct fc_ulp *ulp;
1787:
1788: /* Allocate and initialise structure */
1789: ulp = zalloc ( sizeof ( *ulp ) );
1790: if ( ! ulp )
1791: return NULL;
1792: ref_init ( &ulp->refcnt, fc_ulp_free );
1793: fc_link_init ( &ulp->link, fc_ulp_examine, &ulp->refcnt );
1794: intf_init ( &ulp->prli, &fc_ulp_prli_desc, &ulp->refcnt );
1795: ulp->peer = fc_peer_get ( peer );
1796: list_add_tail ( &ulp->list, &peer->ulps );
1797: ulp->type = type;
1798:
1799: /* Start link state monitor */
1800: fc_link_start ( &ulp->link );
1801:
1802: DBGC ( ulp, "FCULP %s/%02x created\n",
1803: fc_ntoa ( &ulp->peer->port_wwn ), ulp->type );
1804: return ulp;
1805: }
1806:
1807: /**
1808: * Get Fibre Channel upper-layer protocol by peer and type
1809: *
1810: * @v peer Fibre Channel peer
1811: * @v type Type
1812: * @ret ulp Fibre Channel upper-layer protocol, or NULL
1813: */
1814: static struct fc_ulp * fc_ulp_get_type ( struct fc_peer *peer,
1815: unsigned int type ) {
1816: struct fc_ulp *ulp;
1817:
1818: /* Look for an existing ULP */
1819: list_for_each_entry ( ulp, &peer->ulps, list ) {
1820: if ( ulp->type == type )
1821: return fc_ulp_get ( ulp );
1822: }
1823:
1824: /* Create a new ULP */
1825: ulp = fc_ulp_create ( peer, type );
1826: if ( ! ulp )
1827: return NULL;
1828:
1829: return ulp;
1830: }
1831:
1832: /**
1833: * Get Fibre Channel upper-layer protocol by port name and type
1834: *
1835: * @v port_wwn Port name
1836: * @v type Type
1837: * @ret ulp Fibre Channel upper-layer protocol, or NULL
1838: */
1839: struct fc_ulp * fc_ulp_get_wwn_type ( const struct fc_name *port_wwn,
1840: unsigned int type ) {
1841: struct fc_ulp *ulp;
1842: struct fc_peer *peer;
1843:
1844: /* Get peer */
1845: peer = fc_peer_get_wwn ( port_wwn );
1846: if ( ! peer )
1847: goto err_peer_get_wwn;
1848:
1849: /* Get ULP */
1850: ulp = fc_ulp_get_type ( peer, type );
1851: if ( ! ulp )
1852: goto err_ulp_get_type;
1853:
1854: /* Drop temporary reference to peer */
1855: fc_peer_put ( peer );
1856:
1857: return ulp;
1858:
1859: fc_ulp_put ( ulp );
1860: err_ulp_get_type:
1861: fc_peer_put ( peer );
1862: err_peer_get_wwn:
1863: return NULL;
1864: }
1865:
1866: /**
1867: * Get Fibre Channel upper-layer protocol by port ID and type
1868: *
1869: * @v port Fibre Channel port
1870: * @v peer_port_id Peer port ID
1871: * @v type Type
1872: * @ret ulp Fibre Channel upper-layer protocol, or NULL
1873: */
1874: struct fc_ulp * fc_ulp_get_port_id_type ( struct fc_port *port,
1875: const struct fc_port_id *peer_port_id,
1876: unsigned int type ) {
1877: struct fc_ulp *ulp;
1878: struct fc_peer *peer;
1879:
1880: /* Get peer */
1881: peer = fc_peer_get_port_id ( port, peer_port_id );
1882: if ( ! peer )
1883: goto err_peer_get_wwn;
1884:
1885: /* Get ULP */
1886: ulp = fc_ulp_get_type ( peer, type );
1887: if ( ! ulp )
1888: goto err_ulp_get_type;
1889:
1890: /* Drop temporary reference to peer */
1891: fc_peer_put ( peer );
1892:
1893: return ulp;
1894:
1895: fc_ulp_put ( ulp );
1896: err_ulp_get_type:
1897: fc_peer_put ( peer );
1898: err_peer_get_wwn:
1899: return NULL;
1900: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.