![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to netdevice.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net|
Return to netdevice.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net |
1.1 root 1: /*
2: * Copyright (C) 2006 Michael Brown <[email protected]>.
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: FILE_LICENCE ( GPL2_OR_LATER );
20:
21: #include <stdint.h>
22: #include <stdlib.h>
23: #include <stdio.h>
24: #include <byteswap.h>
25: #include <string.h>
26: #include <errno.h>
27: #include <config/general.h>
28: #include <ipxe/if_ether.h>
29: #include <ipxe/iobuf.h>
30: #include <ipxe/tables.h>
31: #include <ipxe/process.h>
32: #include <ipxe/init.h>
33: #include <ipxe/device.h>
34: #include <ipxe/errortab.h>
35: #include <ipxe/netdevice.h>
36:
37: /** @file
38: *
39: * Network device management
40: *
41: */
42:
43: /** List of network devices */
44: struct list_head net_devices = LIST_HEAD_INIT ( net_devices );
45:
46: /** List of open network devices, in reverse order of opening */
47: static struct list_head open_net_devices = LIST_HEAD_INIT ( open_net_devices );
48:
49: /** Default unknown link status code */
50: #define EUNKNOWN_LINK_STATUS __einfo_error ( EINFO_EUNKNOWN_LINK_STATUS )
51: #define EINFO_EUNKNOWN_LINK_STATUS \
52: __einfo_uniqify ( EINFO_EINPROGRESS, 0x01, "Unknown" )
53:
54: /** Default link-down status code */
55: #define ENOTCONN_LINK_DOWN __einfo_error ( EINFO_ENOTCONN_LINK_DOWN )
56: #define EINFO_ENOTCONN_LINK_DOWN \
57: __einfo_uniqify ( EINFO_ENOTCONN, 0x01, "Down" )
58:
59: /** Human-readable message for the default link statuses */
60: struct errortab netdev_errors[] __errortab = {
61: __einfo_errortab ( EINFO_EUNKNOWN_LINK_STATUS ),
62: __einfo_errortab ( EINFO_ENOTCONN_LINK_DOWN ),
63: };
64:
65: /**
66: * Notify drivers of network device or link state change
67: *
68: * @v netdev Network device
69: */
70: static void netdev_notify ( struct net_device *netdev ) {
71: struct net_driver *driver;
72:
73: for_each_table_entry ( driver, NET_DRIVERS )
74: driver->notify ( netdev );
75: }
76:
77: /**
78: * Mark network device as having a specific link state
79: *
80: * @v netdev Network device
81: * @v rc Link status code
82: */
83: void netdev_link_err ( struct net_device *netdev, int rc ) {
84:
85: /* Record link state */
86: netdev->link_rc = rc;
87: if ( netdev->link_rc == 0 ) {
88: DBGC ( netdev, "NETDEV %s link is up\n", netdev->name );
89: } else {
90: DBGC ( netdev, "NETDEV %s link is down: %s\n",
91: netdev->name, strerror ( netdev->link_rc ) );
92: }
93:
94: /* Notify drivers of link state change */
95: netdev_notify ( netdev );
96: }
97:
98: /**
99: * Mark network device as having link down
100: *
101: * @v netdev Network device
102: */
103: void netdev_link_down ( struct net_device *netdev ) {
104:
105: /* Avoid clobbering a more detailed link status code, if one
106: * is already set.
107: */
108: if ( ( netdev->link_rc == 0 ) ||
109: ( netdev->link_rc == -EUNKNOWN_LINK_STATUS ) ) {
110: netdev_link_err ( netdev, -ENOTCONN_LINK_DOWN );
111: }
112: }
113:
114: /**
115: * Record network device statistic
116: *
117: * @v stats Network device statistics
118: * @v rc Status code
119: */
120: static void netdev_record_stat ( struct net_device_stats *stats, int rc ) {
121: struct net_device_error *error;
122: struct net_device_error *least_common_error;
123: unsigned int i;
124:
125: /* If this is not an error, just update the good counter */
126: if ( rc == 0 ) {
127: stats->good++;
128: return;
129: }
130:
131: /* Update the bad counter */
132: stats->bad++;
133:
134: /* Locate the appropriate error record */
135: least_common_error = &stats->errors[0];
136: for ( i = 0 ; i < ( sizeof ( stats->errors ) /
137: sizeof ( stats->errors[0] ) ) ; i++ ) {
138: error = &stats->errors[i];
139: /* Update matching record, if found */
140: if ( error->rc == rc ) {
141: error->count++;
142: return;
143: }
144: if ( error->count < least_common_error->count )
145: least_common_error = error;
146: }
147:
148: /* Overwrite the least common error record */
149: least_common_error->rc = rc;
150: least_common_error->count = 1;
151: }
152:
153: /**
154: * Transmit raw packet via network device
155: *
156: * @v netdev Network device
157: * @v iobuf I/O buffer
158: * @ret rc Return status code
159: *
160: * Transmits the packet via the specified network device. This
161: * function takes ownership of the I/O buffer.
162: */
163: int netdev_tx ( struct net_device *netdev, struct io_buffer *iobuf ) {
164: int rc;
165:
166: DBGC ( netdev, "NETDEV %s transmitting %p (%p+%zx)\n",
167: netdev->name, iobuf, iobuf->data, iob_len ( iobuf ) );
168:
169: /* Enqueue packet */
170: list_add_tail ( &iobuf->list, &netdev->tx_queue );
171:
172: /* Avoid calling transmit() on unopened network devices */
173: if ( ! netdev_is_open ( netdev ) ) {
174: rc = -ENETUNREACH;
175: goto err;
176: }
177:
178: /* Discard packet (for test purposes) if applicable */
179: if ( ( NETDEV_DISCARD_RATE > 0 ) &&
180: ( ( random() % NETDEV_DISCARD_RATE ) == 0 ) ) {
181: rc = -EAGAIN;
182: goto err;
183: }
184:
185: /* Transmit packet */
186: if ( ( rc = netdev->op->transmit ( netdev, iobuf ) ) != 0 )
187: goto err;
188:
189: return 0;
190:
191: err:
192: netdev_tx_complete_err ( netdev, iobuf, rc );
193: return rc;
194: }
195:
196: /**
197: * Complete network transmission
198: *
199: * @v netdev Network device
200: * @v iobuf I/O buffer
201: * @v rc Packet status code
202: *
203: * The packet must currently be in the network device's TX queue.
204: */
205: void netdev_tx_complete_err ( struct net_device *netdev,
206: struct io_buffer *iobuf, int rc ) {
207:
208: /* Update statistics counter */
209: netdev_record_stat ( &netdev->tx_stats, rc );
210: if ( rc == 0 ) {
211: DBGC ( netdev, "NETDEV %s transmission %p complete\n",
212: netdev->name, iobuf );
213: } else {
214: DBGC ( netdev, "NETDEV %s transmission %p failed: %s\n",
215: netdev->name, iobuf, strerror ( rc ) );
216: }
217:
218: /* Catch data corruption as early as possible */
219: assert ( iobuf->list.next != NULL );
220: assert ( iobuf->list.prev != NULL );
221:
222: /* Dequeue and free I/O buffer */
223: list_del ( &iobuf->list );
224: free_iob ( iobuf );
225: }
226:
227: /**
228: * Complete network transmission
229: *
230: * @v netdev Network device
231: * @v rc Packet status code
232: *
233: * Completes the oldest outstanding packet in the TX queue.
234: */
235: void netdev_tx_complete_next_err ( struct net_device *netdev, int rc ) {
236: struct io_buffer *iobuf;
237:
238: list_for_each_entry ( iobuf, &netdev->tx_queue, list ) {
239: netdev_tx_complete_err ( netdev, iobuf, rc );
240: return;
241: }
242: }
243:
244: /**
245: * Flush device's transmit queue
246: *
247: * @v netdev Network device
248: */
249: static void netdev_tx_flush ( struct net_device *netdev ) {
250:
251: /* Discard any packets in the TX queue */
252: while ( ! list_empty ( &netdev->tx_queue ) ) {
253: netdev_tx_complete_next_err ( netdev, -ECANCELED );
254: }
255: }
256:
257: /**
258: * Add packet to receive queue
259: *
260: * @v netdev Network device
261: * @v iobuf I/O buffer, or NULL
262: *
263: * The packet is added to the network device's RX queue. This
264: * function takes ownership of the I/O buffer.
265: */
266: void netdev_rx ( struct net_device *netdev, struct io_buffer *iobuf ) {
267:
268: DBGC ( netdev, "NETDEV %s received %p (%p+%zx)\n",
269: netdev->name, iobuf, iobuf->data, iob_len ( iobuf ) );
270:
271: /* Discard packet (for test purposes) if applicable */
272: if ( ( NETDEV_DISCARD_RATE > 0 ) &&
273: ( ( random() % NETDEV_DISCARD_RATE ) == 0 ) ) {
274: netdev_rx_err ( netdev, iobuf, -EAGAIN );
275: return;
276: }
277:
278: /* Enqueue packet */
279: list_add_tail ( &iobuf->list, &netdev->rx_queue );
280:
281: /* Update statistics counter */
282: netdev_record_stat ( &netdev->rx_stats, 0 );
283: }
284:
285: /**
286: * Discard received packet
287: *
288: * @v netdev Network device
289: * @v iobuf I/O buffer, or NULL
290: * @v rc Packet status code
291: *
292: * The packet is discarded and an RX error is recorded. This function
293: * takes ownership of the I/O buffer. @c iobuf may be NULL if, for
294: * example, the net device wishes to report an error due to being
295: * unable to allocate an I/O buffer.
296: */
297: void netdev_rx_err ( struct net_device *netdev,
298: struct io_buffer *iobuf, int rc ) {
299:
300: DBGC ( netdev, "NETDEV %s failed to receive %p: %s\n",
301: netdev->name, iobuf, strerror ( rc ) );
302:
303: /* Discard packet */
304: free_iob ( iobuf );
305:
306: /* Update statistics counter */
307: netdev_record_stat ( &netdev->rx_stats, rc );
308: }
309:
310: /**
311: * Poll for completed and received packets on network device
312: *
313: * @v netdev Network device
314: *
315: * Polls the network device for completed transmissions and received
316: * packets. Any received packets will be added to the RX packet queue
317: * via netdev_rx().
318: */
319: void netdev_poll ( struct net_device *netdev ) {
320:
321: if ( netdev_is_open ( netdev ) )
322: netdev->op->poll ( netdev );
323: }
324:
325: /**
326: * Remove packet from device's receive queue
327: *
328: * @v netdev Network device
329: * @ret iobuf I/O buffer, or NULL
330: *
331: * Removes the first packet from the device's RX queue and returns it.
332: * Ownership of the packet is transferred to the caller.
333: */
334: struct io_buffer * netdev_rx_dequeue ( struct net_device *netdev ) {
335: struct io_buffer *iobuf;
336:
337: iobuf = list_first_entry ( &netdev->rx_queue, struct io_buffer, list );
338: if ( ! iobuf )
339: return NULL;
340:
341: list_del ( &iobuf->list );
342: return iobuf;
343: }
344:
345: /**
346: * Flush device's receive queue
347: *
348: * @v netdev Network device
349: */
350: static void netdev_rx_flush ( struct net_device *netdev ) {
351: struct io_buffer *iobuf;
352:
353: /* Discard any packets in the RX queue */
354: while ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
355: netdev_rx_err ( netdev, iobuf, -ECANCELED );
356: }
357: }
358:
359: /**
360: * Free network device
361: *
362: * @v refcnt Network device reference counter
363: */
364: static void free_netdev ( struct refcnt *refcnt ) {
365: struct net_device *netdev =
366: container_of ( refcnt, struct net_device, refcnt );
367:
368: netdev_tx_flush ( netdev );
369: netdev_rx_flush ( netdev );
370: clear_settings ( netdev_settings ( netdev ) );
371: free ( netdev );
372: }
373:
374: /**
375: * Allocate network device
376: *
377: * @v priv_size Size of private data area (net_device::priv)
378: * @ret netdev Network device, or NULL
379: *
380: * Allocates space for a network device and its private data area.
381: */
382: struct net_device * alloc_netdev ( size_t priv_size ) {
383: struct net_device *netdev;
384: size_t total_len;
385:
386: total_len = ( sizeof ( *netdev ) + priv_size );
387: netdev = zalloc ( total_len );
388: if ( netdev ) {
389: ref_init ( &netdev->refcnt, free_netdev );
390: netdev->link_rc = -EUNKNOWN_LINK_STATUS;
391: INIT_LIST_HEAD ( &netdev->tx_queue );
392: INIT_LIST_HEAD ( &netdev->rx_queue );
393: netdev_settings_init ( netdev );
394: netdev->priv = ( ( ( void * ) netdev ) + sizeof ( *netdev ) );
395: }
396: return netdev;
397: }
398:
399: /**
400: * Register network device
401: *
402: * @v netdev Network device
403: * @ret rc Return status code
404: *
405: * Gives the network device a name and adds it to the list of network
406: * devices.
407: */
408: int register_netdev ( struct net_device *netdev ) {
409: static unsigned int ifindex = 0;
410: struct net_driver *driver;
411: int rc;
412:
413: /* Create device name */
414: if ( netdev->name[0] == '\0' ) {
415: snprintf ( netdev->name, sizeof ( netdev->name ), "net%d",
416: ifindex++ );
417: }
418:
419: /* Set initial link-layer address */
420: netdev->ll_protocol->init_addr ( netdev->hw_addr, netdev->ll_addr );
421:
422: /* Add to device list */
423: netdev_get ( netdev );
424: list_add_tail ( &netdev->list, &net_devices );
425: DBGC ( netdev, "NETDEV %s registered (phys %s hwaddr %s)\n",
426: netdev->name, netdev->dev->name,
427: netdev_addr ( netdev ) );
428:
429: /* Register per-netdev configuration settings */
430: if ( ( rc = register_settings ( netdev_settings ( netdev ),
431: NULL, netdev->name ) ) != 0 ) {
432: DBGC ( netdev, "NETDEV %s could not register settings: %s\n",
433: netdev->name, strerror ( rc ) );
434: goto err_register_settings;
435: }
436:
437: /* Probe device */
438: for_each_table_entry ( driver, NET_DRIVERS ) {
439: if ( ( rc = driver->probe ( netdev ) ) != 0 ) {
440: DBGC ( netdev, "NETDEV %s could not add %s device: "
441: "%s\n", netdev->name, driver->name,
442: strerror ( rc ) );
443: goto err_probe;
444: }
445: }
446:
447: return 0;
448:
449: err_probe:
450: for_each_table_entry_continue_reverse ( driver, NET_DRIVERS )
451: driver->remove ( netdev );
452: unregister_settings ( netdev_settings ( netdev ) );
453: err_register_settings:
454: return rc;
455: }
456:
457: /**
458: * Open network device
459: *
460: * @v netdev Network device
461: * @ret rc Return status code
462: */
463: int netdev_open ( struct net_device *netdev ) {
464: int rc;
465:
466: /* Do nothing if device is already open */
467: if ( netdev->state & NETDEV_OPEN )
468: return 0;
469:
470: DBGC ( netdev, "NETDEV %s opening\n", netdev->name );
471:
472: /* Open the device */
473: if ( ( rc = netdev->op->open ( netdev ) ) != 0 )
474: return rc;
475:
476: /* Mark as opened */
477: netdev->state |= NETDEV_OPEN;
478:
479: /* Add to head of open devices list */
480: list_add ( &netdev->open_list, &open_net_devices );
481:
482: /* Notify drivers of device state change */
483: netdev_notify ( netdev );
484:
485: return 0;
486: }
487:
488: /**
489: * Close network device
490: *
491: * @v netdev Network device
492: */
493: void netdev_close ( struct net_device *netdev ) {
494:
495: /* Do nothing if device is already closed */
496: if ( ! ( netdev->state & NETDEV_OPEN ) )
497: return;
498:
499: DBGC ( netdev, "NETDEV %s closing\n", netdev->name );
500:
501: /* Remove from open devices list */
502: list_del ( &netdev->open_list );
503:
504: /* Mark as closed */
505: netdev->state &= ~NETDEV_OPEN;
506:
507: /* Notify drivers of device state change */
508: netdev_notify ( netdev );
509:
510: /* Close the device */
511: netdev->op->close ( netdev );
512:
513: /* Flush TX and RX queues */
514: netdev_tx_flush ( netdev );
515: netdev_rx_flush ( netdev );
516: }
517:
518: /**
519: * Unregister network device
520: *
521: * @v netdev Network device
522: *
523: * Removes the network device from the list of network devices.
524: */
525: void unregister_netdev ( struct net_device *netdev ) {
526: struct net_driver *driver;
527:
528: /* Ensure device is closed */
529: netdev_close ( netdev );
530:
531: /* Remove device */
532: for_each_table_entry_reverse ( driver, NET_DRIVERS )
533: driver->remove ( netdev );
534:
535: /* Unregister per-netdev configuration settings */
536: unregister_settings ( netdev_settings ( netdev ) );
537:
538: /* Remove from device list */
539: list_del ( &netdev->list );
540: netdev_put ( netdev );
541: DBGC ( netdev, "NETDEV %s unregistered\n", netdev->name );
542: }
543:
544: /** Enable or disable interrupts
545: *
546: * @v netdev Network device
547: * @v enable Interrupts should be enabled
548: */
549: void netdev_irq ( struct net_device *netdev, int enable ) {
550:
551: /* Do nothing if device does not support interrupts */
552: if ( ! netdev_irq_supported ( netdev ) )
553: return;
554:
555: /* Enable or disable device interrupts */
556: netdev->op->irq ( netdev, enable );
557:
558: /* Record interrupt enabled state */
559: netdev->state &= ~NETDEV_IRQ_ENABLED;
560: if ( enable )
561: netdev->state |= NETDEV_IRQ_ENABLED;
562: }
563:
564: /**
565: * Get network device by name
566: *
567: * @v name Network device name
568: * @ret netdev Network device, or NULL
569: */
570: struct net_device * find_netdev ( const char *name ) {
571: struct net_device *netdev;
572:
573: list_for_each_entry ( netdev, &net_devices, list ) {
574: if ( strcmp ( netdev->name, name ) == 0 )
575: return netdev;
576: }
577:
578: return NULL;
579: }
580:
581: /**
582: * Get network device by PCI bus:dev.fn address
583: *
584: * @v bus_type Bus type
585: * @v location Bus location
586: * @ret netdev Network device, or NULL
587: */
588: struct net_device * find_netdev_by_location ( unsigned int bus_type,
589: unsigned int location ) {
590: struct net_device *netdev;
591:
592: list_for_each_entry ( netdev, &net_devices, list ) {
593: if ( ( netdev->dev->desc.bus_type == bus_type ) &&
594: ( netdev->dev->desc.location == location ) )
595: return netdev;
596: }
597:
598: return NULL;
599: }
600:
601: /**
602: * Get most recently opened network device
603: *
604: * @ret netdev Most recently opened network device, or NULL
605: */
606: struct net_device * last_opened_netdev ( void ) {
607: struct net_device *netdev;
608:
609: netdev = list_first_entry ( &open_net_devices, struct net_device,
610: open_list );
611: if ( ! netdev )
612: return NULL;
613:
614: assert ( netdev_is_open ( netdev ) );
615: return netdev;
616: }
617:
618: /**
619: * Transmit network-layer packet
620: *
621: * @v iobuf I/O buffer
622: * @v netdev Network device
623: * @v net_protocol Network-layer protocol
624: * @v ll_dest Destination link-layer address
625: * @v ll_source Source link-layer address
626: * @ret rc Return status code
627: *
628: * Prepends link-layer headers to the I/O buffer and transmits the
629: * packet via the specified network device. This function takes
630: * ownership of the I/O buffer.
631: */
632: int net_tx ( struct io_buffer *iobuf, struct net_device *netdev,
633: struct net_protocol *net_protocol, const void *ll_dest,
634: const void *ll_source ) {
635: struct ll_protocol *ll_protocol = netdev->ll_protocol;
636: int rc;
637:
638: /* Force a poll on the netdevice to (potentially) clear any
639: * backed-up TX completions. This is needed on some network
640: * devices to avoid excessive losses due to small TX ring
641: * sizes.
642: */
643: netdev_poll ( netdev );
644:
645: /* Add link-layer header */
646: if ( ( rc = ll_protocol->push ( netdev, iobuf, ll_dest, ll_source,
647: net_protocol->net_proto ) ) != 0 ) {
648: free_iob ( iobuf );
649: return rc;
650: }
651:
652: /* Transmit packet */
653: return netdev_tx ( netdev, iobuf );
654: }
655:
656: /**
657: * Process received network-layer packet
658: *
659: * @v iobuf I/O buffer
660: * @v netdev Network device
661: * @v net_proto Network-layer protocol, in network-byte order
662: * @v ll_dest Destination link-layer address
663: * @v ll_source Source link-layer address
664: * @ret rc Return status code
665: */
666: int net_rx ( struct io_buffer *iobuf, struct net_device *netdev,
667: uint16_t net_proto, const void *ll_dest, const void *ll_source ) {
668: struct net_protocol *net_protocol;
669:
670: /* Hand off to network-layer protocol, if any */
671: for_each_table_entry ( net_protocol, NET_PROTOCOLS ) {
672: if ( net_protocol->net_proto == net_proto )
673: return net_protocol->rx ( iobuf, netdev, ll_dest,
674: ll_source );
675: }
676:
677: DBGC ( netdev, "NETDEV %s unknown network protocol %04x\n",
678: netdev->name, ntohs ( net_proto ) );
679: free_iob ( iobuf );
680: return -ENOTSUP;
681: }
682:
683: /**
684: * Poll the network stack
685: *
686: * This polls all interfaces for received packets, and processes
687: * packets from the RX queue.
688: */
689: void net_poll ( void ) {
690: struct net_device *netdev;
691: struct io_buffer *iobuf;
692: struct ll_protocol *ll_protocol;
693: const void *ll_dest;
694: const void *ll_source;
695: uint16_t net_proto;
696: int rc;
697:
698: /* Poll and process each network device */
699: list_for_each_entry ( netdev, &net_devices, list ) {
700:
701: /* Poll for new packets */
702: netdev_poll ( netdev );
703:
704: /* Leave received packets on the queue if receive
705: * queue processing is currently frozen. This will
706: * happen when the raw packets are to be manually
707: * dequeued using netdev_rx_dequeue(), rather than
708: * processed via the usual networking stack.
709: */
710: if ( netdev_rx_frozen ( netdev ) )
711: continue;
712:
713: /* Process at most one received packet. Give priority
714: * to getting packets out of the NIC over processing
715: * the received packets, because we advertise a window
716: * that assumes that we can receive packets from the
717: * NIC faster than they arrive.
718: */
719: if ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
720:
721: DBGC ( netdev, "NETDEV %s processing %p (%p+%zx)\n",
722: netdev->name, iobuf, iobuf->data,
723: iob_len ( iobuf ) );
724:
725: /* Remove link-layer header */
726: ll_protocol = netdev->ll_protocol;
727: if ( ( rc = ll_protocol->pull ( netdev, iobuf,
728: &ll_dest, &ll_source,
729: &net_proto ) ) != 0 ) {
730: free_iob ( iobuf );
731: continue;
732: }
733:
734: /* Hand packet to network layer */
735: if ( ( rc = net_rx ( iob_disown ( iobuf ), netdev,
736: net_proto, ll_dest,
737: ll_source ) ) != 0 ) {
738: /* Record error for diagnosis */
739: netdev_rx_err ( netdev, NULL, rc );
740: }
741: }
742: }
743: }
744:
745: /**
746: * Single-step the network stack
747: *
748: * @v process Network stack process
749: */
750: static void net_step ( struct process *process __unused ) {
751: net_poll();
752: }
753:
754: /** Networking stack process */
755: struct process net_process __permanent_process = {
756: .list = LIST_HEAD_INIT ( net_process.list ),
757: .step = net_step,
758: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.