sys/fs/udf/udf_vfsops.c

   1 /* $NetBSD: udf_vfsops.c,v 1.71 2015/08/24 08:31:56 hannken Exp $ */
   2
   3 /*
   4  * Copyright (c) 2006, 2008 Reinoud Zandijk
   5  * All rights reserved.
   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 ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  *
  27  */
  28
  29 #include <sys/cdefs.h>
  30 #ifndef lint
  31 __KERNEL_RCSID(0, "$NetBSD: udf_vfsops.c,v 1.71 2015/08/24 08:31:56 hannken Exp $");
  32 #endif /* not lint */
  33
  34
  35 #if defined(_KERNEL_OPT)
  36 #include "opt_compat_netbsd.h"
  37 #endif
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/sysctl.h>
  42 #include <sys/namei.h>
  43 #include <sys/proc.h>
  44 #include <sys/kernel.h>
  45 #include <sys/vnode.h>
  46 #include <miscfs/genfs/genfs.h>
  47 #include <miscfs/specfs/specdev.h>
  48 #include <sys/mount.h>
  49 #include <sys/buf.h>
  50 #include <sys/file.h>
  51 #include <sys/device.h>
  52 #include <sys/disklabel.h>
  53 #include <sys/ioctl.h>
  54 #include <sys/malloc.h>
  55 #include <sys/dirent.h>
  56 #include <sys/stat.h>
  57 #include <sys/conf.h>
  58 #include <sys/kauth.h>
  59 #include <sys/module.h>
  60
  61 #include <fs/udf/ecma167-udf.h>
  62 #include <fs/udf/udf_mount.h>
  63 #include <sys/dirhash.h>
  64
  65 #include "udf.h"
  66 #include "udf_subr.h"
  67 #include "udf_bswap.h"
  68
  69 MODULE(MODULE_CLASS_VFS, udf, NULL);
  70
  71 #define VTOI(vnode) ((struct udf_node *) vnode->v_data)
  72
  73 /* verbose levels of the udf filingsystem */
  74 int udf_verbose = UDF_DEBUGGING;
  75
  76 /* malloc regions */
  77 MALLOC_JUSTDEFINE(M_UDFMNT,   "UDF mount",      "UDF mount structures");
  78 MALLOC_JUSTDEFINE(M_UDFVOLD,  "UDF volspace",   "UDF volume space descriptors");
  79 MALLOC_JUSTDEFINE(M_UDFTEMP,  "UDF temp",       "UDF scrap space");
  80 struct pool udf_node_pool;
  81
  82 static struct sysctllog *udf_sysctl_log;
  83
  84 /* internal functions */
  85 static int udf_mountfs(struct vnode *, struct mount *, struct lwp *, struct udf_args *);
  86
  87
  88 /* --------------------------------------------------------------------- */
  89
  90 /* predefine vnode-op list descriptor */
  91 extern const struct vnodeopv_desc udf_vnodeop_opv_desc;
  92
  93 const struct vnodeopv_desc * const udf_vnodeopv_descs[] = {
  94         &udf_vnodeop_opv_desc,
  95         NULL,
  96 };
  97
  98
  99 /* vfsops descriptor linked in as anchor point for the filingsystem */
 100 struct vfsops udf_vfsops = {
 101         .vfs_name = MOUNT_UDF,
 102         .vfs_min_mount_data = sizeof (struct udf_args),
 103         .vfs_mount = udf_mount,
 104         .vfs_start = udf_start,
 105         .vfs_unmount = udf_unmount,
 106         .vfs_root = udf_root,
 107         .vfs_quotactl = (void *)eopnotsupp,
 108         .vfs_statvfs = udf_statvfs,
 109         .vfs_sync = udf_sync,
 110         .vfs_vget = udf_vget,
 111         .vfs_loadvnode = udf_loadvnode,
 112         .vfs_newvnode = udf_newvnode,
 113         .vfs_fhtovp = udf_fhtovp,
 114         .vfs_vptofh = udf_vptofh,
 115         .vfs_init = udf_init,
 116         .vfs_reinit = udf_reinit,
 117         .vfs_done = udf_done,
 118         .vfs_mountroot = udf_mountroot,
 119         .vfs_snapshot = udf_snapshot,
 120         .vfs_extattrctl = vfs_stdextattrctl,
 121         .vfs_suspendctl = (void *)eopnotsupp,
 122         .vfs_renamelock_enter = genfs_renamelock_enter,
 123         .vfs_renamelock_exit = genfs_renamelock_exit,
 124         .vfs_fsync = (void *)eopnotsupp,
 125         .vfs_opv_descs = udf_vnodeopv_descs
 126 };
 127
 128 /* --------------------------------------------------------------------- */
 129
 130 /* file system starts here */
 131 void
 132 udf_init(void)
 133 {
 134         size_t size;
 135
 136         /* setup memory types */
 137         malloc_type_attach(M_UDFMNT);
 138         malloc_type_attach(M_UDFVOLD);
 139         malloc_type_attach(M_UDFTEMP);
 140
 141         /* init node pools */
 142         size = sizeof(struct udf_node);
 143         pool_init(&udf_node_pool, size, 0, 0, 0,
 144                 "udf_node_pool", NULL, IPL_NONE);
 145 }
 146
 147
 148 void
 149 udf_reinit(void)
 150 {
 151         /* nothing to do */
 152 }
 153
 154
 155 void
 156 udf_done(void)
 157 {
 158         /* remove pools */
 159         pool_destroy(&udf_node_pool);
 160
 161         malloc_type_detach(M_UDFMNT);
 162         malloc_type_detach(M_UDFVOLD);
 163         malloc_type_detach(M_UDFTEMP);
 164 }
 165
 166 /*
 167  * If running a DEBUG kernel, provide an easy way to set the debug flags when
 168  * running into a problem.
 169  */
 170 #define UDF_VERBOSE_SYSCTLOPT        1
 171
 172 static int
 173 udf_modcmd(modcmd_t cmd, void *arg)
 174 {
 175         const struct sysctlnode *node;
 176         int error;
 177
 178         switch (cmd) {
 179         case MODULE_CMD_INIT:
 180                 error = vfs_attach(&udf_vfsops);
 181                 if (error != 0)
 182                         break;
 183                 /*
 184                  * XXX the "24" below could be dynamic, thereby eliminating one
 185                  * more instance of the "number to vfs" mapping problem, but
 186                  * "24" is the order as taken from sys/mount.h
 187                  */
 188                 sysctl_createv(&udf_sysctl_log, 0, NULL, &node,
 189                                CTLFLAG_PERMANENT,
 190                                CTLTYPE_NODE, "udf",
 191                                SYSCTL_DESCR("OSTA Universal File System"),
 192                                NULL, 0, NULL, 0,
 193                                CTL_VFS, 24, CTL_EOL);
 194 #ifdef DEBUG
 195                 sysctl_createv(&udf_sysctl_log, 0, NULL, &node,
 196                                CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 197                                CTLTYPE_INT, "verbose",
 198                                SYSCTL_DESCR("Bitmask for filesystem debugging"),
 199                                NULL, 0, &udf_verbose, 0,
 200                                CTL_VFS, 24, UDF_VERBOSE_SYSCTLOPT, CTL_EOL);
 201 #endif
 202                 break;
 203         case MODULE_CMD_FINI:
 204                 error = vfs_detach(&udf_vfsops);
 205                 if (error != 0)
 206                         break;
 207                 sysctl_teardown(&udf_sysctl_log);
 208                 break;
 209         default:
 210                 error = ENOTTY;
 211                 break;
 212         }
 213
 214         return (error);
 215 }
 216
 217 /* --------------------------------------------------------------------- */
 218
 219 int
 220 udf_mountroot(void)
 221 {
 222         return EOPNOTSUPP;
 223 }
 224
 225 /* --------------------------------------------------------------------- */
 226
 227 #define MPFREE(a, lst) \
 228         if ((a)) free((a), lst);
 229 static void
 230 free_udf_mountinfo(struct mount *mp)
 231 {
 232         struct udf_mount *ump;
 233         int i;
 234
 235         if (!mp)
 236                 return;
 237
 238         ump = VFSTOUDF(mp);
 239         if (ump) {
 240                 /* clear our data */
 241                 for (i = 0; i < UDF_ANCHORS; i++)
 242                         MPFREE(ump->anchors[i], M_UDFVOLD);
 243                 MPFREE(ump->primary_vol,      M_UDFVOLD);
 244                 MPFREE(ump->logical_vol,      M_UDFVOLD);
 245                 MPFREE(ump->unallocated,      M_UDFVOLD);
 246                 MPFREE(ump->implementation,   M_UDFVOLD);
 247                 MPFREE(ump->logvol_integrity, M_UDFVOLD);
 248                 for (i = 0; i < UDF_PARTITIONS; i++) {
 249                         MPFREE(ump->partitions[i],        M_UDFVOLD);
 250                         MPFREE(ump->part_unalloc_dscr[i], M_UDFVOLD);
 251                         MPFREE(ump->part_freed_dscr[i],   M_UDFVOLD);
 252                 }
 253                 MPFREE(ump->metadata_unalloc_dscr, M_UDFVOLD);
 254
 255                 MPFREE(ump->fileset_desc,   M_UDFVOLD);
 256                 MPFREE(ump->sparing_table,  M_UDFVOLD);
 257
 258                 MPFREE(ump->la_node_ad_cpy, M_UDFMNT);
 259                 MPFREE(ump->la_pmapping,    M_TEMP);
 260                 MPFREE(ump->la_lmapping,    M_TEMP);
 261
 262                 mutex_destroy(&ump->logvol_mutex);
 263                 mutex_destroy(&ump->allocate_mutex);
 264                 mutex_destroy(&ump->sync_lock);
 265
 266                 MPFREE(ump->vat_table, M_UDFVOLD);
 267
 268                 free(ump, M_UDFMNT);
 269         }
 270 }
 271 #undef MPFREE
 272
 273 /* --------------------------------------------------------------------- */
 274
 275 /* if the system nodes exist, release them */
 276 static void
 277 udf_release_system_nodes(struct mount *mp)
 278 {
 279         struct udf_mount *ump = VFSTOUDF(mp);
 280         int error;
 281
 282         /* if we haven't even got an ump, dont bother */
 283         if (!ump)
 284                 return;
 285
 286         /* VAT partition support */
 287         if (ump->vat_node)
 288                 vrele(ump->vat_node->vnode);
 289
 290         /* Metadata partition support */
 291         if (ump->metadata_node)
 292                 vrele(ump->metadata_node->vnode);
 293         if (ump->metadatamirror_node)
 294                 vrele(ump->metadatamirror_node->vnode);
 295         if (ump->metadatabitmap_node)
 296                 vrele(ump->metadatabitmap_node->vnode);
 297
 298         /* This flush should NOT write anything nor allow any node to remain */
 299         if ((error = vflush(ump->vfs_mountp, NULLVP, 0)) != 0)
 300                 panic("Failure to flush UDF system vnodes\n");
 301 }
 302
 303
 304 int
 305 udf_mount(struct mount *mp, const char *path,
 306           void *data, size_t *data_len)
 307 {
 308         struct lwp *l = curlwp;
 309         struct udf_args *args = data;
 310         struct udf_mount *ump;
 311         struct vnode *devvp;
 312         int openflags, accessmode, error;
 313
 314         DPRINTF(CALL, ("udf_mount called\n"));
 315
 316         if (args == NULL)
 317                 return EINVAL;
 318         if (*data_len < sizeof *args)
 319                 return EINVAL;
 320
 321         if (mp->mnt_flag & MNT_GETARGS) {
 322                 /* request for the mount arguments */
 323                 ump = VFSTOUDF(mp);
 324                 if (ump == NULL)
 325                         return EINVAL;
 326                 *args = ump->mount_args;
 327                 *data_len = sizeof *args;
 328                 return 0;
 329         }
 330
 331         /* handle request for updating mount parameters */
 332         /* TODO can't update my mountpoint yet */
 333         if (mp->mnt_flag & MNT_UPDATE) {
 334                 return EOPNOTSUPP;
 335         }
 336
 337         /* OK, so we are asked to mount the device */
 338
 339         /* check/translate struct version */
 340         /* TODO sanity checking other mount arguments */
 341         if (args->version != 1) {
 342                 printf("mount_udf: unrecognized argument structure version\n");
 343                 return EINVAL;
 344         }
 345
 346         /* lookup name to get its vnode */
 347         error = namei_simple_user(args->fspec,
 348                                 NSM_FOLLOW_NOEMULROOT, &devvp);
 349         if (error)
 350                 return error;
 351
 352 #ifdef DEBUG
 353         if (udf_verbose & UDF_DEBUG_VOLUMES)
 354                 vprint("UDF mount, trying to mount \n", devvp);
 355 #endif
 356
 357         /* check if its a block device specified */
 358         if (devvp->v_type != VBLK) {
 359                 vrele(devvp);
 360                 return ENOTBLK;
 361         }
 362         if (bdevsw_lookup(devvp->v_rdev) == NULL) {
 363                 vrele(devvp);
 364                 return ENXIO;
 365         }
 366
 367         /*
 368          * If mount by non-root, then verify that user has necessary
 369          * permissions on the device.
 370          */
 371         accessmode = VREAD;
 372         if ((mp->mnt_flag & MNT_RDONLY) == 0)
 373                 accessmode |= VWRITE;
 374         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 375         error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
 376             KAUTH_REQ_SYSTEM_MOUNT_DEVICE, mp, devvp, KAUTH_ARG(accessmode));
 377         VOP_UNLOCK(devvp);
 378         if (error) {
 379                 vrele(devvp);
 380                 return error;
 381         }
 382
 383         /*
 384          * Open device and try to mount it!
 385          */
 386         if (mp->mnt_flag & MNT_RDONLY) {
 387                 openflags = FREAD;
 388         } else {
 389                 openflags = FREAD | FWRITE;
 390         }
 391         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 392         error = VOP_OPEN(devvp, openflags, FSCRED);
 393         VOP_UNLOCK(devvp);
 394         if (error == 0) {
 395                 /* opened ok, try mounting */
 396                 error = udf_mountfs(devvp, mp, l, args);
 397                 if (error) {
 398                         udf_release_system_nodes(mp);
 399                         /* cleanup */
 400                         udf_discstrat_finish(VFSTOUDF(mp));
 401                         free_udf_mountinfo(mp);
 402                         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 403                         (void) VOP_CLOSE(devvp, openflags, NOCRED);
 404                         VOP_UNLOCK(devvp);
 405                 }
 406         }
 407         if (error) {
 408                 /* devvp is still locked */
 409                 vrele(devvp);
 410                 return error;
 411         }
 412
 413         /* register our mountpoint being on this device */
 414         spec_node_setmountedfs(devvp, mp);
 415
 416         /* successfully mounted */
 417         DPRINTF(VOLUMES, ("udf_mount() successfull\n"));
 418
 419         error = set_statvfs_info(path, UIO_USERSPACE, args->fspec, UIO_USERSPACE,
 420                         mp->mnt_op->vfs_name, mp, l);
 421         if (error)
 422                 return error;
 423
 424         /* If we're not opened read-only, open its logical volume */
 425         if ((mp->mnt_flag & MNT_RDONLY) == 0) {
 426                 if ((error = udf_open_logvol(VFSTOUDF(mp))) != 0) {
 427                         printf( "mount_udf: can't open logical volume for "
 428                                 "writing, downgrading access to read-only\n");
 429                         mp->mnt_flag |= MNT_RDONLY;
 430                         /* FIXME we can't return error now on open failure */
 431                         return 0;
 432                 }
 433         }
 434
 435         return 0;
 436 }
 437
 438 /* --------------------------------------------------------------------- */
 439
 440 #ifdef DEBUG
 441 static bool
 442 udf_sanity_selector(void *cl, struct vnode *vp)
 443 {
 444
 445         vprint("", vp);
 446         if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) {
 447                 printf("  is locked\n");
 448         }
 449         if (vp->v_usecount > 1)
 450                 printf("  more than one usecount %d\n", vp->v_usecount);
 451         return false;
 452 }
 453
 454 static void
 455 udf_unmount_sanity_check(struct mount *mp)
 456 {
 457         struct vnode_iterator *marker;
 458
 459         printf("On unmount, i found the following nodes:\n");
 460         vfs_vnode_iterator_init(mp, &marker);
 461         vfs_vnode_iterator_next(marker, udf_sanity_selector, NULL);
 462         vfs_vnode_iterator_destroy(marker);
 463 }
 464 #endif
 465
 466
 467 int
 468 udf_unmount(struct mount *mp, int mntflags)
 469 {
 470         struct udf_mount *ump;
 471         int error, flags, closeflags;
 472
 473         DPRINTF(CALL, ("udf_umount called\n"));
 474
 475         ump = VFSTOUDF(mp);
 476         if (!ump)
 477                 panic("UDF unmount: empty ump\n");
 478
 479         flags = (mntflags & MNT_FORCE) ? FORCECLOSE : 0;
 480         /* TODO remove these paranoid functions */
 481 #ifdef DEBUG
 482         if (udf_verbose & UDF_DEBUG_LOCKING)
 483                 udf_unmount_sanity_check(mp);
 484 #endif
 485
 486         /*
 487          * By specifying SKIPSYSTEM we can skip vnodes marked with VV_SYSTEM.
 488          * This hardly documented feature allows us to exempt certain files
 489          * from being flushed.
 490          */
 491         if ((error = vflush(mp, NULLVP, flags | SKIPSYSTEM)) != 0)
 492                 return error;
 493
 494         /* update nodes and wait for completion of writeout of system nodes */
 495         udf_sync(mp, FSYNC_WAIT, NOCRED);
 496
 497 #ifdef DEBUG
 498         if (udf_verbose & UDF_DEBUG_LOCKING)
 499                 udf_unmount_sanity_check(mp);
 500 #endif
 501
 502         /* flush again, to check if we are still busy for something else */
 503         if ((error = vflush(ump->vfs_mountp, NULLVP, flags | SKIPSYSTEM)) != 0)
 504                 return error;
 505
 506         DPRINTF(VOLUMES, ("flush OK on unmount\n"));
 507
 508         /* close logical volume and close session if requested */
 509         if ((error = udf_close_logvol(ump, mntflags)) != 0)
 510                 return error;
 511
 512 #ifdef DEBUG
 513         DPRINTF(VOLUMES, ("FINAL sanity check\n"));
 514         if (udf_verbose & UDF_DEBUG_LOCKING)
 515                 udf_unmount_sanity_check(mp);
 516 #endif
 517
 518         /* NOTE release system nodes should NOT write anything */
 519         udf_release_system_nodes(mp);
 520
 521         /* finalise disc strategy */
 522         udf_discstrat_finish(ump);
 523
 524         /* synchronise device caches */
 525         (void) udf_synchronise_caches(ump);
 526
 527         /* close device */
 528         DPRINTF(VOLUMES, ("closing device\n"));
 529         if (mp->mnt_flag & MNT_RDONLY) {
 530                 closeflags = FREAD;
 531         } else {
 532                 closeflags = FREAD | FWRITE;
 533         }
 534
 535         /* devvp is still locked by us */
 536         vn_lock(ump->devvp, LK_EXCLUSIVE | LK_RETRY);
 537         error = VOP_CLOSE(ump->devvp, closeflags, NOCRED);
 538         if (error)
 539                 printf("Error during closure of device! error %d, "
 540                        "device might stay locked\n", error);
 541         DPRINTF(VOLUMES, ("device close ok\n"));
 542
 543         /* clear our mount reference and release device node */
 544         spec_node_setmountedfs(ump->devvp, NULL);
 545         vput(ump->devvp);
 546
 547         /* free our ump */
 548         free_udf_mountinfo(mp);
 549
 550         /* free ump struct references */
 551         mp->mnt_data = NULL;
 552         mp->mnt_flag &= ~MNT_LOCAL;
 553
 554         DPRINTF(VOLUMES, ("Fin unmount\n"));
 555         return error;
 556 }
 557
 558 /* --------------------------------------------------------------------- */
 559
 560 /*
 561  * Helper function of udf_mount() that actually mounts the disc.
 562  */
 563
 564 static int
 565 udf_mountfs(struct vnode *devvp, struct mount *mp,
 566             struct lwp *l, struct udf_args *args)
 567 {
 568         struct udf_mount     *ump;
 569         uint32_t sector_size, lb_size, bshift;
 570         uint32_t logvol_integrity;
 571         int    num_anchors, error;
 572
 573         /* flush out any old buffers remaining from a previous use. */
 574         if ((error = vinvalbuf(devvp, V_SAVE, l->l_cred, l, 0, 0)))
 575                 return error;
 576
 577         /* setup basic mount information */
 578         mp->mnt_data = NULL;
 579         mp->mnt_stat.f_fsidx.__fsid_val[0] = (uint32_t) devvp->v_rdev;
 580         mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_UDF);
 581         mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
 582         mp->mnt_stat.f_namemax = UDF_MAXNAMLEN;
 583         mp->mnt_flag |= MNT_LOCAL;
 584 //      mp->mnt_iflag |= IMNT_MPSAFE;
 585
 586         /* allocate udf part of mount structure; malloc always succeeds */
 587         ump = malloc(sizeof(struct udf_mount), M_UDFMNT, M_WAITOK | M_ZERO);
 588
 589         /* init locks */
 590         mutex_init(&ump->logvol_mutex, MUTEX_DEFAULT, IPL_NONE);
 591         mutex_init(&ump->allocate_mutex, MUTEX_DEFAULT, IPL_NONE);
 592         mutex_init(&ump->sync_lock, MUTEX_DEFAULT, IPL_NONE);
 593
 594         /* init rbtree for nodes, ordered by their icb address (long_ad) */
 595         udf_init_nodes_tree(ump);
 596
 597         /* set up linkage */
 598         mp->mnt_data    = ump;
 599         ump->vfs_mountp = mp;
 600
 601         /* set up arguments and device */
 602         ump->mount_args = *args;
 603         ump->devvp      = devvp;
 604         if ((error = udf_update_discinfo(ump))) {
 605                 printf("UDF mount: error inspecting fs node\n");
 606                 return error;
 607         }
 608
 609         /* inspect sector size */
 610         sector_size = ump->discinfo.sector_size;
 611         bshift = 1;
 612         while ((1 << bshift) < sector_size)
 613                 bshift++;
 614         if ((1 << bshift) != sector_size) {
 615                 printf("UDF mount: "
 616                        "hit NetBSD implementation fence on sector size\n");
 617                 return EIO;
 618         }
 619
 620         /* temporary check to overcome sectorsize >= 8192 bytes panic */
 621         if (sector_size >= 8192) {
 622                 printf("UDF mount: "
 623                         "hit implementation limit, sectorsize to big\n");
 624                 return EIO;
 625         }
 626
 627         /*
 628          * Inspect if we're asked to mount read-write on a non recordable or
 629          * closed sequential disc.
 630          */
 631         if ((mp->mnt_flag & MNT_RDONLY) == 0) {
 632                 if ((ump->discinfo.mmc_cur & MMC_CAP_RECORDABLE) == 0) {
 633                         printf("UDF mount: disc is not recordable\n");
 634                         return EROFS;
 635                 }
 636                 if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
 637                         if (ump->discinfo.disc_state == MMC_STATE_FULL) {
 638                                 printf("UDF mount: disc is not appendable\n");
 639                                 return EROFS;
 640                         }
 641
 642                         /*
 643                          * TODO if the last session is closed check if there
 644                          * is enough space to open/close new session
 645                          */
 646                 }
 647                 /* double check if we're not mounting a pervious session RW */
 648                 if (args->sessionnr != 0) {
 649                         printf("UDF mount: updating a previous session "
 650                                 "not yet allowed\n");
 651                         return EROFS;
 652                 }
 653         }
 654
 655         /* initialise bootstrap disc strategy */
 656         ump->strategy = &udf_strat_bootstrap;
 657         udf_discstrat_init(ump);
 658
 659         /* read all anchors to get volume descriptor sequence */
 660         num_anchors = udf_read_anchors(ump);
 661         if (num_anchors == 0)
 662                 return EINVAL;
 663
 664         DPRINTF(VOLUMES, ("Read %d anchors on this disc, session %d\n",
 665             num_anchors, args->sessionnr));
 666
 667         /* read in volume descriptor sequence */
 668         if ((error = udf_read_vds_space(ump))) {
 669                 printf("UDF mount: error reading volume space\n");
 670                 return error;
 671         }
 672
 673         /* close down bootstrap disc strategy */
 674         udf_discstrat_finish(ump);
 675
 676         /* check consistency and completeness */
 677         if ((error = udf_process_vds(ump))) {
 678                 printf( "UDF mount: disc not properly formatted"
 679                         "(bad VDS)\n");
 680                 return error;
 681         }
 682
 683         /* switch to new disc strategy */
 684         KASSERT(ump->strategy != &udf_strat_bootstrap);
 685         udf_discstrat_init(ump);
 686
 687         /* initialise late allocation administration space */
 688         ump->la_lmapping = malloc(sizeof(uint64_t) * UDF_MAX_MAPPINGS,
 689                         M_TEMP, M_WAITOK);
 690         ump->la_pmapping = malloc(sizeof(uint64_t) * UDF_MAX_MAPPINGS,
 691                         M_TEMP, M_WAITOK);
 692
 693         /* setup node cleanup extents copy space */
 694         lb_size = udf_rw32(ump->logical_vol->lb_size);
 695         ump->la_node_ad_cpy = malloc(lb_size * UDF_MAX_ALLOC_EXTENTS,
 696                 M_UDFMNT, M_WAITOK);
 697         memset(ump->la_node_ad_cpy, 0, lb_size * UDF_MAX_ALLOC_EXTENTS);
 698
 699         /* setup rest of mount information */
 700         mp->mnt_data = ump;
 701
 702         /* bshift is allways equal to disc sector size */
 703         mp->mnt_dev_bshift = bshift;
 704         mp->mnt_fs_bshift  = bshift;
 705
 706         /* note that the mp info needs to be initialised for reading! */
 707         /* read vds support tables like VAT, sparable etc. */
 708         if ((error = udf_read_vds_tables(ump))) {
 709                 printf( "UDF mount: error in format or damaged disc "
 710                         "(VDS tables failing)\n");
 711                 return error;
 712         }
 713
 714         /* check if volume integrity is closed otherwise its dirty */
 715         logvol_integrity = udf_rw32(ump->logvol_integrity->integrity_type);
 716         if (logvol_integrity != UDF_INTEGRITY_CLOSED) {
 717                 printf("UDF mount: file system is not clean; ");
 718                 printf("please fsck(8)\n");
 719                 return EPERM;
 720         }
 721
 722         /* read root directory */
 723         if ((error = udf_read_rootdirs(ump))) {
 724                 printf( "UDF mount: "
 725                         "disc not properly formatted or damaged disc "
 726                         "(rootdirs failing)\n");
 727                 return error;
 728         }
 729
 730         /* success! */
 731         return 0;
 732 }
 733
 734 /* --------------------------------------------------------------------- */
 735
 736 int
 737 udf_start(struct mount *mp, int flags)
 738 {
 739         /* do we have to do something here? */
 740         return 0;
 741 }
 742
 743 /* --------------------------------------------------------------------- */
 744
 745 int
 746 udf_root(struct mount *mp, struct vnode **vpp)
 747 {
 748         struct vnode *vp;
 749         struct long_ad *dir_loc;
 750         struct udf_mount *ump = VFSTOUDF(mp);
 751         struct udf_node *root_dir;
 752         int error;
 753
 754         DPRINTF(CALL, ("udf_root called\n"));
 755
 756         dir_loc = &ump->fileset_desc->rootdir_icb;
 757         error = udf_get_node(ump, dir_loc, &root_dir);
 758
 759         if (!root_dir)
 760                 error = ENOENT;
 761         if (error)
 762                 return error;
 763
 764         vp = root_dir->vnode;
 765         KASSERT(vp->v_vflag & VV_ROOT);
 766
 767         *vpp = vp;
 768         return 0;
 769 }
 770
 771 /* --------------------------------------------------------------------- */
 772
 773 int
 774 udf_statvfs(struct mount *mp, struct statvfs *sbp)
 775 {
 776         struct udf_mount *ump = VFSTOUDF(mp);
 777         struct logvol_int_desc *lvid;
 778         struct udf_logvol_info *impl;
 779         uint64_t freeblks, sizeblks;
 780         int num_part;
 781
 782         DPRINTF(CALL, ("udf_statvfs called\n"));
 783         sbp->f_flag   = mp->mnt_flag;
 784         sbp->f_bsize  = ump->discinfo.sector_size;
 785         sbp->f_frsize = ump->discinfo.sector_size;
 786         sbp->f_iosize = ump->discinfo.sector_size;
 787
 788         mutex_enter(&ump->allocate_mutex);
 789
 790         udf_calc_freespace(ump, &sizeblks, &freeblks);
 791
 792         sbp->f_blocks = sizeblks;
 793         sbp->f_bfree  = freeblks;
 794         sbp->f_files  = 0;
 795
 796         lvid = ump->logvol_integrity;
 797         num_part = udf_rw32(lvid->num_part);
 798         impl = (struct udf_logvol_info *) (lvid->tables + 2*num_part);
 799         if (impl) {
 800                 sbp->f_files  = udf_rw32(impl->num_files);
 801                 sbp->f_files += udf_rw32(impl->num_directories);
 802         }
 803
 804         /* XXX read only for now XXX */
 805         sbp->f_bavail = 0;
 806         sbp->f_bresvd = 0;
 807
 808         /* tricky, next only aplies to ffs i think, so set to zero */
 809         sbp->f_ffree  = 0;
 810         sbp->f_favail = 0;
 811         sbp->f_fresvd = 0;
 812
 813         mutex_exit(&ump->allocate_mutex);
 814
 815         copy_statvfs_info(sbp, mp);
 816         return 0;
 817 }
 818
 819 /* --------------------------------------------------------------------- */
 820
 821 /*
 822  * TODO what about writing out free space maps, lvid etc? only on `waitfor'
 823  * i.e. explicit syncing by the user?
 824  */
 825
 826 static int
 827 udf_sync_writeout_system_files(struct udf_mount *ump, int clearflags)
 828 {
 829         int error;
 830
 831         /* XXX lock for VAT en bitmaps? */
 832         /* metadata nodes are written synchronous */
 833         DPRINTF(CALL, ("udf_sync: syncing metadata\n"));
 834         if (ump->lvclose & UDF_WRITE_VAT)
 835                 udf_writeout_vat(ump);
 836
 837         error = 0;
 838         if (ump->lvclose & UDF_WRITE_PART_BITMAPS) {
 839                 /* writeout metadata spacetable if existing */
 840                 error = udf_write_metadata_partition_spacetable(ump, MNT_WAIT);
 841                 if (error)
 842                         printf( "udf_writeout_system_files : "
 843                                 " writeout of metadata space bitmap failed\n");
 844
 845                 /* writeout partition spacetables */
 846                 error = udf_write_physical_partition_spacetables(ump, MNT_WAIT);
 847                 if (error)
 848                         printf( "udf_writeout_system_files : "
 849                                 "writeout of space tables failed\n");
 850                 if (!error && clearflags)
 851                         ump->lvclose &= ~UDF_WRITE_PART_BITMAPS;
 852         }
 853
 854         return error;
 855 }
 856
 857
 858 int
 859 udf_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
 860 {
 861         struct udf_mount *ump = VFSTOUDF(mp);
 862
 863         DPRINTF(CALL, ("udf_sync called\n"));
 864         /* if called when mounted readonly, just ignore */
 865         if (mp->mnt_flag & MNT_RDONLY)
 866                 return 0;
 867
 868         if (ump->syncing && !waitfor) {
 869                 printf("UDF: skipping autosync\n");
 870                 return 0;
 871         }
 872
 873         /* get sync lock */
 874         ump->syncing = 1;
 875
 876         /* pre-sync */
 877         udf_do_sync(ump, cred, waitfor);
 878
 879         if (waitfor == MNT_WAIT)
 880                 udf_sync_writeout_system_files(ump, true);
 881
 882         DPRINTF(CALL, ("end of udf_sync()\n"));
 883         ump->syncing = 0;
 884
 885         return 0;
 886 }
 887
 888 /* --------------------------------------------------------------------- */
 889
 890 /*
 891  * Get vnode for the file system type specific file id ino for the fs. Its
 892  * used for reference to files by unique ID and for NFSv3.
 893  * (optional) TODO lookup why some sources state NFSv3
 894  */
 895 int
 896 udf_vget(struct mount *mp, ino_t ino,
 897     struct vnode **vpp)
 898 {
 899         DPRINTF(NOTIMPL, ("udf_vget called\n"));
 900         return EOPNOTSUPP;
 901 }
 902
 903 /* --------------------------------------------------------------------- */
 904
 905 /*
 906  * Lookup vnode for file handle specified
 907  */
 908 int
 909 udf_fhtovp(struct mount *mp, struct fid *fhp,
 910     struct vnode **vpp)
 911 {
 912         DPRINTF(NOTIMPL, ("udf_fhtovp called\n"));
 913         return EOPNOTSUPP;
 914 }
 915
 916 /* --------------------------------------------------------------------- */
 917
 918 /*
 919  * Create an unique file handle. Its structure is opaque and won't be used by
 920  * other subsystems. It should uniquely identify the file in the filingsystem
 921  * and enough information to know if a file has been removed and/or resources
 922  * have been recycled.
 923  */
 924 int
 925 udf_vptofh(struct vnode *vp, struct fid *fid,
 926     size_t *fh_size)
 927 {
 928         DPRINTF(NOTIMPL, ("udf_vptofh called\n"));
 929         return EOPNOTSUPP;
 930 }
 931
 932 /* --------------------------------------------------------------------- */
 933
 934 /*
 935  * Create a filingsystem snapshot at the specified timestamp. Could be
 936  * implemented by explicitly creating a new session or with spare room in the
 937  * integrity descriptor space
 938  */
 939 int
 940 udf_snapshot(struct mount *mp, struct vnode *vp,
 941     struct timespec *tm)
 942 {
 943         DPRINTF(NOTIMPL, ("udf_snapshot called\n"));
 944         return EOPNOTSUPP;
 945 }
 946
 947 /* --------------------------------------------------------------------- */