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