sys/fs/tarfs/tarfs_subr.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2013 Juniper Networks, Inc.
   5  * Copyright (c) 2022-2023 Klara, Inc.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include "opt_tarfs.h"
  30
  31 #include <sys/param.h>
  32 #include <sys/stat.h>
  33 #include <sys/systm.h>
  34 #include <sys/buf.h>
  35 #include <sys/fcntl.h>
  36 #include <sys/libkern.h>
  37 #include <sys/lock.h>
  38 #include <sys/malloc.h>
  39 #include <sys/mount.h>
  40 #include <sys/namei.h>
  41 #include <sys/proc.h>
  42 #include <sys/queue.h>
  43 #include <sys/sysctl.h>
  44 #include <sys/vnode.h>
  45
  46 #include <vm/vm_param.h>
  47
  48 #include <fs/tarfs/tarfs.h>
  49 #include <fs/tarfs/tarfs_dbg.h>
  50
  51 MALLOC_DEFINE(M_TARFSNAME, "tarfs name", "tarfs file names");
  52 MALLOC_DEFINE(M_TARFSBLK, "tarfs blk", "tarfs block maps");
  53
  54 SYSCTL_NODE(_vfs, OID_AUTO, tarfs, CTLFLAG_RW, 0, "Tar filesystem");
  55
  56 unsigned int tarfs_ioshift = TARFS_IOSHIFT_DEFAULT;
  57
  58 static int
  59 tarfs_sysctl_handle_ioshift(SYSCTL_HANDLER_ARGS)
  60 {
  61         unsigned int tmp;
  62         int error;
  63
  64         tmp = *(unsigned int *)arg1;
  65         if ((error = SYSCTL_OUT(req, &tmp, sizeof(tmp))) != 0)
  66                 return (error);
  67         if (req->newptr != NULL) {
  68                 if ((error = SYSCTL_IN(req, &tmp, sizeof(tmp))) != 0)
  69                         return (error);
  70                 if (tmp == 0)
  71                         tmp = TARFS_IOSHIFT_DEFAULT;
  72                 if (tmp < TARFS_IOSHIFT_MIN)
  73                         tmp = TARFS_IOSHIFT_MIN;
  74                 if (tmp > TARFS_IOSHIFT_MAX)
  75                         tmp = TARFS_IOSHIFT_MAX;
  76                 *(unsigned int *)arg1 = tmp;
  77         }
  78         return (0);
  79 }
  80
  81 SYSCTL_PROC(_vfs_tarfs, OID_AUTO, ioshift,
  82     CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RW | CTLFLAG_TUN,
  83     &tarfs_ioshift, 0, tarfs_sysctl_handle_ioshift, "IU",
  84     "Tar filesystem preferred I/O size (log 2)");
  85
  86 #ifdef TARFS_DEBUG
  87 int tarfs_debug;
  88 SYSCTL_INT(_vfs_tarfs, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN,
  89     &tarfs_debug, 0, "Tar filesystem debug mask");
  90 #endif  /* TARFS_DEBUG */
  91
  92 struct tarfs_node *
  93 tarfs_lookup_node(struct tarfs_node *tnp, struct tarfs_node *f,
  94     struct componentname *cnp)
  95 {
  96         boolean_t found;
  97         struct tarfs_node *entry;
  98
  99         TARFS_DPF(LOOKUP, "%s: name: %.*s\n", __func__, (int)cnp->cn_namelen,
 100             cnp->cn_nameptr);
 101
 102         found = false;
 103         TAILQ_FOREACH(entry, &tnp->dir.dirhead, dirents) {
 104                 if (f != NULL && entry != f)
 105                         continue;
 106
 107                 if (entry->namelen == cnp->cn_namelen &&
 108                     bcmp(entry->name, cnp->cn_nameptr,
 109                     entry->namelen) == 0) {
 110                         found = 1;
 111                         break;
 112                 }
 113         }
 114
 115         if (found) {
 116                 if (entry->type == VREG && entry->other != NULL) {
 117                         TARFS_DPF_IFF(LOOKUP, "%s: following hard link %p\n",
 118                             __func__, entry);
 119                         entry = entry->other;
 120                 }
 121                 TARFS_DPF(LOOKUP, "%s: found tarfs_node %p\n", __func__,
 122                     entry);
 123                 return (entry);
 124         }
 125
 126         TARFS_DPF(LOOKUP, "%s: no match found\n", __func__);
 127         return (NULL);
 128 }
 129
 130 struct tarfs_node *
 131 tarfs_lookup_dir(struct tarfs_node *tnp, off_t cookie)
 132 {
 133         struct tarfs_node *current;
 134
 135         TARFS_DPF(LOOKUP, "%s: tarfs_node %p, cookie %jd\n", __func__, tnp,
 136             cookie);
 137         TARFS_DPF(LOOKUP, "%s: name: %s\n", __func__,
 138             (tnp->name == NULL) ? "<<root>>" : tnp->name);
 139
 140         if (cookie == tnp->dir.lastcookie &&
 141             tnp->dir.lastnode != NULL) {
 142                 TARFS_DPF(LOOKUP, "%s: Using cached entry: tarfs_node %p, "
 143                     "cookie %jd\n", __func__, tnp->dir.lastnode,
 144                     tnp->dir.lastcookie);
 145                 return (tnp->dir.lastnode);
 146         }
 147
 148         TAILQ_FOREACH(current, &tnp->dir.dirhead, dirents) {
 149                 TARFS_DPF(LOOKUP, "%s: tarfs_node %p, current %p, ino %lu\n",
 150                     __func__, tnp, current, current->ino);
 151                 TARFS_DPF_IFF(LOOKUP, current->name != NULL,
 152                     "%s: name: %s\n", __func__, current->name);
 153                 if (current->ino == cookie) {
 154                         TARFS_DPF(LOOKUP, "%s: Found entry: tarfs_node %p, "
 155                             "cookie %lu\n", __func__, current,
 156                             current->ino);
 157                         break;
 158                 }
 159         }
 160
 161         return (current);
 162 }
 163
 164 int
 165 tarfs_alloc_node(struct tarfs_mount *tmp, const char *name, size_t namelen,
 166     enum vtype type, off_t off, size_t sz, time_t mtime, uid_t uid, gid_t gid,
 167     mode_t mode, unsigned int flags, const char *linkname, dev_t rdev,
 168     struct tarfs_node *parent, struct tarfs_node **retnode)
 169 {
 170         struct tarfs_node *tnp;
 171
 172         TARFS_DPF(ALLOC, "%s(%.*s)\n", __func__, (int)namelen, name);
 173
 174         if (parent != NULL && parent->type != VDIR)
 175                 return (ENOTDIR);
 176         tnp = malloc(sizeof(struct tarfs_node), M_TARFSNODE, M_WAITOK | M_ZERO);
 177         mtx_init(&tnp->lock, "tarfs node lock", NULL, MTX_DEF);
 178         tnp->gen = arc4random();
 179         tnp->tmp = tmp;
 180         if (namelen > 0) {
 181                 tnp->name = malloc(namelen + 1, M_TARFSNAME, M_WAITOK);
 182                 tnp->namelen = namelen;
 183                 memcpy(tnp->name, name, namelen);
 184                 tnp->name[namelen] = '\0';
 185         }
 186         tnp->type = type;
 187         tnp->uid = uid;
 188         tnp->gid = gid;
 189         tnp->mode = mode;
 190         tnp->nlink = 1;
 191         vfs_timestamp(&tnp->atime);
 192         tnp->mtime.tv_sec = mtime;
 193         tnp->birthtime = tnp->atime;
 194         tnp->ctime = tnp->mtime;
 195         if (parent != NULL) {
 196                 tnp->ino = alloc_unr(tmp->ino_unr);
 197         }
 198         tnp->offset = off;
 199         tnp->size = tnp->physize = sz;
 200         switch (type) {
 201         case VDIR:
 202                 MPASS(parent != tnp);
 203                 MPASS(parent != NULL || tmp->root == NULL);
 204                 TAILQ_INIT(&tnp->dir.dirhead);
 205                 tnp->nlink++;
 206                 if (parent == NULL) {
 207                         tnp->ino = TARFS_ROOTINO;
 208                 }
 209                 tnp->physize = 0;
 210                 break;
 211         case VLNK:
 212                 tnp->link.name = malloc(sz + 1, M_TARFSNAME,
 213                     M_WAITOK);
 214                 tnp->link.namelen = sz;
 215                 memcpy(tnp->link.name, linkname, sz);
 216                 tnp->link.name[sz] = '\0';
 217                 break;
 218         case VREG:
 219                 /* create dummy block map */
 220                 tnp->nblk = 1;
 221                 tnp->blk = malloc(sizeof(*tnp->blk), M_TARFSBLK, M_WAITOK);
 222                 tnp->blk[0].i = 0;
 223                 tnp->blk[0].o = 0;
 224                 tnp->blk[0].l = tnp->physize;
 225                 break;
 226         case VFIFO:
 227                 /* Nothing extra to do */
 228                 break;
 229         case VBLK:
 230         case VCHR:
 231                 tnp->rdev = rdev;
 232                 tnp->physize = 0;
 233                 break;
 234         default:
 235                 panic("%s: type %d not allowed", __func__, type);
 236         }
 237         if (parent != NULL) {
 238                 TARFS_NODE_LOCK(parent);
 239                 TAILQ_INSERT_TAIL(&parent->dir.dirhead, tnp, dirents);
 240                 parent->size += sizeof(struct tarfs_node);
 241                 tnp->parent = parent;
 242                 if (type == VDIR) {
 243                         parent->nlink++;
 244                 }
 245                 TARFS_NODE_UNLOCK(parent);
 246         } else {
 247                 tnp->parent = tnp;
 248         }
 249         MPASS(tnp->ino != 0);
 250
 251         TARFS_ALLNODES_LOCK(tmp);
 252         TAILQ_INSERT_TAIL(&tmp->allnodes, tnp, entries);
 253         TARFS_ALLNODES_UNLOCK(tmp);
 254
 255         *retnode = tnp;
 256         tmp->nfiles++;
 257         return (0);
 258 }
 259
 260 #define is09(ch) ((ch) >= '0' && (ch) <= '9')
 261
 262 int
 263 tarfs_load_blockmap(struct tarfs_node *tnp, size_t realsize)
 264 {
 265         struct tarfs_blk *blk = NULL;
 266         char *map = NULL;
 267         size_t nmap = 0, nblk = 0;
 268         char *p, *q;
 269         ssize_t res;
 270         unsigned int i;
 271         long n;
 272
 273         /*
 274          * Load the entire map into memory.  We don't know how big it is,
 275          * but as soon as we start reading it we will know how many
 276          * entries it contains, and then we can count newlines.
 277          */
 278         do {
 279                 nmap++;
 280                 if (tnp->size < nmap * TARFS_BLOCKSIZE) {
 281                         TARFS_DPF(MAP, "%s: map too large\n", __func__);
 282                         goto bad;
 283                 }
 284                 /* grow the map */
 285                 map = realloc(map, nmap * TARFS_BLOCKSIZE + 1, M_TARFSBLK,
 286                     M_ZERO | M_WAITOK);
 287                 /* read an additional block */
 288                 res = tarfs_io_read_buf(tnp->tmp, false,
 289                     map + (nmap - 1) * TARFS_BLOCKSIZE,
 290                     tnp->offset + (nmap - 1) * TARFS_BLOCKSIZE,
 291                     TARFS_BLOCKSIZE);
 292                 if (res < 0)
 293                         return (-res);
 294                 else if (res < TARFS_BLOCKSIZE)
 295                         return (EIO);
 296                 map[nmap * TARFS_BLOCKSIZE] = '\0'; /* sentinel */
 297                 if (nblk == 0) {
 298                         n = strtol(p = map, &q, 10);
 299                         if (q == p || *q != '\n' || n < 1)
 300                                 goto syntax;
 301                         nblk = n;
 302                 }
 303                 for (n = 0, p = map; *p != '\0'; ++p) {
 304                         if (*p == '\n') {
 305                                 ++n;
 306                         }
 307                 }
 308                 TARFS_DPF(MAP, "%s: %ld newlines in map\n", __func__, n);
 309         } while (n < nblk * 2 + 1);
 310         TARFS_DPF(MAP, "%s: block map length %zu\n", __func__, nblk);
 311         blk = malloc(sizeof(*blk) * nblk, M_TARFSBLK, M_WAITOK | M_ZERO);
 312         p = strchr(map, '\n') + 1;
 313         for (i = 0; i < nblk; i++) {
 314                 if (i == 0)
 315                         blk[i].i = nmap * TARFS_BLOCKSIZE;
 316                 else
 317                         blk[i].i = blk[i - 1].i + blk[i - 1].l;
 318                 n = strtol(p, &q, 10);
 319                 if (q == p || *q != '\n' || n < 0)
 320                         goto syntax;
 321                 p = q + 1;
 322                 blk[i].o = n;
 323                 n = strtol(p, &q, 10);
 324                 if (q == p || *q != '\n' || n < 0)
 325                         goto syntax;
 326                 p = q + 1;
 327                 blk[i].l = n;
 328                 TARFS_DPF(MAP, "%s: %3d %12zu %12zu %12zu\n", __func__,
 329                     i, blk[i].i, blk[i].o, blk[i].l);
 330                 /*
 331                  * Check block alignment if the block is of non-zero
 332                  * length (a zero-length block indicates the end of a
 333                  * trailing hole).  Checking i indirectly checks the
 334                  * previous block's l.  It's ok for the final block to
 335                  * have an uneven length.
 336                  */
 337                 if (blk[i].l == 0) {
 338                         TARFS_DPF(MAP, "%s: zero-length block\n", __func__);
 339                 } else if (blk[i].i % TARFS_BLOCKSIZE != 0 ||
 340                     blk[i].o % TARFS_BLOCKSIZE != 0) {
 341                         TARFS_DPF(MAP, "%s: misaligned map entry\n", __func__);
 342                         goto bad;
 343                 }
 344                 /*
 345                  * Check that this block starts after the end of the
 346                  * previous one.
 347                  */
 348                 if (i > 0 && blk[i].o < blk[i - 1].o + blk[i - 1].l) {
 349                         TARFS_DPF(MAP, "%s: overlapping map entries\n", __func__);
 350                         goto bad;
 351                 }
 352                 /*
 353                  * Check that the block is within the file, both
 354                  * physically and logically.
 355                  */
 356                 if (blk[i].i + blk[i].l > tnp->physize ||
 357                     blk[i].o + blk[i].l > realsize) {
 358                         TARFS_DPF(MAP, "%s: map overflow\n", __func__);
 359                         goto bad;
 360                 }
 361         }
 362         free(map, M_TARFSBLK);
 363
 364         /* store in node */
 365         free(tnp->blk, M_TARFSBLK);
 366         tnp->nblk = nblk;
 367         tnp->blk = blk;
 368         tnp->size = realsize;
 369         return (0);
 370 syntax:
 371         TARFS_DPF(MAP, "%s: syntax error in block map\n", __func__);
 372 bad:
 373         free(map, M_TARFSBLK);
 374         free(blk, M_TARFSBLK);
 375         return (EINVAL);
 376 }
 377
 378 void
 379 tarfs_free_node(struct tarfs_node *tnp)
 380 {
 381         struct tarfs_mount *tmp;
 382
 383         MPASS(tnp != NULL);
 384         tmp = tnp->tmp;
 385
 386         switch (tnp->type) {
 387         case VLNK:
 388                 if (tnp->link.name)
 389                         free(tnp->link.name, M_TARFSNAME);
 390                 break;
 391         default:
 392                 break;
 393         }
 394         if (tnp->name != NULL)
 395                 free(tnp->name, M_TARFSNAME);
 396         if (tnp->blk != NULL)
 397                 free(tnp->blk, M_TARFSBLK);
 398         if (tnp->ino >= TARFS_MININO)
 399                 free_unr(tmp->ino_unr, tnp->ino);
 400         free(tnp, M_TARFSNODE);
 401         tmp->nfiles--;
 402 }
 403
 404 int
 405 tarfs_read_file(struct tarfs_node *tnp, size_t len, struct uio *uiop)
 406 {
 407         struct uio auio;
 408         size_t resid = len;
 409         size_t copylen;
 410         unsigned int i;
 411         int error;
 412
 413         TARFS_DPF(VNODE, "%s(%s, %zu, %zu)\n", __func__,
 414             tnp->name, uiop->uio_offset, resid);
 415         for (i = 0; i < tnp->nblk && resid > 0; ++i) {
 416                 if (uiop->uio_offset > tnp->blk[i].o + tnp->blk[i].l) {
 417                         /* skip this block */
 418                         continue;
 419                 }
 420                 while (resid > 0 &&
 421                     uiop->uio_offset < tnp->blk[i].o) {
 422                         /* move out some zeroes... */
 423                         copylen = tnp->blk[i].o - uiop->uio_offset;
 424                         if (copylen > resid)
 425                                 copylen = resid;
 426                         if (copylen > ZERO_REGION_SIZE)
 427                                 copylen = ZERO_REGION_SIZE;
 428                         auio = *uiop;
 429                         auio.uio_offset = 0;
 430                         auio.uio_resid = copylen;
 431                         error = uiomove(__DECONST(void *, zero_region),
 432                             copylen, &auio);
 433                         if (error != 0)
 434                                 return (error);
 435                         TARFS_DPF(MAP, "%s(%s) = zero %zu\n", __func__,
 436                             tnp->name, copylen - auio.uio_resid);
 437                         uiop->uio_offset += copylen - auio.uio_resid;
 438                         uiop->uio_resid -= copylen - auio.uio_resid;
 439                         resid -= copylen - auio.uio_resid;
 440                 }
 441                 while (resid > 0 &&
 442                     uiop->uio_offset < tnp->blk[i].o + tnp->blk[i].l) {
 443                         /* now actual data */
 444                         copylen = tnp->blk[i].l;
 445                         if (copylen > resid)
 446                                 copylen = resid;
 447                         auio = *uiop;
 448                         auio.uio_offset = tnp->offset + tnp->blk[i].i +
 449                             uiop->uio_offset - tnp->blk[i].o;
 450                         auio.uio_resid = copylen;
 451                         error = tarfs_io_read(tnp->tmp, false, &auio);
 452                         if (error != 0)
 453                                 return (error);
 454                         TARFS_DPF(MAP, "%s(%s) = data %zu\n", __func__,
 455                             tnp->name, copylen - auio.uio_resid);
 456                         uiop->uio_offset += copylen - auio.uio_resid;
 457                         uiop->uio_resid -= copylen - auio.uio_resid;
 458                         resid -= copylen - auio.uio_resid;
 459                 }
 460         }
 461         TARFS_DPF(VNODE, "%s(%s) = %zu\n", __func__,
 462             tnp->name, len - resid);
 463         return (0);
 464 }
 465
 466 /*
 467  * XXX ugly file flag parser which could easily be a finite state machine
 468  * driven by a small precomputed table.
 469  *
 470  * Note that unlike strtofflags(3), we make no attempt to handle negated
 471  * flags, since they shouldn't appear in tar files.
 472  */
 473 static const struct tarfs_flag {
 474         const char *name;
 475         unsigned int flag;
 476 } tarfs_flags[] = {
 477         { "nodump",     UF_NODUMP },
 478         { "uchg",       UF_IMMUTABLE },
 479         { "uappnd",     UF_APPEND },
 480         { "opaque",     UF_OPAQUE },
 481         { "uunlnk",     UF_NOUNLINK },
 482         { "arch",       SF_ARCHIVED },
 483         { "schg",       SF_IMMUTABLE },
 484         { "sappnd",     SF_APPEND },
 485         { "sunlnk",     SF_NOUNLINK },
 486         { NULL, 0 },
 487 };
 488
 489 unsigned int
 490 tarfs_strtofflags(const char *str, char **end)
 491 {
 492         const struct tarfs_flag *tf;
 493         const char *p, *q;
 494         unsigned int ret;
 495
 496         ret = 0;
 497         for (p = q = str; *q != '\0'; p = q + 1) {
 498                 for (q = p; *q != '\0' && *q != ','; ++q) {
 499                         if (*q < 'a' || *q > 'z') {
 500                                 goto end;
 501                         }
 502                         /* nothing */
 503                 }
 504                 for (tf = tarfs_flags; tf->name != NULL; tf++) {
 505                         if (strncmp(tf->name, p, q - p) == 0 &&
 506                             tf->name[q - p] == '\0') {
 507                                 TARFS_DPF(ALLOC, "%s: %.*s = 0x%06x\n", __func__,
 508                                     (int)(q - p), p, tf->flag);
 509                                 ret |= tf->flag;
 510                                 break;
 511                         }
 512                 }
 513                 if (tf->name == NULL) {
 514                         TARFS_DPF(ALLOC, "%s: %.*s = 0x??????\n",
 515                             __func__, (int)(q - p), p);
 516                         goto end;
 517                 }
 518         }
 519 end:
 520         if (*end != NULL) {
 521                 *end = __DECONST(char *, q);
 522         }
 523         return (ret);
 524 }