disk-utils/blockdev.c

   1 /*
   2  * blockdev.c --- Do various simple block device ioctls from the command line
   3  * aeb, 991028
   4  */
   5
   6 #include <stdio.h>
   7 #include <fcntl.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include <sys/ioctl.h>
  12 #include <errno.h>
  13
  14 #include "c.h"
  15 #include "nls.h"
  16 #include "blkdev.h"
  17 #include "pathnames.h"
  18 #include "closestream.h"
  19 #include "strutils.h"
  20 #include "sysfs.h"
  21
  22 struct bdc {
  23         long            ioc;            /* ioctl code */
  24         const char      *iocname;       /* ioctl name (e.g. BLKROSET) */
  25         long            argval;         /* default argument */
  26
  27         const char      *name;          /* --setfoo */
  28         const char      *argname;       /* argument name or NULL */
  29
  30         const char      *help;
  31
  32         int             argtype;
  33         int             flags;
  34 };
  35
  36 /* command flags */
  37 enum {
  38         FL_NOPTR        = (1 << 1),     /* does not assume pointer (ARG_INT only)*/
  39         FL_NORESULT     = (1 << 2)      /* does not return any data */
  40 };
  41
  42 /* ioctl argument types */
  43 enum {
  44         ARG_NONE,
  45         ARG_USHRT,
  46         ARG_INT,
  47         ARG_UINT,
  48         ARG_LONG,
  49         ARG_ULONG,
  50         ARG_LLONG,
  51         ARG_ULLONG
  52 };
  53
  54 #define IOCTL_ENTRY( io )       .ioc = io, .iocname = # io
  55
  56 static const struct bdc bdcms[] =
  57 {
  58         {
  59                 IOCTL_ENTRY(BLKROSET),
  60                 .name = "--setro",
  61                 .argtype = ARG_INT,
  62                 .argval = 1,
  63                 .flags = FL_NORESULT,
  64                 .help = N_("set read-only")
  65         },{
  66                 IOCTL_ENTRY(BLKROSET),
  67                 .name = "--setrw",
  68                 .argtype = ARG_INT,
  69                 .argval = 0,
  70                 .flags = FL_NORESULT,
  71                 .help = N_("set read-write")
  72         },{
  73                 IOCTL_ENTRY(BLKROGET),
  74                 .name = "--getro",
  75                 .argtype = ARG_INT,
  76                 .argval = -1,
  77                 .help = N_("get read-only")
  78         },{
  79                 IOCTL_ENTRY(BLKDISCARDZEROES),
  80                 .name = "--getdiscardzeroes",
  81                 .argtype = ARG_UINT,
  82                 .argval = -1,
  83                 .help = N_("get discard zeroes support status")
  84         },{
  85                 IOCTL_ENTRY(BLKSSZGET),
  86                 .name = "--getss",
  87                 .argtype = ARG_INT,
  88                 .argval = -1,
  89                 .help = N_("get logical block (sector) size")
  90         },{
  91                 IOCTL_ENTRY(BLKPBSZGET),
  92                 .name = "--getpbsz",
  93                 .argtype = ARG_UINT,
  94                 .argval = -1,
  95                 .help = N_("get physical block (sector) size")
  96         },{
  97                 IOCTL_ENTRY(BLKIOMIN),
  98                 .name = "--getiomin",
  99                 .argtype = ARG_UINT,
 100                 .argval = -1,
 101                 .help = N_("get minimum I/O size")
 102         },{
 103                 IOCTL_ENTRY(BLKIOOPT),
 104                 .name = "--getioopt",
 105                 .argtype = ARG_UINT,
 106                 .argval = -1,
 107                 .help = N_("get optimal I/O size")
 108         },{
 109                 IOCTL_ENTRY(BLKALIGNOFF),
 110                 .name = "--getalignoff",
 111                 .argtype = ARG_INT,
 112                 .argval = -1,
 113                 .help = N_("get alignment offset in bytes")
 114         },{
 115                 IOCTL_ENTRY(BLKSECTGET),
 116                 .name = "--getmaxsect",
 117                 .argtype = ARG_USHRT,
 118                 .argval = -1,
 119                 .help = N_("get max sectors per request")
 120         },{
 121                 IOCTL_ENTRY(BLKBSZGET),
 122                 .name = "--getbsz",
 123                 .argtype = ARG_INT,
 124                 .argval = -1,
 125                 .help = N_("get blocksize")
 126         },{
 127                 IOCTL_ENTRY(BLKBSZSET),
 128                 .name = "--setbsz",
 129                 .argname = "<bytes>",
 130                 .argtype = ARG_INT,
 131                 .flags = FL_NORESULT,
 132                 .help = N_("set blocksize on file descriptor opening the block device")
 133         },{
 134                 IOCTL_ENTRY(BLKGETSIZE),
 135                 .name = "--getsize",
 136                 .argtype = ARG_ULONG,
 137                 .argval = -1,
 138                 .help = N_("get 32-bit sector count (deprecated, use --getsz)")
 139         },{
 140                 IOCTL_ENTRY(BLKGETSIZE64),
 141                 .name = "--getsize64",
 142                 .argtype = ARG_ULLONG,
 143                 .argval = -1,
 144                 .help = N_("get size in bytes")
 145         },{
 146                 IOCTL_ENTRY(BLKRASET),
 147                 .name = "--setra",
 148                 .argname = "<sectors>",
 149                 .argtype = ARG_INT,
 150                 .flags = FL_NOPTR | FL_NORESULT,
 151                 .help = N_("set readahead")
 152         },{
 153                 IOCTL_ENTRY(BLKRAGET),
 154                 .name = "--getra",
 155                 .argtype = ARG_LONG,
 156                 .argval = -1,
 157                 .help = N_("get readahead")
 158         },{
 159                 IOCTL_ENTRY(BLKFRASET),
 160                 .name = "--setfra",
 161                 .argname = "<sectors>",
 162                 .argtype = ARG_INT,
 163                 .flags = FL_NOPTR | FL_NORESULT,
 164                 .help = N_("set filesystem readahead")
 165         },{
 166                 IOCTL_ENTRY(BLKFRAGET),
 167                 .name = "--getfra",
 168                 .argtype = ARG_LONG,
 169                 .argval = -1,
 170                 .help = N_("get filesystem readahead")
 171         },{
 172                 IOCTL_ENTRY(BLKGETDISKSEQ),
 173                 .name = "--getdiskseq",
 174                 .argtype = ARG_ULLONG,
 175                 .argval = -1,
 176                 .help = N_("get disk sequence number")
 177         },{
 178                 IOCTL_ENTRY(BLKFLSBUF),
 179                 .name = "--flushbufs",
 180                 .help = N_("flush buffers")
 181         },{
 182                 IOCTL_ENTRY(BLKRRPART),
 183                 .name = "--rereadpt",
 184                 .help = N_("reread partition table")
 185         }
 186 };
 187
 188 static void __attribute__((__noreturn__)) usage(void)
 189 {
 190         size_t i;
 191
 192         fputs(USAGE_HEADER, stdout);
 193         printf(_(
 194                  " %1$s [-v|-q] commands devices\n"
 195                  " %1$s --report [devices]\n"
 196                  " %1$s -h|-V\n"
 197                 ), program_invocation_short_name);
 198
 199         fputs(USAGE_SEPARATOR, stdout);
 200         puts(  _("Call block device ioctls from the command line."));
 201
 202         fputs(USAGE_OPTIONS, stdout);
 203         puts(  _(" -q             quiet mode"));
 204         puts(  _(" -v             verbose mode"));
 205         puts(  _("     --report   print report for specified (or all) devices"));
 206         fputs(USAGE_SEPARATOR, stdout);
 207         printf(USAGE_HELP_OPTIONS(16));
 208
 209         fputs(USAGE_SEPARATOR, stdout);
 210         puts(  _("Available commands:"));
 211         printf(_(" %-25s get size in 512-byte sectors\n"), "--getsz");
 212         for (i = 0; i < ARRAY_SIZE(bdcms); i++) {
 213                 if (bdcms[i].argname)
 214                         printf(" %s %-*s %s\n", bdcms[i].name,
 215                                 (int)(24 - strlen(bdcms[i].name)),
 216                                 bdcms[i].argname, _(bdcms[i].help));
 217                 else
 218                         printf(" %-25s %s\n", bdcms[i].name,
 219                                 _(bdcms[i].help));
 220         }
 221
 222         printf(USAGE_MAN_TAIL("blockdev(8)"));
 223         exit(EXIT_SUCCESS);
 224 }
 225
 226 static int find_cmd(char *s)
 227 {
 228         size_t j;
 229
 230         for (j = 0; j < ARRAY_SIZE(bdcms); j++)
 231                 if (!strcmp(s, bdcms[j].name))
 232                         return j;
 233         return -1;
 234 }
 235
 236 static void do_commands(int fd, char **argv, int d);
 237 static void report_header(void);
 238 static void report_device(char *device, int quiet);
 239 static void report_all_devices(void);
 240
 241 int main(int argc, char **argv)
 242 {
 243         int fd, d, j, k;
 244
 245         setlocale(LC_ALL, "");
 246         bindtextdomain(PACKAGE, LOCALEDIR);
 247         textdomain(PACKAGE);
 248         close_stdout_atexit();
 249
 250         if (argc < 2) {
 251                 warnx(_("not enough arguments"));
 252                 errtryhelp(EXIT_FAILURE);
 253         }
 254
 255         /* -V not together with commands */
 256         if (!strcmp(argv[1], "-V") || !strcmp(argv[1], "--version"))
 257                 print_version(EXIT_SUCCESS);
 258         if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))
 259                 usage();
 260
 261         /* --report not together with other commands */
 262         if (!strcmp(argv[1], "--report")) {
 263                 report_header();
 264                 if (argc > 2) {
 265                         for (d = 2; d < argc; d++)
 266                                 report_device(argv[d], 0);
 267                 } else {
 268                         report_all_devices();
 269                 }
 270                 return EXIT_SUCCESS;
 271         }
 272
 273         /* do each of the commands on each of the devices */
 274         /* devices start after last command */
 275         for (d = 1; d < argc; d++) {
 276                 j = find_cmd(argv[d]);
 277                 if (j >= 0) {
 278                         if (bdcms[j].argname)
 279                                 d++;
 280                         continue;
 281                 }
 282                 if (!strcmp(argv[d], "--getsz"))
 283                         continue;
 284                 if (!strcmp(argv[d], "--")) {
 285                         d++;
 286                         break;
 287                 }
 288                 if (argv[d][0] != '-')
 289                         break;
 290         }
 291
 292         if (d >= argc) {
 293                 warnx(_("no device specified"));
 294                 errtryhelp(EXIT_FAILURE);
 295         }
 296
 297         for (k = d; k < argc; k++) {
 298                 fd = open(argv[k], O_RDONLY, 0);
 299                 if (fd < 0)
 300                         err(EXIT_FAILURE, _("cannot open %s"), argv[k]);
 301                 do_commands(fd, argv, d);
 302                 close(fd);
 303         }
 304         return EXIT_SUCCESS;
 305 }
 306
 307 static void do_commands(int fd, char **argv, int d)
 308 {
 309         int res, i, j;
 310         int iarg = 0;
 311         unsigned int uarg = 0;
 312         unsigned short huarg = 0;
 313         long larg = 0;
 314         long long llarg = 0;
 315         unsigned long lu = 0;
 316         unsigned long long llu = 0;
 317         int verbose = 0;
 318
 319         for (i = 1; i < d; i++) {
 320                 if (!strcmp(argv[i], "-v")) {
 321                         verbose = 1;
 322                         continue;
 323                 }
 324                 if (!strcmp(argv[i], "-q")) {
 325                         verbose = 0;
 326                         continue;
 327                 }
 328
 329                 if (!strcmp(argv[i], "--getsz")) {
 330                         res = blkdev_get_sectors(fd, &llu);
 331                         if (res == 0)
 332                                 printf("%lld\n", llu);
 333                         else
 334                                 errx(EXIT_FAILURE,
 335                                      _("could not get device size"));
 336                         continue;
 337                 }
 338
 339                 j = find_cmd(argv[i]);
 340                 if (j == -1) {
 341                         warnx(_("Unknown command: %s"), argv[i]);
 342                         errtryhelp(EXIT_FAILURE);
 343                 }
 344
 345                 switch (bdcms[j].argtype) {
 346                 default:
 347                 case ARG_NONE:
 348                         res = ioctl(fd, bdcms[j].ioc, 0);
 349                         break;
 350                 case ARG_USHRT:
 351                         huarg = bdcms[j].argval;
 352                         res = ioctl(fd, bdcms[j].ioc, &huarg);
 353                         break;
 354                 case ARG_INT:
 355                         if (bdcms[j].argname) {
 356                                 if (i == d - 1) {
 357                                         warnx(_("%s requires an argument"),
 358                                               bdcms[j].name);
 359                                         errtryhelp(EXIT_FAILURE);
 360                                 }
 361                                 iarg = strtos32_or_err(argv[++i], _("failed to parse command argument"));
 362                         } else
 363                                 iarg = bdcms[j].argval;
 364
 365                         res = bdcms[j].flags & FL_NOPTR ?
 366                             ioctl(fd, bdcms[j].ioc, iarg) :
 367                             ioctl(fd, bdcms[j].ioc, &iarg);
 368                         break;
 369                 case ARG_UINT:
 370                         uarg = bdcms[j].argval;
 371                         res = ioctl(fd, bdcms[j].ioc, &uarg);
 372                         break;
 373                 case ARG_LONG:
 374                         larg = bdcms[j].argval;
 375                         res = ioctl(fd, bdcms[j].ioc, &larg);
 376                         break;
 377                 case ARG_LLONG:
 378                         llarg = bdcms[j].argval;
 379                         res = ioctl(fd, bdcms[j].ioc, &llarg);
 380                         break;
 381                 case ARG_ULONG:
 382                         lu = bdcms[j].argval;
 383                         res = ioctl(fd, bdcms[j].ioc, &lu);
 384                         break;
 385                 case ARG_ULLONG:
 386                         llu = bdcms[j].argval;
 387                         res = ioctl(fd, bdcms[j].ioc, &llu);
 388                         break;
 389                 }
 390
 391                 if (res == -1) {
 392                         warn(_("ioctl error on %s"), bdcms[j].iocname);
 393                         if (verbose)
 394                                 printf(_("%s failed.\n"), _(bdcms[j].help));
 395                         exit(EXIT_FAILURE);
 396                 }
 397
 398                 if (bdcms[j].argtype == ARG_NONE ||
 399                     (bdcms[j].flags & FL_NORESULT)) {
 400                         if (verbose)
 401                                 printf(_("%s succeeded.\n"), _(bdcms[j].help));
 402                         continue;
 403                 }
 404
 405                 if (verbose)
 406                         printf("%s: ", _(bdcms[j].help));
 407
 408                 switch (bdcms[j].argtype) {
 409                 case ARG_USHRT:
 410                         printf("%hu\n", huarg);
 411                         break;
 412                 case ARG_INT:
 413                         printf("%d\n", iarg);
 414                         break;
 415                 case ARG_UINT:
 416                         printf("%u\n", uarg);
 417                         break;
 418                 case ARG_LONG:
 419                         printf("%ld\n", larg);
 420                         break;
 421                 case ARG_LLONG:
 422                         printf("%lld\n", llarg);
 423                         break;
 424                 case ARG_ULONG:
 425                         printf("%lu\n", lu);
 426                         break;
 427                 case ARG_ULLONG:
 428                         printf("%llu\n", llu);
 429                         break;
 430                 }
 431         }
 432 }
 433
 434 static void report_all_devices(void)
 435 {
 436         FILE *procpt;
 437         char line[200];
 438         char ptname[200 + 1];
 439         char device[210];
 440         int ma, mi, sz;
 441
 442         procpt = fopen(_PATH_PROC_PARTITIONS, "r");
 443         if (!procpt)
 444                 err(EXIT_FAILURE, _("cannot open %s"), _PATH_PROC_PARTITIONS);
 445
 446         while (fgets(line, sizeof(line), procpt)) {
 447                 if (sscanf(line, " %d %d %d %200[^\n ]",
 448                            &ma, &mi, &sz, ptname) != 4)
 449                         continue;
 450
 451                 snprintf(device, sizeof(device), "/dev/%s", ptname);
 452                 report_device(device, 1);
 453         }
 454
 455         fclose(procpt);
 456 }
 457
 458 static void report_device(char *device, int quiet)
 459 {
 460         int fd;
 461         int ro, ssz, bsz;
 462         long ra;
 463         unsigned long long bytes;
 464         uint64_t start = 0;
 465         char start_str[16] = { "\0" };
 466         struct stat st;
 467
 468         fd = open(device, O_RDONLY | O_NONBLOCK);
 469         if (fd < 0) {
 470                 if (!quiet)
 471                         warn(_("cannot open %s"), device);
 472                 return;
 473         }
 474
 475         ro = ssz = bsz = 0;
 476         ra = 0;
 477         if (fstat(fd, &st) == 0) {
 478                 dev_t disk;
 479                 struct path_cxt *pc;
 480
 481                 pc = ul_new_sysfs_path(st.st_rdev, NULL, NULL);
 482                 if (pc &&
 483                     sysfs_blkdev_get_wholedisk(pc, NULL, 0, &disk) == 0 &&
 484                     disk != st.st_rdev) {
 485
 486                         if (ul_path_read_u64(pc, &start, "start") != 0)
 487                                 /* TRANSLATORS: Start sector not available. Max. 15 letters. */
 488                                 snprintf(start_str, sizeof(start_str), "%15s", _("N/A"));
 489                 }
 490                 ul_unref_path(pc);
 491         }
 492         if (!*start_str)
 493                 snprintf(start_str, sizeof(start_str), "%15ju", start);
 494
 495         if (ioctl(fd, BLKROGET, &ro) == 0 &&
 496             ioctl(fd, BLKRAGET, &ra) == 0 &&
 497             ioctl(fd, BLKSSZGET, &ssz) == 0 &&
 498             ioctl(fd, BLKBSZGET, &bsz) == 0 &&
 499             blkdev_get_size(fd, &bytes) == 0) {
 500                 printf("%s %5ld %5d %5d %s %15lld   %s\n",
 501                         ro ? "ro" : "rw", ra, ssz, bsz, start_str, bytes, device);
 502         } else {
 503                 if (!quiet)
 504                         warnx(_("ioctl error on %s"), device);
 505         }
 506
 507         close(fd);
 508 }
 509
 510 static void report_header(void)
 511 {
 512         printf(_("RO    RA   SSZ   BSZ        StartSec            Size   Device\n"));
 513 }