kernel/krtld/bootrd_cpio.c

   1 /*
   2  * Copyright 2011-2018 Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <sys/types.h>
  18 #include <sys/sysmacros.h>
  19 #include <sys/bootvfs.h>
  20 #include <sys/filep.h>
  21 #include <sys/sunddi.h>
  22 #include <sys/ccompile.h>
  23
  24 /*
  25  * A cpio archive is just a sequence of files, each consisting of a header
  26  * (struct cpio_hdr) and the file contents.
  27  */
  28
  29 struct cpio_hdr {
  30         uint8_t         magic[6];
  31         uint8_t         dev[6];
  32         uint8_t         ino[6];
  33         uint8_t         mode[6];
  34         uint8_t         uid[6];
  35         uint8_t         gid[6];
  36         uint8_t         nlink[6];
  37         uint8_t         rdev[6];
  38         uint8_t         mtime[11];
  39         uint8_t         namesize[6];
  40         uint8_t         filesize[11];
  41         char            data[];
  42 };
  43
  44 /*
  45  * This structure represents an open file.  The list of all open files is
  46  * rooted in the open_files global.
  47  */
  48 struct cpio_file {
  49         /* pointers into the archive */
  50         const struct cpio_hdr *hdr;
  51         const char *path;               /* pointer into the archive */
  52         const void *data;               /* pointer into the archive */
  53
  54         int fd;
  55         off_t off;
  56         struct bootstat stat;
  57
  58         struct cpio_file *next;
  59         struct cpio_file *prev;
  60 };
  61
  62 extern void *bkmem_alloc(size_t);
  63 extern void bkmem_free(void *, size_t);
  64
  65 static void cpio_closeall(int flag);
  66
  67 static bool mounted;
  68 static struct cpio_file *open_files;
  69
  70 static int
  71 cpio_strcmp(const char *a, const char *b)
  72 {
  73         while ((*a != '\0') && (*b != '\0') && (*a == *b)) {
  74                 a++;
  75                 b++;
  76         }
  77
  78         if (*a == *b)
  79                 return 0;
  80         if (*a < *b)
  81                 return -1;
  82         return 1;
  83 }
  84
  85 /*
  86  * Returns the parsed number on success, or UINT64_MAX on error.  This is
  87  * ok because we will never deal with numbers that large in a cpio archive.
  88  */
  89 static uint64_t
  90 __get_uint64(const uint8_t *str, size_t len, const size_t output_size)
  91 {
  92         uint64_t v;
  93
  94         /* check that we can represent every number */
  95         if (len * 3 > output_size)
  96                 return UINT64_MAX;
  97
  98         for (v = 0; len > 0; len--, str++) {
  99                 const uint8_t c = *str;
 100
 101                 if ((c < '0') || (c > '7'))
 102                         return UINT64_MAX;
 103
 104                 v = (v * 8) + (c - '0');
 105         }
 106
 107         return v;
 108 }
 109
 110 static bool
 111 get_uint64(const uint8_t *str, size_t len, uint64_t *out)
 112 {
 113         *out = __get_uint64(str, len, NBBY * sizeof(*out));
 114         return *out != UINT64_MAX;
 115 }
 116
 117 static bool
 118 get_int64(const uint8_t *str, size_t len, int64_t *out)
 119 {
 120         uint64_t tmp;
 121
 122         tmp = __get_uint64(str, len, NBBY * sizeof(*out) - 1);
 123
 124         *out = tmp;
 125
 126         return tmp != UINT64_MAX;
 127 }
 128
 129 static bool
 130 get_uint32(const uint8_t *str, size_t len, uint32_t *out)
 131 {
 132         uint64_t tmp;
 133
 134         tmp = __get_uint64(str, len, NBBY * sizeof(*out));
 135
 136         *out = tmp;
 137
 138         return tmp != UINT64_MAX;
 139 }
 140
 141 static bool
 142 get_int32(const uint8_t *str, size_t len, int32_t *out)
 143 {
 144         uint64_t tmp;
 145
 146         tmp = __get_uint64(str, len, NBBY * sizeof(*out) - 1);
 147
 148         *out = tmp;
 149
 150         return tmp != UINT64_MAX;
 151 }
 152
 153 static void
 154 add_open_file(struct cpio_file *file)
 155 {
 156         file->next = open_files;
 157         file->prev = NULL;
 158         open_files = file;
 159 }
 160
 161 static void
 162 remove_open_file(struct cpio_file *file)
 163 {
 164         if (file == open_files)
 165                 open_files = file->next;
 166         else
 167                 file->prev->next = file->next;
 168
 169         if (file->next != NULL)
 170                 file->next->prev = file->prev;
 171 }
 172
 173 static struct cpio_file *
 174 find_open_file(int fd)
 175 {
 176         struct cpio_file *file;
 177
 178         if (fd < 0)
 179                 return NULL;
 180
 181         for (file = open_files; file != NULL; file = file->next)
 182                 if (file->fd == fd)
 183                         return file;
 184
 185         return NULL;
 186 }
 187
 188 static const void *
 189 read_ramdisk(size_t off, size_t len)
 190 {
 191         const size_t first_block_offset = off % DEV_BSIZE;
 192         fileid_t tmpfile;
 193
 194         /* return a dummy non-NULL pointer */
 195         if (len == 0)
 196                 return "";
 197
 198         /* we have to read the stuff before the desired location as well */
 199         len += first_block_offset;
 200
 201         tmpfile.fi_blocknum = off / DEV_BSIZE;
 202         tmpfile.fi_count = P2ROUNDUP_TYPED(len, DEV_BSIZE, size_t);
 203         tmpfile.fi_memp = NULL;
 204
 205         if (diskread(&tmpfile) != 0)
 206                 return NULL;
 207
 208         return tmpfile.fi_memp + first_block_offset;
 209 }
 210
 211 static bool
 212 parse_stat(const struct cpio_hdr *hdr, struct bootstat *stat)
 213 {
 214         if (!get_uint64(hdr->dev, sizeof(hdr->dev), &stat->st_dev))
 215                 return false;
 216         if (!get_uint64(hdr->ino, sizeof(hdr->ino), &stat->st_ino))
 217                 return false;
 218         if (!get_uint32(hdr->mode, sizeof(hdr->mode), &stat->st_mode))
 219                 return false;
 220         if (!get_int32(hdr->uid, sizeof(hdr->uid), &stat->st_uid))
 221                 return false;
 222         if (!get_int32(hdr->gid, sizeof(hdr->gid), &stat->st_gid))
 223                 return false;
 224         if (!get_uint32(hdr->nlink, sizeof(hdr->nlink), &stat->st_nlink))
 225                 return false;
 226         if (!get_uint64(hdr->rdev, sizeof(hdr->rdev), &stat->st_rdev))
 227                 return false;
 228
 229         stat->st_mtim.tv_nsec = 0;
 230         if (!get_int64(hdr->mtime, sizeof(hdr->mtime), &stat->st_mtim.tv_sec))
 231                 return false;
 232
 233         stat->st_atim = stat->st_mtim;
 234         stat->st_ctim = stat->st_mtim;
 235
 236         if (!get_uint64(hdr->filesize, sizeof(hdr->filesize), &stat->st_size))
 237                 return false;
 238
 239         stat->st_blksize = DEV_BSIZE;
 240         stat->st_blocks = P2ROUNDUP(stat->st_size, DEV_BSIZE);
 241
 242         return true;
 243 }
 244
 245 /*
 246  * Check if specified header is for a file with a specific path.  If so,
 247  * fill in the file struct and return 0.  If not, return number of bytes to
 248  * skip over to get to the next header.  If an error occurs, -1 is returned.
 249  * If end of archive is reached, return -2 instead.
 250  */
 251 static ssize_t
 252 scan_archive_hdr(const struct cpio_hdr *hdr, size_t off,
 253                  struct cpio_file *file, const char *wanted_path)
 254 {
 255         struct bootstat stat;
 256         uint32_t namesize;
 257         uint64_t filesize;
 258         const char *path;
 259         const void *data;
 260
 261         if ((hdr->magic[0] != '0') || (hdr->magic[1] != '7') ||
 262             (hdr->magic[2] != '0') || (hdr->magic[3] != '7') ||
 263             (hdr->magic[4] != '0') || (hdr->magic[5] != '7'))
 264                 return -1;
 265
 266         if (!get_uint32(hdr->namesize, sizeof(hdr->namesize), &namesize))
 267                 return -1;
 268         if (!get_uint64(hdr->filesize, sizeof(hdr->filesize), &filesize))
 269                 return -1;
 270
 271         /*
 272          * We have the two sizes, let's try to read the name and file
 273          * contents to make sure they are part of the ramdisk.
 274          */
 275
 276         off += offsetof(struct cpio_hdr, data[0]);
 277         path = read_ramdisk(off, namesize);
 278         data = read_ramdisk(off + namesize, filesize);
 279
 280         /* either read failing is fatal */
 281         if (path == NULL || data == NULL)
 282                 return -1;
 283
 284         if (cpio_strcmp(path, "TRAILER!!!") == 0)
 285                 return -2;
 286
 287         if (cpio_strcmp(path, wanted_path) != 0)
 288                 return offsetof(struct cpio_hdr, data[namesize + filesize]);
 289
 290         /*
 291          * This is the file we want!
 292          */
 293
 294         if (!parse_stat(hdr, &stat))
 295                 return -1;
 296
 297         file->hdr = hdr;
 298         file->path = path;
 299         file->data = data;
 300         file->stat = stat;
 301
 302         return 0;
 303 }
 304
 305 static int
 306 find_filename(char *path, struct cpio_file *file)
 307 {
 308         size_t off;
 309
 310         /*
 311          * The paths in the cpio boot archive omit the leading '/'.  So,
 312          * skip checking for it.  If the searched for path does not include
 313          * the leading path (it's a relative path), fail the lookup.
 314          */
 315         if (path[0] != '/')
 316                 return -1;
 317
 318         path++;
 319
 320         /* now scan the archive for the relevant file */
 321
 322         off = 0;
 323
 324         for (;;) {
 325                 const struct cpio_hdr *hdr;
 326                 ssize_t size;
 327
 328                 hdr = read_ramdisk(off, sizeof(struct cpio_hdr));
 329                 if (hdr == NULL)
 330                         return -1;
 331
 332                 size = scan_archive_hdr(hdr, off, file, path);
 333                 if (size <= 0)
 334                         return size;
 335
 336                 off += size;
 337         }
 338 }
 339
 340 static int
 341 bcpio_mountroot(char *str)
 342 {
 343         if (mounted)
 344                 return -1;
 345
 346         mounted = true;
 347
 348         return 0;
 349 }
 350
 351 static int
 352 bcpio_unmountroot(void)
 353 {
 354         if (!mounted)
 355                 return -1;
 356
 357         mounted = false;
 358
 359         return 0;
 360 }
 361
 362 static int
 363 bcpio_open(char *path, int flags)
 364 {
 365         static int filedes = 1;
 366         struct cpio_file temp_file;
 367         struct cpio_file *file;
 368
 369         if (find_filename(path, &temp_file) != 0)
 370                 return -1;
 371
 372         file = bkmem_alloc(sizeof(struct cpio_file));
 373         file->hdr = temp_file.hdr;
 374         file->path = temp_file.path;
 375         file->data = temp_file.data;
 376         file->stat = temp_file.stat;
 377         file->fd = filedes++;
 378         file->off = 0;
 379
 380         add_open_file(file);
 381
 382         return file->fd;
 383 }
 384
 385 static int
 386 bcpio_close(int fd)
 387 {
 388         struct cpio_file *file;
 389
 390         file = find_open_file(fd);
 391         if (file == NULL)
 392                 return -1;
 393
 394         remove_open_file(file);
 395
 396         bkmem_free(file, sizeof(struct cpio_file));
 397
 398         return 0;
 399 }
 400
 401 static void
 402 bcpio_closeall(int flag)
 403 {
 404         struct cpio_file *file, *next;
 405
 406         file = open_files;
 407
 408         while (file != NULL) {
 409                 int fd = file->fd;
 410
 411                 next = file->next;
 412
 413                 if (bcpio_close(fd) != 0)
 414                         printf("closeall invoked close(%d) failed\n", fd);
 415
 416                 file = next;
 417         }
 418 }
 419
 420 static ssize_t
 421 bcpio_read(int fd, caddr_t buf, size_t size)
 422 {
 423         struct cpio_file *file;
 424
 425         file = find_open_file(fd);
 426         if (file == NULL)
 427                 return -1;
 428
 429         if (size == 0)
 430                 return 0;
 431
 432         if (file->off + size > file->stat.st_size)
 433                 size = file->stat.st_size - file->off;
 434
 435         bcopy(file->data + file->off, buf, size);
 436
 437         file->off += size;
 438
 439         return size;
 440 }
 441
 442 static off_t
 443 bcpio_lseek(int fd, off_t addr, int whence)
 444 {
 445         struct cpio_file *file;
 446
 447         file = find_open_file(fd);
 448         if (file == NULL)
 449                 return -1;
 450
 451         switch (whence) {
 452                 case SEEK_CUR:
 453                         file->off += addr;
 454                         break;
 455                 case SEEK_SET:
 456                         file->off = addr;
 457                         break;
 458                 case SEEK_END:
 459                         file->off = file->stat.st_size;
 460                         break;
 461                 default:
 462                         printf("lseek(): invalid whence value %d\n", whence);
 463                         return -1;
 464         }
 465
 466         return 0;
 467 }
 468
 469 static int
 470 bcpio_fstat(int fd, struct bootstat *buf)
 471 {
 472         const struct cpio_file *file;
 473
 474         file = find_open_file(fd);
 475         if (file == NULL)
 476                 return -1;
 477
 478         *buf = file->stat;
 479
 480         return 0;
 481 }
 482
 483 struct boot_fs_ops bcpio_ops = {
 484         .fsw_name               = "boot_cpio",
 485         .fsw_mountroot          = bcpio_mountroot,
 486         .fsw_unmountroot        = bcpio_unmountroot,
 487         .fsw_open               = bcpio_open,
 488         .fsw_close              = bcpio_close,
 489         .fsw_closeall           = bcpio_closeall,
 490         .fsw_read               = bcpio_read,
 491         .fsw_lseek              = bcpio_lseek,
 492         .fsw_fstat              = bcpio_fstat,
 493 };