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)
  29 {
  30         char *tftp_argv[] = {"tftp", NULL, NULL, NULL};
  31
  32         tftp_argv[1] = file_addr;
  33         tftp_argv[2] = (void *)file_path;
  34
  35         if (do_tftpb(ctx->cmdtp, 0, 3, tftp_argv))
  36                 return -ENOENT;
  37
  38         return 1;
  39 }
  40
  41 /*
  42  * Looks for a pxe file with a name based on the pxeuuid environment variable.
  43  *
  44  * Returns 1 on success or < 0 on error.
  45  */
  46 static int pxe_uuid_path(struct pxe_context *ctx, unsigned long pxefile_addr_r)
  47 {
  48         char *uuid_str;
  49
  50         uuid_str = from_env("pxeuuid");
  51
  52         if (!uuid_str)
  53                 return -ENOENT;
  54
  55         return get_pxelinux_path(ctx, uuid_str, pxefile_addr_r);
  56 }
  57
  58 /*
  59  * Looks for a pxe file with a name based on the 'ethaddr' environment
  60  * variable.
  61  *
  62  * Returns 1 on success or < 0 on error.
  63  */
  64 static int pxe_mac_path(struct pxe_context *ctx, unsigned long pxefile_addr_r)
  65 {
  66         char mac_str[21];
  67         int err;
  68
  69         err = format_mac_pxe(mac_str, sizeof(mac_str));
  70
  71         if (err < 0)
  72                 return err;
  73
  74         return get_pxelinux_path(ctx, mac_str, pxefile_addr_r);
  75 }
  76
  77 /*
  78  * Looks for pxe files with names based on our IP address. See pxelinux
  79  * documentation for details on what these file names look like.  We match
  80  * that exactly.
  81  *
  82  * Returns 1 on success or < 0 on error.
  83  */
  84 static int pxe_ipaddr_paths(struct pxe_context *ctx, unsigned long pxefile_addr_r)
  85 {
  86         char ip_addr[9];
  87         int mask_pos, err;
  88
  89         sprintf(ip_addr, "%08X", ntohl(net_ip.s_addr));
  90
  91         for (mask_pos = 7; mask_pos >= 0;  mask_pos--) {
  92                 err = get_pxelinux_path(ctx, ip_addr, pxefile_addr_r);
  93
  94                 if (err > 0)
  95                         return err;
  96
  97                 ip_addr[mask_pos] = '\0';
  98         }
  99
 100         return -ENOENT;
 101 }
 102 /*
 103  * Entry point for the 'pxe get' command.
 104  * This Follows pxelinux's rules to download a config file from a tftp server.
 105  * The file is stored at the location given by the pxefile_addr_r environment
 106  * variable, which must be set.
 107  *
 108  * UUID comes from pxeuuid env variable, if defined
 109  * MAC addr comes from ethaddr env variable, if defined
 110  * IP
 111  *
 112  * see http://syslinux.zytor.com/wiki/index.php/PXELINUX
 113  *
 114  * Returns 0 on success or 1 on error.
 115  */
 116 static int
 117 do_pxe_get(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 118 {
 119         char *pxefile_addr_str;
 120         unsigned long pxefile_addr_r;
 121         struct pxe_context ctx;
 122         int err, i = 0;
 123
 124         pxe_setup_ctx(&ctx, cmdtp, do_get_tftp, NULL);
 125
 126         if (argc != 1)
 127                 return CMD_RET_USAGE;
 128
 129         pxefile_addr_str = from_env("pxefile_addr_r");
 130
 131         if (!pxefile_addr_str)
 132                 return 1;
 133
 134         err = strict_strtoul(pxefile_addr_str, 16,
 135                              (unsigned long *)&pxefile_addr_r);
 136         if (err < 0)
 137                 return 1;
 138
 139         /*
 140          * Keep trying paths until we successfully get a file we're looking
 141          * for.
 142          */
 143         if (pxe_uuid_path(&ctx, pxefile_addr_r) > 0 ||
 144             pxe_mac_path(&ctx, pxefile_addr_r) > 0 ||
 145             pxe_ipaddr_paths(&ctx, pxefile_addr_r) > 0) {
 146                 printf("Config file found\n");
 147
 148                 return 0;
 149         }
 150
 151         while (pxe_default_paths[i]) {
 152                 if (get_pxelinux_path(&ctx, pxe_default_paths[i],
 153                                       pxefile_addr_r) > 0) {
 154                         printf("Config file found\n");
 155                         return 0;
 156                 }
 157                 i++;
 158         }
 159
 160         printf("Config file not found\n");
 161
 162         return 1;
 163 }
 164
 165 /*
 166  * Boots a system using a pxe file
 167  *
 168  * Returns 0 on success, 1 on error.
 169  */
 170 static int
 171 do_pxe_boot(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 172 {
 173         unsigned long pxefile_addr_r;
 174         struct pxe_menu *cfg;
 175         char *pxefile_addr_str;
 176         struct pxe_context ctx;
 177
 178         pxe_setup_ctx(&ctx, cmdtp, do_get_tftp, NULL);
 179
 180         if (argc == 1) {
 181                 pxefile_addr_str = from_env("pxefile_addr_r");
 182                 if (!pxefile_addr_str)
 183                         return 1;
 184
 185         } else if (argc == 2) {
 186                 pxefile_addr_str = argv[1];
 187         } else {
 188                 return CMD_RET_USAGE;
 189         }
 190
 191         if (strict_strtoul(pxefile_addr_str, 16, &pxefile_addr_r) < 0) {
 192                 printf("Invalid pxefile address: %s\n", pxefile_addr_str);
 193                 return 1;
 194         }
 195
 196         cfg = parse_pxefile(&ctx, pxefile_addr_r);
 197
 198         if (!cfg) {
 199                 printf("Error parsing config file\n");
 200                 return 1;
 201         }
 202
 203         handle_pxe_menu(&ctx, cfg);
 204
 205         destroy_pxe_menu(cfg);
 206
 207         copy_filename(net_boot_file_name, "", sizeof(net_boot_file_name));
 208
 209         return 0;
 210 }
 211
 212 static struct cmd_tbl cmd_pxe_sub[] = {
 213         U_BOOT_CMD_MKENT(get, 1, 1, do_pxe_get, "", ""),
 214         U_BOOT_CMD_MKENT(boot, 2, 1, do_pxe_boot, "", "")
 215 };
 216
 217 static void __maybe_unused pxe_reloc(void)
 218 {
 219         static int relocated_pxe;
 220
 221         if (!relocated_pxe) {
 222                 fixup_cmdtable(cmd_pxe_sub, ARRAY_SIZE(cmd_pxe_sub));
 223                 relocated_pxe = 1;
 224         }
 225 }
 226
 227 static int do_pxe(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 228 {
 229         struct cmd_tbl *cp;
 230
 231 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 232         pxe_reloc();
 233 #endif
 234
 235         if (argc < 2)
 236                 return CMD_RET_USAGE;
 237
 238         is_pxe = true;
 239
 240         /* drop initial "pxe" arg */
 241         argc--;
 242         argv++;
 243
 244         cp = find_cmd_tbl(argv[0], cmd_pxe_sub, ARRAY_SIZE(cmd_pxe_sub));
 245
 246         if (cp)
 247                 return cp->cmd(cmdtp, flag, argc, argv);
 248
 249         return CMD_RET_USAGE;
 250 }
 251
 252 U_BOOT_CMD(pxe, 3, 1, do_pxe,
 253            "commands to get and boot from pxe files",
 254            "get - try to retrieve a pxe file using tftp\n"
 255            "pxe boot [pxefile_addr_r] - boot from the pxe file at pxefile_addr_r\n"
 256 );
 257 #endif