src/net/netdevice.c

   1 /*
   2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include <stdint.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <byteswap.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <gpxe/if_ether.h>
  26 #include <gpxe/iobuf.h>
  27 #include <gpxe/tables.h>
  28 #include <gpxe/process.h>
  29 #include <gpxe/init.h>
  30 #include <gpxe/device.h>
  31 #include <gpxe/netdevice.h>
  32
  33 /** @file
  34  *
  35  * Network device management
  36  *
  37  */
  38
  39 /** List of network devices */
  40 struct list_head net_devices = LIST_HEAD_INIT ( net_devices );
  41
  42 /** List of open network devices, in reverse order of opening */
  43 struct list_head open_net_devices = LIST_HEAD_INIT ( open_net_devices );
  44
  45 /**
  46  * Record network device statistic
  47  *
  48  * @v stats             Network device statistics
  49  * @v rc                Status code
  50  */
  51 static void netdev_record_stat ( struct net_device_stats *stats, int rc ) {
  52         struct net_device_error *error;
  53         struct net_device_error *least_common_error;
  54         unsigned int i;
  55
  56         /* If this is not an error, just update the good counter */
  57         if ( rc == 0 ) {
  58                 stats->good++;
  59                 return;
  60         }
  61
  62         /* Update the bad counter */
  63         stats->bad++;
  64
  65         /* Locate the appropriate error record */
  66         least_common_error = &stats->errors[0];
  67         for ( i = 0 ; i < ( sizeof ( stats->errors ) /
  68                             sizeof ( stats->errors[0] ) ) ; i++ ) {
  69                 error = &stats->errors[i];
  70                 /* Update matching record, if found */
  71                 if ( error->rc == rc ) {
  72                         error->count++;
  73                         return;
  74                 }
  75                 if ( error->count < least_common_error->count )
  76                         least_common_error = error;
  77         }
  78
  79         /* Overwrite the least common error record */
  80         least_common_error->rc = rc;
  81         least_common_error->count = 1;
  82 }
  83
  84 /**
  85  * Transmit raw packet via network device
  86  *
  87  * @v netdev            Network device
  88  * @v iobuf             I/O buffer
  89  * @ret rc              Return status code
  90  *
  91  * Transmits the packet via the specified network device.  This
  92  * function takes ownership of the I/O buffer.
  93  */
  94 int netdev_tx ( struct net_device *netdev, struct io_buffer *iobuf ) {
  95         int rc;
  96
  97         DBGC ( netdev, "NETDEV %p transmitting %p (%p+%zx)\n",
  98                netdev, iobuf, iobuf->data, iob_len ( iobuf ) );
  99
 100         list_add_tail ( &iobuf->list, &netdev->tx_queue );
 101
 102         if ( ! ( netdev->state & NETDEV_OPEN ) ) {
 103                 rc = -ENETUNREACH;
 104                 goto err;
 105         }
 106
 107         if ( ( rc = netdev->op->transmit ( netdev, iobuf ) ) != 0 )
 108                 goto err;
 109
 110         return 0;
 111
 112  err:
 113         netdev_tx_complete_err ( netdev, iobuf, rc );
 114         return rc;
 115 }
 116
 117 /**
 118  * Complete network transmission
 119  *
 120  * @v netdev            Network device
 121  * @v iobuf             I/O buffer
 122  * @v rc                Packet status code
 123  *
 124  * The packet must currently be in the network device's TX queue.
 125  */
 126 void netdev_tx_complete_err ( struct net_device *netdev,
 127                               struct io_buffer *iobuf, int rc ) {
 128
 129         /* Update statistics counter */
 130         netdev_record_stat ( &netdev->tx_stats, rc );
 131         if ( rc == 0 ) {
 132                 DBGC ( netdev, "NETDEV %p transmission %p complete\n",
 133                        netdev, iobuf );
 134         } else {
 135                 DBGC ( netdev, "NETDEV %p transmission %p failed: %s\n",
 136                        netdev, iobuf, strerror ( rc ) );
 137         }
 138
 139         /* Catch data corruption as early as possible */
 140         assert ( iobuf->list.next != NULL );
 141         assert ( iobuf->list.prev != NULL );
 142
 143         /* Dequeue and free I/O buffer */
 144         list_del ( &iobuf->list );
 145         free_iob ( iobuf );
 146 }
 147
 148 /**
 149  * Complete network transmission
 150  *
 151  * @v netdev            Network device
 152  * @v rc                Packet status code
 153  *
 154  * Completes the oldest outstanding packet in the TX queue.
 155  */
 156 void netdev_tx_complete_next_err ( struct net_device *netdev, int rc ) {
 157         struct io_buffer *iobuf;
 158
 159         list_for_each_entry ( iobuf, &netdev->tx_queue, list ) {
 160                 netdev_tx_complete_err ( netdev, iobuf, rc );
 161                 return;
 162         }
 163 }
 164
 165 /**
 166  * Flush device's transmit queue
 167  *
 168  * @v netdev            Network device
 169  */
 170 static void netdev_tx_flush ( struct net_device *netdev ) {
 171
 172         /* Discard any packets in the TX queue */
 173         while ( ! list_empty ( &netdev->tx_queue ) ) {
 174                 netdev_tx_complete_next_err ( netdev, -ECANCELED );
 175         }
 176 }
 177
 178 /**
 179  * Add packet to receive queue
 180  *
 181  * @v netdev            Network device
 182  * @v iobuf             I/O buffer, or NULL
 183  *
 184  * The packet is added to the network device's RX queue.  This
 185  * function takes ownership of the I/O buffer.
 186  */
 187 void netdev_rx ( struct net_device *netdev, struct io_buffer *iobuf ) {
 188
 189         DBGC ( netdev, "NETDEV %p received %p (%p+%zx)\n",
 190                netdev, iobuf, iobuf->data, iob_len ( iobuf ) );
 191
 192         /* Enqueue packet */
 193         list_add_tail ( &iobuf->list, &netdev->rx_queue );
 194
 195         /* Update statistics counter */
 196         netdev_record_stat ( &netdev->rx_stats, 0 );
 197 }
 198
 199 /**
 200  * Discard received packet
 201  *
 202  * @v netdev            Network device
 203  * @v iobuf             I/O buffer, or NULL
 204  * @v rc                Packet status code
 205  *
 206  * The packet is discarded and an RX error is recorded.  This function
 207  * takes ownership of the I/O buffer.  @c iobuf may be NULL if, for
 208  * example, the net device wishes to report an error due to being
 209  * unable to allocate an I/O buffer.
 210  */
 211 void netdev_rx_err ( struct net_device *netdev,
 212                      struct io_buffer *iobuf, int rc ) {
 213
 214         DBGC ( netdev, "NETDEV %p failed to receive %p: %s\n",
 215                netdev, iobuf, strerror ( rc ) );
 216
 217         /* Discard packet */
 218         free_iob ( iobuf );
 219
 220         /* Update statistics counter */
 221         netdev_record_stat ( &netdev->rx_stats, rc );
 222 }
 223
 224 /**
 225  * Poll for completed and received packets on network device
 226  *
 227  * @v netdev            Network device
 228  *
 229  * Polls the network device for completed transmissions and received
 230  * packets.  Any received packets will be added to the RX packet queue
 231  * via netdev_rx().
 232  */
 233 void netdev_poll ( struct net_device *netdev ) {
 234
 235         if ( netdev->state & NETDEV_OPEN )
 236                 netdev->op->poll ( netdev );
 237 }
 238
 239 /**
 240  * Remove packet from device's receive queue
 241  *
 242  * @v netdev            Network device
 243  * @ret iobuf           I/O buffer, or NULL
 244  *
 245  * Removes the first packet from the device's RX queue and returns it.
 246  * Ownership of the packet is transferred to the caller.
 247  */
 248 struct io_buffer * netdev_rx_dequeue ( struct net_device *netdev ) {
 249         struct io_buffer *iobuf;
 250
 251         list_for_each_entry ( iobuf, &netdev->rx_queue, list ) {
 252                 list_del ( &iobuf->list );
 253                 return iobuf;
 254         }
 255         return NULL;
 256 }
 257
 258 /**
 259  * Flush device's receive queue
 260  *
 261  * @v netdev            Network device
 262  */
 263 static void netdev_rx_flush ( struct net_device *netdev ) {
 264         struct io_buffer *iobuf;
 265
 266         /* Discard any packets in the RX queue */
 267         while ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
 268                 netdev_rx_err ( netdev, iobuf, -ECANCELED );
 269         }
 270 }
 271
 272 /**
 273  * Free network device
 274  *
 275  * @v refcnt            Network device reference counter
 276  */
 277 static void free_netdev ( struct refcnt *refcnt ) {
 278         struct net_device *netdev =
 279                 container_of ( refcnt, struct net_device, refcnt );
 280
 281         netdev_tx_flush ( netdev );
 282         netdev_rx_flush ( netdev );
 283         free ( netdev );
 284 }
 285
 286 /**
 287  * Allocate network device
 288  *
 289  * @v priv_size         Size of private data area (net_device::priv)
 290  * @ret netdev          Network device, or NULL
 291  *
 292  * Allocates space for a network device and its private data area.
 293  */
 294 struct net_device * alloc_netdev ( size_t priv_size ) {
 295         struct net_device *netdev;
 296         size_t total_len;
 297
 298         total_len = ( sizeof ( *netdev ) + priv_size );
 299         netdev = zalloc ( total_len );
 300         if ( netdev ) {
 301                 netdev->refcnt.free = free_netdev;
 302                 INIT_LIST_HEAD ( &netdev->tx_queue );
 303                 INIT_LIST_HEAD ( &netdev->rx_queue );
 304                 settings_init ( netdev_settings ( netdev ),
 305                                 &netdev_settings_operations, &netdev->refcnt,
 306                                 netdev->name, 0 );
 307                 netdev->priv = ( ( ( void * ) netdev ) + sizeof ( *netdev ) );
 308         }
 309         return netdev;
 310 }
 311
 312 /**
 313  * Register network device
 314  *
 315  * @v netdev            Network device
 316  * @ret rc              Return status code
 317  *
 318  * Gives the network device a name and adds it to the list of network
 319  * devices.
 320  */
 321 int register_netdev ( struct net_device *netdev ) {
 322         static unsigned int ifindex = 0;
 323         int rc;
 324
 325         /* Create device name */
 326         snprintf ( netdev->name, sizeof ( netdev->name ), "net%d",
 327                    ifindex++ );
 328
 329         /* Register per-netdev configuration settings */
 330         if ( ( rc = register_settings ( netdev_settings ( netdev ),
 331                                         NULL ) ) != 0 ) {
 332                 DBGC ( netdev, "NETDEV %p could not register settings: %s\n",
 333                        netdev, strerror ( rc ) );
 334                 return rc;
 335         }
 336
 337         /* Add to device list */
 338         netdev_get ( netdev );
 339         list_add_tail ( &netdev->list, &net_devices );
 340         DBGC ( netdev, "NETDEV %p registered as %s (phys %s hwaddr %s)\n",
 341                netdev, netdev->name, netdev->dev->name,
 342                netdev_hwaddr ( netdev ) );
 343
 344         return 0;
 345 }
 346
 347 /**
 348  * Open network device
 349  *
 350  * @v netdev            Network device
 351  * @ret rc              Return status code
 352  */
 353 int netdev_open ( struct net_device *netdev ) {
 354         int rc;
 355
 356         /* Do nothing if device is already open */
 357         if ( netdev->state & NETDEV_OPEN )
 358                 return 0;
 359
 360         DBGC ( netdev, "NETDEV %p opening\n", netdev );
 361
 362         /* Open the device */
 363         if ( ( rc = netdev->op->open ( netdev ) ) != 0 )
 364                 return rc;
 365
 366         /* Mark as opened */
 367         netdev->state |= NETDEV_OPEN;
 368
 369         /* Add to head of open devices list */
 370         list_add ( &netdev->open_list, &open_net_devices );
 371
 372         return 0;
 373 }
 374
 375 /**
 376  * Close network device
 377  *
 378  * @v netdev            Network device
 379  */
 380 void netdev_close ( struct net_device *netdev ) {
 381
 382         /* Do nothing if device is already closed */
 383         if ( ! ( netdev->state & NETDEV_OPEN ) )
 384                 return;
 385
 386         DBGC ( netdev, "NETDEV %p closing\n", netdev );
 387
 388         /* Close the device */
 389         netdev->op->close ( netdev );
 390
 391         /* Flush TX and RX queues */
 392         netdev_tx_flush ( netdev );
 393         netdev_rx_flush ( netdev );
 394
 395         /* Mark as closed */
 396         netdev->state &= ~NETDEV_OPEN;
 397
 398         /* Remove from open devices list */
 399         list_del ( &netdev->open_list );
 400 }
 401
 402 /**
 403  * Unregister network device
 404  *
 405  * @v netdev            Network device
 406  *
 407  * Removes the network device from the list of network devices.
 408  */
 409 void unregister_netdev ( struct net_device *netdev ) {
 410
 411         /* Ensure device is closed */
 412         netdev_close ( netdev );
 413
 414         /* Unregister per-netdev configuration settings */
 415         unregister_settings ( netdev_settings ( netdev ) );
 416
 417         /* Remove from device list */
 418         list_del ( &netdev->list );
 419         netdev_put ( netdev );
 420         DBGC ( netdev, "NETDEV %p unregistered\n", netdev );
 421 }
 422
 423 /** Enable or disable interrupts
 424  *
 425  * @v netdev            Network device
 426  * @v enable            Interrupts should be enabled
 427  */
 428 void netdev_irq ( struct net_device *netdev, int enable ) {
 429         netdev->op->irq ( netdev, enable );
 430 }
 431
 432 /**
 433  * Get network device by name
 434  *
 435  * @v name              Network device name
 436  * @ret netdev          Network device, or NULL
 437  */
 438 struct net_device * find_netdev ( const char *name ) {
 439         struct net_device *netdev;
 440
 441         list_for_each_entry ( netdev, &net_devices, list ) {
 442                 if ( strcmp ( netdev->name, name ) == 0 )
 443                         return netdev;
 444         }
 445
 446         return NULL;
 447 }
 448
 449 /**
 450  * Get network device by PCI bus:dev.fn address
 451  *
 452  * @v bus_type          Bus type
 453  * @v location          Bus location
 454  * @ret netdev          Network device, or NULL
 455  */
 456 struct net_device * find_netdev_by_location ( unsigned int bus_type,
 457                                               unsigned int location ) {
 458         struct net_device *netdev;
 459
 460         list_for_each_entry ( netdev, &net_devices, list ) {
 461                 if ( ( netdev->dev->desc.bus_type == bus_type ) &&
 462                      ( netdev->dev->desc.location == location ) )
 463                         return netdev;
 464         }
 465
 466         return NULL;
 467 }
 468
 469 /**
 470  * Get most recently opened network device
 471  *
 472  * @ret netdev          Most recently opened network device, or NULL
 473  */
 474 struct net_device * last_opened_netdev ( void ) {
 475         struct net_device *netdev;
 476
 477         list_for_each_entry ( netdev, &open_net_devices, open_list ) {
 478                 assert ( netdev->state & NETDEV_OPEN );
 479                 return netdev;
 480         }
 481
 482         return NULL;
 483 }
 484
 485 /**
 486  * Transmit network-layer packet
 487  *
 488  * @v iobuf             I/O buffer
 489  * @v netdev            Network device
 490  * @v net_protocol      Network-layer protocol
 491  * @v ll_dest           Destination link-layer address
 492  * @ret rc              Return status code
 493  *
 494  * Prepends link-layer headers to the I/O buffer and transmits the
 495  * packet via the specified network device.  This function takes
 496  * ownership of the I/O buffer.
 497  */
 498 int net_tx ( struct io_buffer *iobuf, struct net_device *netdev,
 499              struct net_protocol *net_protocol, const void *ll_dest ) {
 500         struct ll_protocol *ll_protocol = netdev->ll_protocol;
 501         int rc;
 502
 503         /* Force a poll on the netdevice to (potentially) clear any
 504          * backed-up TX completions.  This is needed on some network
 505          * devices to avoid excessive losses due to small TX ring
 506          * sizes.
 507          */
 508         netdev_poll ( netdev );
 509
 510         /* Add link-layer header */
 511         if ( ( rc = ll_protocol->push ( iobuf, ll_dest, netdev->ll_addr,
 512                                         net_protocol->net_proto ) ) != 0 ) {
 513                 free_iob ( iobuf );
 514                 return rc;
 515         }
 516
 517         /* Transmit packet */
 518         return netdev_tx ( netdev, iobuf );
 519 }
 520
 521 /**
 522  * Process received network-layer packet
 523  *
 524  * @v iobuf             I/O buffer
 525  * @v netdev            Network device
 526  * @v net_proto         Network-layer protocol, in network-byte order
 527  * @v ll_source         Source link-layer address
 528  * @ret rc              Return status code
 529  */
 530 int net_rx ( struct io_buffer *iobuf, struct net_device *netdev,
 531              uint16_t net_proto, const void *ll_source ) {
 532         struct net_protocol *net_protocol;
 533
 534         /* Hand off to network-layer protocol, if any */
 535         for_each_table_entry ( net_protocol, NET_PROTOCOLS ) {
 536                 if ( net_protocol->net_proto == net_proto )
 537                         return net_protocol->rx ( iobuf, netdev, ll_source );
 538         }
 539
 540         DBGC ( netdev, "NETDEV %p unknown network protocol %04x\n",
 541                netdev, ntohs ( net_proto ) );
 542         free_iob ( iobuf );
 543         return 0;
 544 }
 545
 546 /**
 547  * Single-step the network stack
 548  *
 549  * @v process           Network stack process
 550  *
 551  * This polls all interfaces for received packets, and processes
 552  * packets from the RX queue.
 553  */
 554 static void net_step ( struct process *process __unused ) {
 555         struct net_device *netdev;
 556         struct io_buffer *iobuf;
 557         struct ll_protocol *ll_protocol;
 558         const void *ll_dest;
 559         const void *ll_source;
 560         uint16_t net_proto;
 561         int rc;
 562
 563         /* Poll and process each network device */
 564         list_for_each_entry ( netdev, &net_devices, list ) {
 565
 566                 /* Poll for new packets */
 567                 netdev_poll ( netdev );
 568
 569                 /* Process at most one received packet.  Give priority
 570                  * to getting packets out of the NIC over processing
 571                  * the received packets, because we advertise a window
 572                  * that assumes that we can receive packets from the
 573                  * NIC faster than they arrive.
 574                  */
 575                 if ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
 576
 577                         DBGC ( netdev, "NETDEV %p processing %p (%p+%zx)\n",
 578                                netdev, iobuf, iobuf->data,
 579                                iob_len ( iobuf ) );
 580
 581                         /* Remove link-layer header */
 582                         ll_protocol = netdev->ll_protocol;
 583                         if ( ( rc = ll_protocol->pull ( iobuf, &ll_dest,
 584                                                         &ll_source,
 585                                                         &net_proto ) ) != 0 ) {
 586                                 free_iob ( iobuf );
 587                                 continue;
 588                         }
 589
 590                         net_rx ( iobuf, netdev, net_proto, ll_source );
 591                 }
 592         }
 593 }
 594
 595 /** Networking stack process */
 596 struct process net_process __permanent_process = {
 597         .step = net_step,
 598 };