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 <byteswap.h>
  21 #include <string.h>
  22 #include <errno.h>
  23 #include <malloc.h>
  24 #include <gpxe/if_ether.h>
  25 #include <gpxe/pkbuff.h>
  26 #include <gpxe/tables.h>
  27 #include <gpxe/process.h>
  28 #include <gpxe/init.h>
  29 #include <gpxe/netdevice.h>
  30
  31 /** @file
  32  *
  33  * Network device management
  34  *
  35  */
  36
  37 /** Registered network-layer protocols */
  38 static struct net_protocol net_protocols[0] __table_start ( net_protocols );
  39 static struct net_protocol net_protocols_end[0] __table_end ( net_protocols );
  40
  41 /** List of network devices */
  42 static LIST_HEAD ( net_devices );
  43
  44 /**
  45  * Transmit raw packet via network device
  46  *
  47  * @v netdev            Network device
  48  * @v pkb               Packet buffer
  49  * @ret rc              Return status code
  50  *
  51  * Transmits the packet via the specified network device.  This
  52  * function takes ownership of the packet buffer.
  53  */
  54 int netdev_tx ( struct net_device *netdev, struct pk_buff *pkb ) {
  55         DBG ( "%s transmitting %p+%zx\n", netdev_name ( netdev ),
  56               pkb->data, pkb_len ( pkb ) );
  57         return netdev->transmit ( netdev, pkb );
  58 }
  59
  60 /**
  61  * Add packet to receive queue
  62  *
  63  * @v netdev            Network device
  64  * @v pkb               Packet buffer
  65  *
  66  * The packet is added to the network device's RX queue.  This
  67  * function takes ownership of the packet buffer.
  68  */
  69 void netdev_rx ( struct net_device *netdev, struct pk_buff *pkb ) {
  70         DBG ( "%s received %p+%zx\n", netdev_name ( netdev ),
  71               pkb->data, pkb_len ( pkb ) );
  72         list_add_tail ( &pkb->list, &netdev->rx_queue );
  73 }
  74
  75 /**
  76  * Transmit network-layer packet
  77  *
  78  * @v pkb               Packet buffer
  79  * @v netdev            Network device
  80  * @v net_protocol      Network-layer protocol
  81  * @v ll_dest           Destination link-layer address
  82  * @ret rc              Return status code
  83  *
  84  * Prepends link-layer headers to the packet buffer and transmits the
  85  * packet via the specified network device.  This function takes
  86  * ownership of the packet buffer.
  87  */
  88 int net_tx ( struct pk_buff *pkb, struct net_device *netdev,
  89              struct net_protocol *net_protocol, const void *ll_dest ) {
  90         return netdev->ll_protocol->tx ( pkb, netdev, net_protocol, ll_dest );
  91 }
  92
  93 /**
  94  * Process received network-layer packet
  95  *
  96  * @v pkb               Packet buffer
  97  * @v netdev            Network device
  98  * @v net_proto         Network-layer protocol, in network-byte order
  99  * @v ll_source         Source link-layer address
 100  */
 101 void net_rx ( struct pk_buff *pkb, struct net_device *netdev,
 102               uint16_t net_proto, const void *ll_source ) {
 103         struct net_protocol *net_protocol;
 104
 105         /* Hand off to network-layer protocol, if any */
 106         for ( net_protocol = net_protocols ; net_protocol < net_protocols_end ;
 107               net_protocol++ ) {
 108                 if ( net_protocol->net_proto == net_proto ) {
 109                         net_protocol->rx ( pkb, netdev, ll_source );
 110                         break;
 111                 }
 112         }
 113 }
 114
 115 /**
 116  * Poll for packet on network device
 117  *
 118  * @v netdev            Network device
 119  * @ret True            There are packets present in the receive queue
 120  * @ret False           There are no packets present in the receive queue
 121  *
 122  * Polls the network device for received packets.  Any received
 123  * packets will be added to the RX packet queue via netdev_rx().
 124  */
 125 int netdev_poll ( struct net_device *netdev ) {
 126         netdev->poll ( netdev );
 127         return ( ! list_empty ( &netdev->rx_queue ) );
 128 }
 129
 130 /**
 131  * Remove packet from device's receive queue
 132  *
 133  * @v netdev            Network device
 134  * @ret pkb             Packet buffer, or NULL
 135  *
 136  * Removes the first packet from the device's RX queue and returns it.
 137  * Ownership of the packet is transferred to the caller.
 138  */
 139 struct pk_buff * netdev_rx_dequeue ( struct net_device *netdev ) {
 140         struct pk_buff *pkb;
 141
 142         list_for_each_entry ( pkb, &netdev->rx_queue, list ) {
 143                 list_del ( &pkb->list );
 144                 return pkb;
 145         }
 146         return NULL;
 147 }
 148
 149 /**
 150  * Allocate network device
 151  *
 152  * @v priv_size         Size of private data area (net_device::priv)
 153  * @ret netdev          Network device, or NULL
 154  *
 155  * Allocates space for a network device and its private data area.
 156  */
 157 struct net_device * alloc_netdev ( size_t priv_size ) {
 158         struct net_device *netdev;
 159
 160         netdev = calloc ( 1, sizeof ( *netdev ) + priv_size );
 161         if ( netdev ) {
 162                 INIT_LIST_HEAD ( &netdev->rx_queue );
 163                 netdev->priv = ( ( ( void * ) netdev ) + sizeof ( *netdev ) );
 164         }
 165         return netdev;
 166 }
 167
 168 /**
 169  * Register network device
 170  *
 171  * @v netdev            Network device
 172  * @ret rc              Return status code
 173  *
 174  * Adds the network device to the list of network devices.
 175  */
 176 int register_netdev ( struct net_device *netdev ) {
 177
 178         /* Add to device list */
 179         list_add_tail ( &netdev->list, &net_devices );
 180         DBG ( "%s registered\n", netdev_name ( netdev ) );
 181
 182         return 0;
 183 }
 184
 185 /**
 186  * Unregister network device
 187  *
 188  * @v netdev            Network device
 189  *
 190  * Removes the network device from the list of network devices.
 191  */
 192 void unregister_netdev ( struct net_device *netdev ) {
 193         struct pk_buff *pkb;
 194
 195         /* Discard any packets in the RX queue */
 196         while ( ( pkb = netdev_rx_dequeue ( netdev ) ) ) {
 197                 DBG ( "%s discarding %p+%zx\n", netdev_name ( netdev ),
 198                       pkb->data, pkb_len ( pkb ) );
 199                 free_pkb ( pkb );
 200         }
 201
 202         /* Remove from device list */
 203         list_del ( &netdev->list );
 204         DBG ( "%s unregistered\n", netdev_name ( netdev ) );
 205 }
 206
 207 /**
 208  * Free network device
 209  *
 210  * @v netdev            Network device
 211  */
 212 void free_netdev ( struct net_device *netdev ) {
 213         free ( netdev );
 214 }
 215
 216 /**
 217  * Iterate through network devices
 218  *
 219  * @ret netdev          Network device, or NULL
 220  *
 221  * This returns the registered network devices in the order of
 222  * registration.  If no network devices are registered, it will return
 223  * NULL.
 224  */
 225 struct net_device * next_netdev ( void ) {
 226         struct net_device *netdev;
 227
 228         list_for_each_entry ( netdev, &net_devices, list ) {
 229                 list_del ( &netdev->list );
 230                 list_add_tail ( &netdev->list, &net_devices );
 231                 return netdev;
 232         }
 233         return NULL;
 234 }
 235
 236 /**
 237  * Single-step the network stack
 238  *
 239  * @v process           Network stack process
 240  *
 241  * This polls all interfaces for any received packets, and processes
 242  * at most one packet from the RX queue.
 243  *
 244  * We avoid processing all received packets, because processing the
 245  * received packet can trigger transmission of a new packet (e.g. an
 246  * ARP response).  Since TX completions will be processed as part of
 247  * the poll operation, it is easy to overflow small TX queues if
 248  * multiple packets are processed per poll.
 249  */
 250 static void net_step ( struct process *process ) {
 251         struct net_device *netdev;
 252         struct pk_buff *pkb;
 253
 254         /* Poll and process each network device */
 255         list_for_each_entry ( netdev, &net_devices, list ) {
 256
 257                 /* Poll for new packets */
 258                 netdev_poll ( netdev );
 259
 260                 /* Handle at most one received packet per poll */
 261                 if ( ( pkb = netdev_rx_dequeue ( netdev ) ) ) {
 262                         DBG ( "%s processing %p+%zx\n", netdev_name ( netdev ),
 263                               pkb->data, pkb_len ( pkb ) );
 264                         netdev->ll_protocol->rx ( pkb, netdev );
 265                 }
 266         }
 267
 268         /* Re-schedule ourself */
 269         schedule ( process );
 270 }
 271
 272 /** Networking stack process */
 273 static struct process net_process = {
 274         .step = net_step,
 275 };
 276
 277 /** Initialise the networking stack process */
 278 static void init_net ( void ) {
 279         schedule ( &net_process );
 280 }
 281
 282 INIT_FN ( INIT_PROCESS, init_net, NULL, NULL );