3949d26de31ef4f5e18c12020c4c932eceb3f248
[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 <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         DBG ( "%s transmitting %p+%zx\n", netdev_name ( netdev ),
56               pkb->data, pkb_len ( pkb ) );
57         return netdev->transmit ( netdev, pkb );
58 }
59
60 /**
61  * Add packet to receive queue
62  *
63  * @v netdev            Network device
64  * @v pkb               Packet buffer
65  *
66  * The packet is added to the network device's RX queue.  This
67  * function takes ownership of the packet buffer.
68  */
69 void netdev_rx ( struct net_device *netdev, struct pk_buff *pkb ) {
70         DBG ( "%s received %p+%zx\n", netdev_name ( netdev ),
71               pkb->data, pkb_len ( pkb ) );
72         list_add_tail ( &pkb->list, &netdev->rx_queue );
73 }
74
75 /**
76  * Transmit network-layer packet
77  *
78  * @v pkb               Packet buffer
79  * @v netdev            Network device
80  * @v net_protocol      Network-layer protocol
81  * @v ll_dest           Destination link-layer address
82  * @ret rc              Return status code
83  *
84  * Prepends link-layer headers to the packet buffer and transmits the
85  * packet via the specified network device.  This function takes
86  * ownership of the packet buffer.
87  */
88 int net_tx ( struct pk_buff *pkb, struct net_device *netdev,
89              struct net_protocol *net_protocol, const void *ll_dest ) {
90         return netdev->ll_protocol->tx ( pkb, netdev, net_protocol, ll_dest );
91 }
92
93 /**
94  * Process received network-layer packet
95  *
96  * @v pkb               Packet buffer
97  * @v netdev            Network device
98  * @v net_proto         Network-layer protocol, in network-byte order
99  * @v ll_source         Source link-layer address
100  * @ret rc              Return status code
101  */
102 int net_rx ( struct pk_buff *pkb, struct net_device *netdev,
103               uint16_t net_proto, const void *ll_source ) {
104         struct net_protocol *net_protocol;
105
106         /* Hand off to network-layer protocol, if any */
107         for ( net_protocol = net_protocols ; net_protocol < net_protocols_end ;
108               net_protocol++ ) {
109                 if ( net_protocol->net_proto == net_proto ) {
110                         return net_protocol->rx ( pkb, netdev, ll_source );
111                 }
112         }
113         free_pkb ( pkb );
114         return 0;
115 }
116
117 /**
118  * Poll for packet on network device
119  *
120  * @v netdev            Network device
121  * @ret True            There are packets present in the receive queue
122  * @ret False           There are no packets present in the receive queue
123  *
124  * Polls the network device for received packets.  Any received
125  * packets will be added to the RX packet queue via netdev_rx().
126  */
127 int netdev_poll ( struct net_device *netdev ) {
128         netdev->poll ( netdev );
129         return ( ! list_empty ( &netdev->rx_queue ) );
130 }
131
132 /**
133  * Remove packet from device's receive queue
134  *
135  * @v netdev            Network device
136  * @ret pkb             Packet buffer, or NULL
137  *
138  * Removes the first packet from the device's RX queue and returns it.
139  * Ownership of the packet is transferred to the caller.
140  */
141 struct pk_buff * netdev_rx_dequeue ( struct net_device *netdev ) {
142         struct pk_buff *pkb;
143
144         list_for_each_entry ( pkb, &netdev->rx_queue, list ) {
145                 list_del ( &pkb->list );
146                 return pkb;
147         }
148         return NULL;
149 }
150
151 /**
152  * Allocate network device
153  *
154  * @v priv_size         Size of private data area (net_device::priv)
155  * @ret netdev          Network device, or NULL
156  *
157  * Allocates space for a network device and its private data area.
158  */
159 struct net_device * alloc_netdev ( size_t priv_size ) {
160         struct net_device *netdev;
161
162         netdev = calloc ( 1, sizeof ( *netdev ) + priv_size );
163         if ( netdev ) {
164                 INIT_LIST_HEAD ( &netdev->references );
165                 INIT_LIST_HEAD ( &netdev->rx_queue );
166                 netdev->priv = ( ( ( void * ) netdev ) + sizeof ( *netdev ) );
167         }
168         return netdev;
169 }
170
171 /**
172  * Register network device
173  *
174  * @v netdev            Network device
175  * @ret rc              Return status code
176  *
177  * Adds the network device to the list of network devices.
178  */
179 int register_netdev ( struct net_device *netdev ) {
180         
181         /* Add to device list */
182         list_add_tail ( &netdev->list, &net_devices );
183         DBG ( "%s registered\n", netdev_name ( netdev ) );
184
185         return 0;
186 }
187
188 /**
189  * Unregister network device
190  *
191  * @v netdev            Network device
192  *
193  * Removes the network device from the list of network devices.
194  */
195 void unregister_netdev ( struct net_device *netdev ) {
196         struct pk_buff *pkb;
197
198         /* Discard any packets in the RX queue */
199         while ( ( pkb = netdev_rx_dequeue ( netdev ) ) ) {
200                 DBG ( "%s discarding %p+%zx\n", netdev_name ( netdev ),
201                       pkb->data, pkb_len ( pkb ) );
202                 free_pkb ( pkb );
203         }
204
205         /* Kill off any persistent references to this device */
206         forget_references ( &netdev->references );
207
208         /* Remove from device list */
209         list_del ( &netdev->list );
210         DBG ( "%s unregistered\n", netdev_name ( netdev ) );
211 }
212
213 /**
214  * Free network device
215  *
216  * @v netdev            Network device
217  */
218 void free_netdev ( struct net_device *netdev ) {
219         free ( netdev );
220 }
221
222 /**
223  * Iterate through network devices
224  *
225  * @ret netdev          Network device, or NULL
226  *
227  * This returns the registered network devices in the order of
228  * registration.  If no network devices are registered, it will return
229  * NULL.
230  */
231 struct net_device * next_netdev ( void ) {
232         struct net_device *netdev;
233
234         list_for_each_entry ( netdev, &net_devices, list ) {
235                 list_del ( &netdev->list );
236                 list_add_tail ( &netdev->list, &net_devices );
237                 return netdev;
238         }
239         return NULL;
240 }
241
242 /**
243  * Single-step the network stack
244  *
245  * @v process           Network stack process
246  *
247  * This polls all interfaces for any received packets, and processes
248  * at most one packet from the RX queue.
249  *
250  * We avoid processing all received packets, because processing the
251  * received packet can trigger transmission of a new packet (e.g. an
252  * ARP response).  Since TX completions will be processed as part of
253  * the poll operation, it is easy to overflow small TX queues if
254  * multiple packets are processed per poll.
255  */
256 static void net_step ( struct process *process ) {
257         struct net_device *netdev;
258         struct pk_buff *pkb;
259
260         /* Poll and process each network device */
261         list_for_each_entry ( netdev, &net_devices, list ) {
262
263                 /* Poll for new packets */
264                 netdev_poll ( netdev );
265
266                 /* Handle at most one received packet per poll */
267                 if ( ( pkb = netdev_rx_dequeue ( netdev ) ) ) {
268                         DBG ( "%s processing %p+%zx\n", netdev_name ( netdev ),
269                               pkb->data, pkb_len ( pkb ) );
270                         netdev->ll_protocol->rx ( pkb, netdev );
271                 }
272         }
273
274         /* Re-schedule ourself */
275         schedule ( process );
276 }
277
278 /** Networking stack process */
279 static struct process net_process = {
280         .step = net_step,
281 };
282
283 /** Initialise the networking stack process */
284 static void init_net ( void ) {
285         schedule ( &net_process );
286 }
287
288 INIT_FN ( INIT_PROCESS, init_net, NULL, NULL );