![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aoe.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 aoe.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net |
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 <string.h>
23: #include <stdio.h>
24: #include <stdlib.h>
25: #include <errno.h>
26: #include <assert.h>
27: #include <byteswap.h>
28: #include <ipxe/list.h>
29: #include <ipxe/if_ether.h>
30: #include <ipxe/iobuf.h>
31: #include <ipxe/uaccess.h>
32: #include <ipxe/netdevice.h>
33: #include <ipxe/features.h>
34: #include <ipxe/interface.h>
35: #include <ipxe/xfer.h>
36: #include <ipxe/uri.h>
37: #include <ipxe/open.h>
38: #include <ipxe/ata.h>
39: #include <ipxe/device.h>
40: #include <ipxe/aoe.h>
41:
42: /** @file
43: *
44: * AoE protocol
45: *
46: */
47:
48: FEATURE ( FEATURE_PROTOCOL, "AoE", DHCP_EB_FEATURE_AOE, 1 );
49:
50: struct net_protocol aoe_protocol __net_protocol;
51:
52: /******************************************************************************
53: *
54: * AoE devices and commands
55: *
56: ******************************************************************************
57: */
58:
59: /** List of all AoE devices */
60: static LIST_HEAD ( aoe_devices );
61:
62: /** List of active AoE commands */
63: static LIST_HEAD ( aoe_commands );
64:
65: /** An AoE device */
66: struct aoe_device {
67: /** Reference counter */
68: struct refcnt refcnt;
69:
70: /** Network device */
71: struct net_device *netdev;
72: /** ATA command issuing interface */
73: struct interface ata;
74:
75: /** Major number */
76: uint16_t major;
77: /** Minor number */
78: uint8_t minor;
79: /** Target MAC address */
80: uint8_t target[MAX_LL_ADDR_LEN];
81:
82: /** Saved timeout value */
83: unsigned long timeout;
84:
85: /** Configuration command interface */
86: struct interface config;
87: /** Device is configued */
88: int configured;
89: };
90:
91: /** An AoE command */
92: struct aoe_command {
93: /** Reference count */
94: struct refcnt refcnt;
95: /** AOE device */
96: struct aoe_device *aoedev;
97: /** List of active commands */
98: struct list_head list;
99:
100: /** ATA command interface */
101: struct interface ata;
102:
103: /** ATA command */
104: struct ata_cmd command;
105: /** Command type */
106: struct aoe_command_type *type;
107: /** Command tag */
108: uint32_t tag;
109:
110: /** Retransmission timer */
111: struct retry_timer timer;
112: };
113:
114: /** An AoE command type */
115: struct aoe_command_type {
116: /**
117: * Calculate length of AoE command IU
118: *
119: * @v aoecmd AoE command
120: * @ret len Length of command IU
121: */
122: size_t ( * cmd_len ) ( struct aoe_command *aoecmd );
123: /**
124: * Build AoE command IU
125: *
126: * @v aoecmd AoE command
127: * @v data Command IU
128: * @v len Length of command IU
129: */
130: void ( * cmd ) ( struct aoe_command *aoecmd, void *data, size_t len );
131: /**
132: * Handle AoE response IU
133: *
134: * @v aoecmd AoE command
135: * @v data Response IU
136: * @v len Length of response IU
137: * @v ll_source Link-layer source address
138: * @ret rc Return status code
139: */
140: int ( * rsp ) ( struct aoe_command *aoecmd, const void *data,
141: size_t len, const void *ll_source );
142: };
143:
144: /**
145: * Get reference to AoE device
146: *
147: * @v aoedev AoE device
148: * @ret aoedev AoE device
149: */
150: static inline __attribute__ (( always_inline )) struct aoe_device *
151: aoedev_get ( struct aoe_device *aoedev ) {
152: ref_get ( &aoedev->refcnt );
153: return aoedev;
154: }
155:
156: /**
157: * Drop reference to AoE device
158: *
159: * @v aoedev AoE device
160: */
161: static inline __attribute__ (( always_inline )) void
162: aoedev_put ( struct aoe_device *aoedev ) {
163: ref_put ( &aoedev->refcnt );
164: }
165:
166: /**
167: * Get reference to AoE command
168: *
169: * @v aoecmd AoE command
170: * @ret aoecmd AoE command
171: */
172: static inline __attribute__ (( always_inline )) struct aoe_command *
173: aoecmd_get ( struct aoe_command *aoecmd ) {
174: ref_get ( &aoecmd->refcnt );
175: return aoecmd;
176: }
177:
178: /**
179: * Drop reference to AoE command
180: *
181: * @v aoecmd AoE command
182: */
183: static inline __attribute__ (( always_inline )) void
184: aoecmd_put ( struct aoe_command *aoecmd ) {
185: ref_put ( &aoecmd->refcnt );
186: }
187:
188: /**
189: * Name AoE device
190: *
191: * @v aoedev AoE device
192: * @ret name AoE device name
193: */
194: static const char * aoedev_name ( struct aoe_device *aoedev ) {
195: static char buf[16];
196:
197: snprintf ( buf, sizeof ( buf ), "%s/e%d.%d", aoedev->netdev->name,
198: aoedev->major, aoedev->minor );
199: return buf;
200: }
201:
202: /**
203: * Free AoE command
204: *
205: * @v refcnt Reference counter
206: */
207: static void aoecmd_free ( struct refcnt *refcnt ) {
208: struct aoe_command *aoecmd =
209: container_of ( refcnt, struct aoe_command, refcnt );
210:
211: assert ( ! timer_running ( &aoecmd->timer ) );
212: assert ( list_empty ( &aoecmd->list ) );
213:
214: aoedev_put ( aoecmd->aoedev );
215: free ( aoecmd );
216: }
217:
218: /**
219: * Close AoE command
220: *
221: * @v aoecmd AoE command
222: * @v rc Reason for close
223: */
224: static void aoecmd_close ( struct aoe_command *aoecmd, int rc ) {
225: struct aoe_device *aoedev = aoecmd->aoedev;
226:
227: /* Stop timer */
228: stop_timer ( &aoecmd->timer );
229:
230: /* Preserve the timeout value for subsequent commands */
231: aoedev->timeout = aoecmd->timer.timeout;
232:
233: /* Remove from list of commands */
234: if ( ! list_empty ( &aoecmd->list ) ) {
235: list_del ( &aoecmd->list );
236: INIT_LIST_HEAD ( &aoecmd->list );
237: aoecmd_put ( aoecmd );
238: }
239:
240: /* Shut down interfaces */
241: intf_shutdown ( &aoecmd->ata, rc );
242: }
243:
244: /**
245: * Transmit AoE command request
246: *
247: * @v aoecmd AoE command
248: * @ret rc Return status code
249: */
250: static int aoecmd_tx ( struct aoe_command *aoecmd ) {
251: struct aoe_device *aoedev = aoecmd->aoedev;
252: struct net_device *netdev = aoedev->netdev;
253: struct io_buffer *iobuf;
254: struct aoehdr *aoehdr;
255: size_t cmd_len;
256: int rc;
257:
258: /* Sanity check */
259: assert ( netdev != NULL );
260:
261: /* If we are transmitting anything that requires a response,
262: * start the retransmission timer. Do this before attempting
263: * to allocate the I/O buffer, in case allocation itself
264: * fails.
265: */
266: start_timer ( &aoecmd->timer );
267:
268: /* Create outgoing I/O buffer */
269: cmd_len = aoecmd->type->cmd_len ( aoecmd );
270: iobuf = alloc_iob ( MAX_LL_HEADER_LEN + cmd_len );
271: if ( ! iobuf )
272: return -ENOMEM;
273: iob_reserve ( iobuf, MAX_LL_HEADER_LEN );
274: aoehdr = iob_put ( iobuf, cmd_len );
275:
276: /* Fill AoE header */
277: memset ( aoehdr, 0, sizeof ( *aoehdr ) );
278: aoehdr->ver_flags = AOE_VERSION;
279: aoehdr->major = htons ( aoedev->major );
280: aoehdr->minor = aoedev->minor;
281: aoehdr->tag = htonl ( aoecmd->tag );
282: aoecmd->type->cmd ( aoecmd, iobuf->data, iob_len ( iobuf ) );
283:
284: /* Send packet */
285: if ( ( rc = net_tx ( iobuf, netdev, &aoe_protocol, aoedev->target,
286: netdev->ll_addr ) ) != 0 ) {
287: DBGC ( aoedev, "AoE %s/%08x could not transmit: %s\n",
288: aoedev_name ( aoedev ), aoecmd->tag,
289: strerror ( rc ) );
290: return rc;
291: }
292:
293: return 0;
294: }
295:
296: /**
297: * Receive AoE command response
298: *
299: * @v aoecmd AoE command
300: * @v iobuf I/O buffer
301: * @v ll_source Link-layer source address
302: * @ret rc Return status code
303: */
304: static int aoecmd_rx ( struct aoe_command *aoecmd, struct io_buffer *iobuf,
305: const void *ll_source ) {
306: struct aoe_device *aoedev = aoecmd->aoedev;
307: struct aoehdr *aoehdr = iobuf->data;
308: int rc;
309:
310: /* Sanity check */
311: if ( iob_len ( iobuf ) < sizeof ( *aoehdr ) ) {
312: DBGC ( aoedev, "AoE %s/%08x received underlength response "
313: "(%zd bytes)\n", aoedev_name ( aoedev ),
314: aoecmd->tag, iob_len ( iobuf ) );
315: rc = -EINVAL;
316: goto done;
317: }
318: if ( ( ntohs ( aoehdr->major ) != aoedev->major ) ||
319: ( aoehdr->minor != aoedev->minor ) ) {
320: DBGC ( aoedev, "AoE %s/%08x received response for incorrect "
321: "device e%d.%d\n", aoedev_name ( aoedev ), aoecmd->tag,
322: ntohs ( aoehdr->major ), aoehdr->minor );
323: rc = -EINVAL;
324: goto done;
325: }
326:
327: /* Catch command failures */
328: if ( aoehdr->ver_flags & AOE_FL_ERROR ) {
329: DBGC ( aoedev, "AoE %s/%08x terminated in error\n",
330: aoedev_name ( aoedev ), aoecmd->tag );
331: aoecmd_close ( aoecmd, -EIO );
332: rc = -EIO;
333: goto done;
334: }
335:
336: /* Hand off to command completion handler */
337: if ( ( rc = aoecmd->type->rsp ( aoecmd, iobuf->data, iob_len ( iobuf ),
338: ll_source ) ) != 0 )
339: goto done;
340:
341: done:
342: /* Free I/O buffer */
343: free_iob ( iobuf );
344:
345: /* Terminate command */
346: aoecmd_close ( aoecmd, rc );
347:
348: return rc;
349: }
350:
351: /**
352: * Handle AoE retry timer expiry
353: *
354: * @v timer AoE retry timer
355: * @v fail Failure indicator
356: */
357: static void aoecmd_expired ( struct retry_timer *timer, int fail ) {
358: struct aoe_command *aoecmd =
359: container_of ( timer, struct aoe_command, timer );
360:
361: if ( fail ) {
362: aoecmd_close ( aoecmd, -ETIMEDOUT );
363: } else {
364: aoecmd_tx ( aoecmd );
365: }
366: }
367:
368: /**
369: * Calculate length of AoE ATA command IU
370: *
371: * @v aoecmd AoE command
372: * @ret len Length of command IU
373: */
374: static size_t aoecmd_ata_cmd_len ( struct aoe_command *aoecmd ) {
375: struct ata_cmd *command = &aoecmd->command;
376:
377: return ( sizeof ( struct aoehdr ) + sizeof ( struct aoeata ) +
378: command->data_out_len );
379: }
380:
381: /**
382: * Build AoE ATA command IU
383: *
384: * @v aoecmd AoE command
385: * @v data Command IU
386: * @v len Length of command IU
387: */
388: static void aoecmd_ata_cmd ( struct aoe_command *aoecmd,
389: void *data, size_t len ) {
390: struct aoe_device *aoedev = aoecmd->aoedev;
391: struct ata_cmd *command = &aoecmd->command;
392: struct aoehdr *aoehdr = data;
393: struct aoeata *aoeata = &aoehdr->payload[0].ata;
394:
395: /* Sanity check */
396: linker_assert ( AOE_FL_DEV_HEAD == ATA_DEV_SLAVE, __fix_ata_h__ );
397: assert ( len == ( sizeof ( *aoehdr ) + sizeof ( *aoeata ) +
398: command->data_out_len ) );
399:
400: /* Build IU */
401: aoehdr->command = AOE_CMD_ATA;
402: memset ( aoeata, 0, sizeof ( *aoeata ) );
403: aoeata->aflags = ( ( command->cb.lba48 ? AOE_FL_EXTENDED : 0 ) |
404: ( command->cb.device & ATA_DEV_SLAVE ) |
405: ( command->data_out_len ? AOE_FL_WRITE : 0 ) );
406: aoeata->err_feat = command->cb.err_feat.bytes.cur;
407: aoeata->count = command->cb.count.native;
408: aoeata->cmd_stat = command->cb.cmd_stat;
409: aoeata->lba.u64 = cpu_to_le64 ( command->cb.lba.native );
410: if ( ! command->cb.lba48 )
411: aoeata->lba.bytes[3] |=
412: ( command->cb.device & ATA_DEV_MASK );
413: copy_from_user ( aoeata->data, command->data_out, 0,
414: command->data_out_len );
415:
416: DBGC2 ( aoedev, "AoE %s/%08x ATA cmd %02x:%02x:%02x:%02x:%08llx",
417: aoedev_name ( aoedev ), aoecmd->tag, aoeata->aflags,
418: aoeata->err_feat, aoeata->count, aoeata->cmd_stat,
419: aoeata->lba.u64 );
420: if ( command->data_out_len )
421: DBGC2 ( aoedev, " out %04zx", command->data_out_len );
422: if ( command->data_in_len )
423: DBGC2 ( aoedev, " in %04zx", command->data_in_len );
424: DBGC2 ( aoedev, "\n" );
425: }
426:
427: /**
428: * Handle AoE ATA response IU
429: *
430: * @v aoecmd AoE command
431: * @v data Response IU
432: * @v len Length of response IU
433: * @v ll_source Link-layer source address
434: * @ret rc Return status code
435: */
436: static int aoecmd_ata_rsp ( struct aoe_command *aoecmd, const void *data,
437: size_t len, const void *ll_source __unused ) {
438: struct aoe_device *aoedev = aoecmd->aoedev;
439: struct ata_cmd *command = &aoecmd->command;
440: const struct aoehdr *aoehdr = data;
441: const struct aoeata *aoeata = &aoehdr->payload[0].ata;
442: size_t data_len;
443:
444: /* Sanity check */
445: if ( len < ( sizeof ( *aoehdr ) + sizeof ( *aoeata ) ) ) {
446: DBGC ( aoedev, "AoE %s/%08x received underlength ATA response "
447: "(%zd bytes)\n", aoedev_name ( aoedev ),
448: aoecmd->tag, len );
449: return -EINVAL;
450: }
451: data_len = ( len - ( sizeof ( *aoehdr ) + sizeof ( *aoeata ) ) );
452: DBGC2 ( aoedev, "AoE %s/%08x ATA rsp %02x in %04zx\n",
453: aoedev_name ( aoedev ), aoecmd->tag, aoeata->cmd_stat,
454: data_len );
455:
456: /* Check for command failure */
457: if ( aoeata->cmd_stat & ATA_STAT_ERR ) {
458: DBGC ( aoedev, "AoE %s/%08x status %02x\n",
459: aoedev_name ( aoedev ), aoecmd->tag, aoeata->cmd_stat );
460: return -EIO;
461: }
462:
463: /* Check data-in length is sufficient. (There may be trailing
464: * garbage due to Ethernet minimum-frame-size padding.)
465: */
466: if ( data_len < command->data_in_len ) {
467: DBGC ( aoedev, "AoE %s/%08x data-in underrun (received %zd, "
468: "expected %zd)\n", aoedev_name ( aoedev ), aoecmd->tag,
469: data_len, command->data_in_len );
470: return -ERANGE;
471: }
472:
473: /* Copy out data payload */
474: copy_to_user ( command->data_in, 0, aoeata->data,
475: command->data_in_len );
476:
477: return 0;
478: }
479:
480: /** AoE ATA command */
481: static struct aoe_command_type aoecmd_ata = {
482: .cmd_len = aoecmd_ata_cmd_len,
483: .cmd = aoecmd_ata_cmd,
484: .rsp = aoecmd_ata_rsp,
485: };
486:
487: /**
488: * Calculate length of AoE configuration command IU
489: *
490: * @v aoecmd AoE command
491: * @ret len Length of command IU
492: */
493: static size_t aoecmd_cfg_cmd_len ( struct aoe_command *aoecmd __unused ) {
494: return ( sizeof ( struct aoehdr ) + sizeof ( struct aoecfg ) );
495: }
496:
497: /**
498: * Build AoE configuration command IU
499: *
500: * @v aoecmd AoE command
501: * @v data Command IU
502: * @v len Length of command IU
503: */
504: static void aoecmd_cfg_cmd ( struct aoe_command *aoecmd,
505: void *data, size_t len ) {
506: struct aoe_device *aoedev = aoecmd->aoedev;
507: struct aoehdr *aoehdr = data;
508: struct aoecfg *aoecfg = &aoehdr->payload[0].cfg;
509:
510: /* Sanity check */
511: assert ( len == ( sizeof ( *aoehdr ) + sizeof ( *aoecfg ) ) );
512:
513: /* Build IU */
514: aoehdr->command = AOE_CMD_CONFIG;
515: memset ( aoecfg, 0, sizeof ( *aoecfg ) );
516:
517: DBGC ( aoedev, "AoE %s/%08x CONFIG cmd\n",
518: aoedev_name ( aoedev ), aoecmd->tag );
519: }
520:
521: /**
522: * Handle AoE configuration response IU
523: *
524: * @v aoecmd AoE command
525: * @v data Response IU
526: * @v len Length of response IU
527: * @v ll_source Link-layer source address
528: * @ret rc Return status code
529: */
530: static int aoecmd_cfg_rsp ( struct aoe_command *aoecmd, const void *data,
531: size_t len, const void *ll_source ) {
532: struct aoe_device *aoedev = aoecmd->aoedev;
533: struct ll_protocol *ll_protocol = aoedev->netdev->ll_protocol;
534: const struct aoehdr *aoehdr = data;
535: const struct aoecfg *aoecfg = &aoehdr->payload[0].cfg;
536:
537: /* Sanity check */
538: if ( len < ( sizeof ( *aoehdr ) + sizeof ( *aoecfg ) ) ) {
539: DBGC ( aoedev, "AoE %s/%08x received underlength "
540: "configuration response (%zd bytes)\n",
541: aoedev_name ( aoedev ), aoecmd->tag, len );
542: return -EINVAL;
543: }
544: DBGC ( aoedev, "AoE %s/%08x CONFIG rsp buf %04x fw %04x scnt %02x\n",
545: aoedev_name ( aoedev ), aoecmd->tag, ntohs ( aoecfg->bufcnt ),
546: aoecfg->fwver, aoecfg->scnt );
547:
548: /* Record target MAC address */
549: memcpy ( aoedev->target, ll_source, ll_protocol->ll_addr_len );
550: DBGC ( aoedev, "AoE %s has MAC address %s\n",
551: aoedev_name ( aoedev ), ll_protocol->ntoa ( aoedev->target ) );
552:
553: return 0;
554: }
555:
556: /** AoE configuration command */
557: static struct aoe_command_type aoecmd_cfg = {
558: .cmd_len = aoecmd_cfg_cmd_len,
559: .cmd = aoecmd_cfg_cmd,
560: .rsp = aoecmd_cfg_rsp,
561: };
562:
563: /** AoE command ATA interface operations */
564: static struct interface_operation aoecmd_ata_op[] = {
565: INTF_OP ( intf_close, struct aoe_command *, aoecmd_close ),
566: };
567:
568: /** AoE command ATA interface descriptor */
569: static struct interface_descriptor aoecmd_ata_desc =
570: INTF_DESC ( struct aoe_command, ata, aoecmd_ata_op );
571:
572: /**
573: * Identify AoE command by tag
574: *
575: * @v tag Command tag
576: * @ret aoecmd AoE command, or NULL
577: */
578: static struct aoe_command * aoecmd_find_tag ( uint32_t tag ) {
579: struct aoe_command *aoecmd;
580:
581: list_for_each_entry ( aoecmd, &aoe_commands, list ) {
582: if ( aoecmd->tag == tag )
583: return aoecmd;
584: }
585: return NULL;
586: }
587:
588: /**
589: * Choose an AoE command tag
590: *
591: * @ret tag New tag, or negative error
592: */
593: static int aoecmd_new_tag ( void ) {
594: static uint16_t tag_idx;
595: unsigned int i;
596:
597: for ( i = 0 ; i < 65536 ; i++ ) {
598: tag_idx++;
599: if ( aoecmd_find_tag ( tag_idx ) == NULL )
600: return ( AOE_TAG_MAGIC | tag_idx );
601: }
602: return -EADDRINUSE;
603: }
604:
605: /**
606: * Create AoE command
607: *
608: * @v aoedev AoE device
609: * @v type AoE command type
610: * @ret aoecmd AoE command
611: */
612: static struct aoe_command * aoecmd_create ( struct aoe_device *aoedev,
613: struct aoe_command_type *type ) {
614: struct aoe_command *aoecmd;
615: int tag;
616:
617: /* Allocate command tag */
618: tag = aoecmd_new_tag();
619: if ( tag < 0 )
620: return NULL;
621:
622: /* Allocate and initialise structure */
623: aoecmd = zalloc ( sizeof ( *aoecmd ) );
624: if ( ! aoecmd )
625: return NULL;
626: ref_init ( &aoecmd->refcnt, aoecmd_free );
627: list_add ( &aoecmd->list, &aoe_commands );
628: intf_init ( &aoecmd->ata, &aoecmd_ata_desc, &aoecmd->refcnt );
629: timer_init ( &aoecmd->timer, aoecmd_expired, &aoecmd->refcnt );
630: aoecmd->aoedev = aoedev_get ( aoedev );
631: aoecmd->type = type;
632: aoecmd->tag = tag;
633:
634: /* Preserve timeout from last completed command */
635: aoecmd->timer.timeout = aoedev->timeout;
636:
637: /* Return already mortalised. (Reference is held by command list.) */
638: return aoecmd;
639: }
640:
641: /**
642: * Issue AoE ATA command
643: *
644: * @v aoedev AoE device
645: * @v parent Parent interface
646: * @v command ATA command
647: * @ret tag Command tag, or negative error
648: */
649: static int aoedev_ata_command ( struct aoe_device *aoedev,
650: struct interface *parent,
651: struct ata_cmd *command ) {
652: struct net_device *netdev = aoedev->netdev;
653: struct aoe_command *aoecmd;
654:
655: /* Fail immediately if net device is closed */
656: if ( ! netdev_is_open ( netdev ) ) {
657: DBGC ( aoedev, "AoE %s cannot issue command while net device "
658: "is closed\n", aoedev_name ( aoedev ) );
659: return -EWOULDBLOCK;
660: }
661:
662: /* Create command */
663: aoecmd = aoecmd_create ( aoedev, &aoecmd_ata );
664: if ( ! aoecmd )
665: return -ENOMEM;
666: memcpy ( &aoecmd->command, command, sizeof ( aoecmd->command ) );
667:
668: /* Attempt to send command. Allow failures to be handled by
669: * the retry timer.
670: */
671: aoecmd_tx ( aoecmd );
672:
673: /* Attach to parent interface, leave reference with command
674: * list, and return.
675: */
676: intf_plug_plug ( &aoecmd->ata, parent );
677: return aoecmd->tag;
678: }
679:
680: /**
681: * Issue AoE configuration command
682: *
683: * @v aoedev AoE device
684: * @v parent Parent interface
685: * @ret tag Command tag, or negative error
686: */
687: static int aoedev_cfg_command ( struct aoe_device *aoedev,
688: struct interface *parent ) {
689: struct aoe_command *aoecmd;
690:
691: /* Create command */
692: aoecmd = aoecmd_create ( aoedev, &aoecmd_cfg );
693: if ( ! aoecmd )
694: return -ENOMEM;
695:
696: /* Attempt to send command. Allow failures to be handled by
697: * the retry timer.
698: */
699: aoecmd_tx ( aoecmd );
700:
701: /* Attach to parent interface, leave reference with command
702: * list, and return.
703: */
704: intf_plug_plug ( &aoecmd->ata, parent );
705: return aoecmd->tag;
706: }
707:
708: /**
709: * Free AoE device
710: *
711: * @v refcnt Reference count
712: */
713: static void aoedev_free ( struct refcnt *refcnt ) {
714: struct aoe_device *aoedev =
715: container_of ( refcnt, struct aoe_device, refcnt );
716:
717: netdev_put ( aoedev->netdev );
718: free ( aoedev );
719: }
720:
721: /**
722: * Close AoE device
723: *
724: * @v aoedev AoE device
725: * @v rc Reason for close
726: */
727: static void aoedev_close ( struct aoe_device *aoedev, int rc ) {
728: struct aoe_command *aoecmd;
729: struct aoe_command *tmp;
730:
731: /* Shut down interfaces */
732: intf_shutdown ( &aoedev->ata, rc );
733: intf_shutdown ( &aoedev->config, rc );
734:
735: /* Shut down any active commands */
736: list_for_each_entry_safe ( aoecmd, tmp, &aoe_commands, list ) {
737: if ( aoecmd->aoedev != aoedev )
738: continue;
739: aoecmd_get ( aoecmd );
740: aoecmd_close ( aoecmd, rc );
741: aoecmd_put ( aoecmd );
742: }
743: }
744:
745: /**
746: * Check AoE device flow-control window
747: *
748: * @v aoedev AoE device
749: * @ret len Length of window
750: */
751: static size_t aoedev_window ( struct aoe_device *aoedev ) {
752: return ( aoedev->configured ? ~( ( size_t ) 0 ) : 0 );
753: }
754:
755: /**
756: * Handle AoE device configuration completion
757: *
758: * @v aoedev AoE device
759: * @v rc Reason for completion
760: */
761: static void aoedev_config_done ( struct aoe_device *aoedev, int rc ) {
762:
763: /* Shut down interface */
764: intf_shutdown ( &aoedev->config, rc );
765:
766: /* Close device on failure */
767: if ( rc != 0 ) {
768: aoedev_close ( aoedev, rc );
769: return;
770: }
771:
772: /* Mark device as configured */
773: aoedev->configured = 1;
774: xfer_window_changed ( &aoedev->ata );
775: }
776:
777: /**
778: * Identify device underlying AoE device
779: *
780: * @v aoedev AoE device
781: * @ret device Underlying device
782: */
783: static struct device * aoedev_identify_device ( struct aoe_device *aoedev ) {
784: return aoedev->netdev->dev;
785: }
786:
787: /**
788: * Describe AoE device in an ACPI table
789: *
790: * @v aoedev AoE device
791: * @v acpi ACPI table
792: * @v len Length of ACPI table
793: * @ret rc Return status code
794: */
795: static int aoedev_describe ( struct aoe_device *aoedev,
796: struct acpi_description_header *acpi,
797: size_t len ) {
798: struct abft_table *abft =
799: container_of ( acpi, struct abft_table, acpi );
800:
801: /* Sanity check */
802: if ( len < sizeof ( *abft ) )
803: return -ENOBUFS;
804:
805: /* Populate table */
806: abft->acpi.signature = cpu_to_le32 ( ABFT_SIG );
807: abft->acpi.length = cpu_to_le32 ( sizeof ( *abft ) );
808: abft->acpi.revision = 1;
809: abft->shelf = cpu_to_le16 ( aoedev->major );
810: abft->slot = aoedev->minor;
811: memcpy ( abft->mac, aoedev->netdev->ll_addr, sizeof ( abft->mac ) );
812:
813: return 0;
814: }
815:
816: /** AoE device ATA interface operations */
817: static struct interface_operation aoedev_ata_op[] = {
818: INTF_OP ( ata_command, struct aoe_device *, aoedev_ata_command ),
819: INTF_OP ( xfer_window, struct aoe_device *, aoedev_window ),
820: INTF_OP ( intf_close, struct aoe_device *, aoedev_close ),
821: INTF_OP ( acpi_describe, struct aoe_device *, aoedev_describe ),
822: INTF_OP ( identify_device, struct aoe_device *,
823: aoedev_identify_device ),
824: };
825:
826: /** AoE device ATA interface descriptor */
827: static struct interface_descriptor aoedev_ata_desc =
828: INTF_DESC ( struct aoe_device, ata, aoedev_ata_op );
829:
830: /** AoE device configuration interface operations */
831: static struct interface_operation aoedev_config_op[] = {
832: INTF_OP ( intf_close, struct aoe_device *, aoedev_config_done ),
833: };
834:
835: /** AoE device configuration interface descriptor */
836: static struct interface_descriptor aoedev_config_desc =
837: INTF_DESC ( struct aoe_device, config, aoedev_config_op );
838:
839: /**
840: * Open AoE device
841: *
842: * @v parent Parent interface
843: * @v netdev Network device
844: * @v major Device major number
845: * @v minor Device minor number
846: * @ret rc Return status code
847: */
848: static int aoedev_open ( struct interface *parent, struct net_device *netdev,
849: unsigned int major, unsigned int minor ) {
850: struct aoe_device *aoedev;
851: int rc;
852:
853: /* Allocate and initialise structure */
854: aoedev = zalloc ( sizeof ( *aoedev ) );
855: if ( ! aoedev ) {
856: rc = -ENOMEM;
857: goto err_zalloc;
858: }
859: ref_init ( &aoedev->refcnt, aoedev_free );
860: intf_init ( &aoedev->ata, &aoedev_ata_desc, &aoedev->refcnt );
861: intf_init ( &aoedev->config, &aoedev_config_desc, &aoedev->refcnt );
862: aoedev->netdev = netdev_get ( netdev );
863: aoedev->major = major;
864: aoedev->minor = minor;
865: memcpy ( aoedev->target, netdev->ll_broadcast,
866: netdev->ll_protocol->ll_addr_len );
867:
868: /* Initiate configuration */
869: if ( ( rc = aoedev_cfg_command ( aoedev, &aoedev->config ) ) < 0 ) {
870: DBGC ( aoedev, "AoE %s could not initiate configuration: %s\n",
871: aoedev_name ( aoedev ), strerror ( rc ) );
872: goto err_config;
873: }
874:
875: /* Attach ATA device to parent interface */
876: if ( ( rc = ata_open ( parent, &aoedev->ata, ATA_DEV_MASTER,
877: AOE_MAX_COUNT ) ) != 0 ) {
878: DBGC ( aoedev, "AoE %s could not create ATA device: %s\n",
879: aoedev_name ( aoedev ), strerror ( rc ) );
880: goto err_ata_open;
881: }
882:
883: /* Mortalise self and return */
884: ref_put ( &aoedev->refcnt );
885: return 0;
886:
887: err_ata_open:
888: err_config:
889: aoedev_close ( aoedev, rc );
890: ref_put ( &aoedev->refcnt );
891: err_zalloc:
892: return rc;
893: }
894:
895: /******************************************************************************
896: *
897: * AoE network protocol
898: *
899: ******************************************************************************
900: */
901:
902: /**
903: * Process incoming AoE packets
904: *
905: * @v iobuf I/O buffer
906: * @v netdev Network device
907: * @v ll_dest Link-layer destination address
908: * @v ll_source Link-layer source address
909: * @ret rc Return status code
910: *
911: */
912: static int aoe_rx ( struct io_buffer *iobuf,
913: struct net_device *netdev __unused,
914: const void *ll_dest __unused,
915: const void *ll_source ) {
916: struct aoehdr *aoehdr = iobuf->data;
917: struct aoe_command *aoecmd;
918: int rc;
919:
920: /* Sanity check */
921: if ( iob_len ( iobuf ) < sizeof ( *aoehdr ) ) {
922: DBG ( "AoE received underlength packet (%zd bytes)\n",
923: iob_len ( iobuf ) );
924: rc = -EINVAL;
925: goto err_sanity;
926: }
927: if ( ( aoehdr->ver_flags & AOE_VERSION_MASK ) != AOE_VERSION ) {
928: DBG ( "AoE received packet for unsupported protocol version "
929: "%02x\n", ( aoehdr->ver_flags & AOE_VERSION_MASK ) );
930: rc = -EPROTONOSUPPORT;
931: goto err_sanity;
932: }
933: if ( ! ( aoehdr->ver_flags & AOE_FL_RESPONSE ) ) {
934: DBG ( "AoE received request packet\n" );
935: rc = -EOPNOTSUPP;
936: goto err_sanity;
937: }
938:
939: /* Demultiplex amongst active AoE commands */
940: aoecmd = aoecmd_find_tag ( ntohl ( aoehdr->tag ) );
941: if ( ! aoecmd ) {
942: DBG ( "AoE received packet for unused tag %08x\n",
943: ntohl ( aoehdr->tag ) );
944: rc = -ENOENT;
945: goto err_demux;
946: }
947:
948: /* Pass received frame to command */
949: aoecmd_get ( aoecmd );
950: if ( ( rc = aoecmd_rx ( aoecmd, iob_disown ( iobuf ),
951: ll_source ) ) != 0 )
952: goto err_rx;
953:
954: err_rx:
955: aoecmd_put ( aoecmd );
956: err_demux:
957: err_sanity:
958: free_iob ( iobuf );
959: return rc;
960: }
961:
962: /** AoE protocol */
963: struct net_protocol aoe_protocol __net_protocol = {
964: .name = "AoE",
965: .net_proto = htons ( ETH_P_AOE ),
966: .rx = aoe_rx,
967: };
968:
969: /******************************************************************************
970: *
971: * AoE URIs
972: *
973: ******************************************************************************
974: */
975:
976: /**
977: * Parse AoE URI
978: *
979: * @v uri URI
980: * @ret major Major device number
981: * @ret minor Minor device number
982: * @ret rc Return status code
983: *
984: * An AoE URI has the form "aoe:e<major>.<minor>".
985: */
986: static int aoe_parse_uri ( struct uri *uri, unsigned int *major,
987: unsigned int *minor ) {
988: const char *ptr;
989: char *end;
990:
991: /* Check for URI with opaque portion */
992: if ( ! uri->opaque )
993: return -EINVAL;
994: ptr = uri->opaque;
995:
996: /* Check for initial 'e' */
997: if ( *ptr != 'e' )
998: return -EINVAL;
999: ptr++;
1000:
1001: /* Parse major device number */
1002: *major = strtoul ( ptr, &end, 10 );
1003: if ( *end != '.' )
1004: return -EINVAL;
1005: ptr = ( end + 1 );
1006:
1007: /* Parse minor device number */
1008: *minor = strtoul ( ptr, &end, 10 );
1009: if ( *end )
1010: return -EINVAL;
1011:
1012: return 0;
1013: }
1014:
1015: /**
1016: * Open AoE URI
1017: *
1018: * @v parent Parent interface
1019: * @v uri URI
1020: * @ret rc Return status code
1021: */
1022: static int aoe_open ( struct interface *parent, struct uri *uri ) {
1023: struct net_device *netdev;
1024: unsigned int major;
1025: unsigned int minor;
1026: int rc;
1027:
1028: /* Identify network device. This is something of a hack, but
1029: * the AoE URI scheme that has been in use for some time now
1030: * provides no way to specify a particular device.
1031: */
1032: netdev = last_opened_netdev();
1033: if ( ! netdev ) {
1034: DBG ( "AoE cannot identify network device\n" );
1035: return -ENODEV;
1036: }
1037:
1038: /* Parse URI */
1039: if ( ( rc = aoe_parse_uri ( uri, &major, &minor ) ) != 0 ) {
1040: DBG ( "AoE cannot parse URI\n" );
1041: return rc;
1042: }
1043:
1044: /* Open AoE device */
1045: if ( ( rc = aoedev_open ( parent, netdev, major, minor ) ) != 0 )
1046: return rc;
1047:
1048: return 0;
1049: }
1050:
1051: /** AoE URI opener */
1052: struct uri_opener aoe_uri_opener __uri_opener = {
1053: .scheme = "aoe",
1054: .open = aoe_open,
1055: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.