cmd/pxe.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2010-2011 Calxeda, Inc.
   4  * Copyright (c) 2014, NVIDIA CORPORATION.  All rights reserved.
   5  */
   6
   7 #include <common.h>
   8 #include <command.h>
   9 #include <fs.h>
  10 #include <net.h>
  11
  12 #include "pxe_utils.h"
  13
  14 #ifdef CONFIG_CMD_NET
  15 const char *pxe_default_paths[] = {
  16 #ifdef CONFIG_SYS_SOC
  17 #ifdef CONFIG_SYS_BOARD
  18         "default-" CONFIG_SYS_ARCH "-" CONFIG_SYS_SOC "-" CONFIG_SYS_BOARD,
  19 #endif
  20         "default-" CONFIG_SYS_ARCH "-" CONFIG_SYS_SOC,
  21 #endif
  22         "default-" CONFIG_SYS_ARCH,
  23         "default",
  24         NULL
  25 };
  26
  27 static int do_get_tftp(struct pxe_context *ctx, const char *file_path,
  28                        char *file_addr, ulong *sizep)
  29 {
  30         char *tftp_argv[] = {"tftp", NULL, NULL, NULL};
  31         int ret;
  32
  33         tftp_argv[1] = file_addr;
  34         tftp_argv[2] = (void *)file_path;
  35
  36         if (do_tftpb(ctx->cmdtp, 0, 3, tftp_argv))
  37                 return -ENOENT;
  38         ret = pxe_get_file_size(sizep);
  39         if (ret)
  40                 return log_msg_ret("tftp", ret);
  41         ctx->pxe_file_size = *sizep;
  42
  43         return 1;
  44 }
  45
  46 /*
  47  * Looks for a pxe file with a name based on the pxeuuid environment variable.
  48  *
  49  * Returns 1 on success or < 0 on error.
  50  */
  51 static int pxe_uuid_path(struct pxe_context *ctx, unsigned long pxefile_addr_r)
  52 {
  53         char *uuid_str;
  54
  55         uuid_str = from_env("pxeuuid");
  56
  57         if (!uuid_str)
  58                 return -ENOENT;
  59
  60         return get_pxelinux_path(ctx, uuid_str, pxefile_addr_r);
  61 }
  62
  63 /*
  64  * Looks for a pxe file with a name based on the 'ethaddr' environment
  65  * variable.
  66  *
  67  * Returns 1 on success or < 0 on error.
  68  */
  69 static int pxe_mac_path(struct pxe_context *ctx, unsigned long pxefile_addr_r)
  70 {
  71         char mac_str[21];
  72         int err;
  73
  74         err = format_mac_pxe(mac_str, sizeof(mac_str));
  75
  76         if (err < 0)
  77                 return err;
  78
  79         return get_pxelinux_path(ctx, mac_str, pxefile_addr_r);
  80 }
  81
  82 /*
  83  * Looks for pxe files with names based on our IP address. See pxelinux
  84  * documentation for details on what these file names look like.  We match
  85  * that exactly.
  86  *
  87  * Returns 1 on success or < 0 on error.
  88  */
  89 static int pxe_ipaddr_paths(struct pxe_context *ctx, unsigned long pxefile_addr_r)
  90 {
  91         char ip_addr[9];
  92         int mask_pos, err;
  93
  94         sprintf(ip_addr, "%08X", ntohl(net_ip.s_addr));
  95
  96         for (mask_pos = 7; mask_pos >= 0;  mask_pos--) {
  97                 err = get_pxelinux_path(ctx, ip_addr, pxefile_addr_r);
  98
  99                 if (err > 0)
 100                         return err;
 101
 102                 ip_addr[mask_pos] = '\0';
 103         }
 104
 105         return -ENOENT;
 106 }
 107
 108 int pxe_get(ulong pxefile_addr_r, char **bootdirp, ulong *sizep)
 109 {
 110         struct cmd_tbl cmdtp[] = {};    /* dummy */
 111         struct pxe_context ctx;
 112         int i;
 113
 114         if (pxe_setup_ctx(&ctx, cmdtp, do_get_tftp, NULL, false,
 115                           env_get("bootfile")))
 116                 return -ENOMEM;
 117         /*
 118          * Keep trying paths until we successfully get a file we're looking
 119          * for.
 120          */
 121         if (pxe_uuid_path(&ctx, pxefile_addr_r) > 0 ||
 122             pxe_mac_path(&ctx, pxefile_addr_r) > 0 ||
 123             pxe_ipaddr_paths(&ctx, pxefile_addr_r) > 0)
 124                 goto done;
 125
 126         i = 0;
 127         while (pxe_default_paths[i]) {
 128                 if (get_pxelinux_path(&ctx, pxe_default_paths[i],
 129                                       pxefile_addr_r) > 0)
 130                         goto done;
 131                 i++;
 132         }
 133
 134         pxe_destroy_ctx(&ctx);
 135
 136         return -ENOENT;
 137 done:
 138         *bootdirp = env_get("bootfile");
 139
 140         /*
 141          * The PXE file size is returned but not the name. It is probably not
 142          * that useful.
 143          */
 144         *sizep = ctx.pxe_file_size;
 145         pxe_destroy_ctx(&ctx);
 146
 147         return 0;
 148 }
 149
 150 /*
 151  * Entry point for the 'pxe get' command.
 152  * This Follows pxelinux's rules to download a config file from a tftp server.
 153  * The file is stored at the location given by the pxefile_addr_r environment
 154  * variable, which must be set.
 155  *
 156  * UUID comes from pxeuuid env variable, if defined
 157  * MAC addr comes from ethaddr env variable, if defined
 158  * IP
 159  *
 160  * see http://syslinux.zytor.com/wiki/index.php/PXELINUX
 161  *
 162  * Returns 0 on success or 1 on error.
 163  */
 164 static int
 165 do_pxe_get(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 166 {
 167         char *pxefile_addr_str;
 168         ulong pxefile_addr_r;
 169         char *fname;
 170         ulong size;
 171         int ret;
 172
 173         if (argc != 1)
 174                 return CMD_RET_USAGE;
 175
 176         pxefile_addr_str = from_env("pxefile_addr_r");
 177
 178         if (!pxefile_addr_str)
 179                 return 1;
 180
 181         ret = strict_strtoul(pxefile_addr_str, 16,
 182                              (unsigned long *)&pxefile_addr_r);
 183         if (ret < 0)
 184                 return 1;
 185
 186         ret = pxe_get(pxefile_addr_r, &fname, &size);
 187         switch (ret) {
 188         case 0:
 189                 printf("Config file '%s' found\n", fname);
 190                 break;
 191         case -ENOMEM:
 192                 printf("Out of memory\n");
 193                 return CMD_RET_FAILURE;
 194         default:
 195                 printf("Config file not found\n");
 196                 return CMD_RET_FAILURE;
 197         }
 198
 199         return 0;
 200 }
 201
 202 /*
 203  * Boots a system using a pxe file
 204  *
 205  * Returns 0 on success, 1 on error.
 206  */
 207 static int
 208 do_pxe_boot(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 209 {
 210         unsigned long pxefile_addr_r;
 211         char *pxefile_addr_str;
 212         struct pxe_context ctx;
 213         int ret;
 214
 215         if (argc == 1) {
 216                 pxefile_addr_str = from_env("pxefile_addr_r");
 217                 if (!pxefile_addr_str)
 218                         return 1;
 219
 220         } else if (argc == 2) {
 221                 pxefile_addr_str = argv[1];
 222         } else {
 223                 return CMD_RET_USAGE;
 224         }
 225
 226         if (strict_strtoul(pxefile_addr_str, 16, &pxefile_addr_r) < 0) {
 227                 printf("Invalid pxefile address: %s\n", pxefile_addr_str);
 228                 return 1;
 229         }
 230
 231         if (pxe_setup_ctx(&ctx, cmdtp, do_get_tftp, NULL, false,
 232                           env_get("bootfile"))) {
 233                 printf("Out of memory\n");
 234                 return CMD_RET_FAILURE;
 235         }
 236         ret = pxe_process(&ctx, pxefile_addr_r, false);
 237         pxe_destroy_ctx(&ctx);
 238         if (ret)
 239                 return CMD_RET_FAILURE;
 240
 241         copy_filename(net_boot_file_name, "", sizeof(net_boot_file_name));
 242
 243         return 0;
 244 }
 245
 246 static struct cmd_tbl cmd_pxe_sub[] = {
 247         U_BOOT_CMD_MKENT(get, 1, 1, do_pxe_get, "", ""),
 248         U_BOOT_CMD_MKENT(boot, 2, 1, do_pxe_boot, "", "")
 249 };
 250
 251 static void __maybe_unused pxe_reloc(void)
 252 {
 253         static int relocated_pxe;
 254
 255         if (!relocated_pxe) {
 256                 fixup_cmdtable(cmd_pxe_sub, ARRAY_SIZE(cmd_pxe_sub));
 257                 relocated_pxe = 1;
 258         }
 259 }
 260
 261 static int do_pxe(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 262 {
 263         struct cmd_tbl *cp;
 264
 265 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 266         pxe_reloc();
 267 #endif
 268
 269         if (argc < 2)
 270                 return CMD_RET_USAGE;
 271
 272         /* drop initial "pxe" arg */
 273         argc--;
 274         argv++;
 275
 276         cp = find_cmd_tbl(argv[0], cmd_pxe_sub, ARRAY_SIZE(cmd_pxe_sub));
 277
 278         if (cp)
 279                 return cp->cmd(cmdtp, flag, argc, argv);
 280
 281         return CMD_RET_USAGE;
 282 }
 283
 284 U_BOOT_CMD(pxe, 3, 1, do_pxe,
 285            "commands to get and boot from pxe files",
 286            "get - try to retrieve a pxe file using tftp\n"
 287            "pxe boot [pxefile_addr_r] - boot from the pxe file at pxefile_addr_r\n"
 288 );
 289 #endif