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[512] = { '\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 == -1)
 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 static int do_part(struct cmd_tbl *cmdtp, int flag, int argc,
 186                    char *const argv[])
 187 {
 188         if (argc < 2)
 189                 return CMD_RET_USAGE;
 190
 191         if (!strcmp(argv[1], "uuid"))
 192                 return do_part_uuid(argc - 2, argv + 2);
 193         else if (!strcmp(argv[1], "list"))
 194                 return do_part_list(argc - 2, argv + 2);
 195         else if (!strcmp(argv[1], "start"))
 196                 return do_part_start(argc - 2, argv + 2);
 197         else if (!strcmp(argv[1], "size"))
 198                 return do_part_size(argc - 2, argv + 2);
 199         else if (!strcmp(argv[1], "number"))
 200                 return do_part_number(argc - 2, argv + 2);
 201
 202         return CMD_RET_USAGE;
 203 }
 204
 205 U_BOOT_CMD(
 206         part,   CONFIG_SYS_MAXARGS,     1,      do_part,
 207         "disk partition related commands",
 208         "uuid <interface> <dev>:<part>\n"
 209         "    - print partition UUID\n"
 210         "part uuid <interface> <dev>:<part> <varname>\n"
 211         "    - set environment variable to partition UUID\n"
 212         "part list <interface> <dev>\n"
 213         "    - print a device's partition table\n"
 214         "part list <interface> <dev> [flags] <varname>\n"
 215         "    - set environment variable to the list of partitions\n"
 216         "      flags can be -bootable (list only bootable partitions)\n"
 217         "part start <interface> <dev> <part> <varname>\n"
 218         "    - set environment variable to the start of the partition (in blocks)\n"
 219         "      part can be either partition number or partition name\n"
 220         "part size <interface> <dev> <part> <varname>\n"
 221         "    - set environment variable to the size of the partition (in blocks)\n"
 222         "      part can be either partition number or partition name\n"
 223         "part number <interface> <dev> <part> <varname>\n"
 224         "    - set environment variable to the partition number using the partition name\n"
 225         "      part must be specified as partition name"
 226 );