[zbin] Fix check for existence of most recent output byte
[ipxe.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., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 */
19
20 FILE_LICENCE ( GPL2_OR_LATER );
21
22 #include <stdint.h>
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <byteswap.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <config/general.h>
29 #include <ipxe/if_ether.h>
30 #include <ipxe/iobuf.h>
31 #include <ipxe/tables.h>
32 #include <ipxe/process.h>
33 #include <ipxe/init.h>
34 #include <ipxe/malloc.h>
35 #include <ipxe/device.h>
36 #include <ipxe/errortab.h>
37 #include <ipxe/profile.h>
38 #include <ipxe/vlan.h>
39 #include <ipxe/netdevice.h>
40
41 /** @file
42 *
43 * Network device management
44 *
45 */
46
47 /** List of network devices */
48 struct list_head net_devices = LIST_HEAD_INIT ( net_devices );
49
50 /** List of open network devices, in reverse order of opening */
51 static struct list_head open_net_devices = LIST_HEAD_INIT ( open_net_devices );
52
53 /** Network device index */
54 static unsigned int netdev_index = 0;
55
56 /** Network polling profiler */
57 static struct profiler net_poll_profiler __profiler = { .name = "net.poll" };
58
59 /** Network receive profiler */
60 static struct profiler net_rx_profiler __profiler = { .name = "net.rx" };
61
62 /** Network transmit profiler */
63 static struct profiler net_tx_profiler __profiler = { .name = "net.tx" };
64
65 /** Default unknown link status code */
66 #define EUNKNOWN_LINK_STATUS __einfo_error ( EINFO_EUNKNOWN_LINK_STATUS )
67 #define EINFO_EUNKNOWN_LINK_STATUS \
68 __einfo_uniqify ( EINFO_EINPROGRESS, 0x01, "Unknown" )
69
70 /** Default not-yet-attempted-configuration status code */
71 #define EUNUSED_CONFIG __einfo_error ( EINFO_EUNUSED_CONFIG )
72 #define EINFO_EUNUSED_CONFIG \
73 __einfo_uniqify ( EINFO_EINPROGRESS, 0x02, "Unused" )
74
75 /** Default configuration-in-progress status code */
76 #define EINPROGRESS_CONFIG __einfo_error ( EINFO_EINPROGRESS_CONFIG )
77 #define EINFO_EINPROGRESS_CONFIG \
78 __einfo_uniqify ( EINFO_EINPROGRESS, 0x03, "Incomplete" )
79
80 /** Default link-down status code */
81 #define ENOTCONN_LINK_DOWN __einfo_error ( EINFO_ENOTCONN_LINK_DOWN )
82 #define EINFO_ENOTCONN_LINK_DOWN \
83 __einfo_uniqify ( EINFO_ENOTCONN, 0x01, "Down" )
84
85 /** Human-readable message for the default link statuses */
86 struct errortab netdev_errors[] __errortab = {
87 __einfo_errortab ( EINFO_EUNKNOWN_LINK_STATUS ),
88 __einfo_errortab ( EINFO_ENOTCONN_LINK_DOWN ),
89 __einfo_errortab ( EINFO_EUNUSED_CONFIG ),
90 __einfo_errortab ( EINFO_EINPROGRESS_CONFIG ),
91 };
92
93 /**
94 * Check whether or not network device has a link-layer address
95 *
96 * @v netdev Network device
97 * @ret has_ll_addr Network device has a link-layer address
98 */
99 static int netdev_has_ll_addr ( struct net_device *netdev ) {
100 uint8_t *ll_addr = netdev->ll_addr;
101 size_t remaining = sizeof ( netdev->ll_addr );
102
103 while ( remaining-- ) {
104 if ( *(ll_addr++) != 0 )
105 return 1;
106 }
107 return 0;
108 }
109
110 /**
111 * Notify drivers of network device or link state change
112 *
113 * @v netdev Network device
114 */
115 static void netdev_notify ( struct net_device *netdev ) {
116 struct net_driver *driver;
117
118 for_each_table_entry ( driver, NET_DRIVERS ) {
119 if ( driver->notify )
120 driver->notify ( netdev );
121 }
122 }
123
124 /**
125 * Freeze network device receive queue processing
126 *
127 * @v netdev Network device
128 */
129 void netdev_rx_freeze ( struct net_device *netdev ) {
130
131 /* Mark receive queue processing as frozen */
132 netdev->state |= NETDEV_RX_FROZEN;
133
134 /* Notify drivers of change */
135 netdev_notify ( netdev );
136 }
137
138 /**
139 * Unfreeze network device receive queue processing
140 *
141 * @v netdev Network device
142 */
143 void netdev_rx_unfreeze ( struct net_device *netdev ) {
144
145 /* Mark receive queue processing as not frozen */
146 netdev->state &= ~NETDEV_RX_FROZEN;
147
148 /* Notify drivers of change */
149 netdev_notify ( netdev );
150 }
151
152 /**
153 * Mark network device as having a specific link state
154 *
155 * @v netdev Network device
156 * @v rc Link status code
157 */
158 void netdev_link_err ( struct net_device *netdev, int rc ) {
159
160 /* Record link state */
161 netdev->link_rc = rc;
162 if ( netdev->link_rc == 0 ) {
163 DBGC ( netdev, "NETDEV %s link is up\n", netdev->name );
164 } else {
165 DBGC ( netdev, "NETDEV %s link is down: %s\n",
166 netdev->name, strerror ( netdev->link_rc ) );
167 }
168
169 /* Notify drivers of link state change */
170 netdev_notify ( netdev );
171 }
172
173 /**
174 * Mark network device as having link down
175 *
176 * @v netdev Network device
177 */
178 void netdev_link_down ( struct net_device *netdev ) {
179
180 /* Avoid clobbering a more detailed link status code, if one
181 * is already set.
182 */
183 if ( ( netdev->link_rc == 0 ) ||
184 ( netdev->link_rc == -EUNKNOWN_LINK_STATUS ) ) {
185 netdev_link_err ( netdev, -ENOTCONN_LINK_DOWN );
186 }
187 }
188
189 /**
190 * Record network device statistic
191 *
192 * @v stats Network device statistics
193 * @v rc Status code
194 */
195 static void netdev_record_stat ( struct net_device_stats *stats, int rc ) {
196 struct net_device_error *error;
197 struct net_device_error *least_common_error;
198 unsigned int i;
199
200 /* If this is not an error, just update the good counter */
201 if ( rc == 0 ) {
202 stats->good++;
203 return;
204 }
205
206 /* Update the bad counter */
207 stats->bad++;
208
209 /* Locate the appropriate error record */
210 least_common_error = &stats->errors[0];
211 for ( i = 0 ; i < ( sizeof ( stats->errors ) /
212 sizeof ( stats->errors[0] ) ) ; i++ ) {
213 error = &stats->errors[i];
214 /* Update matching record, if found */
215 if ( error->rc == rc ) {
216 error->count++;
217 return;
218 }
219 if ( error->count < least_common_error->count )
220 least_common_error = error;
221 }
222
223 /* Overwrite the least common error record */
224 least_common_error->rc = rc;
225 least_common_error->count = 1;
226 }
227
228 /**
229 * Transmit raw packet via network device
230 *
231 * @v netdev Network device
232 * @v iobuf I/O buffer
233 * @ret rc Return status code
234 *
235 * Transmits the packet via the specified network device. This
236 * function takes ownership of the I/O buffer.
237 */
238 int netdev_tx ( struct net_device *netdev, struct io_buffer *iobuf ) {
239 int rc;
240
241 DBGC2 ( netdev, "NETDEV %s transmitting %p (%p+%zx)\n",
242 netdev->name, iobuf, iobuf->data, iob_len ( iobuf ) );
243 profile_start ( &net_tx_profiler );
244
245 /* Enqueue packet */
246 list_add_tail ( &iobuf->list, &netdev->tx_queue );
247
248 /* Avoid calling transmit() on unopened network devices */
249 if ( ! netdev_is_open ( netdev ) ) {
250 rc = -ENETUNREACH;
251 goto err;
252 }
253
254 /* Discard packet (for test purposes) if applicable */
255 if ( ( NETDEV_DISCARD_RATE > 0 ) &&
256 ( ( random() % NETDEV_DISCARD_RATE ) == 0 ) ) {
257 rc = -EAGAIN;
258 goto err;
259 }
260
261 /* Transmit packet */
262 if ( ( rc = netdev->op->transmit ( netdev, iobuf ) ) != 0 )
263 goto err;
264
265 profile_stop ( &net_tx_profiler );
266 return 0;
267
268 err:
269 netdev_tx_complete_err ( netdev, iobuf, rc );
270 return rc;
271 }
272
273 /**
274 * Defer transmitted packet
275 *
276 * @v netdev Network device
277 * @v iobuf I/O buffer
278 *
279 * Drivers may call netdev_tx_defer() if there is insufficient space
280 * in the transmit descriptor ring. Any packets deferred in this way
281 * will be automatically retransmitted as soon as space becomes
282 * available (i.e. as soon as the driver calls netdev_tx_complete()).
283 *
284 * The packet must currently be in the network device's TX queue.
285 *
286 * Drivers utilising netdev_tx_defer() must ensure that space in the
287 * transmit descriptor ring is freed up @b before calling
288 * netdev_tx_complete(). For example, if the ring is modelled using a
289 * producer counter and a consumer counter, then the consumer counter
290 * must be incremented before the call to netdev_tx_complete().
291 * Failure to do this will cause the retransmitted packet to be
292 * immediately redeferred (which will result in out-of-order
293 * transmissions and other nastiness).
294 */
295 void netdev_tx_defer ( struct net_device *netdev, struct io_buffer *iobuf ) {
296
297 /* Catch data corruption as early as possible */
298 list_check_contains_entry ( iobuf, &netdev->tx_queue, list );
299
300 /* Remove from transmit queue */
301 list_del ( &iobuf->list );
302
303 /* Add to deferred transmit queue */
304 list_add_tail ( &iobuf->list, &netdev->tx_deferred );
305
306 /* Record "out of space" statistic */
307 netdev_tx_err ( netdev, NULL, -ENOBUFS );
308 }
309
310 /**
311 * Discard transmitted packet
312 *
313 * @v netdev Network device
314 * @v iobuf I/O buffer, or NULL
315 * @v rc Packet status code
316 *
317 * The packet is discarded and a TX error is recorded. This function
318 * takes ownership of the I/O buffer.
319 */
320 void netdev_tx_err ( struct net_device *netdev,
321 struct io_buffer *iobuf, int rc ) {
322
323 /* Update statistics counter */
324 netdev_record_stat ( &netdev->tx_stats, rc );
325 if ( rc == 0 ) {
326 DBGC2 ( netdev, "NETDEV %s transmission %p complete\n",
327 netdev->name, iobuf );
328 } else {
329 DBGC ( netdev, "NETDEV %s transmission %p failed: %s\n",
330 netdev->name, iobuf, strerror ( rc ) );
331 }
332
333 /* Discard packet */
334 free_iob ( iobuf );
335 }
336
337 /**
338 * Complete network transmission
339 *
340 * @v netdev Network device
341 * @v iobuf I/O buffer
342 * @v rc Packet status code
343 *
344 * The packet must currently be in the network device's TX queue.
345 */
346 void netdev_tx_complete_err ( struct net_device *netdev,
347 struct io_buffer *iobuf, int rc ) {
348
349 /* Catch data corruption as early as possible */
350 list_check_contains_entry ( iobuf, &netdev->tx_queue, list );
351
352 /* Dequeue and free I/O buffer */
353 list_del ( &iobuf->list );
354 netdev_tx_err ( netdev, iobuf, rc );
355
356 /* Transmit first pending packet, if any */
357 if ( ( iobuf = list_first_entry ( &netdev->tx_deferred,
358 struct io_buffer, list ) ) != NULL ) {
359 list_del ( &iobuf->list );
360 netdev_tx ( netdev, iobuf );
361 }
362 }
363
364 /**
365 * Complete network transmission
366 *
367 * @v netdev Network device
368 * @v rc Packet status code
369 *
370 * Completes the oldest outstanding packet in the TX queue.
371 */
372 void netdev_tx_complete_next_err ( struct net_device *netdev, int rc ) {
373 struct io_buffer *iobuf;
374
375 if ( ( iobuf = list_first_entry ( &netdev->tx_queue, struct io_buffer,
376 list ) ) != NULL ) {
377 netdev_tx_complete_err ( netdev, iobuf, rc );
378 }
379 }
380
381 /**
382 * Flush device's transmit queue
383 *
384 * @v netdev Network device
385 */
386 static void netdev_tx_flush ( struct net_device *netdev ) {
387
388 /* Discard any packets in the TX queue. This will also cause
389 * any packets in the deferred TX queue to be discarded
390 * automatically.
391 */
392 while ( ! list_empty ( &netdev->tx_queue ) ) {
393 netdev_tx_complete_next_err ( netdev, -ECANCELED );
394 }
395 assert ( list_empty ( &netdev->tx_queue ) );
396 assert ( list_empty ( &netdev->tx_deferred ) );
397 }
398
399 /**
400 * Add packet to receive queue
401 *
402 * @v netdev Network device
403 * @v iobuf I/O buffer, or NULL
404 *
405 * The packet is added to the network device's RX queue. This
406 * function takes ownership of the I/O buffer.
407 */
408 void netdev_rx ( struct net_device *netdev, struct io_buffer *iobuf ) {
409
410 DBGC2 ( netdev, "NETDEV %s received %p (%p+%zx)\n",
411 netdev->name, iobuf, iobuf->data, iob_len ( iobuf ) );
412
413 /* Discard packet (for test purposes) if applicable */
414 if ( ( NETDEV_DISCARD_RATE > 0 ) &&
415 ( ( random() % NETDEV_DISCARD_RATE ) == 0 ) ) {
416 netdev_rx_err ( netdev, iobuf, -EAGAIN );
417 return;
418 }
419
420 /* Enqueue packet */
421 list_add_tail ( &iobuf->list, &netdev->rx_queue );
422
423 /* Update statistics counter */
424 netdev_record_stat ( &netdev->rx_stats, 0 );
425 }
426
427 /**
428 * Discard received packet
429 *
430 * @v netdev Network device
431 * @v iobuf I/O buffer, or NULL
432 * @v rc Packet status code
433 *
434 * The packet is discarded and an RX error is recorded. This function
435 * takes ownership of the I/O buffer. @c iobuf may be NULL if, for
436 * example, the net device wishes to report an error due to being
437 * unable to allocate an I/O buffer.
438 */
439 void netdev_rx_err ( struct net_device *netdev,
440 struct io_buffer *iobuf, int rc ) {
441
442 DBGC ( netdev, "NETDEV %s failed to receive %p: %s\n",
443 netdev->name, iobuf, strerror ( rc ) );
444
445 /* Discard packet */
446 free_iob ( iobuf );
447
448 /* Update statistics counter */
449 netdev_record_stat ( &netdev->rx_stats, rc );
450 }
451
452 /**
453 * Poll for completed and received packets on network device
454 *
455 * @v netdev Network device
456 *
457 * Polls the network device for completed transmissions and received
458 * packets. Any received packets will be added to the RX packet queue
459 * via netdev_rx().
460 */
461 void netdev_poll ( struct net_device *netdev ) {
462
463 if ( netdev_is_open ( netdev ) )
464 netdev->op->poll ( netdev );
465 }
466
467 /**
468 * Remove packet from device's receive queue
469 *
470 * @v netdev Network device
471 * @ret iobuf I/O buffer, or NULL
472 *
473 * Removes the first packet from the device's RX queue and returns it.
474 * Ownership of the packet is transferred to the caller.
475 */
476 struct io_buffer * netdev_rx_dequeue ( struct net_device *netdev ) {
477 struct io_buffer *iobuf;
478
479 iobuf = list_first_entry ( &netdev->rx_queue, struct io_buffer, list );
480 if ( ! iobuf )
481 return NULL;
482
483 list_del ( &iobuf->list );
484 return iobuf;
485 }
486
487 /**
488 * Flush device's receive queue
489 *
490 * @v netdev Network device
491 */
492 static void netdev_rx_flush ( struct net_device *netdev ) {
493 struct io_buffer *iobuf;
494
495 /* Discard any packets in the RX queue */
496 while ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
497 netdev_rx_err ( netdev, iobuf, -ECANCELED );
498 }
499 }
500
501 /**
502 * Finish network device configuration
503 *
504 * @v config Network device configuration
505 * @v rc Reason for completion
506 */
507 static void netdev_config_close ( struct net_device_configuration *config,
508 int rc ) {
509 struct net_device_configurator *configurator = config->configurator;
510 struct net_device *netdev = config->netdev;
511
512 /* Restart interface */
513 intf_restart ( &config->job, rc );
514
515 /* Record configuration result */
516 config->rc = rc;
517 if ( rc == 0 ) {
518 DBGC ( netdev, "NETDEV %s configured via %s\n",
519 netdev->name, configurator->name );
520 } else {
521 DBGC ( netdev, "NETDEV %s configuration via %s failed: %s\n",
522 netdev->name, configurator->name, strerror ( rc ) );
523 }
524 }
525
526 /** Network device configuration interface operations */
527 static struct interface_operation netdev_config_ops[] = {
528 INTF_OP ( intf_close, struct net_device_configuration *,
529 netdev_config_close ),
530 };
531
532 /** Network device configuration interface descriptor */
533 static struct interface_descriptor netdev_config_desc =
534 INTF_DESC ( struct net_device_configuration, job, netdev_config_ops );
535
536 /**
537 * Free network device
538 *
539 * @v refcnt Network device reference counter
540 */
541 static void free_netdev ( struct refcnt *refcnt ) {
542 struct net_device *netdev =
543 container_of ( refcnt, struct net_device, refcnt );
544
545 netdev_tx_flush ( netdev );
546 netdev_rx_flush ( netdev );
547 clear_settings ( netdev_settings ( netdev ) );
548 free ( netdev );
549 }
550
551 /**
552 * Allocate network device
553 *
554 * @v priv_len Length of private data area (net_device::priv)
555 * @ret netdev Network device, or NULL
556 *
557 * Allocates space for a network device and its private data area.
558 */
559 struct net_device * alloc_netdev ( size_t priv_len ) {
560 struct net_device *netdev;
561 struct net_device_configurator *configurator;
562 struct net_device_configuration *config;
563 unsigned int num_configs;
564 size_t confs_len;
565 size_t total_len;
566
567 num_configs = table_num_entries ( NET_DEVICE_CONFIGURATORS );
568 confs_len = ( num_configs * sizeof ( netdev->configs[0] ) );
569 total_len = ( sizeof ( *netdev ) + confs_len + priv_len );
570 netdev = zalloc ( total_len );
571 if ( netdev ) {
572 ref_init ( &netdev->refcnt, free_netdev );
573 netdev->link_rc = -EUNKNOWN_LINK_STATUS;
574 INIT_LIST_HEAD ( &netdev->tx_queue );
575 INIT_LIST_HEAD ( &netdev->tx_deferred );
576 INIT_LIST_HEAD ( &netdev->rx_queue );
577 netdev_settings_init ( netdev );
578 config = netdev->configs;
579 for_each_table_entry ( configurator, NET_DEVICE_CONFIGURATORS ){
580 config->netdev = netdev;
581 config->configurator = configurator;
582 config->rc = -EUNUSED_CONFIG;
583 intf_init ( &config->job, &netdev_config_desc,
584 &netdev->refcnt );
585 config++;
586 }
587 netdev->priv = ( ( ( void * ) netdev ) + sizeof ( *netdev ) +
588 confs_len );
589 }
590 return netdev;
591 }
592
593 /**
594 * Register network device
595 *
596 * @v netdev Network device
597 * @ret rc Return status code
598 *
599 * Gives the network device a name and adds it to the list of network
600 * devices.
601 */
602 int register_netdev ( struct net_device *netdev ) {
603 struct ll_protocol *ll_protocol = netdev->ll_protocol;
604 struct net_driver *driver;
605 struct net_device *duplicate;
606 uint32_t seed;
607 int rc;
608
609 /* Set initial link-layer address, if not already set */
610 if ( ! netdev_has_ll_addr ( netdev ) ) {
611 ll_protocol->init_addr ( netdev->hw_addr, netdev->ll_addr );
612 }
613
614 /* Reject network devices that are already available via a
615 * different hardware device.
616 */
617 duplicate = find_netdev_by_ll_addr ( ll_protocol, netdev->ll_addr );
618 if ( duplicate && ( duplicate->dev != netdev->dev ) ) {
619 DBGC ( netdev, "NETDEV rejecting duplicate (phys %s) of %s "
620 "(phys %s)\n", netdev->dev->name, duplicate->name,
621 duplicate->dev->name );
622 rc = -EEXIST;
623 goto err_duplicate;
624 }
625
626 /* Record device index and create device name */
627 netdev->index = netdev_index++;
628 if ( netdev->name[0] == '\0' ) {
629 snprintf ( netdev->name, sizeof ( netdev->name ), "net%d",
630 netdev->index );
631 }
632
633 /* Use least significant bits of the link-layer address to
634 * improve the randomness of the (non-cryptographic) random
635 * number generator.
636 */
637 memcpy ( &seed, ( netdev->ll_addr + ll_protocol->ll_addr_len
638 - sizeof ( seed ) ), sizeof ( seed ) );
639 srand ( rand() ^ seed );
640
641 /* Add to device list */
642 netdev_get ( netdev );
643 list_add_tail ( &netdev->list, &net_devices );
644 DBGC ( netdev, "NETDEV %s registered (phys %s hwaddr %s)\n",
645 netdev->name, netdev->dev->name,
646 netdev_addr ( netdev ) );
647
648 /* Register per-netdev configuration settings */
649 if ( ( rc = register_settings ( netdev_settings ( netdev ),
650 NULL, netdev->name ) ) != 0 ) {
651 DBGC ( netdev, "NETDEV %s could not register settings: %s\n",
652 netdev->name, strerror ( rc ) );
653 goto err_register_settings;
654 }
655
656 /* Probe device */
657 for_each_table_entry ( driver, NET_DRIVERS ) {
658 if ( driver->probe && ( rc = driver->probe ( netdev ) ) != 0 ) {
659 DBGC ( netdev, "NETDEV %s could not add %s device: "
660 "%s\n", netdev->name, driver->name,
661 strerror ( rc ) );
662 goto err_probe;
663 }
664 }
665
666 return 0;
667
668 err_probe:
669 for_each_table_entry_continue_reverse ( driver, NET_DRIVERS ) {
670 if ( driver->remove )
671 driver->remove ( netdev );
672 }
673 clear_settings ( netdev_settings ( netdev ) );
674 unregister_settings ( netdev_settings ( netdev ) );
675 err_register_settings:
676 err_duplicate:
677 return rc;
678 }
679
680 /**
681 * Open network device
682 *
683 * @v netdev Network device
684 * @ret rc Return status code
685 */
686 int netdev_open ( struct net_device *netdev ) {
687 int rc;
688
689 /* Do nothing if device is already open */
690 if ( netdev->state & NETDEV_OPEN )
691 return 0;
692
693 DBGC ( netdev, "NETDEV %s opening\n", netdev->name );
694
695 /* Mark as opened */
696 netdev->state |= NETDEV_OPEN;
697
698 /* Open the device */
699 if ( ( rc = netdev->op->open ( netdev ) ) != 0 )
700 goto err;
701
702 /* Add to head of open devices list */
703 list_add ( &netdev->open_list, &open_net_devices );
704
705 /* Notify drivers of device state change */
706 netdev_notify ( netdev );
707
708 return 0;
709
710 err:
711 netdev->state &= ~NETDEV_OPEN;
712 return rc;
713 }
714
715 /**
716 * Close network device
717 *
718 * @v netdev Network device
719 */
720 void netdev_close ( struct net_device *netdev ) {
721 unsigned int num_configs;
722 unsigned int i;
723
724 /* Do nothing if device is already closed */
725 if ( ! ( netdev->state & NETDEV_OPEN ) )
726 return;
727
728 DBGC ( netdev, "NETDEV %s closing\n", netdev->name );
729
730 /* Terminate any ongoing configurations. Use intf_close()
731 * rather than intf_restart() to allow the cancellation to be
732 * reported back to us if a configuration is actually in
733 * progress.
734 */
735 num_configs = table_num_entries ( NET_DEVICE_CONFIGURATORS );
736 for ( i = 0 ; i < num_configs ; i++ )
737 intf_close ( &netdev->configs[i].job, -ECANCELED );
738
739 /* Remove from open devices list */
740 list_del ( &netdev->open_list );
741
742 /* Mark as closed */
743 netdev->state &= ~NETDEV_OPEN;
744
745 /* Notify drivers of device state change */
746 netdev_notify ( netdev );
747
748 /* Close the device */
749 netdev->op->close ( netdev );
750
751 /* Flush TX and RX queues */
752 netdev_tx_flush ( netdev );
753 netdev_rx_flush ( netdev );
754 }
755
756 /**
757 * Unregister network device
758 *
759 * @v netdev Network device
760 *
761 * Removes the network device from the list of network devices.
762 */
763 void unregister_netdev ( struct net_device *netdev ) {
764 struct net_driver *driver;
765
766 /* Ensure device is closed */
767 netdev_close ( netdev );
768
769 /* Remove device */
770 for_each_table_entry_reverse ( driver, NET_DRIVERS ) {
771 if ( driver->remove )
772 driver->remove ( netdev );
773 }
774
775 /* Unregister per-netdev configuration settings */
776 clear_settings ( netdev_settings ( netdev ) );
777 unregister_settings ( netdev_settings ( netdev ) );
778
779 /* Remove from device list */
780 DBGC ( netdev, "NETDEV %s unregistered\n", netdev->name );
781 list_del ( &netdev->list );
782 netdev_put ( netdev );
783
784 /* Reset network device index if no devices remain */
785 if ( list_empty ( &net_devices ) )
786 netdev_index = 0;
787 }
788
789 /** Enable or disable interrupts
790 *
791 * @v netdev Network device
792 * @v enable Interrupts should be enabled
793 */
794 void netdev_irq ( struct net_device *netdev, int enable ) {
795
796 /* Do nothing if device does not support interrupts */
797 if ( ! netdev_irq_supported ( netdev ) )
798 return;
799
800 /* Enable or disable device interrupts */
801 netdev->op->irq ( netdev, enable );
802
803 /* Record interrupt enabled state */
804 netdev->state &= ~NETDEV_IRQ_ENABLED;
805 if ( enable )
806 netdev->state |= NETDEV_IRQ_ENABLED;
807 }
808
809 /**
810 * Get network device by name
811 *
812 * @v name Network device name
813 * @ret netdev Network device, or NULL
814 */
815 struct net_device * find_netdev ( const char *name ) {
816 struct net_device *netdev;
817
818 /* Allow "netX" shortcut */
819 if ( strcmp ( name, "netX" ) == 0 )
820 return last_opened_netdev();
821
822 /* Identify network device by name */
823 list_for_each_entry ( netdev, &net_devices, list ) {
824 if ( strcmp ( netdev->name, name ) == 0 )
825 return netdev;
826 }
827
828 return NULL;
829 }
830
831 /**
832 * Get network device by index
833 *
834 * @v index Network device index
835 * @ret netdev Network device, or NULL
836 */
837 struct net_device * find_netdev_by_index ( unsigned int index ) {
838 struct net_device *netdev;
839
840 /* Identify network device by index */
841 list_for_each_entry ( netdev, &net_devices, list ) {
842 if ( netdev->index == index )
843 return netdev;
844 }
845
846 return NULL;
847 }
848
849 /**
850 * Get network device by PCI bus:dev.fn address
851 *
852 * @v bus_type Bus type
853 * @v location Bus location
854 * @ret netdev Network device, or NULL
855 */
856 struct net_device * find_netdev_by_location ( unsigned int bus_type,
857 unsigned int location ) {
858 struct net_device *netdev;
859
860 list_for_each_entry ( netdev, &net_devices, list ) {
861 if ( ( netdev->dev->desc.bus_type == bus_type ) &&
862 ( netdev->dev->desc.location == location ) )
863 return netdev;
864 }
865
866 return NULL;
867 }
868
869 /**
870 * Get network device by link-layer address
871 *
872 * @v ll_protocol Link-layer protocol
873 * @v ll_addr Link-layer address
874 * @ret netdev Network device, or NULL
875 */
876 struct net_device * find_netdev_by_ll_addr ( struct ll_protocol *ll_protocol,
877 const void *ll_addr ) {
878 struct net_device *netdev;
879
880 list_for_each_entry ( netdev, &net_devices, list ) {
881 if ( ( netdev->ll_protocol == ll_protocol ) &&
882 ( memcmp ( netdev->ll_addr, ll_addr,
883 ll_protocol->ll_addr_len ) == 0 ) )
884 return netdev;
885 }
886
887 return NULL;
888 }
889
890 /**
891 * Get most recently opened network device
892 *
893 * @ret netdev Most recently opened network device, or NULL
894 */
895 struct net_device * last_opened_netdev ( void ) {
896 struct net_device *netdev;
897
898 netdev = list_first_entry ( &open_net_devices, struct net_device,
899 open_list );
900 if ( ! netdev )
901 return NULL;
902
903 assert ( netdev_is_open ( netdev ) );
904 return netdev;
905 }
906
907 /**
908 * Transmit network-layer packet
909 *
910 * @v iobuf I/O buffer
911 * @v netdev Network device
912 * @v net_protocol Network-layer protocol
913 * @v ll_dest Destination link-layer address
914 * @v ll_source Source link-layer address
915 * @ret rc Return status code
916 *
917 * Prepends link-layer headers to the I/O buffer and transmits the
918 * packet via the specified network device. This function takes
919 * ownership of the I/O buffer.
920 */
921 int net_tx ( struct io_buffer *iobuf, struct net_device *netdev,
922 struct net_protocol *net_protocol, const void *ll_dest,
923 const void *ll_source ) {
924 struct ll_protocol *ll_protocol = netdev->ll_protocol;
925 int rc;
926
927 /* Add link-layer header */
928 if ( ( rc = ll_protocol->push ( netdev, iobuf, ll_dest, ll_source,
929 net_protocol->net_proto ) ) != 0 ) {
930 /* Record error for diagnosis */
931 netdev_tx_err ( netdev, iobuf, rc );
932 return rc;
933 }
934
935 /* Transmit packet */
936 return netdev_tx ( netdev, iobuf );
937 }
938
939 /**
940 * Process received network-layer packet
941 *
942 * @v iobuf I/O buffer
943 * @v netdev Network device
944 * @v net_proto Network-layer protocol, in network-byte order
945 * @v ll_dest Destination link-layer address
946 * @v ll_source Source link-layer address
947 * @v flags Packet flags
948 * @ret rc Return status code
949 */
950 int net_rx ( struct io_buffer *iobuf, struct net_device *netdev,
951 uint16_t net_proto, const void *ll_dest, const void *ll_source,
952 unsigned int flags ) {
953 struct net_protocol *net_protocol;
954
955 /* Hand off to network-layer protocol, if any */
956 for_each_table_entry ( net_protocol, NET_PROTOCOLS ) {
957 if ( net_protocol->net_proto == net_proto )
958 return net_protocol->rx ( iobuf, netdev, ll_dest,
959 ll_source, flags );
960 }
961
962 DBGC ( netdev, "NETDEV %s unknown network protocol %04x\n",
963 netdev->name, ntohs ( net_proto ) );
964 free_iob ( iobuf );
965 return -ENOTSUP;
966 }
967
968 /**
969 * Poll the network stack
970 *
971 * This polls all interfaces for received packets, and processes
972 * packets from the RX queue.
973 */
974 void net_poll ( void ) {
975 struct net_device *netdev;
976 struct io_buffer *iobuf;
977 struct ll_protocol *ll_protocol;
978 const void *ll_dest;
979 const void *ll_source;
980 uint16_t net_proto;
981 unsigned int flags;
982 int rc;
983
984 /* Poll and process each network device */
985 list_for_each_entry ( netdev, &net_devices, list ) {
986
987 /* Poll for new packets */
988 profile_start ( &net_poll_profiler );
989 netdev_poll ( netdev );
990 profile_stop ( &net_poll_profiler );
991
992 /* Leave received packets on the queue if receive
993 * queue processing is currently frozen. This will
994 * happen when the raw packets are to be manually
995 * dequeued using netdev_rx_dequeue(), rather than
996 * processed via the usual networking stack.
997 */
998 if ( netdev_rx_frozen ( netdev ) )
999 continue;
1000
1001 /* Process all received packets */
1002 while ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
1003
1004 DBGC2 ( netdev, "NETDEV %s processing %p (%p+%zx)\n",
1005 netdev->name, iobuf, iobuf->data,
1006 iob_len ( iobuf ) );
1007 profile_start ( &net_rx_profiler );
1008
1009 /* Remove link-layer header */
1010 ll_protocol = netdev->ll_protocol;
1011 if ( ( rc = ll_protocol->pull ( netdev, iobuf,
1012 &ll_dest, &ll_source,
1013 &net_proto,
1014 &flags ) ) != 0 ) {
1015 free_iob ( iobuf );
1016 continue;
1017 }
1018
1019 /* Hand packet to network layer */
1020 if ( ( rc = net_rx ( iob_disown ( iobuf ), netdev,
1021 net_proto, ll_dest,
1022 ll_source, flags ) ) != 0 ) {
1023 /* Record error for diagnosis */
1024 netdev_rx_err ( netdev, NULL, rc );
1025 }
1026 profile_stop ( &net_rx_profiler );
1027 }
1028 }
1029 }
1030
1031 /**
1032 * Single-step the network stack
1033 *
1034 * @v process Network stack process
1035 */
1036 static void net_step ( struct process *process __unused ) {
1037 net_poll();
1038 }
1039
1040 /**
1041 * Get the VLAN tag (when VLAN support is not present)
1042 *
1043 * @v netdev Network device
1044 * @ret tag 0, indicating that device is not a VLAN device
1045 */
1046 __weak unsigned int vlan_tag ( struct net_device *netdev __unused ) {
1047 return 0;
1048 }
1049
1050 /**
1051 * Identify VLAN device (when VLAN support is not present)
1052 *
1053 * @v trunk Trunk network device
1054 * @v tag VLAN tag
1055 * @ret netdev VLAN device, if any
1056 */
1057 __weak struct net_device * vlan_find ( struct net_device *trunk __unused,
1058 unsigned int tag __unused ) {
1059 return NULL;
1060 }
1061
1062 /** Networking stack process */
1063 PERMANENT_PROCESS ( net_process, net_step );
1064
1065 /**
1066 * Discard some cached network device data
1067 *
1068 * @ret discarded Number of cached items discarded
1069 */
1070 static unsigned int net_discard ( void ) {
1071 struct net_device *netdev;
1072 struct io_buffer *iobuf;
1073 unsigned int discarded = 0;
1074
1075 /* Try to drop one deferred TX packet from each network device */
1076 for_each_netdev ( netdev ) {
1077 if ( ( iobuf = list_first_entry ( &netdev->tx_deferred,
1078 struct io_buffer,
1079 list ) ) != NULL ) {
1080
1081 /* Discard first deferred packet */
1082 list_del ( &iobuf->list );
1083 free_iob ( iobuf );
1084
1085 /* Report discard */
1086 discarded++;
1087 }
1088 }
1089
1090 return discarded;
1091 }
1092
1093 /** Network device cache discarder */
1094 struct cache_discarder net_discarder __cache_discarder ( CACHE_NORMAL ) = {
1095 .discard = net_discard,
1096 };
1097
1098 /**
1099 * Find network device configurator
1100 *
1101 * @v name Name
1102 * @ret configurator Network device configurator, or NULL
1103 */
1104 struct net_device_configurator * find_netdev_configurator ( const char *name ) {
1105 struct net_device_configurator *configurator;
1106
1107 for_each_table_entry ( configurator, NET_DEVICE_CONFIGURATORS ) {
1108 if ( strcmp ( configurator->name, name ) == 0 )
1109 return configurator;
1110 }
1111 return NULL;
1112 }
1113
1114 /**
1115 * Start network device configuration
1116 *
1117 * @v netdev Network device
1118 * @v configurator Network device configurator
1119 * @ret rc Return status code
1120 */
1121 int netdev_configure ( struct net_device *netdev,
1122 struct net_device_configurator *configurator ) {
1123 struct net_device_configuration *config =
1124 netdev_configuration ( netdev, configurator );
1125 int rc;
1126
1127 /* Check applicability of configurator */
1128 if ( ! netdev_configurator_applies ( netdev, configurator ) ) {
1129 DBGC ( netdev, "NETDEV %s does not support configuration via "
1130 "%s\n", netdev->name, configurator->name );
1131 return -ENOTSUP;
1132 }
1133
1134 /* Terminate any ongoing configuration */
1135 intf_restart ( &config->job, -ECANCELED );
1136
1137 /* Mark configuration as being in progress */
1138 config->rc = -EINPROGRESS_CONFIG;
1139
1140 DBGC ( netdev, "NETDEV %s starting configuration via %s\n",
1141 netdev->name, configurator->name );
1142
1143 /* Start configuration */
1144 if ( ( rc = configurator->start ( &config->job, netdev ) ) != 0 ) {
1145 DBGC ( netdev, "NETDEV %s could not start configuration via "
1146 "%s: %s\n", netdev->name, configurator->name,
1147 strerror ( rc ) );
1148 config->rc = rc;
1149 return rc;
1150 }
1151
1152 return 0;
1153 }
1154
1155 /**
1156 * Start network device configuration via all supported configurators
1157 *
1158 * @v netdev Network device
1159 * @ret rc Return status code
1160 */
1161 int netdev_configure_all ( struct net_device *netdev ) {
1162 struct net_device_configurator *configurator;
1163 int rc;
1164
1165 /* Start configuration for each configurator */
1166 for_each_table_entry ( configurator, NET_DEVICE_CONFIGURATORS ) {
1167
1168 /* Skip any inapplicable configurators */
1169 if ( ! netdev_configurator_applies ( netdev, configurator ) )
1170 continue;
1171
1172 /* Start configuration */
1173 if ( ( rc = netdev_configure ( netdev, configurator ) ) != 0 )
1174 return rc;
1175 }
1176
1177 return 0;
1178 }
1179
1180 /**
1181 * Check if network device has a configuration with a specified status code
1182 *
1183 * @v netdev Network device
1184 * @v rc Status code
1185 * @ret has_rc Network device has a configuration with this status code
1186 */
1187 static int netdev_has_configuration_rc ( struct net_device *netdev, int rc ) {
1188 unsigned int num_configs;
1189 unsigned int i;
1190
1191 num_configs = table_num_entries ( NET_DEVICE_CONFIGURATORS );
1192 for ( i = 0 ; i < num_configs ; i++ ) {
1193 if ( netdev->configs[i].rc == rc )
1194 return 1;
1195 }
1196 return 0;
1197 }
1198
1199 /**
1200 * Check if network device configuration is in progress
1201 *
1202 * @v netdev Network device
1203 * @ret is_in_progress Network device configuration is in progress
1204 */
1205 int netdev_configuration_in_progress ( struct net_device *netdev ) {
1206
1207 return netdev_has_configuration_rc ( netdev, -EINPROGRESS_CONFIG );
1208 }
1209
1210 /**
1211 * Check if network device has at least one successful configuration
1212 *
1213 * @v netdev Network device
1214 * @v configurator Configurator
1215 * @ret rc Return status code
1216 */
1217 int netdev_configuration_ok ( struct net_device *netdev ) {
1218
1219 return netdev_has_configuration_rc ( netdev, 0 );
1220 }