sys/boot/uboot/lib/disk.c

   1 /*-
   2  * Copyright (c) 2008 Semihalf, Rafal Jaworowski
   3  * Copyright (c) 2009 Semihalf, Piotr Ziecik
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  */
  28
  29 /*
  30  * Block storage I/O routines for U-Boot
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <sys/param.h>
  37 #include <sys/endian.h>
  38 #include <sys/queue.h>
  39 #include <netinet/in.h>
  40 #include <machine/stdarg.h>
  41 #include <stand.h>
  42 #include <uuid.h>
  43
  44 #define FSTYPENAMES
  45 #include <sys/disklabel.h>
  46 #include <sys/diskmbr.h>
  47 #include <sys/gpt.h>
  48
  49 #include "api_public.h"
  50 #include "bootstrap.h"
  51 #include "glue.h"
  52 #include "libuboot.h"
  53
  54 #define DEBUG
  55 #undef DEBUG
  56
  57 #define stor_printf(fmt, args...) do {                  \
  58     printf("%s%d: ", dev->d_dev->dv_name, dev->d_unit); \
  59     printf(fmt, ##args);                                \
  60 } while (0)
  61
  62 #ifdef DEBUG
  63 #define debugf(fmt, args...) do { printf("%s(): ", __func__);   \
  64     printf(fmt,##args); } while (0)
  65 #else
  66 #define debugf(fmt, args...)
  67 #endif
  68
  69 struct gpt_part {
  70         int             gp_index;
  71         uuid_t          gp_type;
  72         uint64_t        gp_start;
  73         uint64_t        gp_end;
  74 };
  75
  76 struct open_dev {
  77         int             od_bsize;       /* block size */
  78         int             od_bstart;      /* start block offset from beginning of disk */
  79         union {
  80                 struct {
  81                         struct disklabel bsdlabel;
  82                 } _bsd;
  83                 struct {
  84                         struct gpt_part *gpt_partitions;
  85                         int             gpt_nparts;
  86                 } _gpt;
  87         } _data;
  88 };
  89
  90 #define od_bsdlabel     _data._bsd.bsdlabel
  91 #define od_nparts       _data._gpt.gpt_nparts
  92 #define od_partitions   _data._gpt.gpt_partitions
  93
  94 static uuid_t efi = GPT_ENT_TYPE_EFI;
  95 static uuid_t freebsd_boot = GPT_ENT_TYPE_FREEBSD_BOOT;
  96 static uuid_t freebsd_ufs = GPT_ENT_TYPE_FREEBSD_UFS;
  97 static uuid_t freebsd_swap = GPT_ENT_TYPE_FREEBSD_SWAP;
  98 static uuid_t freebsd_zfs = GPT_ENT_TYPE_FREEBSD_ZFS;
  99 static uuid_t ms_basic_data = GPT_ENT_TYPE_MS_BASIC_DATA;
 100
 101 static int stor_info[UB_MAX_DEV];
 102 static int stor_info_no = 0;
 103 static int stor_opendev(struct open_dev **, struct uboot_devdesc *);
 104 static int stor_closedev(struct uboot_devdesc *);
 105 static int stor_readdev(struct uboot_devdesc *, daddr_t, size_t, char *);
 106 static int stor_open_count = 0;
 107
 108 /* devsw I/F */
 109 static int stor_init(void);
 110 static int stor_strategy(void *, int, daddr_t, size_t, char *, size_t *);
 111 static int stor_open(struct open_file *, ...);
 112 static int stor_close(struct open_file *);
 113 static void stor_print(int);
 114
 115 struct devsw uboot_storage = {
 116         "disk",
 117         DEVT_DISK,
 118         stor_init,
 119         stor_strategy,
 120         stor_open,
 121         stor_close,
 122         noioctl,
 123         stor_print
 124 };
 125
 126 static void
 127 uuid_letoh(uuid_t *uuid)
 128 {
 129
 130         uuid->time_low = le32toh(uuid->time_low);
 131         uuid->time_mid = le16toh(uuid->time_mid);
 132         uuid->time_hi_and_version = le16toh(uuid->time_hi_and_version);
 133 }
 134
 135 static int
 136 stor_init(void)
 137 {
 138         struct device_info *di;
 139         int i, found = 0;
 140
 141         if (devs_no == 0) {
 142                 printf("No U-Boot devices! Really enumerated?\n");
 143                 return (-1);
 144         }
 145
 146         for (i = 0; i < devs_no; i++) {
 147                 di = ub_dev_get(i);
 148                 if ((di != NULL) && (di->type & DEV_TYP_STOR)) {
 149                         if (stor_info_no >= UB_MAX_DEV) {
 150                                 printf("Too many storage devices: %d\n",
 151                                     stor_info_no);
 152                                 return (-1);
 153                         }
 154                         stor_info[stor_info_no++] = i;
 155                         found = 1;
 156                 }
 157         }
 158
 159         if (!found) {
 160                 printf("No storage devices\n");
 161                 return (-1);
 162         }
 163
 164         debugf("storage devices found: %d\n", stor_info_no);
 165         return (0);
 166 }
 167
 168 static int
 169 stor_strategy(void *devdata, int rw, daddr_t blk, size_t size, char *buf,
 170     size_t *rsize)
 171 {
 172         struct uboot_devdesc *dev = (struct uboot_devdesc *)devdata;
 173         struct open_dev *od = (struct open_dev *)dev->d_disk.data;
 174         int bcount, err;
 175
 176         debugf("od=%p, size=%d, bsize=%d\n", od, size, od->od_bsize);
 177
 178         if (rw != F_READ) {
 179                 stor_printf("write attempt, operation not supported!\n");
 180                 return (EROFS);
 181         }
 182
 183         if (size % od->od_bsize) {
 184                 stor_printf("size=%d not multiple of device block size=%d\n",
 185                     size, od->od_bsize);
 186                 return (EIO);
 187         }
 188         bcount = size / od->od_bsize;
 189
 190         if (rsize)
 191                 *rsize = 0;
 192
 193         err = stor_readdev(dev, blk + od->od_bstart, bcount, buf);
 194         if (!err && rsize)
 195                 *rsize = size;
 196
 197         return (err);
 198 }
 199
 200 static int
 201 stor_open(struct open_file *f, ...)
 202 {
 203         va_list ap;
 204         struct open_dev *od;
 205         struct uboot_devdesc *dev;
 206         int err;
 207
 208         va_start(ap, f);
 209         dev = va_arg(ap, struct uboot_devdesc *);
 210         va_end(ap);
 211
 212         if ((err = stor_opendev(&od, dev)) != 0)
 213                 return (err);
 214
 215         ((struct uboot_devdesc *)(f->f_devdata))->d_disk.data = od;
 216
 217         return (0);
 218 }
 219
 220 static int
 221 stor_close(struct open_file *f)
 222 {
 223         struct uboot_devdesc *dev;
 224
 225         dev = (struct uboot_devdesc *)(f->f_devdata);
 226
 227         return (stor_closedev(dev));
 228 }
 229
 230 static int
 231 stor_open_gpt(struct open_dev *od, struct uboot_devdesc *dev)
 232 {
 233         char *buf;
 234         struct dos_partition *dp;
 235         struct gpt_hdr *hdr;
 236         struct gpt_ent *ent;
 237         daddr_t slba, lba, elba;
 238         int eps, part, i;
 239         int err = 0;
 240
 241         od->od_nparts = 0;
 242         od->od_partitions = NULL;
 243
 244         /* Devices with block size smaller than 512 bytes cannot use GPT */
 245         if (od->od_bsize < 512)
 246                 return (ENXIO);
 247
 248         /* Allocate 1 block */
 249         buf = malloc(od->od_bsize);
 250         if (!buf) {
 251                 stor_printf("could not allocate memory for GPT\n");
 252                 return (ENOMEM);
 253         }
 254
 255         /* Read MBR */
 256         err = stor_readdev(dev, 0, 1, buf);
 257         if (err) {
 258                 stor_printf("GPT read error=%d\n", err);
 259                 err = EIO;
 260                 goto out;
 261         }
 262
 263         /* Check the slice table magic. */
 264         if (le16toh(*((uint16_t *)(buf + DOSMAGICOFFSET))) != DOSMAGIC) {
 265                 err = ENXIO;
 266                 goto out;
 267         }
 268
 269         /* Check GPT slice */
 270         dp = (struct dos_partition *)(buf + DOSPARTOFF);
 271         part = 0;
 272
 273         for (i = 0; i < NDOSPART; i++) {
 274                 if (dp[i].dp_typ == 0xee)
 275                         part += 1;
 276                 else if (dp[i].dp_typ != 0x00) {
 277                         err = EINVAL;
 278                         goto out;
 279                 }
 280         }
 281
 282         if (part != 1) {
 283                 err = EINVAL;
 284                 goto out;
 285         }
 286
 287         /* Read primary GPT header */
 288         err = stor_readdev(dev, 1, 1, buf);
 289         if (err) {
 290                 stor_printf("GPT read error=%d\n", err);
 291                 err = EIO;
 292                 goto out;
 293         }
 294
 295         hdr = (struct gpt_hdr *)buf;
 296
 297         /* Check GPT header */
 298         if (bcmp(hdr->hdr_sig, GPT_HDR_SIG, sizeof(hdr->hdr_sig)) != 0 ||
 299             le64toh(hdr->hdr_lba_self) != 1 ||
 300             le32toh(hdr->hdr_revision) < 0x00010000 ||
 301             le32toh(hdr->hdr_entsz) < sizeof(*ent) ||
 302             od->od_bsize % le32toh(hdr->hdr_entsz) != 0) {
 303                 debugf("Invalid GPT header!\n");
 304                 err = EINVAL;
 305                 goto out;
 306         }
 307
 308         /* Count number of valid partitions */
 309         part = 0;
 310         eps = od->od_bsize / le32toh(hdr->hdr_entsz);
 311         slba = le64toh(hdr->hdr_lba_table);
 312         elba = slba + le32toh(hdr->hdr_entries) / eps;
 313
 314         for (lba = slba; lba < elba; lba++) {
 315                 err = stor_readdev(dev, lba, 1, buf);
 316                 if (err) {
 317                         stor_printf("GPT read error=%d\n", err);
 318                         err = EIO;
 319                         goto out;
 320                 }
 321
 322                 ent = (struct gpt_ent *)buf;
 323
 324                 for (i = 0; i < eps; i++) {
 325                         if (uuid_is_nil(&ent[i].ent_type, NULL) ||
 326                             le64toh(ent[i].ent_lba_start) == 0 ||
 327                             le64toh(ent[i].ent_lba_end) <
 328                             le64toh(ent[i].ent_lba_start))
 329                                 continue;
 330
 331                         part += 1;
 332                 }
 333         }
 334
 335         /* Save information about partitions */
 336         if (part != 0) {
 337                 od->od_nparts = part;
 338                 od->od_partitions = malloc(part * sizeof(struct gpt_part));
 339                 if (!od->od_partitions) {
 340                         stor_printf("could not allocate memory for GPT\n");
 341                         err = ENOMEM;
 342                         goto out;
 343                 }
 344
 345                 part = 0;
 346                 for (lba = slba; lba < elba; lba++) {
 347                         err = stor_readdev(dev, lba, 1, buf);
 348                         if (err) {
 349                                 stor_printf("GPT read error=%d\n", err);
 350                                 err = EIO;
 351                                 goto out;
 352                         }
 353
 354                         ent = (struct gpt_ent *)buf;
 355
 356                         for (i = 0; i < eps; i++) {
 357                                 if (uuid_is_nil(&ent[i].ent_type, NULL) ||
 358                                     le64toh(ent[i].ent_lba_start) == 0 ||
 359                                     le64toh(ent[i].ent_lba_end) <
 360                                     le64toh(ent[i].ent_lba_start))
 361                                         continue;
 362
 363                                 od->od_partitions[part].gp_index = (lba - slba)
 364                                     * eps + i + 1;
 365                                 od->od_partitions[part].gp_type =
 366                                     ent[i].ent_type;
 367                                 od->od_partitions[part].gp_start =
 368                                     le64toh(ent[i].ent_lba_start);
 369                                 od->od_partitions[part].gp_end =
 370                                     le64toh(ent[i].ent_lba_end);
 371
 372                                 uuid_letoh(&od->od_partitions[part].gp_type);
 373                                 part += 1;
 374                         }
 375                 }
 376         }
 377
 378         dev->d_disk.ptype = PTYPE_GPT;
 379
 380         for (i = 0; i < od->od_nparts; i++)
 381                 if (od->od_partitions[i].gp_index == dev->d_disk.pnum)
 382                         od->od_bstart = od->od_partitions[i].gp_start;
 383
 384 out:
 385         if (err && od->od_partitions)
 386                 free(od->od_partitions);
 387
 388         free(buf);
 389         return (err);
 390 }
 391
 392 static int
 393 stor_open_bsdlabel(struct open_dev *od, struct uboot_devdesc *dev)
 394 {
 395         char *buf;
 396         struct disklabel *dl;
 397         int err = 0;
 398
 399         /* Allocate 1 block */
 400         buf = malloc(od->od_bsize);
 401         if (!buf) {
 402                 stor_printf("could not allocate memory for disklabel\n");
 403                 return (ENOMEM);
 404         }
 405
 406         /* Read disklabel */
 407         err = stor_readdev(dev, LABELSECTOR, 1, buf);
 408         if (err) {
 409                 stor_printf("disklabel read error=%d\n", err);
 410                 err = ERDLAB;
 411                 goto out;
 412         }
 413         bcopy(buf + LABELOFFSET, &od->od_bsdlabel, sizeof(struct disklabel));
 414         dl = &od->od_bsdlabel;
 415
 416         if (dl->d_magic != DISKMAGIC) {
 417                 stor_printf("no disklabel magic!\n");
 418                 err = EUNLAB;
 419                 goto out;
 420         }
 421
 422         od->od_bstart = dl->d_partitions[dev->d_disk.pnum].p_offset;
 423         dev->d_disk.ptype = PTYPE_BSDLABEL;
 424
 425         debugf("bstart=%d\n", od->od_bstart);
 426
 427 out:
 428         free(buf);
 429         return (err);
 430 }
 431
 432 static int
 433 stor_readdev(struct uboot_devdesc *dev, daddr_t blk, size_t size, char *buf)
 434 {
 435         lbasize_t real_size;
 436         int err, handle;
 437
 438         debugf("reading size=%d @ 0x%08x\n", size, (uint32_t)buf);
 439
 440         handle = stor_info[dev->d_unit];
 441         err = ub_dev_read(handle, buf, size, blk, &real_size);
 442         if (err != 0) {
 443                 stor_printf("read failed, error=%d\n", err);
 444                 return (EIO);
 445         }
 446
 447         if (real_size != size) {
 448                 stor_printf("real size != size\n");
 449                 err = EIO;
 450         }
 451
 452         return (err);
 453 }
 454
 455
 456 static int
 457 stor_opendev(struct open_dev **odp, struct uboot_devdesc *dev)
 458 {
 459         struct device_info *di;
 460         struct open_dev *od;
 461         int err, h;
 462
 463         h = stor_info[dev->d_unit];
 464
 465         debugf("refcount=%d\n", stor_open_count);
 466
 467         /*
 468          * There can be recursive open calls from the infrastructure, but at
 469          * U-Boot level open the device only the first time.
 470          */
 471         if (stor_open_count > 0)
 472                 stor_open_count++;
 473         else if ((err = ub_dev_open(h)) != 0) {
 474                 stor_printf("device open failed with error=%d, handle=%d\n",
 475                     err, h);
 476                 *odp = NULL;
 477                 return (ENXIO);
 478         }
 479
 480         if ((di = ub_dev_get(h)) == NULL)
 481                 panic("could not retrieve U-Boot device_info, handle=%d", h);
 482
 483         if ((od = malloc(sizeof(struct open_dev))) == NULL) {
 484                 stor_printf("could not allocate memory for open_dev\n");
 485                 return (ENOMEM);
 486         }
 487         od->od_bsize = di->di_stor.block_size;
 488         od->od_bstart = 0;
 489
 490         if ((err = stor_open_gpt(od, dev)) != 0)
 491                 err = stor_open_bsdlabel(od, dev);
 492
 493         if (err != 0)
 494                 free(od);
 495         else {
 496                 stor_open_count = 1;
 497                 *odp = od;
 498         }
 499
 500         return (err);
 501 }
 502
 503 static int
 504 stor_closedev(struct uboot_devdesc *dev)
 505 {
 506         struct open_dev *od;
 507         int err, h;
 508
 509         od = (struct open_dev *)dev->d_disk.data;
 510         if (dev->d_disk.ptype == PTYPE_GPT && od->od_nparts != 0)
 511                 free(od->od_partitions);
 512
 513         free(od);
 514         dev->d_disk.data = NULL;
 515
 516         if (--stor_open_count == 0) {
 517                 h = stor_info[dev->d_unit];
 518                 if ((err = ub_dev_close(h)) != 0) {
 519                         stor_printf("device close failed with error=%d, "
 520                             "handle=%d\n", err, h);
 521                         return (ENXIO);
 522                 }
 523         }
 524
 525         return (0);
 526 }
 527
 528 /* Given a size in 512 byte sectors, convert it to a human-readable number. */
 529 /* XXX stolen from sys/boot/i386/libi386/biosdisk.c, should really be shared */
 530 static char *
 531 display_size(uint64_t size)
 532 {
 533         static char buf[80];
 534         char unit;
 535
 536         size /= 2;
 537         unit = 'K';
 538         if (size >= 10485760000LL) {
 539                 size /= 1073741824;
 540                 unit = 'T';
 541         } else if (size >= 10240000) {
 542                 size /= 1048576;
 543                 unit = 'G';
 544         } else if (size >= 10000) {
 545                 size /= 1024;
 546                 unit = 'M';
 547         }
 548         sprintf(buf, "%.6ld%cB", (long)size, unit);
 549         return (buf);
 550 }
 551
 552 static void
 553 stor_print_bsdlabel(struct uboot_devdesc *dev, char *prefix, int verbose)
 554 {
 555         char buf[512], line[80];
 556         struct disklabel *dl;
 557         uint32_t off, size;
 558         int err, i, t;
 559
 560         /* Read disklabel */
 561         err = stor_readdev(dev, LABELSECTOR, 1, buf);
 562         if (err) {
 563                 sprintf(line, "%s%d: disklabel read error=%d\n",
 564                     dev->d_dev->dv_name, dev->d_unit, err);
 565                 pager_output(line);
 566                 return;
 567         }
 568         dl = (struct disklabel *)buf;
 569
 570         if (dl->d_magic != DISKMAGIC) {
 571                 sprintf(line, "%s%d: no disklabel magic!\n",
 572                     dev->d_dev->dv_name, dev->d_unit);
 573                 pager_output(line);
 574                 return;
 575         }
 576
 577         /* Print partitions info */
 578         for (i = 0; i < dl->d_npartitions; i++) {
 579                 if ((t = dl->d_partitions[i].p_fstype) < FSMAXTYPES) {
 580
 581                         off = dl->d_partitions[i].p_offset;
 582                         size = dl->d_partitions[i].p_size;
 583                         if (fstypenames[t] == NULL || size == 0)
 584                                 continue;
 585
 586                         if ((('a' + i) == 'c') && (!verbose))
 587                                 continue;
 588
 589                         sprintf(line, "  %s%c: %s %s (%d - %d)\n", prefix,
 590                             'a' + i, fstypenames[t], display_size(size),
 591                             off, off + size);
 592
 593                         pager_output(line);
 594                 }
 595         }
 596 }
 597
 598 static void
 599 stor_print_gpt(struct uboot_devdesc *dev, char *prefix, int verbose)
 600 {
 601         struct open_dev *od = (struct open_dev *)dev->d_disk.data;
 602         struct gpt_part *gp;
 603         char line[80];
 604         char *fs;
 605         int i;
 606
 607         for (i = 0; i < od->od_nparts; i++) {
 608                 gp = &od->od_partitions[i];
 609
 610                 if (uuid_equal(&gp->gp_type, &efi, NULL))
 611                         fs = "EFI";
 612                 else if (uuid_equal(&gp->gp_type, &ms_basic_data, NULL))
 613                         fs = "FAT/NTFS";
 614                 else if (uuid_equal(&gp->gp_type, &freebsd_boot, NULL))
 615                         fs = "FreeBSD Boot";
 616                 else if (uuid_equal(&gp->gp_type, &freebsd_ufs, NULL))
 617                         fs = "FreeBSD UFS";
 618                 else if (uuid_equal(&gp->gp_type, &freebsd_swap, NULL))
 619                         fs = "FreeBSD Swap";
 620                 else if (uuid_equal(&gp->gp_type, &freebsd_zfs, NULL))
 621                         fs = "FreeBSD ZFS";
 622                 else
 623                         fs = "unknown";
 624
 625                 sprintf(line, "  %sp%u: %s %s (%lld - %lld)\n", prefix,
 626                     gp->gp_index, fs,
 627                     display_size(gp->gp_end + 1 - gp->gp_start), gp->gp_start,
 628                     gp->gp_end);
 629
 630                 pager_output(line);
 631         }
 632 }
 633
 634 static void
 635 stor_print_one(int i, struct device_info *di, int verbose)
 636 {
 637         struct uboot_devdesc dev;
 638         struct open_dev *od;
 639         char line[80];
 640
 641         sprintf(line, "\tdisk%d (%s)\n", i, ub_stor_type(di->type));
 642         pager_output(line);
 643
 644         dev.d_dev = &uboot_storage;
 645         dev.d_unit = i;
 646         dev.d_disk.pnum = -1;
 647         dev.d_disk.data = NULL;
 648
 649         if (stor_opendev(&od, &dev) == 0) {
 650                 dev.d_disk.data = od;
 651
 652                 if (dev.d_disk.ptype == PTYPE_GPT) {
 653                         sprintf(line, "\t\tdisk%d", i);
 654                         stor_print_gpt(&dev, line, verbose);
 655                 } else if (dev.d_disk.ptype == PTYPE_BSDLABEL) {
 656                         sprintf(line, "\t\tdisk%d", i);
 657                         stor_print_bsdlabel(&dev, line, verbose);
 658                 }
 659
 660                 stor_closedev(&dev);
 661         }
 662 }
 663
 664 static void
 665 stor_print(int verbose)
 666 {
 667         struct device_info *di;
 668         int i;
 669
 670         for (i = 0; i < stor_info_no; i++) {
 671                 di = ub_dev_get(stor_info[i]);
 672                 if (di != NULL)
 673                         stor_print_one(i, di, verbose);
 674         }
 675 }