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