Put in a method to get the MAC address for the AoE target. (It's not
[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 <vsprintf.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/pkbuff.h>
28 #include <gpxe/uaccess.h>
29 #include <gpxe/ata.h>
30 #include <gpxe/netdevice.h>
31 #include <gpxe/async.h>
32 #include <gpxe/aoe.h>
33
34 /** @file
35  *
36  * AoE protocol
37  *
38  */
39
40 struct net_protocol aoe_protocol;
41
42 /** List of all AoE sessions */
43 static LIST_HEAD ( aoe_sessions );
44
45 /**
46  * Mark current AoE command complete
47  *
48  * @v aoe               AoE session
49  * @v rc                Return status code
50  */
51 static void aoe_done ( struct aoe_session *aoe, int rc ) {
52
53         /* Record overall command status */
54         aoe->command->cb.cmd_stat = aoe->status;
55         aoe->command = NULL;
56
57         /* Mark async operation as complete */
58         async_done ( &aoe->aop, rc );
59 }
60
61 /**
62  * Send AoE command
63  *
64  * @v aoe               AoE session
65  * @ret rc              Return status code
66  *
67  * This transmits an AoE command packet.  It does not wait for a
68  * response.
69  */
70 static int aoe_send_command ( struct aoe_session *aoe ) {
71         struct ata_command *command = aoe->command;
72         struct pk_buff *pkb;
73         struct aoehdr *aoehdr;
74         struct aoecmd *aoecmd;
75         unsigned int count;
76         unsigned int data_out_len;
77
78         /* Calculate count and data_out_len for this subcommand */
79         count = command->cb.count.native;
80         if ( count > AOE_MAX_COUNT )
81                 count = AOE_MAX_COUNT;
82         data_out_len = ( command->data_out ? ( count * ATA_SECTOR_SIZE ) : 0 );
83
84         /* Create outgoing packet buffer */
85         pkb = alloc_pkb ( ETH_HLEN + sizeof ( *aoehdr ) + sizeof ( *aoecmd ) +
86                           data_out_len );
87         if ( ! pkb )
88                 return -ENOMEM;
89         pkb->net_protocol = &aoe_protocol;
90         pkb_reserve ( pkb, ETH_HLEN );
91         aoehdr = pkb_put ( pkb, sizeof ( *aoehdr ) );
92         aoecmd = pkb_put ( pkb, sizeof ( *aoecmd ) );
93         memset ( aoehdr, 0, ( sizeof ( *aoehdr ) + sizeof ( *aoecmd ) ) );
94
95         /* Fill AoE header */
96         aoehdr->ver_flags = AOE_VERSION;
97         aoehdr->major = htons ( aoe->major );
98         aoehdr->minor = aoe->minor;
99         aoehdr->tag = htonl ( ++aoe->tag );
100
101         /* Fill AoE command */
102         linker_assert ( AOE_FL_DEV_HEAD == ATA_DEV_SLAVE, __fix_ata_h__ );
103         aoecmd->aflags = ( ( command->cb.lba48 ? AOE_FL_EXTENDED : 0 ) |
104                            ( command->cb.device & ATA_DEV_SLAVE ) |
105                            ( data_out_len ? AOE_FL_WRITE : 0 ) );
106         aoecmd->err_feat = command->cb.err_feat.bytes.cur;
107         aoecmd->count = count;
108         aoecmd->cmd_stat = command->cb.cmd_stat;
109         aoecmd->lba.u64 = cpu_to_le64 ( command->cb.lba.native );
110         if ( ! command->cb.lba48 )
111                 aoecmd->lba.bytes[3] |= ( command->cb.device & ATA_DEV_MASK );
112
113         /* Fill data payload */
114         copy_from_user ( pkb_put ( pkb, data_out_len ), command->data_out,
115                          aoe->command_offset, data_out_len );
116
117         /* Send packet */
118         return net_transmit_via ( pkb, aoe->netdev );
119 }
120
121 /**
122  * Handle AoE response
123  *
124  * @v aoe               AoE session
125  * @v aoehdr            AoE header
126  * @ret rc              Return status code
127  */
128 static int aoe_rx_response ( struct aoe_session *aoe, struct aoehdr *aoehdr,
129                              unsigned int len ) {
130         struct aoecmd *aoecmd = aoehdr->arg.command;
131         struct ata_command *command = aoe->command;
132         unsigned int rx_data_len;
133         unsigned int count;
134         unsigned int data_len;
135         
136         /* Sanity check */
137         if ( len < ( sizeof ( *aoehdr ) + sizeof ( *aoecmd ) ) )
138                 return -EINVAL;
139         rx_data_len = ( len - sizeof ( *aoehdr ) - sizeof ( *aoecmd ) );
140
141         /* Check for fatal errors */
142         if ( aoehdr->ver_flags & AOE_FL_ERROR ) {
143                 aoe_done ( aoe, -EIO );
144                 return 0;
145         }
146
147         /* Calculate count and data_len for this subcommand */
148         count = command->cb.count.native;
149         if ( count > AOE_MAX_COUNT )
150                 count = AOE_MAX_COUNT;
151         data_len = count * ATA_SECTOR_SIZE;
152
153         /* Merge into overall ATA status */
154         aoe->status |= aoecmd->cmd_stat;
155
156         /* Copy data payload */
157         if ( command->data_in ) {
158                 if ( rx_data_len > data_len )
159                         rx_data_len = data_len;
160                 copy_to_user ( command->data_in, aoe->command_offset,
161                                aoecmd->data, rx_data_len );
162         }
163
164         /* Update ATA command and offset */
165         aoe->command_offset += data_len;
166         command->cb.lba.native += count;
167         command->cb.count.native -= count;
168
169         /* Check for operation complete */
170         if ( ! command->cb.count.native ) {
171                 aoe_done ( aoe, 0 );
172                 return 0;
173         }
174
175         /* Transmit next portion of request */
176         aoe_send_command ( aoe );
177
178         return 0;
179 }
180
181 /**
182  * Process incoming AoE packets
183  *
184  * @v pkb               Packet buffer
185  * @ret rc              Return status code
186  *
187  */
188 static int aoe_rx ( struct pk_buff *pkb ) {
189         struct aoehdr *aoehdr = pkb->data;
190         unsigned int len = pkb_len ( pkb );
191         struct ethhdr *ethhdr = pkb_push ( pkb, sizeof ( *ethhdr ) );
192         struct aoe_session *aoe;
193         int rc = 0;
194
195         /* Sanity checks */
196         if ( len < sizeof ( *aoehdr ) ) {
197                 rc = -EINVAL;
198                 goto done;
199         }
200         if ( ( aoehdr->ver_flags & AOE_VERSION_MASK ) != AOE_VERSION ) {
201                 rc = -EPROTONOSUPPORT;
202                 goto done;
203         }
204         if ( ! ( aoehdr->ver_flags & AOE_FL_RESPONSE ) ) {
205                 /* Ignore AoE requests that we happen to see */
206                 goto done;
207         }
208
209         /* Demultiplex amongst active AoE sessions */
210         list_for_each_entry ( aoe, &aoe_sessions, list ) {
211                 if ( ntohs ( aoehdr->major ) != aoe->major )
212                         continue;
213                 if ( aoehdr->minor != aoe->minor )
214                         continue;
215                 if ( ntohl ( aoehdr->tag ) != aoe->tag )
216                         continue;
217                 memcpy ( aoe->target, ethhdr->h_source,
218                          sizeof ( aoe->target ) );
219                 rc = aoe_rx_response ( aoe, aoehdr, len );
220                 break;
221         }
222
223  done:
224         free_pkb ( pkb );
225         return rc;
226 }
227
228 /**
229  * Perform AoE network-layer routing
230  *
231  * @v pkb       Packet buffer
232  * @ret source  Network-layer source address
233  * @ret dest    Network-layer destination address
234  * @ret rc      Return status code
235  */
236 static int aoe_route ( const struct pk_buff *pkb __unused,
237                        struct net_header *nethdr ) {
238         struct aoehdr *aoehdr = pkb->data;
239         struct aoe_session *aoe;
240
241         list_for_each_entry ( aoe, &aoe_sessions, list ) {
242                 if ( ( ntohs ( aoehdr->major ) == aoe->major ) &&
243                      ( aoehdr->minor == aoe->minor ) ) {
244                         nethdr->flags = PKT_FL_RAW_ADDR;
245                         memcpy ( nethdr->dest_net_addr, aoe->target,
246                                  sizeof ( aoe->target ) );
247                         return 0;
248                 }
249         }
250                 
251         return -EHOSTUNREACH;
252 }
253
254 /** AoE protocol */
255 struct net_protocol aoe_protocol = {
256         .name = "AoE",
257         .net_proto = htons ( ETH_P_AOE ),
258         .rx_process = aoe_rx,
259         .route = aoe_route,
260 };
261
262 NET_PROTOCOL ( aoe_protocol );
263
264 /**
265  * Open AoE session
266  *
267  * @v aoe               AoE session
268  */
269 void aoe_open ( struct aoe_session *aoe ) {
270         memset ( aoe->target, 0xff, sizeof ( aoe->target ) );
271         list_add ( &aoe->list, &aoe_sessions );
272 }
273
274 /**
275  * Close AoE session
276  *
277  * @v aoe               AoE session
278  */
279 void aoe_close ( struct aoe_session *aoe ) {
280         list_del ( &aoe->list );
281 }
282
283 /**
284  * Issue ATA command via an open AoE session
285  *
286  * @v aoe               AoE session
287  * @v command           ATA command
288  * @ret aop             Asynchronous operation
289  *
290  * Only one command may be issued concurrently per session.  This call
291  * is non-blocking; use async_wait() to wait for the command to
292  * complete.
293  */
294 struct async_operation * aoe_issue ( struct aoe_session *aoe,
295                                      struct ata_command *command ) {
296         aoe->command = command;
297         aoe->status = 0;
298         aoe->command_offset = 0;
299         aoe_send_command ( aoe );
300         return &aoe->aop;
301 }