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