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