cmd/part.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
   4  *
   5  * made from cmd_ext2, which was:
   6  *
   7  * (C) Copyright 2004
   8  * esd gmbh <www.esd-electronics.com>
   9  * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
  10  *
  11  * made from cmd_reiserfs by
  12  *
  13  * (C) Copyright 2003 - 2004
  14  * Sysgo Real-Time Solutions, AG <www.elinos.com>
  15  * Pavel Bartusek <pba@sysgo.com>
  16  */
  17
  18 #include <common.h>
  19 #include <config.h>
  20 #include <command.h>
  21 #include <env.h>
  22 #include <part.h>
  23 #include <vsprintf.h>
  24
  25 enum cmd_part_info {
  26         CMD_PART_INFO_START = 0,
  27         CMD_PART_INFO_SIZE,
  28         CMD_PART_INFO_NUMBER
  29 };
  30
  31 static int do_part_uuid(int argc, char *const argv[])
  32 {
  33         int part;
  34         struct blk_desc *dev_desc;
  35         struct disk_partition info;
  36
  37         if (argc < 2)
  38                 return CMD_RET_USAGE;
  39         if (argc > 3)
  40                 return CMD_RET_USAGE;
  41
  42         part = blk_get_device_part_str(argv[0], argv[1], &dev_desc, &info, 0);
  43         if (part < 0)
  44                 return 1;
  45
  46         if (argc > 2)
  47                 env_set(argv[2], info.uuid);
  48         else
  49                 printf("%s\n", info.uuid);
  50
  51         return 0;
  52 }
  53
  54 static int do_part_list(int argc, char *const argv[])
  55 {
  56         int ret;
  57         struct blk_desc *desc;
  58         char *var = NULL;
  59         bool bootable = false;
  60         int i;
  61
  62         if (argc < 2)
  63                 return CMD_RET_USAGE;
  64
  65         if (argc > 2) {
  66                 for (i = 2; i < argc ; i++) {
  67                         if (argv[i][0] == '-') {
  68                                 if (!strcmp(argv[i], "-bootable")) {
  69                                         bootable = true;
  70                                 } else {
  71                                         printf("Unknown option %s\n", argv[i]);
  72                                         return CMD_RET_USAGE;
  73                                 }
  74                         } else {
  75                                 var = argv[i];
  76                                 break;
  77                         }
  78                 }
  79
  80                 /* Loops should have been exited at the last argument, which
  81                  * as it contained the variable */
  82                 if (argc != i + 1)
  83                         return CMD_RET_USAGE;
  84         }
  85
  86         ret = blk_get_device_by_str(argv[0], argv[1], &desc);
  87         if (ret < 0)
  88                 return 1;
  89
  90         if (var != NULL) {
  91                 int p;
  92                 char str[3 * MAX_SEARCH_PARTITIONS] = { '\0', };
  93                 struct disk_partition info;
  94
  95                 for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
  96                         char t[5];
  97                         int r = part_get_info(desc, p, &info);
  98
  99                         if (r != 0)
 100                                 continue;
 101
 102                         if (bootable && !info.bootable)
 103                                 continue;
 104
 105                         sprintf(t, "%s%x", str[0] ? " " : "", p);
 106                         strcat(str, t);
 107                 }
 108                 env_set(var, str);
 109                 return 0;
 110         }
 111
 112         part_print(desc);
 113
 114         return 0;
 115 }
 116
 117 static int do_part_info(int argc, char *const argv[], enum cmd_part_info param)
 118 {
 119         struct blk_desc *desc;
 120         struct disk_partition info;
 121         char buf[512] = { 0 };
 122         char *endp;
 123         int part;
 124         int err;
 125         int ret;
 126
 127         if (argc < 3)
 128                 return CMD_RET_USAGE;
 129         if (argc > 4)
 130                 return CMD_RET_USAGE;
 131
 132         ret = blk_get_device_by_str(argv[0], argv[1], &desc);
 133         if (ret < 0)
 134                 return 1;
 135
 136         part = simple_strtoul(argv[2], &endp, 0);
 137         if (*endp == '\0') {
 138                 err = part_get_info(desc, part, &info);
 139                 if (err)
 140                         return 1;
 141         } else {
 142                 part = part_get_info_by_name(desc, argv[2], &info);
 143                 if (part < 0)
 144                         return 1;
 145         }
 146
 147         switch (param) {
 148         case CMD_PART_INFO_START:
 149                 snprintf(buf, sizeof(buf), LBAF, info.start);
 150                 break;
 151         case CMD_PART_INFO_SIZE:
 152                 snprintf(buf, sizeof(buf), LBAF, info.size);
 153                 break;
 154         case CMD_PART_INFO_NUMBER:
 155                 snprintf(buf, sizeof(buf), "0x%x", part);
 156                 break;
 157         default:
 158                 printf("** Unknown cmd_part_info value: %d\n", param);
 159                 return 1;
 160         }
 161
 162         if (argc > 3)
 163                 env_set(argv[3], buf);
 164         else
 165                 printf("%s\n", buf);
 166
 167         return 0;
 168 }
 169
 170 static int do_part_start(int argc, char *const argv[])
 171 {
 172         return do_part_info(argc, argv, CMD_PART_INFO_START);
 173 }
 174
 175 static int do_part_size(int argc, char *const argv[])
 176 {
 177         return do_part_info(argc, argv, CMD_PART_INFO_SIZE);
 178 }
 179
 180 static int do_part_number(int argc, char *const argv[])
 181 {
 182         return do_part_info(argc, argv, CMD_PART_INFO_NUMBER);
 183 }
 184
 185 #ifdef CONFIG_PARTITION_TYPE_GUID
 186 static int do_part_type(int argc, char *const argv[])
 187 {
 188         int part;
 189         struct blk_desc *dev_desc;
 190         struct disk_partition info;
 191
 192         if (argc < 2)
 193                 return CMD_RET_USAGE;
 194         if (argc > 3)
 195                 return CMD_RET_USAGE;
 196
 197         part = blk_get_device_part_str(argv[0], argv[1], &dev_desc, &info, 0);
 198         if (part < 0)
 199                 return 1;
 200
 201         if (argc > 2)
 202                 env_set(argv[2], info.type_guid);
 203         else
 204                 printf("%s\n", info.type_guid);
 205
 206         return 0;
 207 }
 208 #endif
 209
 210 static int do_part_types(int argc, char * const argv[])
 211 {
 212         struct part_driver *drv = ll_entry_start(struct part_driver,
 213                                                  part_driver);
 214         const int n_ents = ll_entry_count(struct part_driver, part_driver);
 215         struct part_driver *entry;
 216         int i = 0;
 217
 218         puts("Supported partition tables");
 219
 220         for (entry = drv; entry != drv + n_ents; entry++) {
 221                 printf("%c %s", i ? ',' : ':', entry->name);
 222                 i++;
 223         }
 224         if (!i)
 225                 puts(": <none>");
 226         puts("\n");
 227         return CMD_RET_SUCCESS;
 228 }
 229
 230 static int do_part(struct cmd_tbl *cmdtp, int flag, int argc,
 231                    char *const argv[])
 232 {
 233         if (argc < 2)
 234                 return CMD_RET_USAGE;
 235
 236         if (!strcmp(argv[1], "uuid"))
 237                 return do_part_uuid(argc - 2, argv + 2);
 238         else if (!strcmp(argv[1], "list"))
 239                 return do_part_list(argc - 2, argv + 2);
 240         else if (!strcmp(argv[1], "start"))
 241                 return do_part_start(argc - 2, argv + 2);
 242         else if (!strcmp(argv[1], "size"))
 243                 return do_part_size(argc - 2, argv + 2);
 244         else if (!strcmp(argv[1], "number"))
 245                 return do_part_number(argc - 2, argv + 2);
 246         else if (!strcmp(argv[1], "types"))
 247                 return do_part_types(argc - 2, argv + 2);
 248 #ifdef CONFIG_PARTITION_TYPE_GUID
 249         else if (!strcmp(argv[1], "type"))
 250                 return do_part_type(argc - 2, argv + 2);
 251 #endif
 252         return CMD_RET_USAGE;
 253 }
 254
 255 U_BOOT_CMD(
 256         part,   CONFIG_SYS_MAXARGS,     1,      do_part,
 257         "disk partition related commands",
 258         "uuid <interface> <dev>:<part>\n"
 259         "    - print partition UUID\n"
 260         "part uuid <interface> <dev>:<part> <varname>\n"
 261         "    - set environment variable to partition UUID\n"
 262         "part list <interface> <dev>\n"
 263         "    - print a device's partition table\n"
 264         "part list <interface> <dev> [flags] <varname>\n"
 265         "    - set environment variable to the list of partitions\n"
 266         "      flags can be -bootable (list only bootable partitions)\n"
 267         "part start <interface> <dev> <part> <varname>\n"
 268         "    - set environment variable to the start of the partition (in blocks)\n"
 269         "      part can be either partition number or partition name\n"
 270         "part size <interface> <dev> <part> <varname>\n"
 271         "    - set environment variable to the size of the partition (in blocks)\n"
 272         "      part can be either partition number or partition name\n"
 273         "part number <interface> <dev> <part> <varname>\n"
 274         "    - set environment variable to the partition number using the partition name\n"
 275         "      part must be specified as partition name\n"
 276 #ifdef CONFIG_PARTITION_TYPE_GUID
 277         "part type <interface> <dev>:<part>\n"
 278         "    - print partition type\n"
 279 #endif
 280         "part type <interface> <dev>:<part> <varname>\n"
 281         "    - set environment variable to partition type\n"
 282         "part types\n"
 283         "    - list supported partition table types"
 284 );