gpxe/src/net/aoe.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 FILE_LICENCE ( GPL2_OR_LATER );
  20
  21 #include <stddef.h>
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27 #include <byteswap.h>
  28 #include <gpxe/list.h>
  29 #include <gpxe/if_ether.h>
  30 #include <gpxe/ethernet.h>
  31 #include <gpxe/iobuf.h>
  32 #include <gpxe/uaccess.h>
  33 #include <gpxe/ata.h>
  34 #include <gpxe/netdevice.h>
  35 #include <gpxe/process.h>
  36 #include <gpxe/features.h>
  37 #include <gpxe/aoe.h>
  38
  39 /** @file
  40  *
  41  * AoE protocol
  42  *
  43  */
  44
  45 FEATURE ( FEATURE_PROTOCOL, "AoE", DHCP_EB_FEATURE_AOE, 1 );
  46
  47 struct net_protocol aoe_protocol;
  48
  49 /** List of all AoE sessions */
  50 static LIST_HEAD ( aoe_sessions );
  51
  52 static void aoe_free ( struct refcnt *refcnt ) {
  53         struct aoe_session *aoe =
  54                 container_of ( refcnt, struct aoe_session, refcnt );
  55
  56         netdev_put ( aoe->netdev );
  57         free ( aoe );
  58 }
  59
  60 /**
  61  * Mark current AoE command complete
  62  *
  63  * @v aoe               AoE session
  64  * @v rc                Return status code
  65  */
  66 static void aoe_done ( struct aoe_session *aoe, int rc ) {
  67
  68         /* Record overall command status */
  69         if ( aoe->command ) {
  70                 aoe->command->cb.cmd_stat = aoe->status;
  71                 aoe->command->rc = rc;
  72                 aoe->command = NULL;
  73         }
  74
  75         /* Stop retransmission timer */
  76         stop_timer ( &aoe->timer );
  77
  78         /* Mark operation as complete */
  79         aoe->rc = rc;
  80 }
  81
  82 /**
  83  * Send AoE command
  84  *
  85  * @v aoe               AoE session
  86  * @ret rc              Return status code
  87  *
  88  * This transmits an AoE command packet.  It does not wait for a
  89  * response.
  90  */
  91 static int aoe_send_command ( struct aoe_session *aoe ) {
  92         struct ata_command *command = aoe->command;
  93         struct io_buffer *iobuf;
  94         struct aoehdr *aoehdr;
  95         union aoecmd *aoecmd;
  96         struct aoeata *aoeata;
  97         unsigned int count;
  98         unsigned int data_out_len;
  99         unsigned int aoecmdlen;
 100
 101         /* Fail immediately if we have no netdev to send on */
 102         if ( ! aoe->netdev ) {
 103                 aoe_done ( aoe, -ENETUNREACH );
 104                 return -ENETUNREACH;
 105         }
 106
 107         /* If we are transmitting anything that requires a response,
 108          * start the retransmission timer.  Do this before attempting
 109          * to allocate the I/O buffer, in case allocation itself
 110          * fails.
 111          */
 112         start_timer ( &aoe->timer );
 113
 114         /* Calculate count and data_out_len for this subcommand */
 115         switch ( aoe->aoe_cmd_type ) {
 116         case AOE_CMD_ATA:
 117                 count = command->cb.count.native;
 118                 if ( count > AOE_MAX_COUNT )
 119                         count = AOE_MAX_COUNT;
 120                 data_out_len = ( command->data_out ?
 121                                  ( count * ATA_SECTOR_SIZE ) : 0 );
 122                 aoecmdlen = sizeof ( aoecmd->ata );
 123                 break;
 124         case AOE_CMD_CONFIG:
 125                 count = 0;
 126                 data_out_len = 0;
 127                 aoecmdlen = sizeof ( aoecmd->cfg );
 128                 break;
 129         default:
 130                 return -ENOTSUP;
 131         }
 132
 133         /* Create outgoing I/O buffer */
 134         iobuf = alloc_iob ( ETH_HLEN + sizeof ( *aoehdr ) +
 135                             aoecmdlen + data_out_len );
 136
 137         if ( ! iobuf )
 138                 return -ENOMEM;
 139         iob_reserve ( iobuf, ETH_HLEN );
 140         aoehdr = iob_put ( iobuf, sizeof ( *aoehdr ) );
 141         aoecmd = iob_put ( iobuf, aoecmdlen );
 142         memset ( aoehdr, 0, ( sizeof ( *aoehdr ) + aoecmdlen ) );
 143
 144         /* Fill AoE header */
 145         aoehdr->ver_flags = AOE_VERSION;
 146         aoehdr->major = htons ( aoe->major );
 147         aoehdr->minor = aoe->minor;
 148         aoehdr->command = aoe->aoe_cmd_type;
 149         aoehdr->tag = htonl ( ++aoe->tag );
 150
 151         /* Fill AoE payload */
 152         switch ( aoe->aoe_cmd_type ) {
 153         case AOE_CMD_ATA:
 154                 /* Fill AoE command */
 155                 aoeata = &aoecmd->ata;
 156                 linker_assert ( AOE_FL_DEV_HEAD == ATA_DEV_SLAVE,
 157                                 __fix_ata_h__ );
 158                 aoeata->aflags = ( ( command->cb.lba48 ? AOE_FL_EXTENDED : 0 )|
 159                                    ( command->cb.device & ATA_DEV_SLAVE ) |
 160                                    ( data_out_len ? AOE_FL_WRITE : 0 ) );
 161                 aoeata->err_feat = command->cb.err_feat.bytes.cur;
 162                 aoeata->count = count;
 163                 aoeata->cmd_stat = command->cb.cmd_stat;
 164                 aoeata->lba.u64 = cpu_to_le64 ( command->cb.lba.native );
 165                 if ( ! command->cb.lba48 )
 166                         aoeata->lba.bytes[3] |=
 167                                 ( command->cb.device & ATA_DEV_MASK );
 168
 169                 /* Fill data payload */
 170                 copy_from_user ( iob_put ( iobuf, data_out_len ),
 171                                  command->data_out, aoe->command_offset,
 172                                  data_out_len );
 173                 break;
 174         case AOE_CMD_CONFIG:
 175                 /* Nothing to do */
 176                 break;
 177         default:
 178                 assert ( 0 );
 179         }
 180
 181         /* Send packet */
 182         return net_tx ( iobuf, aoe->netdev, &aoe_protocol, aoe->target );
 183 }
 184
 185 /**
 186  * Handle AoE retry timer expiry
 187  *
 188  * @v timer             AoE retry timer
 189  * @v fail              Failure indicator
 190  */
 191 static void aoe_timer_expired ( struct retry_timer *timer, int fail ) {
 192         struct aoe_session *aoe =
 193                 container_of ( timer, struct aoe_session, timer );
 194
 195         if ( fail ) {
 196                 aoe_done ( aoe, -ETIMEDOUT );
 197         } else {
 198                 aoe_send_command ( aoe );
 199         }
 200 }
 201
 202 /**
 203  * Handle AoE configuration command response
 204  *
 205  * @v aoe               AoE session
 206  * @v ll_source         Link-layer source address
 207  * @ret rc              Return status code
 208  */
 209 static int aoe_rx_cfg ( struct aoe_session *aoe, const void *ll_source ) {
 210
 211         /* Record target MAC address */
 212         memcpy ( aoe->target, ll_source, sizeof ( aoe->target ) );
 213         DBGC ( aoe, "AoE %p target MAC address %s\n",
 214                aoe, eth_ntoa ( aoe->target ) );
 215
 216         /* Mark config request as complete */
 217         aoe_done ( aoe, 0 );
 218
 219         return 0;
 220 }
 221
 222 /**
 223  * Handle AoE ATA command response
 224  *
 225  * @v aoe               AoE session
 226  * @v aoeata            AoE ATA command
 227  * @v len               Length of AoE ATA command
 228  * @ret rc              Return status code
 229  */
 230 static int aoe_rx_ata ( struct aoe_session *aoe, struct aoeata *aoeata,
 231                         size_t len ) {
 232         struct ata_command *command = aoe->command;
 233         unsigned int rx_data_len;
 234         unsigned int count;
 235         unsigned int data_len;
 236
 237         /* Sanity check */
 238         if ( len < sizeof ( *aoeata ) ) {
 239                 /* Ignore packet; allow timer to trigger retransmit */
 240                 return -EINVAL;
 241         }
 242         rx_data_len = ( len - sizeof ( *aoeata ) );
 243
 244         /* Calculate count and data_len for this subcommand */
 245         count = command->cb.count.native;
 246         if ( count > AOE_MAX_COUNT )
 247                 count = AOE_MAX_COUNT;
 248         data_len = count * ATA_SECTOR_SIZE;
 249
 250         /* Merge into overall ATA status */
 251         aoe->status |= aoeata->cmd_stat;
 252
 253         /* Copy data payload */
 254         if ( command->data_in ) {
 255                 if ( rx_data_len > data_len )
 256                         rx_data_len = data_len;
 257                 copy_to_user ( command->data_in, aoe->command_offset,
 258                                aoeata->data, rx_data_len );
 259         }
 260
 261         /* Update ATA command and offset */
 262         aoe->command_offset += data_len;
 263         command->cb.lba.native += count;
 264         command->cb.count.native -= count;
 265
 266         /* Check for operation complete */
 267         if ( ! command->cb.count.native ) {
 268                 aoe_done ( aoe, 0 );
 269                 return 0;
 270         }
 271
 272         /* Transmit next portion of request */
 273         stop_timer ( &aoe->timer );
 274         aoe_send_command ( aoe );
 275
 276         return 0;
 277 }
 278
 279 /**
 280  * Process incoming AoE packets
 281  *
 282  * @v iobuf             I/O buffer
 283  * @v netdev            Network device
 284  * @v ll_source         Link-layer source address
 285  * @ret rc              Return status code
 286  *
 287  */
 288 static int aoe_rx ( struct io_buffer *iobuf,
 289                     struct net_device *netdev __unused,
 290                     const void *ll_source ) {
 291         struct aoehdr *aoehdr = iobuf->data;
 292         struct aoe_session *aoe;
 293         int rc = 0;
 294
 295         /* Sanity checks */
 296         if ( iob_len ( iobuf ) < sizeof ( *aoehdr ) ) {
 297                 rc = -EINVAL;
 298                 goto done;
 299         }
 300         if ( ( aoehdr->ver_flags & AOE_VERSION_MASK ) != AOE_VERSION ) {
 301                 rc = -EPROTONOSUPPORT;
 302                 goto done;
 303         }
 304         if ( ! ( aoehdr->ver_flags & AOE_FL_RESPONSE ) ) {
 305                 /* Ignore AoE requests that we happen to see */
 306                 goto done;
 307         }
 308         iob_pull ( iobuf, sizeof ( *aoehdr ) );
 309
 310         /* Demultiplex amongst active AoE sessions */
 311         list_for_each_entry ( aoe, &aoe_sessions, list ) {
 312                 if ( ntohs ( aoehdr->major ) != aoe->major )
 313                         continue;
 314                 if ( aoehdr->minor != aoe->minor )
 315                         continue;
 316                 if ( ntohl ( aoehdr->tag ) != aoe->tag )
 317                         continue;
 318                 if ( aoehdr->ver_flags & AOE_FL_ERROR ) {
 319                         aoe_done ( aoe, -EIO );
 320                         break;
 321                 }
 322                 switch ( aoehdr->command ) {
 323                 case AOE_CMD_ATA:
 324                         rc = aoe_rx_ata ( aoe, iobuf->data, iob_len ( iobuf ));
 325                         break;
 326                 case AOE_CMD_CONFIG:
 327                         rc = aoe_rx_cfg ( aoe, ll_source );
 328                         break;
 329                 default:
 330                         DBGC ( aoe, "AoE %p ignoring command %02x\n",
 331                                aoe, aoehdr->command );
 332                         break;
 333                 }
 334                 break;
 335         }
 336
 337  done:
 338         free_iob ( iobuf );
 339         return rc;
 340 }
 341
 342 /** AoE protocol */
 343 struct net_protocol aoe_protocol __net_protocol = {
 344         .name = "AoE",
 345         .net_proto = htons ( ETH_P_AOE ),
 346         .rx = aoe_rx,
 347 };
 348
 349 /**
 350  * Issue ATA command via an open AoE session
 351  *
 352  * @v ata               ATA device
 353  * @v command           ATA command
 354  * @ret rc              Return status code
 355  */
 356 static int aoe_command ( struct ata_device *ata,
 357                          struct ata_command *command ) {
 358         struct aoe_session *aoe =
 359                 container_of ( ata->backend, struct aoe_session, refcnt );
 360
 361         aoe->command = command;
 362         aoe->status = 0;
 363         aoe->command_offset = 0;
 364         aoe->aoe_cmd_type = AOE_CMD_ATA;
 365
 366         aoe_send_command ( aoe );
 367
 368         return 0;
 369 }
 370
 371 /**
 372  * Issue AoE config query for AoE target discovery
 373  *
 374  * @v aoe               AoE session
 375  * @ret rc              Return status code
 376  */
 377 static int aoe_discover ( struct aoe_session *aoe ) {
 378         int rc;
 379
 380         aoe->status = 0;
 381         aoe->aoe_cmd_type = AOE_CMD_CONFIG;
 382         aoe->command = NULL;
 383
 384         aoe_send_command ( aoe );
 385
 386         aoe->rc = -EINPROGRESS;
 387         while ( aoe->rc == -EINPROGRESS )
 388                 step();
 389         rc = aoe->rc;
 390
 391         return rc;
 392 }
 393
 394 static int aoe_detached_command ( struct ata_device *ata __unused,
 395                                   struct ata_command *command __unused ) {
 396         return -ENODEV;
 397 }
 398
 399 void aoe_detach ( struct ata_device *ata ) {
 400         struct aoe_session *aoe =
 401                 container_of ( ata->backend, struct aoe_session, refcnt );
 402
 403         stop_timer ( &aoe->timer );
 404         ata->command = aoe_detached_command;
 405         list_del ( &aoe->list );
 406         ref_put ( ata->backend );
 407         ata->backend = NULL;
 408 }
 409
 410 static int aoe_parse_root_path ( struct aoe_session *aoe,
 411                                  const char *root_path ) {
 412         char *ptr;
 413
 414         if ( strncmp ( root_path, "aoe:", 4 ) != 0 )
 415                 return -EINVAL;
 416         ptr = ( ( char * ) root_path + 4 );
 417
 418         if ( *ptr++ != 'e' )
 419                 return -EINVAL;
 420
 421         aoe->major = strtoul ( ptr, &ptr, 10 );
 422         if ( *ptr++ != '.' )
 423                 return -EINVAL;
 424
 425         aoe->minor = strtoul ( ptr, &ptr, 10 );
 426         if ( *ptr )
 427                 return -EINVAL;
 428
 429         return 0;
 430 }
 431
 432 int aoe_attach ( struct ata_device *ata, struct net_device *netdev,
 433                  const char *root_path ) {
 434         struct aoe_session *aoe;
 435         int rc;
 436
 437         /* Allocate and initialise structure */
 438         aoe = zalloc ( sizeof ( *aoe ) );
 439         if ( ! aoe )
 440                 return -ENOMEM;
 441         aoe->refcnt.free = aoe_free;
 442         aoe->netdev = netdev_get ( netdev );
 443         memcpy ( aoe->target, netdev->ll_broadcast, sizeof ( aoe->target ) );
 444         aoe->tag = AOE_TAG_MAGIC;
 445         aoe->timer.expired = aoe_timer_expired;
 446
 447         /* Parse root path */
 448         if ( ( rc = aoe_parse_root_path ( aoe, root_path ) ) != 0 )
 449                 goto err;
 450
 451         /* Attach parent interface, transfer reference to connection
 452          * list, and return
 453          */
 454         ata->backend = ref_get ( &aoe->refcnt );
 455         ata->command = aoe_command;
 456         list_add ( &aoe->list, &aoe_sessions );
 457
 458         /* Send discovery packet to find the target MAC address.
 459          * Ideally, this ought to be done asynchronously, but the
 460          * block device interface does not yet support asynchronous
 461          * operation.
 462          */
 463         if ( ( rc = aoe_discover( aoe ) ) != 0 )
 464                goto err;
 465
 466         return 0;
 467
 468  err:
 469         ref_put ( &aoe->refcnt );
 470         return rc;
 471 }