lib/libpuffs/null.c

   1 /*      $NetBSD: null.c,v 1.27 2009/01/08 02:19:48 lukem Exp $  */
   2
   3 /*
   4  * Copyright (c) 2007  Antti Kantee.  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 ``AS IS'' AND ANY EXPRESS
  16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18  * 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 OR
  21  * 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 #include <sys/cdefs.h>
  29 #if !defined(lint)
  30 __RCSID("$NetBSD: null.c,v 1.27 2009/01/08 02:19:48 lukem Exp $");
  31 #endif /* !lint */
  32
  33 /*
  34  * A "nullfs" using puffs, i.e. maps one location in the hierarchy
  35  * to another using standard system calls.
  36  */
  37
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <sys/time.h>
  41
  42 #include <assert.h>
  43 #include <dirent.h>
  44 #include <errno.h>
  45 #include <fcntl.h>
  46 #include <puffs.h>
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <time.h>
  50 #include <unistd.h>
  51
  52 PUFFSOP_PROTOS(puffs_null)
  53
  54 /*
  55  * set attributes to what is specified.  XXX: no rollback in case of failure
  56  */
  57 static int
  58 processvattr(const char *path, const struct vattr *va, int regular)
  59 {
  60         struct timeval tv[2];
  61
  62         /* XXX: -1 == PUFFS_VNOVAL, but shouldn't trust that */
  63         if (va->va_uid != (unsigned)-1 || va->va_gid != (unsigned)-1)
  64                 if (lchown(path, va->va_uid, va->va_gid) == -1)
  65                         return errno;
  66
  67         if (va->va_mode != (unsigned)PUFFS_VNOVAL)
  68                 if (lchmod(path, va->va_mode) == -1)
  69                         return errno;
  70
  71         /* sloppy */
  72         if (va->va_atime.tv_sec != (time_t)PUFFS_VNOVAL
  73             || va->va_mtime.tv_sec != (time_t)PUFFS_VNOVAL) {
  74                 TIMESPEC_TO_TIMEVAL(&tv[0], &va->va_atime);
  75                 TIMESPEC_TO_TIMEVAL(&tv[1], &va->va_mtime);
  76
  77                 if (lutimes(path, tv) == -1)
  78                         return errno;
  79         }
  80
  81         if (regular && va->va_size != (u_quad_t)PUFFS_VNOVAL)
  82                 if (truncate(path, (off_t)va->va_size) == -1)
  83                         return errno;
  84
  85         return 0;
  86 }
  87
  88 /*
  89  * Kludge to open files which aren't writable *any longer*.  This kinda
  90  * works because the vfs layer does validation checks based on the file's
  91  * permissions to allow writable opening before opening them.  However,
  92  * the problem arises if we want to create a file, write to it (cache),
  93  * adjust permissions and then flush the file.
  94  */
  95 static int
  96 writeableopen(const char *path)
  97 {
  98         struct stat sb;
  99         mode_t origmode;
 100         int sverr = 0;
 101         int fd;
 102
 103         fd = open(path, O_WRONLY);
 104         if (fd == -1) {
 105                 if (errno == EACCES) {
 106                         if (stat(path, &sb) == -1)
 107                                 return -1;
 108                         origmode = sb.st_mode & ALLPERMS;
 109
 110                         if (chmod(path, 0200) == -1)
 111                                 return -1;
 112
 113                         fd = open(path, O_WRONLY);
 114                         if (fd == -1)
 115                                 sverr = errno;
 116
 117                         chmod(path, origmode);
 118                         if (sverr)
 119                                 errno = sverr;
 120                 } else
 121                         return -1;
 122         }
 123
 124         return fd;
 125 }
 126
 127 /*ARGSUSED*/
 128 static void *
 129 inodecmp(struct puffs_usermount *pu, struct puffs_node *pn, void *arg)
 130 {
 131         ino_t *cmpino = arg;
 132
 133         if (pn->pn_va.va_fileid == *cmpino)
 134                 return pn;
 135         return NULL;
 136 }
 137
 138 static int
 139 makenode(struct puffs_usermount *pu, struct puffs_newinfo *pni,
 140         const struct puffs_cn *pcn, const struct vattr *va, int regular)
 141 {
 142         struct puffs_node *pn;
 143         struct stat sb;
 144         int rv;
 145
 146         if ((rv = processvattr(PCNPATH(pcn), va, regular)) != 0)
 147                 return rv;
 148
 149         pn = puffs_pn_new(pu, NULL);
 150         if (!pn)
 151                 return ENOMEM;
 152         puffs_setvattr(&pn->pn_va, va);
 153
 154         if (lstat(PCNPATH(pcn), &sb) == -1)
 155                 return errno;
 156         puffs_stat2vattr(&pn->pn_va, &sb);
 157
 158         puffs_newinfo_setcookie(pni, pn);
 159         return 0;
 160 }
 161
 162 /* This should be called first and overriden from the file system */
 163 void
 164 puffs_null_setops(struct puffs_ops *pops)
 165 {
 166
 167         PUFFSOP_SET(pops, puffs_null, fs, statvfs);
 168         PUFFSOP_SETFSNOP(pops, unmount);
 169         PUFFSOP_SETFSNOP(pops, sync);
 170         PUFFSOP_SET(pops, puffs_null, fs, fhtonode);
 171         PUFFSOP_SET(pops, puffs_null, fs, nodetofh);
 172
 173         PUFFSOP_SET(pops, puffs_null, node, lookup);
 174         PUFFSOP_SET(pops, puffs_null, node, create);
 175         PUFFSOP_SET(pops, puffs_null, node, mknod);
 176         PUFFSOP_SET(pops, puffs_null, node, getattr);
 177         PUFFSOP_SET(pops, puffs_null, node, setattr);
 178         PUFFSOP_SET(pops, puffs_null, node, fsync);
 179         PUFFSOP_SET(pops, puffs_null, node, remove);
 180         PUFFSOP_SET(pops, puffs_null, node, link);
 181         PUFFSOP_SET(pops, puffs_null, node, rename);
 182         PUFFSOP_SET(pops, puffs_null, node, mkdir);
 183         PUFFSOP_SET(pops, puffs_null, node, rmdir);
 184         PUFFSOP_SET(pops, puffs_null, node, symlink);
 185         PUFFSOP_SET(pops, puffs_null, node, readlink);
 186         PUFFSOP_SET(pops, puffs_null, node, readdir);
 187         PUFFSOP_SET(pops, puffs_null, node, read);
 188         PUFFSOP_SET(pops, puffs_null, node, write);
 189         PUFFSOP_SET(pops, puffs_genfs, node, reclaim);
 190 }
 191
 192 /*ARGSUSED*/
 193 int
 194 puffs_null_fs_statvfs(struct puffs_usermount *pu, struct statvfs *svfsb)
 195 {
 196
 197         if (statvfs(PNPATH(puffs_getroot(pu)), svfsb) == -1)
 198                 return errno;
 199
 200         return 0;
 201 }
 202
 203 /*
 204  * XXX: this is the stupidest crap ever, but:
 205  * getfh() returns the fhandle type, when we are expected to deliver
 206  * the fid type.  Just adjust it a bit and stop whining.
 207  *
 208  * Yes, this really really needs fixing.  Yes, *REALLY*.
 209  */
 210 #define FHANDLE_HEADERLEN 8
 211 struct kernfid {
 212         unsigned short  fid_len;                /* length of data in bytes */
 213         unsigned short  fid_reserved;           /* compat: historic align */
 214         char            fid_data[0];            /* data (variable length) */
 215 };
 216
 217 /*ARGSUSED*/
 218 static void *
 219 fhcmp(struct puffs_usermount *pu, struct puffs_node *pn, void *arg)
 220 {
 221         struct kernfid *kf1, *kf2;
 222
 223         if ((kf1 = pn->pn_data) == NULL)
 224                 return NULL;
 225         kf2 = arg;
 226
 227         if (kf1->fid_len != kf2->fid_len)
 228                 return NULL;
 229
 230         /*LINTED*/
 231         if (memcmp(kf1, kf2, kf1->fid_len) == 0)
 232                 return pn;
 233         return NULL;
 234 }
 235
 236 /*
 237  * This routine only supports file handles which have been issued while
 238  * the server was alive.  Not really stable ones, that is.
 239  */
 240 /*ARGSUSED*/
 241 int
 242 puffs_null_fs_fhtonode(struct puffs_usermount *pu, void *fid, size_t fidsize,
 243         struct puffs_newinfo *pni)
 244 {
 245         struct puffs_node *pn_res;
 246
 247         pn_res = puffs_pn_nodewalk(pu, fhcmp, fid);
 248         if (pn_res == NULL)
 249                 return ENOENT;
 250
 251         puffs_newinfo_setcookie(pni, pn_res);
 252         puffs_newinfo_setvtype(pni, pn_res->pn_va.va_type);
 253         puffs_newinfo_setsize(pni, (voff_t)pn_res->pn_va.va_size);
 254         puffs_newinfo_setrdev(pni, pn_res->pn_va.va_rdev);
 255         return 0;
 256 }
 257
 258 /*ARGSUSED*/
 259 int
 260 puffs_null_fs_nodetofh(struct puffs_usermount *pu, puffs_cookie_t opc,
 261         void *fid, size_t *fidsize)
 262 {
 263         struct puffs_node *pn = opc;
 264         struct kernfid *kfid;
 265         void *bounce;
 266         int rv;
 267
 268         rv = 0;
 269         bounce = NULL;
 270         if (*fidsize) {
 271                 bounce = malloc(*fidsize + FHANDLE_HEADERLEN);
 272                 if (!bounce)
 273                         return ENOMEM;
 274                 *fidsize += FHANDLE_HEADERLEN;
 275         }
 276         if (getfh(PNPATH(pn), bounce, fidsize) == -1)
 277                 rv = errno;
 278         else
 279                 memcpy(fid, (uint8_t *)bounce + FHANDLE_HEADERLEN,
 280                     *fidsize - FHANDLE_HEADERLEN);
 281         kfid = fid;
 282         if (rv == 0) {
 283                 *fidsize = kfid->fid_len;
 284                 pn->pn_data = malloc(*fidsize);
 285                 if (pn->pn_data == NULL)
 286                         abort(); /* lazy */
 287                 memcpy(pn->pn_data, fid, *fidsize);
 288         } else {
 289                 *fidsize -= FHANDLE_HEADERLEN;
 290         }
 291         free(bounce);
 292
 293         return rv;
 294 }
 295
 296 int
 297 puffs_null_node_lookup(struct puffs_usermount *pu, puffs_cookie_t opc,
 298         struct puffs_newinfo *pni, const struct puffs_cn *pcn)
 299 {
 300         struct puffs_node *pn = opc, *pn_res;
 301         struct stat sb;
 302         int rv;
 303
 304         assert(pn->pn_va.va_type == VDIR);
 305
 306         /*
 307          * Note to whoever is copypasting this: you must first check
 308          * if the node is there and only then do nodewalk.  Alternatively
 309          * you could make sure that you don't return unlinked/rmdir'd
 310          * nodes in some other fashion
 311          */
 312         rv = lstat(PCNPATH(pcn), &sb);
 313         if (rv)
 314                 return errno;
 315
 316         /* XXX2: nodewalk is a bit too slow here */
 317         pn_res = puffs_pn_nodewalk(pu, inodecmp, &sb.st_ino);
 318
 319         if (pn_res == NULL) {
 320                 pn_res = puffs_pn_new(pu, NULL);
 321                 if (pn_res == NULL)
 322                         return ENOMEM;
 323                 puffs_stat2vattr(&pn_res->pn_va, &sb);
 324         }
 325
 326         puffs_newinfo_setcookie(pni, pn_res);
 327         puffs_newinfo_setvtype(pni, pn_res->pn_va.va_type);
 328         puffs_newinfo_setsize(pni, (voff_t)pn_res->pn_va.va_size);
 329         puffs_newinfo_setrdev(pni, pn_res->pn_va.va_rdev);
 330
 331         return 0;
 332 }
 333
 334 /*ARGSUSED*/
 335 int
 336 puffs_null_node_create(struct puffs_usermount *pu, puffs_cookie_t opc,
 337         struct puffs_newinfo *pni, const struct puffs_cn *pcn,
 338         const struct vattr *va)
 339 {
 340         int fd, rv;
 341
 342         fd = open(PCNPATH(pcn), O_RDWR | O_CREAT | O_TRUNC);
 343         if (fd == -1)
 344                 return errno;
 345         close(fd);
 346
 347         rv = makenode(pu, pni, pcn, va, 1);
 348         if (rv)
 349                 unlink(PCNPATH(pcn));
 350         return rv;
 351 }
 352
 353 /*ARGSUSED*/
 354 int
 355 puffs_null_node_mknod(struct puffs_usermount *pu, puffs_cookie_t opc,
 356         struct puffs_newinfo *pni, const struct puffs_cn *pcn,
 357         const struct vattr *va)
 358 {
 359         mode_t mode;
 360         int rv;
 361
 362         mode = puffs_addvtype2mode(va->va_mode, va->va_type);
 363         if (mknod(PCNPATH(pcn), mode, va->va_rdev) == -1)
 364                 return errno;
 365
 366         rv = makenode(pu, pni, pcn, va, 0);
 367         if (rv)
 368                 unlink(PCNPATH(pcn));
 369         return rv;
 370 }
 371
 372 /*ARGSUSED*/
 373 int
 374 puffs_null_node_getattr(struct puffs_usermount *pu, puffs_cookie_t opc,
 375         struct vattr *va, const struct puffs_cred *pcred)
 376 {
 377         struct puffs_node *pn = opc;
 378         struct stat sb;
 379
 380         if (lstat(PNPATH(pn), &sb) == -1)
 381                 return errno;
 382         puffs_stat2vattr(va, &sb);
 383
 384         return 0;
 385 }
 386
 387 /*ARGSUSED*/
 388 int
 389 puffs_null_node_setattr(struct puffs_usermount *pu, puffs_cookie_t opc,
 390         const struct vattr *va, const struct puffs_cred *pcred)
 391 {
 392         struct puffs_node *pn = opc;
 393         int rv;
 394
 395         rv = processvattr(PNPATH(pn), va, pn->pn_va.va_type == VREG);
 396         if (rv)
 397                 return rv;
 398
 399         puffs_setvattr(&pn->pn_va, va);
 400
 401         return 0;
 402 }
 403
 404 /*ARGSUSED*/
 405 int
 406 puffs_null_node_fsync(struct puffs_usermount *pu, puffs_cookie_t opc,
 407         const struct puffs_cred *pcred, int how,
 408         off_t offlo, off_t offhi)
 409 {
 410         struct puffs_node *pn = opc;
 411         int fd, rv;
 412         int fflags;
 413
 414         rv = 0;
 415         fd = writeableopen(PNPATH(pn));
 416         if (fd == -1)
 417                 return errno;
 418
 419         if (how & PUFFS_FSYNC_DATAONLY)
 420                 fflags = FDATASYNC;
 421         else
 422                 fflags = FFILESYNC;
 423         if (how & PUFFS_FSYNC_CACHE)
 424                 fflags |= FDISKSYNC;
 425
 426         if (fsync_range(fd, fflags, offlo, offhi - offlo) == -1)
 427                 rv = errno;
 428
 429         close(fd);
 430
 431         return rv;
 432 }
 433
 434 /*ARGSUSED*/
 435 int
 436 puffs_null_node_remove(struct puffs_usermount *pu, puffs_cookie_t opc,
 437         puffs_cookie_t targ, const struct puffs_cn *pcn)
 438 {
 439         struct puffs_node *pn_targ = targ;
 440
 441         if (unlink(PNPATH(pn_targ)) == -1)
 442                 return errno;
 443         puffs_pn_remove(pn_targ);
 444
 445         return 0;
 446 }
 447
 448 /*ARGSUSED*/
 449 int
 450 puffs_null_node_link(struct puffs_usermount *pu, puffs_cookie_t opc,
 451         puffs_cookie_t targ, const struct puffs_cn *pcn)
 452 {
 453         struct puffs_node *pn_targ = targ;
 454
 455         if (link(PNPATH(pn_targ), PCNPATH(pcn)) == -1)
 456                 return errno;
 457
 458         return 0;
 459 }
 460
 461 /*ARGSUSED*/
 462 int
 463 puffs_null_node_rename(struct puffs_usermount *pu, puffs_cookie_t opc,
 464         puffs_cookie_t src, const struct puffs_cn *pcn_src,
 465         puffs_cookie_t targ_dir, puffs_cookie_t targ,
 466         const struct puffs_cn *pcn_targ)
 467 {
 468
 469         if (rename(PCNPATH(pcn_src), PCNPATH(pcn_targ)) == -1)
 470                 return errno;
 471
 472         return 0;
 473 }
 474
 475 /*ARGSUSED*/
 476 int
 477 puffs_null_node_mkdir(struct puffs_usermount *pu, puffs_cookie_t opc,
 478         struct puffs_newinfo *pni, const struct puffs_cn *pcn,
 479         const struct vattr *va)
 480 {
 481         int rv;
 482
 483         if (mkdir(PCNPATH(pcn), va->va_mode) == -1)
 484                 return errno;
 485
 486         rv = makenode(pu, pni, pcn, va, 0);
 487         if (rv)
 488                 rmdir(PCNPATH(pcn));
 489         return rv;
 490 }
 491
 492 /*ARGSUSED*/
 493 int
 494 puffs_null_node_rmdir(struct puffs_usermount *pu, puffs_cookie_t opc,
 495         puffs_cookie_t targ, const struct puffs_cn *pcn)
 496 {
 497         struct puffs_node *pn_targ = targ;
 498
 499         if (rmdir(PNPATH(pn_targ)) == -1)
 500                 return errno;
 501         puffs_pn_remove(pn_targ);
 502
 503         return 0;
 504 }
 505
 506 /*ARGSUSED*/
 507 int
 508 puffs_null_node_symlink(struct puffs_usermount *pu, puffs_cookie_t opc,
 509         struct puffs_newinfo *pni, const struct puffs_cn *pcn,
 510         const struct vattr *va, const char *linkname)
 511 {
 512         int rv;
 513
 514         if (symlink(linkname, PCNPATH(pcn)) == -1)
 515                 return errno;
 516
 517         rv = makenode(pu, pni, pcn, va, 0);
 518         if (rv)
 519                 unlink(PCNPATH(pcn));
 520         return rv;
 521 }
 522
 523 /*ARGSUSED*/
 524 int
 525 puffs_null_node_readlink(struct puffs_usermount *pu, puffs_cookie_t opc,
 526         const struct puffs_cred *pcred, char *linkname, size_t *linklen)
 527 {
 528         struct puffs_node *pn = opc;
 529         ssize_t rv;
 530
 531         rv = readlink(PNPATH(pn), linkname, *linklen);
 532         if (rv == -1)
 533                 return errno;
 534
 535         *linklen = rv;
 536         return 0;
 537 }
 538
 539 /*ARGSUSED*/
 540 int
 541 puffs_null_node_readdir(struct puffs_usermount *pu, puffs_cookie_t opc,
 542         struct dirent *de, off_t *off, size_t *reslen,
 543         const struct puffs_cred *pcred, int *eofflag, off_t *cookies,
 544         size_t *ncookies)
 545 {
 546         struct puffs_node *pn = opc;
 547         struct dirent entry, *result;
 548         DIR *dp;
 549         off_t i;
 550         int rv;
 551
 552         *ncookies = 0;
 553         dp = opendir(PNPATH(pn));
 554         if (dp == NULL)
 555                 return errno;
 556
 557         rv = 0;
 558         i = *off;
 559
 560         /*
 561          * XXX: need to do trickery here, telldir/seekdir would be nice, but
 562          * then we'd need to keep state, which I'm too lazy to keep
 563          */
 564         while (i--) {
 565                 rv = readdir_r(dp, &entry, &result);
 566                 if (rv || !result)
 567                         goto out;
 568         }
 569
 570         for (;;) {
 571                 rv = readdir_r(dp, &entry, &result);
 572                 if (rv != 0)
 573                         goto out;
 574
 575                 if (!result) {
 576                         *eofflag = 1;
 577                         goto out;
 578                 }
 579
 580                 if (_DIRENT_SIZE(result) > *reslen)
 581                         goto out;
 582
 583                 *de = *result;
 584                 *reslen -= _DIRENT_SIZE(result);
 585                 de = _DIRENT_NEXT(de);
 586
 587                 (*off)++;
 588                 PUFFS_STORE_DCOOKIE(cookies, ncookies, *off);
 589         }
 590
 591  out:
 592         closedir(dp);
 593         return 0;
 594 }
 595
 596 /*ARGSUSED*/
 597 int
 598 puffs_null_node_read(struct puffs_usermount *pu, puffs_cookie_t opc,
 599         uint8_t *buf, off_t offset, size_t *buflen,
 600         const struct puffs_cred *pcred, int ioflag)
 601 {
 602         struct puffs_node *pn = opc;
 603         ssize_t n;
 604         off_t off;
 605         int fd, rv;
 606
 607         rv = 0;
 608         fd = open(PNPATH(pn), O_RDONLY);
 609         if (fd == -1)
 610                 return errno;
 611         off = lseek(fd, offset, SEEK_SET);
 612         if (off == -1) {
 613                 rv = errno;
 614                 goto out;
 615         }
 616
 617         n = read(fd, buf, *buflen);
 618         if (n == -1)
 619                 rv = errno;
 620         else
 621                 *buflen -= n;
 622
 623  out:
 624         close(fd);
 625         return rv;
 626 }
 627
 628 /*ARGSUSED*/
 629 int
 630 puffs_null_node_write(struct puffs_usermount *pu, puffs_cookie_t opc,
 631         uint8_t *buf, off_t offset, size_t *buflen,
 632         const struct puffs_cred *pcred, int ioflag)
 633 {
 634         struct puffs_node *pn = opc;
 635         ssize_t n;
 636         off_t off;
 637         int fd, rv;
 638
 639         rv = 0;
 640         fd = writeableopen(PNPATH(pn));
 641         if (fd == -1)
 642                 return errno;
 643
 644         off = lseek(fd, offset, SEEK_SET);
 645         if (off == -1) {
 646                 rv = errno;
 647                 goto out;
 648         }
 649
 650         n = write(fd, buf, *buflen);
 651         if (n == -1)
 652                 rv = errno;
 653         else
 654                 *buflen -= n;
 655
 656  out:
 657         close(fd);
 658         return rv;
 659 }