pkbuff->iobuf changeover
[people/meteger/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 #include <stddef.h>
20 #include <string.h>
21 #include <stdio.h>
22 #include <errno.h>
23 #include <assert.h>
24 #include <byteswap.h>
25 #include <gpxe/list.h>
26 #include <gpxe/if_ether.h>
27 #include <gpxe/ethernet.h>
28 #include <gpxe/iobuf.h>
29 #include <gpxe/uaccess.h>
30 #include <gpxe/ata.h>
31 #include <gpxe/netdevice.h>
32 #include <gpxe/async.h>
33 #include <gpxe/aoe.h>
34
35 /** @file
36  *
37  * AoE protocol
38  *
39  */
40
41 struct net_protocol aoe_protocol;
42
43 /** List of all AoE sessions */
44 static LIST_HEAD ( aoe_sessions );
45
46 /**
47  * Mark current AoE command complete
48  *
49  * @v aoe               AoE session
50  * @v rc                Return status code
51  */
52 static void aoe_done ( struct aoe_session *aoe, int rc ) {
53
54         /* Record overall command status */
55         aoe->command->cb.cmd_stat = aoe->status;
56         aoe->command = NULL;
57
58         /* Mark async operation as complete */
59         async_done ( &aoe->async, rc );
60 }
61
62 /**
63  * Send AoE command
64  *
65  * @v aoe               AoE session
66  * @ret rc              Return status code
67  *
68  * This transmits an AoE command packet.  It does not wait for a
69  * response.
70  */
71 static int aoe_send_command ( struct aoe_session *aoe ) {
72         struct ata_command *command = aoe->command;
73         struct io_buffer *iobuf;
74         struct aoehdr *aoehdr;
75         struct aoecmd *aoecmd;
76         unsigned int count;
77         unsigned int data_out_len;
78
79         /* Fail immediately if we have no netdev to send on */
80         if ( ! aoe->netdev ) {
81                 aoe_done ( aoe, -ENETUNREACH );
82                 return -ENETUNREACH;
83         }
84
85         /* Calculate count and data_out_len for this subcommand */
86         count = command->cb.count.native;
87         if ( count > AOE_MAX_COUNT )
88                 count = AOE_MAX_COUNT;
89         data_out_len = ( command->data_out ? ( count * ATA_SECTOR_SIZE ) : 0 );
90
91         /* Create outgoing I/O buffer */
92         iobuf = alloc_iob ( ETH_HLEN + sizeof ( *aoehdr ) + sizeof ( *aoecmd ) +
93                           data_out_len );
94         if ( ! iobuf )
95                 return -ENOMEM;
96         iob_reserve ( iobuf, ETH_HLEN );
97         aoehdr = iob_put ( iobuf, sizeof ( *aoehdr ) );
98         aoecmd = iob_put ( iobuf, sizeof ( *aoecmd ) );
99         memset ( aoehdr, 0, ( sizeof ( *aoehdr ) + sizeof ( *aoecmd ) ) );
100
101         /* Fill AoE header */
102         aoehdr->ver_flags = AOE_VERSION;
103         aoehdr->major = htons ( aoe->major );
104         aoehdr->minor = aoe->minor;
105         aoehdr->tag = htonl ( ++aoe->tag );
106
107         /* Fill AoE command */
108         linker_assert ( AOE_FL_DEV_HEAD == ATA_DEV_SLAVE, __fix_ata_h__ );
109         aoecmd->aflags = ( ( command->cb.lba48 ? AOE_FL_EXTENDED : 0 ) |
110                            ( command->cb.device & ATA_DEV_SLAVE ) |
111                            ( data_out_len ? AOE_FL_WRITE : 0 ) );
112         aoecmd->err_feat = command->cb.err_feat.bytes.cur;
113         aoecmd->count = count;
114         aoecmd->cmd_stat = command->cb.cmd_stat;
115         aoecmd->lba.u64 = cpu_to_le64 ( command->cb.lba.native );
116         if ( ! command->cb.lba48 )
117                 aoecmd->lba.bytes[3] |= ( command->cb.device & ATA_DEV_MASK );
118
119         /* Fill data payload */
120         copy_from_user ( iob_put ( iobuf, data_out_len ), command->data_out,
121                          aoe->command_offset, data_out_len );
122
123         /* Send packet */
124         start_timer ( &aoe->timer );
125         return net_tx ( iobuf, aoe->netdev, &aoe_protocol, aoe->target );
126 }
127
128 /**
129  * Handle AoE retry timer expiry
130  *
131  * @v timer             AoE retry timer
132  * @v fail              Failure indicator
133  */
134 static void aoe_timer_expired ( struct retry_timer *timer, int fail ) {
135         struct aoe_session *aoe =
136                 container_of ( timer, struct aoe_session, timer );
137
138         if ( fail ) {
139                 aoe_done ( aoe, -ETIMEDOUT );
140         } else {
141                 aoe_send_command ( aoe );
142         }
143 }
144
145 /**
146  * Handle AoE response
147  *
148  * @v aoe               AoE session
149  * @v aoehdr            AoE header
150  * @ret rc              Return status code
151  */
152 static int aoe_rx_response ( struct aoe_session *aoe, struct aoehdr *aoehdr,
153                              unsigned int len ) {
154         struct aoecmd *aoecmd = aoehdr->arg.command;
155         struct ata_command *command = aoe->command;
156         unsigned int rx_data_len;
157         unsigned int count;
158         unsigned int data_len;
159         
160         /* Sanity check */
161         if ( len < ( sizeof ( *aoehdr ) + sizeof ( *aoecmd ) ) ) {
162                 /* Ignore packet; allow timer to trigger retransmit */
163                 return -EINVAL;
164         }
165         rx_data_len = ( len - sizeof ( *aoehdr ) - sizeof ( *aoecmd ) );
166
167         /* Stop retry timer.  After this point, every code path must
168          * either terminate the AoE operation via aoe_done(), or
169          * transmit a new packet.
170          */
171         stop_timer ( &aoe->timer );
172
173         /* Check for fatal errors */
174         if ( aoehdr->ver_flags & AOE_FL_ERROR ) {
175                 aoe_done ( aoe, -EIO );
176                 return 0;
177         }
178
179         /* Calculate count and data_len for this subcommand */
180         count = command->cb.count.native;
181         if ( count > AOE_MAX_COUNT )
182                 count = AOE_MAX_COUNT;
183         data_len = count * ATA_SECTOR_SIZE;
184
185         /* Merge into overall ATA status */
186         aoe->status |= aoecmd->cmd_stat;
187
188         /* Copy data payload */
189         if ( command->data_in ) {
190                 if ( rx_data_len > data_len )
191                         rx_data_len = data_len;
192                 copy_to_user ( command->data_in, aoe->command_offset,
193                                aoecmd->data, rx_data_len );
194         }
195
196         /* Update ATA command and offset */
197         aoe->command_offset += data_len;
198         command->cb.lba.native += count;
199         command->cb.count.native -= count;
200
201         /* Check for operation complete */
202         if ( ! command->cb.count.native ) {
203                 aoe_done ( aoe, 0 );
204                 return 0;
205         }
206
207         /* Transmit next portion of request */
208         aoe_send_command ( aoe );
209
210         return 0;
211 }
212
213 /**
214  * Process incoming AoE packets
215  *
216  * @v iobuf             I/O buffer
217  * @v netdev            Network device
218  * @v ll_source         Link-layer source address
219  * @ret rc              Return status code
220  *
221  */
222 static int aoe_rx ( struct io_buffer *iobuf, struct net_device *netdev __unused,
223                     const void *ll_source ) {
224         struct aoehdr *aoehdr = iobuf->data;
225         unsigned int len = iob_len ( iobuf );
226         struct aoe_session *aoe;
227         int rc = 0;
228
229         /* Sanity checks */
230         if ( len < sizeof ( *aoehdr ) ) {
231                 rc = -EINVAL;
232                 goto done;
233         }
234         if ( ( aoehdr->ver_flags & AOE_VERSION_MASK ) != AOE_VERSION ) {
235                 rc = -EPROTONOSUPPORT;
236                 goto done;
237         }
238         if ( ! ( aoehdr->ver_flags & AOE_FL_RESPONSE ) ) {
239                 /* Ignore AoE requests that we happen to see */
240                 goto done;
241         }
242
243         /* Demultiplex amongst active AoE sessions */
244         list_for_each_entry ( aoe, &aoe_sessions, list ) {
245                 if ( ntohs ( aoehdr->major ) != aoe->major )
246                         continue;
247                 if ( aoehdr->minor != aoe->minor )
248                         continue;
249                 if ( ntohl ( aoehdr->tag ) != aoe->tag )
250                         continue;
251                 memcpy ( aoe->target, ll_source, sizeof ( aoe->target ) );
252                 rc = aoe_rx_response ( aoe, aoehdr, len );
253                 break;
254         }
255
256  done:
257         free_iob ( iobuf );
258         return rc;
259 }
260
261 /** AoE protocol */
262 struct net_protocol aoe_protocol __net_protocol = {
263         .name = "AoE",
264         .net_proto = htons ( ETH_P_AOE ),
265         .rx = aoe_rx,
266 };
267
268 /**
269  * Forget reference to net_device
270  *
271  * @v ref               Persistent reference
272  */
273 static void aoe_forget_netdev ( struct reference *ref ) {
274         struct aoe_session *aoe
275                 = container_of ( ref, struct aoe_session, netdev_ref );
276
277         aoe->netdev = NULL;
278         ref_del ( &aoe->netdev_ref );
279 }
280
281 /**
282  * Open AoE session
283  *
284  * @v aoe               AoE session
285  */
286 void aoe_open ( struct aoe_session *aoe ) {
287         memcpy ( aoe->target, ethernet_protocol.ll_broadcast,
288                  sizeof ( aoe->target ) );
289         aoe->tag = AOE_TAG_MAGIC;
290         aoe->timer.expired = aoe_timer_expired;
291         aoe->netdev_ref.forget = aoe_forget_netdev;
292         ref_add ( &aoe->netdev_ref, &aoe->netdev->references );
293         list_add ( &aoe->list, &aoe_sessions );
294 }
295
296 /**
297  * Close AoE session
298  *
299  * @v aoe               AoE session
300  */
301 void aoe_close ( struct aoe_session *aoe ) {
302         if ( aoe->netdev )
303                 ref_del ( &aoe->netdev_ref );
304         list_del ( &aoe->list );
305 }
306
307 /**
308  * Issue ATA command via an open AoE session
309  *
310  * @v aoe               AoE session
311  * @v command           ATA command
312  * @v parent            Parent asynchronous operation
313  * @ret rc              Return status code
314  *
315  * Only one command may be issued concurrently per session.  This call
316  * is non-blocking; use async_wait() to wait for the command to
317  * complete.
318  */
319 int aoe_issue ( struct aoe_session *aoe, struct ata_command *command,
320                 struct async *parent ) {
321         aoe->command = command;
322         aoe->status = 0;
323         aoe->command_offset = 0;
324         aoe_send_command ( aoe );
325         async_init ( &aoe->async, &default_async_operations, parent );
326         return 0;
327 }