[ata] Make ATA command issuing partially asynchronous
[people/sha0/gpxe.git] / src / net / aoe.c
1 /*
2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
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 <gpxe/list.h>
29 #include <gpxe/if_ether.h>
30 #include <gpxe/ethernet.h>
31 #include <gpxe/iobuf.h>
32 #include <gpxe/uaccess.h>
33 #include <gpxe/ata.h>
34 #include <gpxe/netdevice.h>
35 #include <gpxe/process.h>
36 #include <gpxe/features.h>
37 #include <gpxe/aoe.h>
38
39 /** @file
40  *
41  * AoE protocol
42  *
43  */
44
45 FEATURE ( FEATURE_PROTOCOL, "AoE", DHCP_EB_FEATURE_AOE, 1 );
46
47 struct net_protocol aoe_protocol;
48
49 /** List of all AoE sessions */
50 static LIST_HEAD ( aoe_sessions );
51
52 static void aoe_free ( struct refcnt *refcnt ) {
53         struct aoe_session *aoe =
54                 container_of ( refcnt, struct aoe_session, refcnt );
55
56         netdev_put ( aoe->netdev );
57         free ( aoe );
58 }
59
60 /**
61  * Mark current AoE command complete
62  *
63  * @v aoe               AoE session
64  * @v rc                Return status code
65  */
66 static void aoe_done ( struct aoe_session *aoe, int rc ) {
67
68         /* Record overall command status */
69         if ( aoe->command ) {
70                 aoe->command->cb.cmd_stat = aoe->status;
71                 aoe->command->rc = rc;
72                 aoe->command = NULL;
73         }
74
75         /* Stop retransmission timer */
76         stop_timer ( &aoe->timer );
77
78         /* Mark operation as complete */
79         aoe->rc = rc;
80 }
81
82 /**
83  * Send AoE command
84  *
85  * @v aoe               AoE session
86  * @ret rc              Return status code
87  *
88  * This transmits an AoE command packet.  It does not wait for a
89  * response.
90  */
91 static int aoe_send_command ( struct aoe_session *aoe ) {
92         struct ata_command *command = aoe->command;
93         struct io_buffer *iobuf;
94         struct aoehdr *aoehdr;
95         union aoecmd *aoecmd;
96         struct aoeata *aoeata;
97         unsigned int count;
98         unsigned int data_out_len;
99         unsigned int aoecmdlen;
100
101         /* Fail immediately if we have no netdev to send on */
102         if ( ! aoe->netdev ) {
103                 aoe_done ( aoe, -ENETUNREACH );
104                 return -ENETUNREACH;
105         }
106
107         /* If we are transmitting anything that requires a response,
108          * start the retransmission timer.  Do this before attempting
109          * to allocate the I/O buffer, in case allocation itself
110          * fails.
111          */
112         start_timer ( &aoe->timer );
113
114         /* Calculate count and data_out_len for this subcommand */
115         switch ( aoe->aoe_cmd_type ) {
116         case AOE_CMD_ATA:
117                 count = command->cb.count.native;
118                 if ( count > AOE_MAX_COUNT )
119                         count = AOE_MAX_COUNT;
120                 data_out_len = ( command->data_out ?
121                                  ( count * ATA_SECTOR_SIZE ) : 0 );
122                 aoecmdlen = sizeof ( aoecmd->ata );
123                 break;
124         case AOE_CMD_CONFIG:
125                 count = 0;
126                 data_out_len = 0;
127                 aoecmdlen = sizeof ( aoecmd->cfg );
128                 break;
129         default:
130                 return -ENOTSUP;
131         }
132
133         /* Create outgoing I/O buffer */
134         iobuf = alloc_iob ( ETH_HLEN + sizeof ( *aoehdr ) +
135                             aoecmdlen + data_out_len );
136
137         if ( ! iobuf )
138                 return -ENOMEM;
139         iob_reserve ( iobuf, ETH_HLEN );
140         aoehdr = iob_put ( iobuf, sizeof ( *aoehdr ) );
141         aoecmd = iob_put ( iobuf, aoecmdlen );
142         memset ( aoehdr, 0, ( sizeof ( *aoehdr ) + aoecmdlen ) );
143
144         /* Fill AoE header */
145         aoehdr->ver_flags = AOE_VERSION;
146         aoehdr->major = htons ( aoe->major );
147         aoehdr->minor = aoe->minor;
148         aoehdr->command = aoe->aoe_cmd_type;
149         aoehdr->tag = htonl ( ++aoe->tag );
150
151         /* Fill AoE payload */
152         switch ( aoe->aoe_cmd_type ) {
153         case AOE_CMD_ATA:
154                 /* Fill AoE command */
155                 aoeata = &aoecmd->ata;
156                 linker_assert ( AOE_FL_DEV_HEAD == ATA_DEV_SLAVE,
157                                 __fix_ata_h__ );
158                 aoeata->aflags = ( ( command->cb.lba48 ? AOE_FL_EXTENDED : 0 )|
159                                    ( command->cb.device & ATA_DEV_SLAVE ) |
160                                    ( data_out_len ? AOE_FL_WRITE : 0 ) );
161                 aoeata->err_feat = command->cb.err_feat.bytes.cur;
162                 aoeata->count = count;
163                 aoeata->cmd_stat = command->cb.cmd_stat;
164                 aoeata->lba.u64 = cpu_to_le64 ( command->cb.lba.native );
165                 if ( ! command->cb.lba48 )
166                         aoeata->lba.bytes[3] |=
167                                 ( command->cb.device & ATA_DEV_MASK );
168
169                 /* Fill data payload */
170                 copy_from_user ( iob_put ( iobuf, data_out_len ),
171                                  command->data_out, aoe->command_offset,
172                                  data_out_len );
173                 break;
174         case AOE_CMD_CONFIG:
175                 /* Nothing to do */
176                 break;
177         default:
178                 assert ( 0 );
179         }
180
181         /* Send packet */
182         return net_tx ( iobuf, aoe->netdev, &aoe_protocol, aoe->target );
183 }
184
185 /**
186  * Handle AoE retry timer expiry
187  *
188  * @v timer             AoE retry timer
189  * @v fail              Failure indicator
190  */
191 static void aoe_timer_expired ( struct retry_timer *timer, int fail ) {
192         struct aoe_session *aoe =
193                 container_of ( timer, struct aoe_session, timer );
194
195         if ( fail ) {
196                 aoe_done ( aoe, -ETIMEDOUT );
197         } else {
198                 aoe_send_command ( aoe );
199         }
200 }
201
202 /**
203  * Handle AoE configuration command response
204  *
205  * @v aoe               AoE session
206  * @v ll_source         Link-layer source address
207  * @ret rc              Return status code
208  */
209 static int aoe_rx_cfg ( struct aoe_session *aoe, const void *ll_source ) {
210
211         /* Record target MAC address */
212         memcpy ( aoe->target, ll_source, sizeof ( aoe->target ) );
213         DBGC ( aoe, "AoE %p target MAC address %s\n",
214                aoe, eth_ntoa ( aoe->target ) );
215
216         /* Mark config request as complete */
217         aoe_done ( aoe, 0 );
218
219         return 0;
220 }
221
222 /**
223  * Handle AoE ATA command response
224  *
225  * @v aoe               AoE session
226  * @v aoeata            AoE ATA command
227  * @v len               Length of AoE ATA command
228  * @ret rc              Return status code
229  */
230 static int aoe_rx_ata ( struct aoe_session *aoe, struct aoeata *aoeata,
231                         size_t len ) {
232         struct ata_command *command = aoe->command;
233         unsigned int rx_data_len;
234         unsigned int count;
235         unsigned int data_len;
236
237         /* Sanity check */
238         if ( len < sizeof ( *aoeata ) ) {
239                 /* Ignore packet; allow timer to trigger retransmit */
240                 return -EINVAL;
241         }
242         rx_data_len = ( len - sizeof ( *aoeata ) );
243
244         /* Calculate count and data_len for this subcommand */
245         count = command->cb.count.native;
246         if ( count > AOE_MAX_COUNT )
247                 count = AOE_MAX_COUNT;
248         data_len = count * ATA_SECTOR_SIZE;
249
250         /* Merge into overall ATA status */
251         aoe->status |= aoeata->cmd_stat;
252
253         /* Copy data payload */
254         if ( command->data_in ) {
255                 if ( rx_data_len > data_len )
256                         rx_data_len = data_len;
257                 copy_to_user ( command->data_in, aoe->command_offset,
258                                aoeata->data, rx_data_len );
259         }
260
261         /* Update ATA command and offset */
262         aoe->command_offset += data_len;
263         command->cb.lba.native += count;
264         command->cb.count.native -= count;
265
266         /* Check for operation complete */
267         if ( ! command->cb.count.native ) {
268                 aoe_done ( aoe, 0 );
269                 return 0;
270         }
271
272         /* Transmit next portion of request */
273         stop_timer ( &aoe->timer );
274         aoe_send_command ( aoe );
275
276         return 0;
277 }
278
279 /**
280  * Process incoming AoE packets
281  *
282  * @v iobuf             I/O buffer
283  * @v netdev            Network device
284  * @v ll_source         Link-layer source address
285  * @ret rc              Return status code
286  *
287  */
288 static int aoe_rx ( struct io_buffer *iobuf,
289                     struct net_device *netdev __unused,
290                     const void *ll_source ) {
291         struct aoehdr *aoehdr = iobuf->data;
292         struct aoe_session *aoe;
293         int rc = 0;
294
295         /* Sanity checks */
296         if ( iob_len ( iobuf ) < sizeof ( *aoehdr ) ) {
297                 rc = -EINVAL;
298                 goto done;
299         }
300         if ( ( aoehdr->ver_flags & AOE_VERSION_MASK ) != AOE_VERSION ) {
301                 rc = -EPROTONOSUPPORT;
302                 goto done;
303         }
304         if ( ! ( aoehdr->ver_flags & AOE_FL_RESPONSE ) ) {
305                 /* Ignore AoE requests that we happen to see */
306                 goto done;
307         }
308         iob_pull ( iobuf, sizeof ( *aoehdr ) );
309
310         /* Demultiplex amongst active AoE sessions */
311         list_for_each_entry ( aoe, &aoe_sessions, list ) {
312                 if ( ntohs ( aoehdr->major ) != aoe->major )
313                         continue;
314                 if ( aoehdr->minor != aoe->minor )
315                         continue;
316                 if ( ntohl ( aoehdr->tag ) != aoe->tag )
317                         continue;
318                 if ( aoehdr->ver_flags & AOE_FL_ERROR ) {
319                         aoe_done ( aoe, -EIO );
320                         break;
321                 }
322                 switch ( aoehdr->command ) {
323                 case AOE_CMD_ATA:
324                         rc = aoe_rx_ata ( aoe, iobuf->data, iob_len ( iobuf ));
325                         break;
326                 case AOE_CMD_CONFIG:
327                         rc = aoe_rx_cfg ( aoe, ll_source );
328                         break;
329                 default:
330                         DBGC ( aoe, "AoE %p ignoring command %02x\n",
331                                aoe, aoehdr->command );
332                         break;
333                 }
334                 break;
335         }
336
337  done:
338         free_iob ( iobuf );
339         return rc;
340 }
341
342 /** AoE protocol */
343 struct net_protocol aoe_protocol __net_protocol = {
344         .name = "AoE",
345         .net_proto = htons ( ETH_P_AOE ),
346         .rx = aoe_rx,
347 };
348
349 /**
350  * Issue ATA command via an open AoE session
351  *
352  * @v ata               ATA device
353  * @v command           ATA command
354  * @ret rc              Return status code
355  */
356 static int aoe_command ( struct ata_device *ata,
357                          struct ata_command *command ) {
358         struct aoe_session *aoe =
359                 container_of ( ata->backend, struct aoe_session, refcnt );
360
361         aoe->command = command;
362         aoe->status = 0;
363         aoe->command_offset = 0;
364         aoe->aoe_cmd_type = AOE_CMD_ATA;
365
366         aoe_send_command ( aoe );
367
368         return 0;
369 }
370
371 /**
372  * Issue AoE config query for AoE target discovery
373  *
374  * @v aoe               AoE session
375  * @ret rc              Return status code
376  */
377 static int aoe_discover ( struct aoe_session *aoe ) {
378         int rc;
379
380         aoe->status = 0;
381         aoe->aoe_cmd_type = AOE_CMD_CONFIG;
382         aoe->command = NULL;
383
384         aoe_send_command ( aoe );
385
386         aoe->rc = -EINPROGRESS;
387         while ( aoe->rc == -EINPROGRESS )
388                 step();
389         rc = aoe->rc;
390
391         return rc;
392 }
393
394 static int aoe_detached_command ( struct ata_device *ata __unused,
395                                   struct ata_command *command __unused ) {
396         return -ENODEV;
397 }
398
399 void aoe_detach ( struct ata_device *ata ) {
400         struct aoe_session *aoe =
401                 container_of ( ata->backend, struct aoe_session, refcnt );
402
403         stop_timer ( &aoe->timer );
404         ata->command = aoe_detached_command;
405         list_del ( &aoe->list );
406         ref_put ( ata->backend );
407         ata->backend = NULL;
408 }
409
410 static int aoe_parse_root_path ( struct aoe_session *aoe,
411                                  const char *root_path ) {
412         char *ptr;
413
414         if ( strncmp ( root_path, "aoe:", 4 ) != 0 )
415                 return -EINVAL;
416         ptr = ( ( char * ) root_path + 4 );
417
418         if ( *ptr++ != 'e' )
419                 return -EINVAL;
420
421         aoe->major = strtoul ( ptr, &ptr, 10 );
422         if ( *ptr++ != '.' )
423                 return -EINVAL;
424
425         aoe->minor = strtoul ( ptr, &ptr, 10 );
426         if ( *ptr )
427                 return -EINVAL;
428
429         return 0;
430 }
431
432 int aoe_attach ( struct ata_device *ata, struct net_device *netdev,
433                  const char *root_path ) {
434         struct aoe_session *aoe;
435         int rc;
436
437         /* Allocate and initialise structure */
438         aoe = zalloc ( sizeof ( *aoe ) );
439         if ( ! aoe )
440                 return -ENOMEM;
441         aoe->refcnt.free = aoe_free;
442         aoe->netdev = netdev_get ( netdev );
443         memcpy ( aoe->target, ethernet_protocol.ll_broadcast,
444                  sizeof ( aoe->target ) );
445         aoe->tag = AOE_TAG_MAGIC;
446         aoe->timer.expired = aoe_timer_expired;
447
448         /* Parse root path */
449         if ( ( rc = aoe_parse_root_path ( aoe, root_path ) ) != 0 )
450                 goto err;
451
452         /* Attach parent interface, transfer reference to connection
453          * list, and return
454          */
455         ata->backend = ref_get ( &aoe->refcnt );
456         ata->command = aoe_command;
457         list_add ( &aoe->list, &aoe_sessions );
458
459         /* Send discovery packet to find the target MAC address.
460          * Ideally, this ought to be done asynchronously, but the
461          * block device interface does not yet support asynchronous
462          * operation.
463          */
464         if ( ( rc = aoe_discover( aoe ) ) != 0 )
465                goto err;
466
467         return 0;
468
469  err:
470         ref_put ( &aoe->refcnt );
471         return rc;
472 }