Added net device TX queue; this will be needed to support the PXE UNDI API
[people/xl0/gpxe.git] / src / net / netdevice.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 <stdint.h>
20 #include <stdlib.h>
21 #include <byteswap.h>
22 #include <string.h>
23 #include <errno.h>
24 #include <gpxe/if_ether.h>
25 #include <gpxe/pkbuff.h>
26 #include <gpxe/tables.h>
27 #include <gpxe/process.h>
28 #include <gpxe/init.h>
29 #include <gpxe/netdevice.h>
30
31 /** @file
32  *
33  * Network device management
34  *
35  */
36
37 /** Registered network-layer protocols */
38 static struct net_protocol net_protocols[0] __table_start ( net_protocols );
39 static struct net_protocol net_protocols_end[0] __table_end ( net_protocols );
40
41 /** List of network devices */
42 static LIST_HEAD ( net_devices );
43
44 /**
45  * Transmit raw packet via network device
46  *
47  * @v netdev            Network device
48  * @v pkb               Packet buffer
49  * @ret rc              Return status code
50  *
51  * Transmits the packet via the specified network device.  This
52  * function takes ownership of the packet buffer.
53  */
54 int netdev_tx ( struct net_device *netdev, struct pk_buff *pkb ) {
55         int rc;
56
57         DBGC ( netdev, "NETDEV %p transmitting %p (%p+%zx)\n",
58                netdev, pkb, pkb->data, pkb_len ( pkb ) );
59
60         list_add_tail ( &pkb->list, &netdev->tx_queue );
61
62         if ( ! ( netdev->state & NETDEV_OPEN ) ) {
63                 rc = -ENETUNREACH;
64                 goto err;
65         }
66                 
67         if ( ( rc = netdev->transmit ( netdev, pkb ) ) != 0 )
68                 goto err;
69
70         return 0;
71
72  err:
73         DBGC ( netdev, "NETDEV %p transmission %p failed: %s\n",
74                netdev, pkb, strerror ( rc ) );
75         netdev_tx_complete ( netdev, pkb );
76         return rc;
77 }
78
79 /**
80  * Complete network transmission
81  *
82  * @v netdev            Network device
83  * @v pkb               Packet buffer
84  *
85  * The packet must currently be in the network device's TX queue.
86  */
87 void netdev_tx_complete ( struct net_device *netdev, struct pk_buff *pkb ) {
88         DBGC ( netdev, "NETDEV %p transmission %p complete\n", netdev, pkb );
89
90         list_del ( &pkb->list );
91         free_pkb ( pkb );
92 }
93
94 /**
95  * Complete network transmission
96  *
97  * @v netdev            Network device
98  *
99  * Completes the oldest outstanding packet in the TX queue.
100  */
101 void netdev_tx_complete_next ( struct net_device *netdev ) {
102         struct pk_buff *pkb;
103
104         list_for_each_entry ( pkb, &netdev->tx_queue, list ) {
105                 netdev_tx_complete ( netdev, pkb );
106                 return;
107         }
108 }
109
110 /**
111  * Add packet to receive queue
112  *
113  * @v netdev            Network device
114  * @v pkb               Packet buffer
115  *
116  * The packet is added to the network device's RX queue.  This
117  * function takes ownership of the packet buffer.
118  */
119 void netdev_rx ( struct net_device *netdev, struct pk_buff *pkb ) {
120         DBGC ( netdev, "NETDEV %p received %p (%p+%zx)\n",
121                netdev, pkb, pkb->data, pkb_len ( pkb ) );
122         list_add_tail ( &pkb->list, &netdev->rx_queue );
123 }
124
125 /**
126  * Poll for packet on network device
127  *
128  * @v netdev            Network device
129  * @ret True            There are packets present in the receive queue
130  * @ret False           There are no packets present in the receive queue
131  *
132  * Polls the network device for received packets.  Any received
133  * packets will be added to the RX packet queue via netdev_rx().
134  */
135 int netdev_poll ( struct net_device *netdev ) {
136
137         if ( netdev->state & NETDEV_OPEN )
138                 netdev->poll ( netdev );
139
140         return ( ! list_empty ( &netdev->rx_queue ) );
141 }
142
143 /**
144  * Remove packet from device's receive queue
145  *
146  * @v netdev            Network device
147  * @ret pkb             Packet buffer, or NULL
148  *
149  * Removes the first packet from the device's RX queue and returns it.
150  * Ownership of the packet is transferred to the caller.
151  */
152 struct pk_buff * netdev_rx_dequeue ( struct net_device *netdev ) {
153         struct pk_buff *pkb;
154
155         list_for_each_entry ( pkb, &netdev->rx_queue, list ) {
156                 list_del ( &pkb->list );
157                 return pkb;
158         }
159         return NULL;
160 }
161
162 /**
163  * Allocate network device
164  *
165  * @v priv_size         Size of private data area (net_device::priv)
166  * @ret netdev          Network device, or NULL
167  *
168  * Allocates space for a network device and its private data area.
169  */
170 struct net_device * alloc_netdev ( size_t priv_size ) {
171         struct net_device *netdev;
172
173         netdev = calloc ( 1, sizeof ( *netdev ) + priv_size );
174         if ( netdev ) {
175                 INIT_LIST_HEAD ( &netdev->references );
176                 INIT_LIST_HEAD ( &netdev->tx_queue );
177                 INIT_LIST_HEAD ( &netdev->rx_queue );
178                 netdev->priv = ( ( ( void * ) netdev ) + sizeof ( *netdev ) );
179         }
180         return netdev;
181 }
182
183 /**
184  * Register network device
185  *
186  * @v netdev            Network device
187  * @ret rc              Return status code
188  *
189  * Adds the network device to the list of network devices.
190  */
191 int register_netdev ( struct net_device *netdev ) {
192         
193         /* Add to device list */
194         list_add_tail ( &netdev->list, &net_devices );
195         DBGC ( netdev, "NETDEV %p registered as %s\n",
196                netdev, netdev_name ( netdev ) );
197
198         return 0;
199 }
200
201 /**
202  * Open network device
203  *
204  * @v netdev            Network device
205  * @ret rc              Return status code
206  */
207 int netdev_open ( struct net_device *netdev ) {
208         int rc;
209
210         /* Do nothing if device is already open */
211         if ( netdev->state & NETDEV_OPEN )
212                 return 0;
213
214         DBGC ( netdev, "NETDEV %p opening\n", netdev );
215
216         /* Open the device */
217         if ( ( rc = netdev->open ( netdev ) ) != 0 )
218                 return rc;
219
220         /* Mark as opened */
221         netdev->state |= NETDEV_OPEN;
222         return 0;
223 }
224
225 /**
226  * Close network device
227  *
228  * @v netdev            Network device
229  */
230 void netdev_close ( struct net_device *netdev ) {
231         struct pk_buff *pkb;
232
233         /* Do nothing if device is already closed */
234         if ( ! ( netdev->state & NETDEV_OPEN ) )
235                 return;
236
237         DBGC ( netdev, "NETDEV %p closing\n", netdev );
238
239         /* Close the device */
240         netdev->close ( netdev );
241
242         /* Discard any packets in the TX queue */
243         while ( ! list_empty ( &netdev->tx_queue ) ) {
244                 netdev_tx_complete_next ( netdev );
245         }
246
247         /* Discard any packets in the RX queue */
248         while ( ( pkb = netdev_rx_dequeue ( netdev ) ) ) {
249                 DBGC ( netdev, "NETDEV %p discarding received %p\n",
250                        netdev, pkb );
251                 free_pkb ( pkb );
252         }
253
254         /* Mark as closed */
255         netdev->state &= ~NETDEV_OPEN;
256 }
257
258 /**
259  * Unregister network device
260  *
261  * @v netdev            Network device
262  *
263  * Removes the network device from the list of network devices.
264  */
265 void unregister_netdev ( struct net_device *netdev ) {
266
267         /* Ensure device is closed */
268         netdev_close ( netdev );
269
270         /* Kill off any persistent references to this device */
271         forget_references ( &netdev->references );
272
273         /* Remove from device list */
274         list_del ( &netdev->list );
275         DBGC ( netdev, "NETDEV %p unregistered\n", netdev );
276 }
277
278 /**
279  * Free network device
280  *
281  * @v netdev            Network device
282  */
283 void free_netdev ( struct net_device *netdev ) {
284         free ( netdev );
285 }
286
287 /**
288  * Iterate through network devices
289  *
290  * @ret netdev          Network device, or NULL
291  *
292  * This returns the registered network devices in the order of
293  * registration.  If no network devices are registered, it will return
294  * NULL.
295  */
296 struct net_device * next_netdev ( void ) {
297         struct net_device *netdev;
298
299         list_for_each_entry ( netdev, &net_devices, list ) {
300                 list_del ( &netdev->list );
301                 list_add_tail ( &netdev->list, &net_devices );
302                 return netdev;
303         }
304         return NULL;
305 }
306
307 /**
308  * Transmit network-layer packet
309  *
310  * @v pkb               Packet buffer
311  * @v netdev            Network device
312  * @v net_protocol      Network-layer protocol
313  * @v ll_dest           Destination link-layer address
314  * @ret rc              Return status code
315  *
316  * Prepends link-layer headers to the packet buffer and transmits the
317  * packet via the specified network device.  This function takes
318  * ownership of the packet buffer.
319  */
320 int net_tx ( struct pk_buff *pkb, struct net_device *netdev,
321              struct net_protocol *net_protocol, const void *ll_dest ) {
322         return netdev->ll_protocol->tx ( pkb, netdev, net_protocol, ll_dest );
323 }
324
325 /**
326  * Process received network-layer packet
327  *
328  * @v pkb               Packet buffer
329  * @v netdev            Network device
330  * @v net_proto         Network-layer protocol, in network-byte order
331  * @v ll_source         Source link-layer address
332  * @ret rc              Return status code
333  */
334 int net_rx ( struct pk_buff *pkb, struct net_device *netdev,
335              uint16_t net_proto, const void *ll_source ) {
336         struct net_protocol *net_protocol;
337
338         /* Hand off to network-layer protocol, if any */
339         for ( net_protocol = net_protocols ; net_protocol < net_protocols_end ;
340               net_protocol++ ) {
341                 if ( net_protocol->net_proto == net_proto ) {
342                         return net_protocol->rx ( pkb, netdev, ll_source );
343                 }
344         }
345         free_pkb ( pkb );
346         return 0;
347 }
348
349 /**
350  * Single-step the network stack
351  *
352  * @v process           Network stack process
353  *
354  * This polls all interfaces for any received packets, and processes
355  * at most one packet from the RX queue.
356  *
357  * We avoid processing all received packets, because processing the
358  * received packet can trigger transmission of a new packet (e.g. an
359  * ARP response).  Since TX completions will be processed as part of
360  * the poll operation, it is easy to overflow small TX queues if
361  * multiple packets are processed per poll.
362  */
363 static void net_step ( struct process *process ) {
364         struct net_device *netdev;
365         struct pk_buff *pkb;
366
367         /* Poll and process each network device */
368         list_for_each_entry ( netdev, &net_devices, list ) {
369
370                 /* Poll for new packets */
371                 netdev_poll ( netdev );
372
373                 /* Handle at most one received packet per poll */
374                 if ( ( pkb = netdev_rx_dequeue ( netdev ) ) ) {
375                         DBGC ( netdev, "NETDEV %p processing %p\n",
376                                netdev, pkb );
377                         netdev->ll_protocol->rx ( pkb, netdev );
378                 }
379         }
380
381         /* Re-schedule ourself */
382         schedule ( process );
383 }
384
385 /** Networking stack process */
386 static struct process net_process = {
387         .step = net_step,
388 };
389
390 /** Initialise the networking stack process */
391 static void init_net ( void ) {
392         schedule ( &net_process );
393 }
394
395 INIT_FN ( INIT_PROCESS, init_net, NULL, NULL );