src/hci/commands/image_cmd.c

   1 /*
   2  * Copyright (C) 2007 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 <stdint.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <libgen.h>
  26 #include <getopt.h>
  27 #include <gpxe/image.h>
  28 #include <gpxe/command.h>
  29 #include <usr/imgmgmt.h>
  30
  31 /** @file
  32  *
  33  * Image management commands
  34  *
  35  */
  36
  37 enum image_action {
  38         IMG_FETCH = 0,
  39         IMG_LOAD,
  40         IMG_EXEC,
  41 };
  42
  43 /**
  44  * Fill in image command line
  45  *
  46  * @v image             Image
  47  * @v nargs             Argument count
  48  * @v args              Argument list
  49  * @ret rc              Return status code
  50  */
  51 static int imgfill_cmdline ( struct image *image, unsigned int nargs,
  52                              char **args ) {
  53         size_t len;
  54         unsigned int i;
  55
  56         /* Determine total length of command line */
  57         len = 1; /* NUL */
  58         for ( i = 0 ; i < nargs ; i++ )
  59                 len += ( 1 /* possible space */ + strlen ( args[i] ) );
  60
  61         {
  62                 char buf[len];
  63                 char *ptr = buf;
  64
  65                 /* Assemble command line */
  66                 buf[0] = '\0';
  67                 for ( i = 0 ; i < nargs ; i++ ) {
  68                         ptr += sprintf ( ptr, "%s%s", ( i ? " " : "" ),
  69                                          args[i] );
  70                 }
  71                 assert ( ptr < ( buf + len ) );
  72
  73                 return image_set_cmdline ( image, buf );
  74         }
  75 }
  76
  77 /**
  78  * "imgfetch"/"module"/"kernel" command syntax message
  79  *
  80  * @v argv              Argument list
  81  */
  82 static void imgfetch_core_syntax ( char **argv, enum image_action action ) {
  83         static const char *actions[] = {
  84                 [IMG_FETCH]     = "Fetch",
  85                 [IMG_LOAD]      = "Fetch and load",
  86                 [IMG_EXEC]      = "Fetch and execute",
  87         };
  88
  89         printf ( "Usage:\n"
  90                  "  %s [-n|--name <name>] filename [arguments...]\n"
  91                  "\n"
  92                  "%s executable/loadable image\n",
  93                  argv[0], actions[action] );
  94 }
  95
  96 /**
  97  * The "imgfetch"/"module"/"kernel" command body
  98  *
  99  * @v image_type        Image type to assign (or NULL)
 100  * @v load              Image will be automatically loaded after fetching
 101  * @v argc              Argument count
 102  * @v argv              Argument list
 103  * @ret rc              Return status code
 104  */
 105 static int imgfetch_core_exec ( struct image_type *image_type,
 106                                 enum image_action action,
 107                                 int argc, char **argv ) {
 108         static struct option longopts[] = {
 109                 { "help", 0, NULL, 'h' },
 110                 { "name", required_argument, NULL, 'n' },
 111                 { NULL, 0, NULL, 0 },
 112         };
 113         struct image *image;
 114         const char *name = NULL;
 115         char *filename;
 116         int ( * image_register ) ( struct image *image );
 117         int c;
 118         int rc;
 119
 120         /* Parse options */
 121         while ( ( c = getopt_long ( argc, argv, "hn:",
 122                                     longopts, NULL ) ) >= 0 ) {
 123                 switch ( c ) {
 124                 case 'n':
 125                         /* Set image name */
 126                         name = optarg;
 127                         break;
 128                 case 'h':
 129                         /* Display help text */
 130                 default:
 131                         /* Unrecognised/invalid option */
 132                         imgfetch_core_syntax ( argv, action );
 133                         return -EINVAL;
 134                 }
 135         }
 136
 137         /* Need at least a filename remaining after the options */
 138         if ( optind == argc ) {
 139                 imgfetch_core_syntax ( argv, action );
 140                 return -EINVAL;
 141         }
 142         filename = argv[optind++];
 143         if ( ! name )
 144                 name = basename ( filename );
 145
 146         /* Allocate image */
 147         image = alloc_image();
 148         if ( ! image ) {
 149                 printf ( "%s\n", strerror ( -ENOMEM ) );
 150                 return -ENOMEM;
 151         }
 152
 153         /* Fill in image name */
 154         if ( name ) {
 155                 if ( ( rc = image_set_name ( image, name ) ) != 0 )
 156                         return rc;
 157         }
 158
 159         /* Set image type (if specified) */
 160         image->type = image_type;
 161
 162         /* Fill in command line */
 163         if ( ( rc = imgfill_cmdline ( image, ( argc - optind ),
 164                                       &argv[optind] ) ) != 0 )
 165                 return rc;
 166
 167         /* Fetch the image */
 168         switch ( action ) {
 169         case IMG_FETCH:
 170                 image_register = register_image;
 171                 break;
 172         case IMG_LOAD:
 173                 image_register = register_and_autoload_image;
 174                 break;
 175         case IMG_EXEC:
 176                 image_register = register_and_autoexec_image;
 177                 break;
 178         default:
 179                 assert ( 0 );
 180                 return -EINVAL;
 181         }
 182         if ( ( rc = imgfetch ( image, filename, image_register ) ) != 0 ) {
 183                 printf ( "Could not fetch %s: %s\n",
 184                          filename, strerror ( rc ) );
 185                 image_put ( image );
 186                 return rc;
 187         }
 188
 189         image_put ( image );
 190         return 0;
 191 }
 192
 193 /**
 194  * The "imgfetch"/"module" command
 195  *
 196  * @v argc              Argument count
 197  * @v argv              Argument list
 198  * @ret rc              Exit code
 199  */
 200 static int imgfetch_exec ( int argc, char **argv ) {
 201         int rc;
 202
 203         if ( ( rc = imgfetch_core_exec ( NULL, IMG_FETCH,
 204                                          argc, argv ) ) != 0 )
 205                 return rc;
 206
 207         return 0;
 208 }
 209
 210 /**
 211  * The "kernel" command
 212  *
 213  * @v argc              Argument count
 214  * @v argv              Argument list
 215  * @ret rc              Exit code
 216  */
 217 static int kernel_exec ( int argc, char **argv ) {
 218         int rc;
 219
 220         if ( ( rc = imgfetch_core_exec ( NULL, IMG_LOAD, argc, argv ) ) != 0 )
 221                 return rc;
 222
 223         return 0;
 224 }
 225
 226 /**
 227  * The "chain" command
 228  *
 229  * @v argc              Argument count
 230  * @v argv              Argument list
 231  * @ret rc              Exit code
 232  */
 233 static int chain_exec ( int argc, char **argv) {
 234         int rc;
 235
 236         if ( ( rc = imgfetch_core_exec ( NULL, IMG_EXEC, argc, argv ) ) != 0 )
 237                 return rc;
 238
 239         return 0;
 240 }
 241
 242 /**
 243  * "imgload" command syntax message
 244  *
 245  * @v argv              Argument list
 246  */
 247 static void imgload_syntax ( char **argv ) {
 248         printf ( "Usage:\n"
 249                  "  %s <image name>\n"
 250                  "\n"
 251                  "Load executable/loadable image\n",
 252                  argv[0] );
 253 }
 254
 255 /**
 256  * The "imgload" command
 257  *
 258  * @v argc              Argument count
 259  * @v argv              Argument list
 260  * @ret rc              Exit code
 261  */
 262 static int imgload_exec ( int argc, char **argv ) {
 263         static struct option longopts[] = {
 264                 { "help", 0, NULL, 'h' },
 265                 { NULL, 0, NULL, 0 },
 266         };
 267         struct image *image;
 268         const char *name;
 269         int c;
 270         int rc;
 271
 272         /* Parse options */
 273         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
 274                 switch ( c ) {
 275                 case 'h':
 276                         /* Display help text */
 277                 default:
 278                         /* Unrecognised/invalid option */
 279                         imgload_syntax ( argv );
 280                         return 1;
 281                 }
 282         }
 283
 284         /* Need exactly one image name remaining after the options */
 285         if ( optind != ( argc - 1 ) ) {
 286                 imgload_syntax ( argv );
 287                 return 1;
 288         }
 289         name = argv[optind];
 290
 291         /* Load all specified images */
 292         image = find_image ( name );
 293         if ( ! image ) {
 294                 printf ( "No such image: %s\n", name );
 295                 return 1;
 296         }
 297         if ( ( rc = imgload ( image ) ) != 0 ) {
 298                 printf ( "Could not load %s: %s\n", name, strerror ( rc ) );
 299                 return rc;
 300         }
 301
 302         return 0;
 303 }
 304
 305 /**
 306  * "imgargs" command syntax message
 307  *
 308  * @v argv              Argument list
 309  */
 310 static void imgargs_syntax ( char **argv ) {
 311         printf ( "Usage:\n"
 312                  "  %s <image name> [<arguments>...]\n"
 313                  "\n"
 314                  "Set arguments for executable/loadable image\n",
 315                  argv[0] );
 316 }
 317
 318 /**
 319  * The "imgargs" command body
 320  *
 321  * @v argc              Argument count
 322  * @v argv              Argument list
 323  * @ret rc              Exit code
 324  */
 325 static int imgargs_exec ( int argc, char **argv ) {
 326         static struct option longopts[] = {
 327                 { "help", 0, NULL, 'h' },
 328                 { NULL, 0, NULL, 0 },
 329         };
 330         struct image *image;
 331         const char *name;
 332         int c;
 333         int rc;
 334
 335         /* Parse options */
 336         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
 337                 switch ( c ) {
 338                 case 'h':
 339                         /* Display help text */
 340                 default:
 341                         /* Unrecognised/invalid option */
 342                         imgargs_syntax ( argv );
 343                         return 1;
 344                 }
 345         }
 346
 347         /* Need at least an image name remaining after the options */
 348         if ( optind == argc ) {
 349                 imgargs_syntax ( argv );
 350                 return 1;
 351         }
 352         name = argv[optind++];
 353
 354         /* Fill in command line */
 355         image = find_image ( name );
 356         if ( ! image ) {
 357                 printf ( "No such image: %s\n", name );
 358                 return 1;
 359         }
 360         if ( ( rc = imgfill_cmdline ( image, ( argc - optind ),
 361                                       &argv[optind] ) ) != 0 )
 362                 return rc;
 363
 364
 365         return 0;
 366 }
 367
 368 /**
 369  * "imgexec" command syntax message
 370  *
 371  * @v argv              Argument list
 372  */
 373 static void imgexec_syntax ( char **argv ) {
 374         printf ( "Usage:\n"
 375                  "  %s <image name>\n"
 376                  "\n"
 377                  "Execute executable/loadable image\n",
 378                  argv[0] );
 379 }
 380
 381 /**
 382  * The "imgexec" command
 383  *
 384  * @v argc              Argument count
 385  * @v argv              Argument list
 386  * @ret rc              Exit code
 387  */
 388 static int imgexec_exec ( int argc, char **argv ) {
 389         static struct option longopts[] = {
 390                 { "help", 0, NULL, 'h' },
 391                 { NULL, 0, NULL, 0 },
 392         };
 393         struct image *image;
 394         const char *name = NULL;
 395         int c;
 396         int rc;
 397
 398         /* Parse options */
 399         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
 400                 switch ( c ) {
 401                 case 'h':
 402                         /* Display help text */
 403                 default:
 404                         /* Unrecognised/invalid option */
 405                         imgexec_syntax ( argv );
 406                         return 1;
 407                 }
 408         }
 409
 410         /* Need no more than one image name */
 411         if ( optind != argc )
 412                 name = argv[optind++];
 413         if ( optind != argc ) {
 414                 imgexec_syntax ( argv );
 415                 return 1;
 416         }
 417
 418         /* Execute specified image */
 419         if ( name ) {
 420                 image = find_image ( name );
 421                 if ( ! image ) {
 422                         printf ( "No such image: %s\n", name );
 423                         return 1;
 424                 }
 425         } else {
 426                 image = imgautoselect();
 427                 if ( ! image ) {
 428                         printf ( "No (unique) loaded image\n" );
 429                         return 1;
 430                 }
 431         }
 432
 433         if ( ( rc = imgexec ( image ) ) != 0 ) {
 434                 printf ( "Could not execute %s: %s\n",
 435                          image->name, strerror ( rc ) );
 436                 return 1;
 437         }
 438
 439         return 0;
 440 }
 441
 442 /**
 443  * "imgstat" command syntax message
 444  *
 445  * @v argv              Argument list
 446  */
 447 static void imgstat_syntax ( char **argv ) {
 448         printf ( "Usage:\n"
 449                  "  %s\n"
 450                  "\n"
 451                  "List executable/loadable images\n",
 452                  argv[0] );
 453 }
 454
 455 /**
 456  * The "imgstat" command
 457  *
 458  * @v argc              Argument count
 459  * @v argv              Argument list
 460  * @ret rc              Exit code
 461  */
 462 static int imgstat_exec ( int argc, char **argv ) {
 463         static struct option longopts[] = {
 464                 { "help", 0, NULL, 'h' },
 465                 { NULL, 0, NULL, 0 },
 466         };
 467         struct image *image;
 468         int c;
 469
 470         /* Parse options */
 471         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
 472                 switch ( c ) {
 473                 case 'h':
 474                         /* Display help text */
 475                 default:
 476                         /* Unrecognised/invalid option */
 477                         imgstat_syntax ( argv );
 478                         return 1;
 479                 }
 480         }
 481
 482         /* No arguments */
 483         if ( optind != argc ) {
 484                 imgstat_syntax ( argv );
 485                 return 1;
 486         }
 487
 488         /* Show status of all images */
 489         for_each_image ( image ) {
 490                 imgstat ( image );
 491         }
 492         return 0;
 493 }
 494
 495 /**
 496  * "imgstat" command syntax message
 497  *
 498  * @v argv              Argument list
 499  */
 500 static void imgfree_syntax ( char **argv ) {
 501         printf ( "Usage:\n"
 502                  "  %s [<image name>]\n"
 503                  "\n"
 504                  "Free one or all executable/loadable images\n",
 505                  argv[0] );
 506 }
 507
 508 /**
 509  * The "imgfree" command
 510  *
 511  * @v argc              Argument count
 512  * @v argv              Argument list
 513  * @ret rc              Exit code
 514  */
 515 static int imgfree_exec ( int argc, char **argv ) {
 516         static struct option longopts[] = {
 517                 { "help", 0, NULL, 'h' },
 518                 { NULL, 0, NULL, 0 },
 519         };
 520         struct image *image;
 521         struct image *tmp;
 522         const char *name = NULL;
 523         int c;
 524
 525         /* Parse options */
 526         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
 527                 switch ( c ) {
 528                 case 'h':
 529                         /* Display help text */
 530                 default:
 531                         /* Unrecognised/invalid option */
 532                         imgfree_syntax ( argv );
 533                         return 1;
 534                 }
 535         }
 536
 537         /* Need no more than one image name */
 538         if ( optind != argc )
 539                 name = argv[optind++];
 540         if ( optind != argc ) {
 541                 imgfree_syntax ( argv );
 542                 return 1;
 543         }
 544
 545         if ( name ) {
 546                 /* Free specified image (may leak) */
 547                 image = find_image ( name );
 548                 if ( ! image ) {
 549                         printf ( "No such image: %s\n", name );
 550                         return 1;
 551                 }
 552                 imgfree ( image );
 553         } else {
 554                 /* Free all images */
 555                 list_for_each_entry_safe ( image, tmp, &images, list ) {
 556                         imgfree ( image );
 557                 }
 558         }
 559         return 0;
 560 }
 561
 562 /** Image management commands */
 563 struct command image_commands[] __command = {
 564         {
 565                 .name = "imgfetch",
 566                 .exec = imgfetch_exec,
 567         },
 568         {
 569                 .name = "module",
 570                 .exec = imgfetch_exec, /* synonym for "imgfetch" */
 571         },
 572         {
 573                 .name = "initrd",
 574                 .exec = imgfetch_exec, /* synonym for "imgfetch" */
 575         },
 576         {
 577                 .name = "kernel",
 578                 .exec = kernel_exec,
 579         },
 580         {
 581                 .name = "chain",
 582                 .exec = chain_exec,
 583         },
 584         {
 585                 .name = "imgload",
 586                 .exec = imgload_exec,
 587         },
 588         {
 589                 .name = "imgargs",
 590                 .exec = imgargs_exec,
 591         },
 592         {
 593                 .name = "imgexec",
 594                 .exec = imgexec_exec,
 595         },
 596         {
 597                 .name = "boot", /* synonym for "imgexec" */
 598                 .exec = imgexec_exec,
 599         },
 600         {
 601                 .name = "imgstat",
 602                 .exec = imgstat_exec,
 603         },
 604         {
 605                 .name = "imgfree",
 606                 .exec = imgfree_exec,
 607         },
 608 };