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
udf_init(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
udf_reinit(void)149 udf_reinit(void)
150 {
151 /* nothing to do */
152 }
153
154
155 void
udf_done(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
udf_modcmd(modcmd_t cmd,void * arg)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
udf_mountroot(void)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
free_udf_mountinfo(struct mount * mp)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
udf_release_system_nodes(struct mount * mp)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
udf_mount(struct mount * mp,const char * path,void * data,size_t * data_len)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
udf_sanity_selector(void * cl,struct vnode * vp)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
udf_unmount_sanity_check(struct mount * mp)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
udf_unmount(struct mount * mp,int mntflags)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
udf_mountfs(struct vnode * devvp,struct mount * mp,struct lwp * l,struct udf_args * args)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
udf_start(struct mount * mp,int flags)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
udf_root(struct mount * mp,struct vnode ** vpp)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
udf_statvfs(struct mount * mp,struct statvfs * sbp)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
udf_sync_writeout_system_files(struct udf_mount * ump,int clearflags)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
udf_sync(struct mount * mp,int waitfor,kauth_cred_t cred)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
udf_vget(struct mount * mp,ino_t ino,struct vnode ** vpp)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
udf_fhtovp(struct mount * mp,struct fid * fhp,struct vnode ** vpp)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
udf_vptofh(struct vnode * vp,struct fid * fid,size_t * fh_size)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
udf_snapshot(struct mount * mp,struct vnode * vp,struct timespec * tm)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 /* --------------------------------------------------------------------- */
948