D9614.id25223.diff
No OneTemporary
Actions

Size

476 KB

Referenced Files

None

Subscribers

None

D9614.id25223.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	Index: sbin/Makefile
	===================================================================
	--- sbin/Makefile
	+++ sbin/Makefile
	@@ -49,6 +49,7 @@
	mount_nfs \
	mount_nullfs \
	mount_udf \
	+ mount_udf2 \
	mount_unionfs \
	newfs \
	newfs_msdos \
	Index: sbin/mount_udf2/Makefile
	===================================================================
	--- /dev/null
	+++ sbin/mount_udf2/Makefile
	@@ -0,0 +1,19 @@
	+# $FreeBSD$
	+
	+PROG= mount_udf2
	+SRCS= mount_udf.c getmntopts.c
	+MAN= mount_udf2.8
	+LIBADD+=kiconv
	+
	+MOUNT= ${.CURDIR}/../mount
	+CFLAGS+= -I${MOUNT} -I${.CURDIR}/../../sys
	+.PATH: ${MOUNT}
	+WARNS?= 1
	+
	+# Needs to be dynamically linked for optional dlopen() access to
	+# userland libiconv
	+NO_SHARED?= NO
	+
	+BINDIR=/sbin
	+
	+.include <bsd.prog.mk>
	Index: sbin/mount_udf2/getmntopts.c
	===================================================================
	--- /dev/null
	+++ sbin/mount_udf2/getmntopts.c
	@@ -0,0 +1,182 @@
	+/*-
	+ * Copyright (c) 1994
	+ * The Regents of the University of California. All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ * 4. Neither the name of the University nor the names of its contributors
	+ * may be used to endorse or promote products derived from this software
	+ * without specific prior written permission.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#if 0
	+#ifndef lint
	+static char sccsid[] = "@(#)getmntopts.c 8.3 (Berkeley) 3/29/95";
	+#endif /* not lint */
	+#endif
	+#include <sys/cdefs.h>
	+__FBSDID("$FreeBSD$");
	+
	+#include <sys/param.h>
	+#include <sys/mount.h>
	+#include <sys/stat.h>
	+#include <sys/uio.h>
	+
	+#include <err.h>
	+#include <errno.h>
	+#include <stdarg.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <sysexits.h>
	+
	+#include "mntopts.h"
	+
	+int getmnt_silent = 0;
	+
	+void
	+getmntopts(const char options, const struct mntopt m0, int *flagp,
	+ int *altflagp)
	+{
	+ const struct mntopt *m;
	+ int negative, len;
	+ char opt, optbuf, *p;
	+ int *thisflagp;
	+
	+ /* Copy option string, since it is about to be torn asunder... */
	+ if ((optbuf = strdup(options)) == NULL)
	+ err(1, NULL);
	+
	+ for (opt = optbuf; (opt = strtok(opt, ",")) != NULL; opt = NULL) {
	+ /* Check for "no" prefix. */
	+ if (opt[0] == 'n' && opt[1] == 'o') {
	+ negative = 1;
	+ opt += 2;
	+ } else
	+ negative = 0;
	+
	+ /*
	+ * for options with assignments in them (ie. quotas)
	+ * ignore the assignment as it's handled elsewhere
	+ */
	+ p = strchr(opt, '=');
	+ if (p != NULL)
	+ *++p = '\0';
	+
	+ /* Scan option table. */
	+ for (m = m0; m->m_option != NULL; ++m) {
	+ len = strlen(m->m_option);
	+ if (strncasecmp(opt, m->m_option, len) == 0)
	+ if (opt[len] == '\0' \|\| opt[len] == '=')
	+ break;
	+ }
	+
	+ /* Save flag, or fail if option is not recognized. */
	+ if (m->m_option) {
	+ thisflagp = m->m_altloc ? altflagp : flagp;
	+ if (negative == m->m_inverse)
	+ *thisflagp \|= m->m_flag;
	+ else
	+ *thisflagp &= ~m->m_flag;
	+ } else if (!getmnt_silent) {
	+ errx(1, "-o %s: option not supported", opt);
	+ }
	+ }
	+
	+ free(optbuf);
	+}
	+
	+void
	+rmslashes(char rrpin, char rrpout)
	+{
	+ char *rrpoutstart;
	+
	+ rrpout = rrpin;
	+ for (rrpoutstart = rrpout; rrpin != '\0'; rrpout++ = *rrpin++) {
	+
	+ /* skip all double slashes */
	+ while (rrpin == '/' && (rrpin + 1) == '/')
	+ rrpin++;
	+ }
	+
	+ /* remove trailing slash if necessary */
	+ if (rrpout - rrpoutstart > 1 && *(rrpout - 1) == '/')
	+ *(rrpout - 1) = '\0';
	+ else
	+ *rrpout = '\0';
	+}
	+
	+void
	+checkpath(const char path, char resolved)
	+{
	+ struct stat sb;
	+
	+ if (realpath(path, resolved) != NULL && stat(resolved, &sb) == 0) {
	+ if (!S_ISDIR(sb.st_mode))
	+ errx(EX_USAGE, "%s: not a directory", resolved);
	+ } else
	+ errx(EX_USAGE, "%s: %s", resolved, strerror(errno));
	+}
	+
	+void
	+build_iovec(struct iovec *iov, int iovlen, const char name, void val,
	+ size_t len)
	+{
	+ int i;
	+
	+ if (*iovlen < 0)
	+ return;
	+ i = *iovlen;
	+ iov = realloc(iov, sizeof *iov (i + 2));
	+ if (*iov == NULL) {
	+ *iovlen = -1;
	+ return;
	+ }
	+ (*iov)[i].iov_base = strdup(name);
	+ (*iov)[i].iov_len = strlen(name) + 1;
	+ i++;
	+ (*iov)[i].iov_base = val;
	+ if (len == (size_t)-1) {
	+ if (val != NULL)
	+ len = strlen(val) + 1;
	+ else
	+ len = 0;
	+ }
	+ (*iov)[i].iov_len = (int)len;
	+ *iovlen = ++i;
	+}
	+
	+/*
	+ * This function is needed for compatibility with parameters
	+ * which used to use the mount_argf() command for the old mount() syscall.
	+ */
	+void
	+build_iovec_argf(struct iovec *iov, int iovlen, const char *name,
	+ const char *fmt, ...)
	+{
	+ va_list ap;
	+ char val[255] = { 0 };
	+
	+ va_start(ap, fmt);
	+ vsnprintf(val, sizeof(val), fmt, ap);
	+ va_end(ap);
	+ build_iovec(iov, iovlen, name, strdup(val), (size_t)-1);
	+}
	Index: sbin/mount_udf2/mntopts.h
	===================================================================
	--- /dev/null
	+++ sbin/mount_udf2/mntopts.h
	@@ -0,0 +1,99 @@
	+/*-
	+ * Copyright (c) 1994
	+ * The Regents of the University of California. All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ * 4. Neither the name of the University nor the names of its contributors
	+ * may be used to endorse or promote products derived from this software
	+ * without specific prior written permission.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ *
	+ * @(#)mntopts.h 8.7 (Berkeley) 3/29/95
	+ * $FreeBSD$
	+ */
	+
	+struct mntopt {
	+ const char m_option; / option name */
	+ int m_inverse; /* if a negative option, e.g. "atime" */
	+ int m_flag; /* bit to set, e.g. MNT_RDONLY */
	+ int m_altloc; /* 1 => set bit in altflags */
	+};
	+
	+/* User-visible MNT_ flags. */
	+#define MOPT_ASYNC { "async", 0, MNT_ASYNC, 0 }
	+#define MOPT_NOATIME { "atime", 1, MNT_NOATIME, 0 }
	+#define MOPT_NOEXEC { "exec", 1, MNT_NOEXEC, 0 }
	+#define MOPT_NOSUID { "suid", 1, MNT_NOSUID, 0 }
	+#define MOPT_NOSYMFOLLOW { "symfollow", 1, MNT_NOSYMFOLLOW, 0 }
	+#define MOPT_RDONLY { "rdonly", 0, MNT_RDONLY, 0 }
	+#define MOPT_SYNC { "sync", 0, MNT_SYNCHRONOUS, 0 }
	+#define MOPT_UNION { "union", 0, MNT_UNION, 0 }
	+#define MOPT_USERQUOTA { "userquota", 0, 0, 0 }
	+#define MOPT_GROUPQUOTA { "groupquota", 0, 0, 0 }
	+#define MOPT_NOCLUSTERR { "clusterr", 1, MNT_NOCLUSTERR, 0 }
	+#define MOPT_NOCLUSTERW { "clusterw", 1, MNT_NOCLUSTERW, 0 }
	+#define MOPT_SUIDDIR { "suiddir", 0, MNT_SUIDDIR, 0 }
	+#define MOPT_SNAPSHOT { "snapshot", 0, MNT_SNAPSHOT, 0 }
	+#define MOPT_MULTILABEL { "multilabel", 0, MNT_MULTILABEL, 0 }
	+#define MOPT_ACLS { "acls", 0, MNT_ACLS, 0 }
	+#define MOPT_NFS4ACLS { "nfsv4acls", 0, MNT_NFS4ACLS, 0 }
	+
	+/* Control flags. */
	+#define MOPT_FORCE { "force", 0, MNT_FORCE, 0 }
	+#define MOPT_UPDATE { "update", 0, MNT_UPDATE, 0 }
	+#define MOPT_RO { "ro", 0, MNT_RDONLY, 0 }
	+#define MOPT_RW { "rw", 1, MNT_RDONLY, 0 }
	+
	+/* This is parsed by mount(8), but is ignored by specific mount_(8)s. /
	+#define MOPT_AUTO { "auto", 0, 0, 0 }
	+
	+/* A handy macro as terminator of MNT_ array. */
	+#define MOPT_END { NULL, 0, 0, 0 }
	+
	+#define MOPT_FSTAB_COMPAT \
	+ MOPT_RO, \
	+ MOPT_RW, \
	+ MOPT_AUTO
	+
	+/* Standard options which all mounts can understand. */
	+#define MOPT_STDOPTS \
	+ MOPT_USERQUOTA, \
	+ MOPT_GROUPQUOTA, \
	+ MOPT_FSTAB_COMPAT, \
	+ MOPT_NOATIME, \
	+ MOPT_NOEXEC, \
	+ MOPT_SUIDDIR, /* must be before MOPT_NOSUID */ \
	+ MOPT_NOSUID, \
	+ MOPT_NOSYMFOLLOW, \
	+ MOPT_RDONLY, \
	+ MOPT_UNION, \
	+ MOPT_NOCLUSTERR, \
	+ MOPT_NOCLUSTERW, \
	+ MOPT_MULTILABEL, \
	+ MOPT_ACLS, \
	+ MOPT_NFS4ACLS
	+
	+void getmntopts(const char , const struct mntopt , int , int );
	+void rmslashes(char , char );
	+void checkpath(const char *, char resolved_path[]);
	+extern int getmnt_silent;
	+void build_iovec(struct iovec *iov, int iovlen, const char name, void val, size_t len);
	+void build_iovec_argf(struct iovec *iov, int iovlen, const char name, const char fmt, ...);
	Index: sbin/mount_udf2/mount_udf.c
	===================================================================
	--- /dev/null
	+++ sbin/mount_udf2/mount_udf.c
	@@ -0,0 +1,223 @@
	+/*
	+ * Copyright (c) 1992, 1993, 1994
	+ * The Regents of the University of California. All rights reserved.
	+ * Copyright (c) 2002 Scott Long
	+ * Copyright (c) 2012 Oleksandr Dudinskyi
	+ *
	+ * This code is derived from software contributed to Berkeley
	+ * by Pace Willisson (pace@blitz.com). The Rock Ridge Extension
	+ * Support code is derived from software contributed to Berkeley
	+ * by Atsushi Murai (amurai@spec.co.jp).
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ * 4. Neither the name of the University nor the names of its contributors
	+ * may be used to endorse or promote products derived from this software
	+ * without specific prior written permission.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ *
	+ * $FreeBSD$
	+ */
	+
	+/*
	+ * This is just a rip-off of mount_iso9660.c. It's been vastly simplified
	+ * because UDF doesn't take any options at this time.
	+ */
	+
	+#include <sys/cdio.h>
	+#include <sys/file.h>
	+#include <sys/iconv.h>
	+#include <sys/param.h>
	+#include <sys/linker.h>
	+#include <sys/module.h>
	+#include <sys/mount.h>
	+#include <sys/uio.h>
	+#include <sys/endian.h>
	+#include <sys/ioctl.h>
	+
	+#include "fs/udf2/udf_mount.h"
	+
	+#include <err.h>
	+#include <errno.h>
	+#include <stdlib.h>
	+#include <stdio.h>
	+#include <string.h>
	+#include <sysexits.h>
	+#include <unistd.h>
	+#include <fcntl.h>
	+
	+#include "mntopts.h"
	+
	+
	+struct mntopt mopts[] = {
	+ MOPT_STDOPTS,
	+ MOPT_UPDATE,
	+ MOPT_END
	+};
	+
	+static int set_charset(char , char , const char *);
	+static void usage(void);
	+
	+int
	+main(int argc, char **argv)
	+{
	+ struct udf_args args;
	+ struct iovec iov[14];
	+ int ch, i, mntflags, opts, udf_flags, verbose;
	+ char dev, dir, mntpath[MAXPATHLEN], cs_disk, cs_local, *endp;
	+
	+ /* read in disk info from options */
	+ args.anon_uid = 0;
	+ args.anon_gid = 0;
	+ args.nobody_uid = -1;
	+ args.nobody_gid = -1;
	+
	+ i = mntflags = opts = udf_flags = verbose = 0;
	+ cs_disk = cs_local = NULL;
	+ while ((ch = getopt(argc, argv, "o:vC:s:c:g:u:")) != -1)
	+ switch (ch) {
	+ case 'c':
	+ args.udfmflags \|= UDFMNT_CLOSESESSION;
	+ break;
	+ case 'g':
	+ args.anon_gid = strtol(optarg, &endp, 10);
	+ if (optarg == endp \|\| *endp != '\0')
	+ usage();
	+ break;
	+ case 'u':
	+ args.anon_uid = strtol(optarg, &endp, 10);
	+ if (optarg == endp \|\| *endp != '\0')
	+ usage();
	+ break;
	+ case 'o':
	+ getmntopts(optarg, mopts, &mntflags, &opts);
	+ break;
	+ case 'v':
	+ verbose++;
	+ break;
	+ case 'C':
	+ if (set_charset(&cs_disk, &cs_local, optarg) == -1)
	+ err(EX_OSERR, "udf2_iconv");
	+ udf_flags \|= UDFMNT_KICONV;
	+ break;
	+ case 's':
	+ args.sessionnr = strtol(optarg, &endp, 10);
	+ if (optarg == endp \|\| *endp != '\0')
	+ usage();
	+ break;
	+ case '?':
	+ default:
	+ usage();
	+ }
	+ argc -= optind;
	+ argv += optind;
	+
	+ if (argc != 2)
	+ usage();
	+
	+ dev = argv[0];
	+ dir = argv[1];
	+
	+
	+ /*
	+ * Resolve the mountpoint with realpath(3) and remove unnecessary
	+ * slashes from the devicename if there are any.
	+ */
	+ (void)checkpath(dir, mntpath);
	+ (void)rmslashes(dev, dev);
	+
	+ /*
	+ * UDF file systems are not writeable.
	+ */
	+ mntflags \|= MNT_RDONLY;
	+
	+ iov[i].iov_base = "fstype";
	+ iov[i++].iov_len = sizeof("fstype");
	+ iov[i].iov_base = "udf2";
	+ iov[i].iov_len = strlen(iov[i].iov_base) + 1;
	+ i++;
	+
	+ iov[i].iov_base = "fspath";
	+ iov[i++].iov_len = sizeof("fspath");
	+ iov[i].iov_base = mntpath;
	+ iov[i++].iov_len = strlen(mntpath) + 1;
	+
	+ iov[i].iov_base = "from";
	+ iov[i++].iov_len = sizeof("from");
	+ iov[i].iov_base = dev;
	+ iov[i++].iov_len = strlen(dev) + 1;
	+
	+ iov[i].iov_base = "flags";
	+ iov[i++].iov_len = sizeof("flags");
	+ iov[i].iov_base = &udf_flags;
	+ iov[i++].iov_len = sizeof(udf_flags);
	+
	+ iov[i].iov_base = "udf_args";
	+ iov[i++].iov_len = sizeof("udf_args");
	+ iov[i].iov_base = &args;
	+ iov[i++].iov_len = sizeof(args);
	+
	+ if (udf_flags & UDFMNT_KICONV) {
	+ iov[i].iov_base = "cs_disk";
	+ iov[i++].iov_len = sizeof("cs_disk");
	+ iov[i].iov_base = cs_disk;
	+ iov[i++].iov_len = strlen(cs_disk) + 1;
	+ iov[i].iov_base = "cs_local";
	+ iov[i++].iov_len = sizeof("cs_local");
	+ iov[i].iov_base = cs_local;
	+ iov[i++].iov_len = strlen(cs_local) + 1;
	+ }
	+ if (nmount(iov, i, mntflags) < 0)
	+ err(1, "%s", dev);
	+ exit(0);
	+}
	+
	+static int
	+set_charset(char cs_disk, char cs_local, const char *localcs)
	+{
	+ int error;
	+
	+ if (modfind("udf2_iconv") < 0)
	+ if (kldload("udf2_iconv") < 0 \|\| modfind("udf2_iconv") < 0) {
	+ warnx( "cannot find or load \"udf2_iconv\" kernel module");
	+ return (-1);
	+ }
	+
	+ if ((*cs_disk = malloc(ICONV_CSNMAXLEN)) == NULL)
	+ return (-1);
	+ if ((*cs_local = malloc(ICONV_CSNMAXLEN)) == NULL)
	+ return (-1);
	+ strncpy(*cs_disk, ENCODING_UNICODE, ICONV_CSNMAXLEN);
	+ strncpy(*cs_local, localcs, ICONV_CSNMAXLEN);
	+ error = kiconv_add_xlat16_cspairs(cs_disk, cs_local);
	+ if (error)
	+ return (-1);
	+
	+ return (0);
	+}
	+
	+static void
	+usage(void)
	+{
	+ (void)fprintf(stderr,
	+ "usage: mount_udf2 [-v] [-o options] [-C charset] [-s session] "
	+ "[-g gid] [-u uid] special node\n");
	+ exit(EX_USAGE);
	+}
	Index: sbin/mount_udf2/mount_udf2.8
	===================================================================
	--- /dev/null
	+++ sbin/mount_udf2/mount_udf2.8
	@@ -0,0 +1,115 @@
	+.\" Copyright (c) 2002
	+.\" Scott Long <scottl@FreeBSD.org>
	+.\" Jeroen Ruigrok van der Werven <asmodai@wxs.nl>
	+.\" All rights reserved.
	+.\"
	+.\" Redistribution and use in source and binary forms, with or without
	+.\" modification, are permitted provided that the following conditions
	+.\" are met:
	+.\" 1. Redistributions of source code must retain the above copyright
	+.\" notice, this list of conditions and the following disclaimer.
	+.\" 2. Redistributions in binary form must reproduce the above copyright
	+.\" notice, this list of conditions and the following disclaimer in the
	+.\" documentation and/or other materials provided with the distribution.
	+.\"
	+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+.\" SUCH DAMAGE.
	+.\"
	+.\" $FreeBSD$
	+.\"
	+.Dd March 23, 2002
	+.Dt MOUNT_UDF2 8
	+.Os
	+.Sh NAME
	+.Nm mount_udf2
	+.Nd mount a UDF file system
	+.Sh SYNOPSIS
	+.Nm
	+.Op Fl v
	+.Op Fl c
	+.Op Fl g Ar gid
	+.Op Fl o Ar options
	+.Op Fl C Ar charset
	+.Op Fl s Ar session
	+.Op Fl u Ar uid
	+.Ar special node
	+.Sh DESCRIPTION
	+The
	+.Nm
	+utility attaches the UDF file system residing on the device
	+.Ar special
	+to the global file system namespace at the location indicated by
	+.Ar node .
	+.Pp
	+The options are as follows:
	+.Bl -tag -width indent
	+.It Fl c
	+Close the session after unmount creating remountable snapshots.
	+Closing a session also allows -ROM devices to read the disc created.
	+Note that this option only makes sense when mounting sequential
	+recordable media like CD-R and DVD*R.
	+.It Fl g Ar gid
	+Set the group of anonymous files on the file system.
	+The default group is the nobody group.
	+.It Fl o
	+Options are specified with a
	+.Fl o
	+flag followed by a comma separated string of options.
	+See the
	+.Xr mount 8
	+man page for possible options and their meanings.
	+The following UDF specific options are available:
	+.It Fl v
	+Be verbose about mounting the UDF file system.
	+.It Fl C Ar charset
	+Specify local
	+.Ar charset
	+to convert Unicode file names.
	+.It Fl s Ar session
	+Select the session
	+.Ar session
	+to be mounted instead of the default last one.
	+Implements readonly snapshots on sequential media.
	+Positive
	+.Ar session
	+values indicate an absolute session number.
	+Negative
	+.Ar session
	+values are relative to the last session found on the disc.
	+Note that this option only makes sense when mounting sequential
	+recordable media like CD-R and DVD*R.
	+.It Fl u Ar uid
	+Set the owner of anonymous files on the file system.
	+The default owner is the user nobody.
	+.El
	+.Sh SEE ALSO
	+.Xr cdcontrol 1 ,
	+.Xr mount 2 ,
	+.Xr unmount 2 ,
	+.Xr fstab 5 ,
	+.Xr mount 8
	+.Sh NOTES
	+UDF is a file system defined by the OSTA standardization group and
	+is tailored for data interchange on optical discs (like CDs and
	+DVDs) between different operating systems.
	+Its also more and more common on other media like Compact
	+Flash (CF) cards.
	+.Pp
	+Read-only access is supported for all media types that CD/DVD/BD type drives
	+can recognise including DVD-RAM.
	+.Pp
	+All current UDF versions up to version 2.60 are supported.
	+.Sh HISTORY
	+The
	+.Nm
	+utility first appeared in
	+.Fx 5.0 .
	Index: sys/fs/udf2/Makefile
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/Makefile
	@@ -0,0 +1,13 @@
	+# $FreeBSD$
	+
	+.PATH: ${.CURDIR}
	+
	+KMOD= udf2
	+
	+SRCS= udf_readwrite.c udf_subr.c udf_allocation.c \
	+ udf_osta.c udf_vfsops.c udf_vnops.c udf_filenames.c
	+# udf_strat_bootstrap.c udf_strat_direct.c udf_strat_rmw.c udf_strat_sequential.c
	+SRCS+= vnode_if.h
	+EXPORT_SYMS= udf_iconv
	+
	+.include <bsd.kmod.mk>
	Index: sys/fs/udf2/ecma167-udf.h
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/ecma167-udf.h
	@@ -0,0 +1,835 @@
	+/* $NetBSD: ecma167-udf.h,v 1.14 2011/07/07 17:45:38 reinoud Exp $ */
	+
	+/*-
	+ * Copyright (c) 2003, 2004, 2005, 2006, 2008, 2009
	+ * Reinoud Zandijk * <reinoud@NetBSD.org>
	+ * Copyright (c) 2001, 2002 Scott Long <scottl@freebsd.org>
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ *
	+ *
	+ * Extended and adapted for UDFv2.50+ bij Reinoud Zandijk based on the
	+ * original by Scott Long.
	+ *
	+ * 20030508 Made some small typo and explanatory comments
	+ * 20030510 Added UDF 2.01 structures
	+ * 20030519 Added/correct comments on multi-partitioned logical volume space
	+ * 20050616 Added pseudo overwrite
	+ * 20050624 Added the missing extended attribute types and `magic values'.
	+ * 20051106 Reworked some implementation use parts
	+ *
	+ */
	+
	+
	+#ifndef _FS_UDF_ECMA167_UDF_H_
	+#define _FS_UDF_ECMA167_UDF_H_
	+
	+
	+/*
	+ * in case of an older gcc versions, define the __packed as explicit
	+ * attribute
	+ */
	+
	+/*
	+ * You may specify the `aligned' and `transparent_union' attributes either in
	+ * a `typedef' declaration or just past the closing curly brace of a complete
	+ * enum, struct or union type _definition_ and the `packed' attribute only
	+ * past the closing brace of a definition. You may also specify attributes
	+ * between the enum, struct or union tag and the name of the type rather than
	+ * after the closing brace.
	+*/
	+
	+#ifndef __packed
	+#define __packed __attribute__((packed))
	+#endif
	+
	+
	+/* ecma167-udf.h */
	+
	+/* Volume recognition sequence ECMA 167 rev. 3 16.1 */
	+struct vrs_desc {
	+ uint8_t struct_type;
	+ uint8_t identifier[5];
	+ uint8_t version;
	+ uint8_t data[2041];
	+} __packed;
	+
	+
	+#define VRS_NSR02 "NSR02"
	+#define VRS_NSR03 "NSR03"
	+#define VRS_BEA01 "BEA01"
	+#define VRS_TEA01 "TEA01"
	+#define VRS_CD001 "CD001"
	+#define VRS_CDW02 "CDW02"
	+
	+
	+/* Structure/definitions/constants a la ECMA 167 rev. 3 */
	+
	+
	+#define MAX_TAGID_VOLUMES 9
	+/* Tag identifiers */
	+enum {
	+ TAGID_SPARING_TABLE = 0,
	+ TAGID_PRI_VOL = 1,
	+ TAGID_ANCHOR = 2,
	+ TAGID_VOL = 3,
	+ TAGID_IMP_VOL = 4,
	+ TAGID_PARTITION = 5,
	+ TAGID_LOGVOL = 6,
	+ TAGID_UNALLOC_SPACE = 7,
	+ TAGID_TERM = 8,
	+ TAGID_LOGVOL_INTEGRITY= 9,
	+ TAGID_FSD = 256,
	+ TAGID_FID = 257,
	+ TAGID_ALLOCEXTENT = 258,
	+ TAGID_INDIRECTENTRY = 259,
	+ TAGID_ICB_TERM = 260,
	+ TAGID_FENTRY = 261,
	+ TAGID_EXTATTR_HDR = 262,
	+ TAGID_UNALL_SP_ENTRY = 263,
	+ TAGID_SPACE_BITMAP = 264,
	+ TAGID_PART_INTEGRITY = 265,
	+ TAGID_EXTFENTRY = 266,
	+ TAGID_MAX = 266
	+};
	+
	+
	+enum {
	+ UDF_DOMAIN_FLAG_HARD_WRITE_PROTECT = 1,
	+ UDF_DOMAIN_FLAG_SOFT_WRITE_PROTECT = 2
	+};
	+
	+
	+enum {
	+ UDF_ACCESSTYPE_NOT_SPECIFIED = 0, /* unknown */
	+ UDF_ACCESSTYPE_PSEUDO_OVERWITE = 0, /* pseudo overwritable, e.g. BD-R's LOW */
	+ UDF_ACCESSTYPE_READ_ONLY = 1, /* really only readable */
	+ UDF_ACCESSTYPE_WRITE_ONCE = 2, /* write once and you're done */
	+ UDF_ACCESSTYPE_REWRITEABLE = 3, /* may need extra work to rewrite */
	+ UDF_ACCESSTYPE_OVERWRITABLE = 4 /* no limits on rewriting; e.g. harddisc*/
	+};
	+
	+
	+/* Descriptor tag [3/7.2] */
	+struct desc_tag {
	+ uint16_t id;
	+ uint16_t descriptor_ver;
	+ uint8_t cksum;
	+ uint8_t reserved;
	+ uint16_t serial_num;
	+ uint16_t desc_crc;
	+ uint16_t desc_crc_len;
	+ uint32_t tag_loc;
	+} __packed;
	+#define UDF_DESC_TAG_LENGTH 16
	+
	+
	+/* Recorded Address [4/7.1] */
	+struct lb_addr { /* within partition space */
	+ uint32_t lb_num;
	+ uint16_t part_num;
	+} __packed;
	+
	+
	+/* Extent Descriptor [3/7.1] */
	+struct extent_ad {
	+ uint32_t len;
	+ uint32_t loc;
	+} __packed;
	+
	+
	+/* Short Allocation Descriptor [4/14.14.1] */
	+struct short_ad {
	+ uint32_t len;
	+ uint32_t lb_num;
	+} __packed;
	+
	+
	+/* Long Allocation Descriptor [4/14.14.2] */
	+struct UDF_ADImp_use {
	+ uint16_t flags;
	+ uint32_t unique_id;
	+} __packed;
	+#define UDF_ADIMP_FLAGS_EXTENT_ERASED 1
	+
	+
	+struct long_ad {
	+ uint32_t len;
	+ struct lb_addr loc; /* within a logical volume mapped partition space !! */
	+ union {
	+ uint8_t bytes[6];
	+ struct UDF_ADImp_use im_used;
	+ } impl;
	+} __packed;
	+#define longad_uniqueid impl.im_used.unique_id
	+
	+
	+/* Extended Allocation Descriptor [4/14.14.3] ; identifies an extent of allocation descriptors ; also in UDF ? */
	+struct ext_ad {
	+ uint32_t ex_len;
	+ uint32_t rec_len;
	+ uint32_t inf_len;
	+ struct lb_addr ex_loc;
	+ uint8_t reserved[2];
	+} __packed;
	+
	+
	+/* ICB : Information Control Block; positioning */
	+union icb {
	+ struct short_ad s_ad;
	+ struct long_ad l_ad;
	+ struct ext_ad e_ad;
	+};
	+
	+
	+/* short/long/ext extent have flags encoded in length */
	+#define UDF_EXT_ALLOCATED (0<<30)
	+#define UDF_EXT_FREED (1<<30)
	+#define UDF_EXT_ALLOCATED_BUT_NOT_USED (1<<30)
	+#define UDF_EXT_FREE (2<<30)
	+#define UDF_EXT_REDIRECT (3<<30)
	+#define UDF_EXT_FLAGS(len) ((len) & (3<<30))
	+#define UDF_EXT_LEN(len) ((len) & ((1<<30)-1))
	+#define UDF_EXT_MAXLEN ((1<<30)-1)
	+
	+
	+/* Character set spec [1/7.2.1] */
	+struct charspec {
	+ uint8_t type;
	+ uint8_t inf[63];
	+} __packed;
	+
	+
	+struct pathcomp {
	+ uint8_t type;
	+ uint8_t l_ci;
	+ uint16_t comp_filever;
	+ uint8_t ident[256];
	+} __packed;
	+#define UDF_PATH_COMP_SIZE 4
	+#define UDF_PATH_COMP_RESERVED 0
	+#define UDF_PATH_COMP_ROOT 1
	+#define UDF_PATH_COMP_MOUNTROOT 2
	+#define UDF_PATH_COMP_PARENTDIR 3
	+#define UDF_PATH_COMP_CURDIR 4
	+#define UDF_PATH_COMP_NAME 5
	+
	+
	+/* Timestamp [1/7.3] */
	+struct timestamp {
	+ uint16_t type_tz;
	+ uint16_t year;
	+ uint8_t month;
	+ uint8_t day;
	+ uint8_t hour;
	+ uint8_t minute;
	+ uint8_t second;
	+ uint8_t centisec;
	+ uint8_t hund_usec;
	+ uint8_t usec;
	+} __packed;
	+#define UDF_TIMESTAMP_SIZE 12
	+
	+
	+/* Entity Identifier [1/7.4] */
	+#define UDF_REGID_ID_SIZE 23
	+struct regid {
	+ uint8_t flags;
	+ uint8_t id[UDF_REGID_ID_SIZE];
	+ uint8_t id_suffix[8];
	+} __packed;
	+
	+
	+/* ICB Tag [4/14.6] */
	+struct icb_tag {
	+ uint32_t prev_num_dirs;
	+ uint16_t strat_type;
	+ uint8_t strat_param[2];
	+ uint16_t max_num_entries;
	+ uint8_t reserved;
	+ uint8_t file_type;
	+ struct lb_addr parent_icb;
	+ uint16_t flags;
	+} __packed;
	+#define UDF_ICB_TAG_FLAGS_ALLOC_MASK 0x03
	+#define UDF_ICB_SHORT_ALLOC 0x00
	+#define UDF_ICB_LONG_ALLOC 0x01
	+#define UDF_ICB_EXT_ALLOC 0x02
	+#define UDF_ICB_INTERN_ALLOC 0x03
	+
	+#define UDF_ICB_TAG_FLAGS_DIRORDERED (1<< 3)
	+#define UDF_ICB_TAG_FLAGS_NONRELOC (1<< 4)
	+#define UDF_ICB_TAG_FLAGS_CONTIGUES (1<< 9)
	+#define UDF_ICB_TAG_FLAGS_MULTIPLEVERS (1<<12)
	+
	+#define UDF_ICB_TAG_FLAGS_SETUID (1<< 6)
	+#define UDF_ICB_TAG_FLAGS_SETGID (1<< 7)
	+#define UDF_ICB_TAG_FLAGS_STICKY (1<< 8)
	+
	+#define UDF_ICB_FILETYPE_UNKNOWN 0
	+#define UDF_ICB_FILETYPE_UNALLOCSPACE 1
	+#define UDF_ICB_FILETYPE_PARTINTEGRITY 2
	+#define UDF_ICB_FILETYPE_INDIRECTENTRY 3
	+#define UDF_ICB_FILETYPE_DIRECTORY 4
	+#define UDF_ICB_FILETYPE_RANDOMACCESS 5
	+#define UDF_ICB_FILETYPE_BLOCKDEVICE 6
	+#define UDF_ICB_FILETYPE_CHARDEVICE 7
	+#define UDF_ICB_FILETYPE_EXTATTRREC 8
	+#define UDF_ICB_FILETYPE_FIFO 9
	+#define UDF_ICB_FILETYPE_SOCKET 10
	+#define UDF_ICB_FILETYPE_TERM 11
	+#define UDF_ICB_FILETYPE_SYMLINK 12
	+#define UDF_ICB_FILETYPE_STREAMDIR 13
	+#define UDF_ICB_FILETYPE_VAT 248
	+#define UDF_ICB_FILETYPE_REALTIME 249
	+#define UDF_ICB_FILETYPE_META_MAIN 250
	+#define UDF_ICB_FILETYPE_META_MIRROR 251
	+#define UDF_ICB_FILETYPE_META_BITMAP 252
	+
	+
	+/* Anchor Volume Descriptor Pointer [3/10.2] */
	+struct anchor_vdp {
	+ struct desc_tag tag;
	+ struct extent_ad main_vds_ex; /* to main volume descriptor set ; 16 sectors min */
	+ struct extent_ad reserve_vds_ex; /* copy of main volume descriptor set ; 16 sectors min */
	+} __packed;
	+
	+
	+/* Volume Descriptor Pointer [3/10.3] */
	+struct vol_desc_ptr {
	+ struct desc_tag tag; /* use for extending the volume descriptor space */
	+ uint32_t vds_number;
	+ struct extent_ad next_vds_ex; /* points to the next block for volume descriptor space */
	+} __packed;
	+
	+
	+/* Primary Volume Descriptor [3/10.1] */
	+struct pri_vol_desc {
	+ struct desc_tag tag;
	+ uint32_t seq_num; /* MAX prevail */
	+ uint32_t pvd_num; /* assigned by author; 0 is special as in it may only occur once */
	+ char vol_id[32]; /* KEY ; main identifier of this disc */
	+ uint16_t vds_num; /* volume descriptor number; i.e. what volume number is it */
	+ uint16_t max_vol_seq; /* maximum volume descriptor number known */
	+ uint16_t ichg_lvl;
	+ uint16_t max_ichg_lvl;
	+ uint32_t charset_list;
	+ uint32_t max_charset_list;
	+ char volset_id[128]; /* KEY ; if part of a multi-disc set or a band of volumes */
	+ struct charspec desc_charset; /* KEY according to ECMA 167 */
	+ struct charspec explanatory_charset;
	+ struct extent_ad vol_abstract;
	+ struct extent_ad vol_copyright;
	+ struct regid app_id;
	+ struct timestamp time;
	+ struct regid imp_id;
	+ uint8_t imp_use[64];
	+ uint32_t prev_vds_loc; /* location of predecessor _lov ? */
	+ uint16_t flags; /* bit 0 : if set indicates volume set name is meaningful */
	+ uint8_t reserved[22];
	+} __packed;
	+
	+
	+/* UDF specific implementation use part of the implementation use volume descriptor */
	+struct udf_lv_info {
	+ struct charspec lvi_charset;
	+ char logvol_id[128];
	+
	+ char lvinfo1[36];
	+ char lvinfo2[36];
	+ char lvinfo3[36];
	+
	+ struct regid impl_id;
	+ uint8_t impl_use[128];
	+} __packed;
	+
	+
	+/* Implementation use Volume Descriptor */
	+struct impvol_desc {
	+ struct desc_tag tag;
	+ uint32_t seq_num;
	+ struct regid impl_id;
	+ union {
	+ struct udf_lv_info lv_info;
	+ char impl_use[460];
	+ } _impl_use;
	+} __packed;
	+
	+
	+/* Logical Volume Descriptor [3/10.6] */
	+struct logvol_desc {
	+ struct desc_tag tag;
	+ uint32_t seq_num; /* MAX prevail */
	+ struct charspec desc_charset; /* KEY */
	+ char logvol_id[128]; /* KEY */
	+ uint32_t lb_size;
	+ struct regid domain_id;
	+ union {
	+ struct long_ad fsd_loc; /* to fileset descriptor SEQUENCE */
	+ uint8_t logvol_content_use[16];
	+ } _lvd_use;
	+ uint32_t mt_l; /* Partition map length */
	+ uint32_t n_pm; /* Number of partition maps */
	+ struct regid imp_id;
	+ uint8_t imp_use[128];
	+ struct extent_ad integrity_seq_loc;
	+ uint8_t maps[1];
	+} __packed;
	+#define lv_fsd_loc _lvd_use.fsd_loc
	+
	+#define UDF_INTEGRITY_OPEN 0
	+#define UDF_INTEGRITY_CLOSED 1
	+
	+
	+#define UDF_PMAP_SIZE 64
	+
	+/* Type 1 Partition Map [3/10.7.2] */
	+struct part_map_1 {
	+ uint8_t type;
	+ uint8_t len;
	+ uint16_t vol_seq_num;
	+ uint16_t part_num;
	+} __packed;
	+
	+
	+/* Type 2 Partition Map [3/10.7.3] */
	+struct part_map_2 {
	+ uint8_t type;
	+ uint8_t len;
	+ uint8_t reserved[2];
	+ struct regid part_id;
	+ uint16_t vol_seq_num;
	+ uint16_t part_num;
	+ uint8_t reserved2[24];
	+} __packed;
	+
	+
	+/* Virtual Partition Map [UDF 2.01/2.2.8] */
	+struct part_map_virt {
	+ uint8_t type;
	+ uint8_t len;
	+ uint8_t reserved[2];
	+ struct regid id;
	+ uint16_t vol_seq_num;
	+ uint16_t part_num;
	+ uint8_t reserved1[24];
	+} __packed;
	+
	+
	+/* Sparable Partition Map [UDF 2.01/2.2.9] */
	+struct part_map_spare {
	+ uint8_t type;
	+ uint8_t len;
	+ uint8_t reserved[2];
	+ struct regid id;
	+ uint16_t vol_seq_num;
	+ uint16_t part_num;
	+ uint16_t packet_len;
	+ uint8_t n_st; /* Number of redundant sparing tables range 1-4 */
	+ uint8_t reserved1;
	+ uint32_t st_size; /* size of EACH sparing table */
	+ uint32_t st_loc[1]; /* locations of sparing tables */
	+} __packed;
	+
	+
	+/* Metadata Partition Map [UDF 2.50/2.2.10] */
	+struct part_map_meta {
	+ uint8_t type;
	+ uint8_t len;
	+ uint8_t reserved[2];
	+ struct regid id;
	+ uint16_t vol_seq_num;
	+ uint16_t part_num;
	+ uint32_t meta_file_lbn; /* logical block number for file entry within part_num */
	+ uint32_t meta_mirror_file_lbn;
	+ uint32_t meta_bitmap_file_lbn;
	+ uint32_t alloc_unit_size; /* allocation unit size in blocks */
	+ uint16_t alignment_unit_size; /* alignment necessary in blocks */
	+ uint8_t flags;
	+ uint8_t reserved1[5];
	+} __packed;
	+#define METADATA_DUPLICATED 1
	+
	+
	+union udf_pmap {
	+ uint8_t data[UDF_PMAP_SIZE];
	+ struct part_map_1 pm1;
	+ struct part_map_2 pm2;
	+ struct part_map_virt pmv;
	+ struct part_map_spare pms;
	+ struct part_map_meta pmm;
	+};
	+
	+
	+/* Sparing Map Entry [UDF 2.01/2.2.11] */
	+struct spare_map_entry {
	+ uint32_t org; /* partition relative address */
	+ uint32_t map; /* absolute disc address (!) can be in partition, but doesn't have to be */
	+} __packed;
	+
	+
	+/* Sparing Table [UDF 2.01/2.2.11] */
	+struct udf_sparing_table {
	+ struct desc_tag tag;
	+ struct regid id;
	+ uint16_t rt_l; /* Relocation Table len */
	+ uint8_t reserved[2];
	+ uint32_t seq_num;
	+ struct spare_map_entry entries[1];
	+} __packed;
	+
	+
	+#define UDF_NO_PREV_VAT 0xffffffff
	+/* UDF 1.50 VAT suffix [UDF 2.2.10 (UDF 1.50 spec)] */
	+struct udf_oldvat_tail {
	+ struct regid id; /* "UDF Virtual Alloc Tbl" /
	+ uint32_t prev_vat;
	+} __packed;
	+
	+
	+/* VAT table [UDF 2.0.1/2.2.10] */
	+struct udf_vat {
	+ uint16_t header_len;
	+ uint16_t impl_use_len;
	+ char logvol_id[128]; /* newer version of the LVD one */
	+ uint32_t prev_vat;
	+ uint32_t num_files;
	+ uint32_t num_directories;
	+ uint16_t min_udf_readver;
	+ uint16_t min_udf_writever;
	+ uint16_t max_udf_writever;
	+ uint16_t reserved;
	+ uint8_t data[1]; /* impl.use followed by VAT entries (uint32_t) */
	+} __packed;
	+
	+
	+/* Space bitmap descriptor as found in the partition header descriptor */
	+struct space_bitmap_desc {
	+ struct desc_tag tag; /* TagId 264 */
	+ uint32_t num_bits; /* number of bits */
	+ uint32_t num_bytes; /* bytes that contain it */
	+ uint8_t data[1];
	+} __packed;
	+
	+
	+/* Unalloc space entry as found in the partition header descriptor */
	+struct space_entry_desc {
	+ struct desc_tag tag; /* TagId 263 */
	+ struct icb_tag icbtag; /* type 1 */
	+ uint32_t l_ad; /* in bytes */
	+ uint8_t entry[1];
	+} __packed;
	+
	+
	+/* Partition header descriptor; in the contents_use of part_desc */
	+struct part_hdr_desc {
	+ struct short_ad unalloc_space_table;
	+ struct short_ad unalloc_space_bitmap;
	+ struct short_ad part_integrity_table; /* has to be ZERO for UDF */
	+ struct short_ad freed_space_table;
	+ struct short_ad freed_space_bitmap;
	+ uint8_t reserved[88];
	+} __packed;
	+
	+
	+/* Partition Descriptor [3/10.5] */
	+struct part_desc {
	+ struct desc_tag tag;
	+ uint32_t seq_num; /* MAX prevailing */
	+ uint16_t flags; /* bit 0 : if set the space is allocated */
	+ uint16_t part_num; /* KEY */
	+ struct regid contents;
	+ union {
	+ struct part_hdr_desc part_hdr;
	+ uint8_t contents_use[128];
	+ } _impl_use;
	+ uint32_t access_type; /* R/W, WORM etc. */
	+ uint32_t start_loc; /* start of partition with given length */
	+ uint32_t part_len;
	+ struct regid imp_id;
	+ uint8_t imp_use[128];
	+ uint8_t reserved[156];
	+} __packed;
	+#define pd_part_hdr _impl_use.part_hdr
	+#define UDF_PART_FLAG_ALLOCATED 1
	+
	+
	+/* Unallocated Space Descriptor (UDF 2.01/2.2.5) */
	+struct unalloc_sp_desc {
	+ struct desc_tag tag;
	+ uint32_t seq_num; /* MAX prevailing */
	+ uint32_t alloc_desc_num;
	+ struct extent_ad alloc_desc[1];
	+} __packed;
	+
	+
	+/* Logical Volume Integrity Descriptor [3/30.10] */
	+struct logvolhdr {
	+ uint64_t next_unique_id;
	+ /* rest reserved */
	+} __packed;
	+
	+
	+struct udf_logvol_info {
	+ struct regid impl_id;
	+ uint32_t num_files;
	+ uint32_t num_directories;
	+ uint16_t min_udf_readver;
	+ uint16_t min_udf_writever;
	+ uint16_t max_udf_writever;
	+} __packed;
	+
	+
	+struct logvol_int_desc {
	+ struct desc_tag tag;
	+ struct timestamp time;
	+ uint32_t integrity_type;
	+ struct extent_ad next_extent;
	+ union {
	+ struct logvolhdr logvolhdr;
	+ int8_t reserved[32];
	+ } _impl_use;
	+ uint32_t num_part;
	+ uint32_t l_iu;
	+ uint32_t tables[1]; /* Freespace table, Sizetable, Implementation use */
	+} __packed;
	+#define lvint_next_unique_id _impl_use.logvolhdr.next_unique_id
	+
	+
	+/* File Set Descriptor [4/14.1] */
	+struct fileset_desc {
	+ struct desc_tag tag;
	+ struct timestamp time;
	+ uint16_t ichg_lvl;
	+ uint16_t max_ichg_lvl;
	+ uint32_t charset_list;
	+ uint32_t max_charset_list;
	+ uint32_t fileset_num; /* key! */
	+ uint32_t fileset_desc_num;
	+ struct charspec logvol_id_charset;
	+ char logvol_id[128]; /* for recovery */
	+ struct charspec fileset_charset;
	+ char fileset_id[32]; /* Mountpoint !! */
	+ char copyright_file_id[32];
	+ char abstract_file_id[32];
	+ struct long_ad rootdir_icb; /* to rootdir; icb->virtual ? */
	+ struct regid domain_id;
	+ struct long_ad next_ex; /* to the next fileset_desc extent */
	+ struct long_ad streamdir_icb; /* streamdir; needed? */
	+ uint8_t reserved[32];
	+} __packed;
	+
	+
	+/* File Identifier Descriptor [4/14.4] */
	+struct fileid_desc {
	+ struct desc_tag tag;
	+ uint16_t file_version_num;
	+ uint8_t file_char;
	+ uint8_t l_fi; /* Length of file identifier area */
	+ struct long_ad icb;
	+ uint16_t l_iu; /* Length of implementation use area */
	+ uint8_t data[0];
	+} __packed;
	+#define UDF_FID_SIZE 38
	+#define UDF_FILE_CHAR_VIS (1 << 0) /* Invisible */
	+#define UDF_FILE_CHAR_DIR (1 << 1) /* Directory */
	+#define UDF_FILE_CHAR_DEL (1 << 2) /* Deleted */
	+#define UDF_FILE_CHAR_PAR (1 << 3) /* Parent Directory */
	+#define UDF_FILE_CHAR_META (1 << 4) /* Stream metadata */
	+
	+
	+/* Extended attributes [4/14.10.1] */
	+struct extattrhdr_desc {
	+ struct desc_tag tag;
	+ uint32_t impl_attr_loc; /* offsets within this descriptor */
	+ uint32_t appl_attr_loc; /* ditto */
	+} __packed;
	+#define UDF_IMPL_ATTR_LOC_NOT_PRESENT 0xffffffff
	+#define UDF_APPL_ATTR_LOC_NOT_PRESENT 0xffffffff
	+
	+
	+/* Extended attribute entry [4/48.10.2] */
	+struct extattr_entry {
	+ uint32_t type;
	+ uint8_t subtype;
	+ uint8_t reserved[3];
	+ uint32_t a_l;
	+} __packed;
	+
	+
	+/* Extended attribute entry; type 2048 [4/48.10.8] */
	+struct impl_extattr_entry {
	+ struct extattr_entry hdr;
	+ uint32_t iu_l;
	+ struct regid imp_id;
	+ uint8_t data[1];
	+} __packed;
	+
	+
	+/* Extended attribute entry; type 65 536 [4/48.10.9] */
	+struct appl_extattr_entry {
	+ struct extattr_entry hdr;
	+ uint32_t au_l;
	+ struct regid appl_id;
	+ uint8_t data[1];
	+} __packed;
	+
	+
	+/* File Times attribute entry; type 5 or type 6 [4/48.10.5], [4/48.10.6] */
	+struct filetimes_extattr_entry {
	+ struct extattr_entry hdr;
	+ uint32_t d_l; /* length of times[] data following */
	+ uint32_t existence; /* bitmask */
	+ struct timestamp times[1]; /* in order of ascending bits */
	+} __packed;
	+#define UDF_FILETIMES_ATTR_NO 5
	+#define UDF_FILETIMES_FILE_CREATION 1
	+#define UDF_FILETIMES_FILE_DELETION 4
	+#define UDF_FILETIMES_FILE_EFFECTIVE 8
	+#define UDF_FILETIMES_FILE_BACKUPED 16
	+#define UDF_FILETIMES_ATTR_SIZE(no) (20 + (no)*sizeof(struct timestamp))
	+
	+
	+/* Device Specification Extended Attribute [4/4.10.7] */
	+struct device_extattr_entry {
	+ struct extattr_entry hdr;
	+ uint32_t iu_l; /* length of implementation use */
	+ uint32_t major;
	+ uint32_t minor;
	+ uint8_t data[1]; /* UDF: if nonzero length, contain developer ID regid */
	+} __packed;
	+#define UDF_DEVICESPEC_ATTR_NO 12
	+
	+
	+/* VAT LV extension Extended Attribute [UDF 3.3.4.5.1.3] 1.50 errata */
	+struct vatlvext_extattr_entry {
	+ uint64_t unique_id_chk; /* needs to be copy of ICB's */
	+ uint32_t num_files;
	+ uint32_t num_directories;
	+ char logvol_id[128]; /* replaces logvol name */
	+} __packed;
	+
	+
	+/* File Entry [4/14.9] */
	+struct file_entry {
	+ struct desc_tag tag;
	+ struct icb_tag icbtag;
	+ uint32_t uid;
	+ uint32_t gid;
	+ uint32_t perm;
	+ uint16_t link_cnt;
	+ uint8_t rec_format;
	+ uint8_t rec_disp_attr;
	+ uint32_t rec_len;
	+ uint64_t inf_len;
	+ uint64_t logblks_rec;
	+ struct timestamp atime;
	+ struct timestamp mtime;
	+ struct timestamp attrtime;
	+ uint32_t ckpoint;
	+ struct long_ad ex_attr_icb;
	+ struct regid imp_id;
	+ uint64_t unique_id;
	+ uint32_t l_ea; /* Length of extended attribute area */
	+ uint32_t l_ad; /* Length of allocation descriptors */
	+ uint8_t data[1];
	+} __packed;
	+#define UDF_FENTRY_SIZE 176
	+#define UDF_FENTRY_PERM_USER_MASK 0x07
	+#define UDF_FENTRY_PERM_GRP_MASK 0xE0
	+#define UDF_FENTRY_PERM_OWNER_MASK 0x1C00
	+
	+
	+/* Extended File Entry [4/48.17] */
	+struct extfile_entry {
	+ struct desc_tag tag;
	+ struct icb_tag icbtag;
	+ uint32_t uid;
	+ uint32_t gid;
	+ uint32_t perm;
	+ uint16_t link_cnt;
	+ uint8_t rec_format;
	+ uint8_t rec_disp_attr;
	+ uint32_t rec_len;
	+ uint64_t inf_len;
	+ uint64_t obj_size;
	+ uint64_t logblks_rec;
	+ struct timestamp atime;
	+ struct timestamp mtime;
	+ struct timestamp ctime;
	+ struct timestamp attrtime;
	+ uint32_t ckpoint;
	+ uint32_t reserved1;
	+ struct long_ad ex_attr_icb;
	+ struct long_ad streamdir_icb;
	+ struct regid imp_id;
	+ uint64_t unique_id;
	+ uint32_t l_ea; /* Length of extended attribute area */
	+ uint32_t l_ad; /* Length of allocation descriptors */
	+ uint8_t data[1];
	+} __packed;
	+#define UDF_EXTFENTRY_SIZE 216
	+
	+
	+/* Indirect entry [ecma 48.7] */
	+struct indirect_entry {
	+ struct desc_tag tag;
	+ struct icb_tag icbtag;
	+ struct long_ad indirect_icb;
	+} __packed;
	+
	+
	+/* Allocation extent descriptor [ecma 48.5] */
	+struct alloc_ext_entry {
	+ struct desc_tag tag;
	+ uint32_t prev_entry;
	+ uint32_t l_ad;
	+ uint8_t data[1];
	+} __packed;
	+
	+
	+union dscrptr {
	+ struct desc_tag tag;
	+ struct anchor_vdp avdp;
	+ struct vol_desc_ptr vdp;
	+ struct pri_vol_desc pvd;
	+ struct logvol_desc lvd;
	+ struct unalloc_sp_desc usd;
	+ struct logvol_int_desc lvid;
	+ struct impvol_desc ivd;
	+ struct part_desc pd;
	+ struct fileset_desc fsd;
	+ struct fileid_desc fid;
	+ struct file_entry fe;
	+ struct extfile_entry efe;
	+ struct extattrhdr_desc eahd;
	+ struct indirect_entry inde;
	+ struct alloc_ext_entry aee;
	+ struct udf_sparing_table spt;
	+ struct space_bitmap_desc sbd;
	+ struct space_entry_desc sed;
	+};
	+
	+
	+#endif /* !_FS_UDF_ECMA167_UDF_H_ */
	+
	Index: sys/fs/udf2/udf.h
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf.h
	@@ -0,0 +1,440 @@
	+/*-
	+ * Copyright (c) 2006, 2008 Reinoud Zandijk
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ */
	+
	+#ifndef _FS_UDF_UDF_H_
	+#define _FS_UDF_UDF_H_
	+
	+#include "udf_osta.h"
	+#include "udf_mount.h"
	+#include "udfio.h"
	+
	+/* lets see debug stuff for now */
	+#define DEBUG
	+
	+/* debug section */
	+extern int udf_verbose;
	+
	+/* undefine UDF_COMPLETE_DELETE to need `purge'; but purge is not implemented */
	+#define UDF_COMPLETE_DELETE
	+
	+/* debug categories */
	+#define UDF_DEBUG_VOLUMES 0x0000001
	+#define UDF_DEBUG_LOCKING 0x0000002
	+#define UDF_DEBUG_NODE 0x0000004
	+#define UDF_DEBUG_LOOKUP 0x0000008
	+#define UDF_DEBUG_READDIR 0x0000010
	+#define UDF_DEBUG_FIDS 0x0000020
	+#define UDF_DEBUG_DESCRIPTOR 0x0000040
	+#define UDF_DEBUG_TRANSLATE 0x0000080
	+#define UDF_DEBUG_STRATEGY 0x0000100
	+#define UDF_DEBUG_READ 0x0000200
	+#define UDF_DEBUG_WRITE 0x0000400
	+#define UDF_DEBUG_CALL 0x0000800
	+#define UDF_DEBUG_ATTR 0x0001000
	+#define UDF_DEBUG_EXTATTR 0x0002000
	+#define UDF_DEBUG_ALLOC 0x0004000
	+#define UDF_DEBUG_ADWLK 0x0008000
	+#define UDF_DEBUG_DIRHASH 0x0010000
	+#define UDF_DEBUG_NOTIMPL 0x0020000
	+#define UDF_DEBUG_SHEDULE 0x0040000
	+#define UDF_DEBUG_ECCLINE 0x0080000
	+#define UDF_DEBUG_SYNC 0x0100000
	+#define UDF_DEBUG_PARANOIA 0x0200000
	+#define UDF_DEBUG_PARANOIDADWLK 0x0400000
	+#define UDF_DEBUG_NODEDUMP 0x0800000
	+#define UDF_DEBUG_RESERVE 0x1000000
	+
	+/* initial value of udf_verbose */
	+#define UDF_DEBUGGING 0
	+
	+#ifdef DEBUG
	+#define DPRINTF(name, arg) { \
	+ if (udf_verbose & UDF_DEBUG_##name) {\
	+ printf arg;\
	+ };\
	+ }
	+#define DPRINTFIF(name, cond, arg) { \
	+ if (udf_verbose & UDF_DEBUG_##name) { \
	+ if (cond) printf arg;\
	+ };\
	+ }
	+#else
	+#define DPRINTF(name, arg) {}
	+#define DPRINTFIF(name, cond, arg) {}
	+#endif
	+
	+/* constants to identify what kind of identifier we are dealing with */
	+#define UDF_REGID_DOMAIN 1
	+#define UDF_REGID_UDF 2
	+#define UDF_REGID_IMPLEMENTATION 3
	+#define UDF_REGID_APPLICATION 4
	+#define UDF_REGID_NAME 99
	+
	+
	+/* DON'T change these: they identify 13thmonkey's UDF implementation */
	+#define APP_NAME "*NetBSD UDF"
	+#define APP_VERSION_MAIN 0
	+#define APP_VERSION_SUB 5
	+#define IMPL_NAME "*NetBSD kernel UDF"
	+
	+
	+/* Configuration values */
	+#if 0
	+#define UDF_ECCBUF_HASHBITS 10
	+#define UDF_ECCBUF_HASHSIZE (1<<UDF_ECCBUF_HASHBITS)
	+#define UDF_ECCBUF_HASHMASK (UDF_ECCBUF_HASHSIZE -1)
	+
	+#define UDF_ECCLINE_MAXFREE 5 /* picked, needs calculation */
	+#define UDF_ECCLINE_MAXBUSY 100 /* picked, needs calculation */
	+
	+#define UDF_MAX_MAPPINGS (MAXPHYS/DEV_BSIZE) /* 128 */
	+#endif
	+#define UDF_VAT_CHUNKSIZE (641024) / picked */
	+#define UDF_SYMLINKBUFLEN (641024) / picked */
	+
	+#define UDF_DISC_SLACK (128) /* picked, at least 64 kb or 128 */
	+#define UDF_ISO_VRS_SIZE (322048) / 32 ISO `sectors' */
	+
	+
	+/* structure space */
	+#define UDF_ANCHORS 4 /* 256, 512, N-256, N */
	+#define UDF_PARTITIONS 4 /* overkill */
	+#define UDF_PMAPS 5 /* overkill */
	+#define UDF_LVDINT_SEGMENTS 100 /* big overkill */
	+#define UDF_LVINT_LOSSAGE 4 /* lose 2 openings */
	+#define UDF_MAX_ALLOC_EXTENTS 50 /* overkill */
	+
	+
	+/* constants */
	+#define UDF_MAX_NAMELEN 255 /* as per SPEC */
	+#define UDF_TRANS_ZERO ((uint64_t) -1)
	+#define UDF_TRANS_UNMAPPED ((uint64_t) -2)
	+#define UDF_TRANS_INTERN ((uint64_t) -3)
	+#define UDF_MAX_SECTOR ((uint64_t) -10) /* high water mark */
	+
	+
	+/* RW content hint for allocation and other purposes */
	+#define UDF_C_ABSOLUTE 0 /* blob to write at absolute */
	+#define UDF_C_PROCESSED 0 /* not relevant */
	+#define UDF_C_USERDATA 1 /* all but userdata is metadata */
	+#define UDF_C_DSCR 2 /* update sectornr and CRC */
	+#define UDF_C_FLOAT_DSCR 3 /* update sectornr and CRC; sequential */
	+#define UDF_C_NODE 4 /* file/dir node, update sectornr and CRC */
	+#define UDF_C_FIDS 5 /* update all contained fids */
	+#define UDF_C_METADATA_SBM 6 /* space bitmap, update sectornr and CRC */
	+#define UDF_C_EXTATTRS 7 /* dunno what to do yet */
	+
	+/* use unused b_freelistindex for our UDF_C_TYPE */
	+#define b_udf_c_type b_freelistindex
	+
	+
	+/* virtual to physical mapping types */
	+#define UDF_VTOP_RAWPART UDF_PMAPS /* [0..UDF_PMAPS> are normal */
	+
	+#define UDF_VTOP_TYPE_RAW 0
	+#define UDF_VTOP_TYPE_UNKNOWN 0
	+#define UDF_VTOP_TYPE_PHYS 1
	+#define UDF_VTOP_TYPE_VIRT 2
	+#define UDF_VTOP_TYPE_SPARABLE 3
	+#define UDF_VTOP_TYPE_META 4
	+
	+
	+/* allocation strategies */
	+#define UDF_ALLOC_INVALID 0
	+#define UDF_ALLOC_SEQUENTIAL 1 /* linear on NWA */
	+#define UDF_ALLOC_VAT 2 /* VAT handling */
	+#define UDF_ALLOC_SPACEMAP 3 /* spacemaps */
	+#define UDF_ALLOC_METABITMAP 4 /* metadata bitmap */
	+#define UDF_ALLOC_METASEQUENTIAL 5 /* in chunks seq., nodes not seq */
	+#define UDF_ALLOC_RELAXEDSEQUENTIAL 6 /* only nodes not seq. */
	+
	+
	+/* logical volume open/close actions */
	+#define UDF_OPEN_SESSION 0x01 /* if needed writeout VRS + VDS */
	+#define UDF_CLOSE_SESSION 0x02 /* close session after writing VAT */
	+#define UDF_FINALISE_DISC 0x04 /* close session after writing VAT */
	+#define UDF_WRITE_VAT 0x08 /* sequential VAT filesystem */
	+#define UDF_WRITE_LVINT 0x10 /* write out open lvint */
	+#define UDF_WRITE_PART_BITMAPS 0x20 /* write out partition space bitmaps */
	+#define UDF_APPENDONLY_LVINT 0x40 /* no shifting, only appending */
	+#define UDF_WRITE_METAPART_NODES 0x80 /* write out metadata partition nodes*/
	+#define UDFLOGVOL_BITS "\20\1OPEN_SESSION\2CLOSE_SESSION\3FINALISE_DISC" \
	+ "\4WRITE_VAT\5WRITE_LVINT\6WRITE_PART_BITMAPS" \
	+ "\7APPENDONLY_LVINT\10WRITE_METAPART_NODES"
	+
	+/* logical volume error handling actions */
	+#define UDF_UPDATE_TRACKINFO 0x01 /* update trackinfo and re-shedule */
	+#define UDF_REMAP_BLOCK 0x02 /* remap the failing block length */
	+#define UDFONERROR_BITS "\20\1UPDATE_TRACKINFO\2REMAP_BLOCK"
	+
	+
	+/* readdir cookies */
	+#define UDF_DIRCOOKIE_DOT 1
	+
	+
	+/* malloc pools */
	+MALLOC_DECLARE(M_UDFTEMP);
	+
	+//struct pool udf_node_pool;
	+struct udf_node;
	+struct udf_strategy;
	+
	+
	+struct udf_lvintq {
	+ uint32_t start;
	+ uint32_t end;
	+ uint32_t pos;
	+ uint32_t wpos;
	+};
	+
	+
	+struct udf_bitmap {
	+ uint8_t blob; / allocated */
	+ uint8_t bits; / bits themselves */
	+ uint8_t pages; / dirty pages */
	+ uint32_t max_offset; /* in bits */
	+ uint32_t data_pos; /* position in data */
	+ uint32_t metadata_pos; /* .. in metadata */
	+};
	+
	+
	+struct udf_strat_args {
	+ struct udf_mount *ump;
	+ struct udf_node *udf_node;
	+ struct long_ad *icb;
	+ union dscrptr *dscr;
	+ struct buf *nestbuf;
	+/* kauth_cred_t cred; / / Not ever used? */
	+ int waitfor;
	+};
	+
	+struct udf_strategy {
	+ int (create_logvol_dscr) (struct udf_strat_args args);
	+ void (free_logvol_dscr) (struct udf_strat_args args);
	+ int (read_logvol_dscr) (struct udf_strat_args args);
	+ int (write_logvol_dscr) (struct udf_strat_args args);
	+ void (queuebuf) (struct udf_strat_args args);
	+ void (discstrat_init) (struct udf_strat_args args);
	+ void (discstrat_finish) (struct udf_strat_args args);
	+};
	+
	+//extern struct udf_strategy udf_strat_bootstrap;
	+//extern struct udf_strategy udf_strat_sequential;
	+//extern struct udf_strategy udf_strat_direct;
	+//extern struct udf_strategy udf_strat_rmw;
	+extern struct udf_strategy udf_strat_readonly;
	+
	+
	+/* pre cleanup */
	+struct udf_mount {
	+ struct mount *vfs_mountp;
	+ struct vnode *devvp;
	+ struct cdev *dev;
	+ struct g_consumer *geomcp;
	+ struct bufobj *bo;
	+ struct mmc_discinfo discinfo;
	+ struct udf_args mount_args;
	+ int flags;
	+
	+ /* iconv */
	+ void iconv_d2l; / disk to local */
	+#if 0
	+ void iconv_l2d; / local to disk */
	+#endif
	+
	+ /* format descriptors */
	+/* kmutex_t logvol_mutex; / / Who needs locks... */
	+ struct anchor_vdp anchors[UDF_ANCHORS]; / anchors to VDS */
	+ struct pri_vol_desc primary_vol; / identification */
	+ struct logvol_desc logical_vol; / main mapping v->p */
	+ struct unalloc_sp_desc unallocated; / free UDF space */
	+ struct impvol_desc implementation; / likely reduntant */
	+ struct logvol_int_desc logvol_integrity; / current integrity */
	+ struct part_desc partitions[UDF_PARTITIONS]; / partitions */
	+ /* logvol_info is derived; points into other structures */
	+ struct udf_logvol_info logvol_info; / integrity descr. */
	+
	+ /* fileset and root directories */
	+ struct fileset_desc fileset_desc; / normally one */
	+
	+ /* tracing logvol integrity history */
	+ struct udf_lvintq lvint_trace[UDF_LVDINT_SEGMENTS];
	+ int lvopen; /* logvol actions */
	+ int lvclose; /* logvol actions */
	+
	+ /* logical to physical translations */
	+ int vtop[UDF_PMAPS+1]; /* vpartnr trans */
	+ int vtop_tp[UDF_PMAPS+1]; /* type of trans */
	+
	+ /* disc allocation / writing method */
	+/* kmutex_t allocate_mutex; */
	+ int lvreadwrite; /* error handling */
	+ int vtop_alloc[UDF_PMAPS+1]; /* alloc scheme */
	+ int data_part;
	+ int node_part;
	+ int fids_part;
	+
	+ /* sequential track info */
	+/* struct mmc_trackinfo data_track;
	+ struct mmc_trackinfo metadata_track; */
	+
	+ /* VAT */
	+ uint32_t first_possible_vat_location;
	+ uint32_t last_possible_vat_location;
	+ uint32_t vat_entries;
	+ uint32_t vat_offset; /* offset in table */
	+ uint32_t vat_last_free_lb; /* last free lb_num */
	+ uint32_t vat_table_len;
	+ uint32_t vat_table_alloc_len;
	+ uint8_t *vat_table;
	+ uint8_t vat_pages; / TODO */
	+ struct udf_node vat_node; / system node */
	+
	+ /* space bitmaps for physical partitions */
	+ struct space_bitmap_desc*part_unalloc_dscr[UDF_PARTITIONS];
	+ struct space_bitmap_desc*part_freed_dscr [UDF_PARTITIONS];
	+ struct udf_bitmap part_unalloc_bits[UDF_PARTITIONS];
	+ struct udf_bitmap part_freed_bits [UDF_PARTITIONS];
	+
	+ /* sparable */
	+ uint32_t sparable_packet_size;
	+ uint32_t packet_size;
	+ struct udf_sparing_table*sparing_table;
	+
	+ /* meta */
	+ struct udf_node metadata_node; / system node */
	+ struct udf_node metadatamirror_node; / system node */
	+ struct udf_node metadatabitmap_node; / system node */
	+ struct space_bitmap_desc*metadata_unalloc_dscr;
	+ struct udf_bitmap metadata_unalloc_bits;
	+ uint32_t metadata_alloc_unit_size;
	+ uint16_t metadata_alignment_unit_size;
	+ uint8_t metadata_flags;
	+
	+ /* rb tree for lookup icb to udf_node and sorted list for sync */
	+/* kmutex_t ihash_lock;
	+ kmutex_t get_node_lock; */
	+/* struct rb_tree udf_node_tree; */
	+
	+ /* syncing */
	+ int syncing; /* are we syncing? */
	+/* kcondvar_t dirtynodes_cv; / / sleeping on sync */
	+
	+ /* late allocation */
	+ int32_t uncommitted_lbs[UDF_PARTITIONS];
	+// struct long_ad la_node_ad_cpy; / issue buf */
	+// uint64_t la_lmapping, la_pmapping; /* issue buf */
	+
	+ /* lists */
	+ STAILQ_HEAD(udfmntpts, udf_mount) all_udf_mntpnts;
	+
	+ /* device strategy */
	+ struct udf_strategy *strategy;
	+ void *strategy_private;
	+};
	+
	+#if 0
	+#define RBTOUDFNODE(node) \
	+ ((node) ? \
	+ (void *)((uintptr_t)(node) - offsetof(struct udf_node, rbnode)) \
	+ : NULL)
	+#endif
	+
	+/*
	+ * UDF node describing a file/directory.
	+ *
	+ * BUGALERT claim node_mutex before reading/writing to prevent inconsistencies !
	+ */
	+struct udf_node {
	+/* struct genfs_node i_gnode; / / has to be first */
	+ struct vnode vnode; / vnode associated */
	+ struct udf_mount *ump;
	+
	+ ino_t hash_id; /* should contain inode */
	+ int diroff; /* used in lookup */
	+/* kmutex_t node_mutex;
	+ kcondvar_t node_lock; / / sleeping lock */
	+ char const *lock_fname;
	+ int lock_lineno;
	+
	+ /* rb_node for fast lookup and fast sequential visiting */
	+/* struct rb_node rbnode; */
	+
	+ /* one of `fe' or `efe' can be set, not both (UDF file entry dscr.) */
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct alloc_ext_entry *ext[UDF_MAX_ALLOC_EXTENTS];
	+ int num_extensions;
	+
	+ /* location found, recording location & hints */
	+ struct long_ad loc; /* FID/hash loc. */
	+ struct long_ad write_loc; /* strat 4096 loc */
	+ int needs_indirect; /* has missing indr. */
	+ struct long_ad ext_loc[UDF_MAX_ALLOC_EXTENTS];
	+
	+ struct dirhash *dir_hash;
	+
	+ /* misc */
	+ uint32_t i_flags; /* associated flags */
	+ struct lockf lockf; / lock list */
	+ uint32_t outstanding_bufs; /* file data */
	+ uint32_t outstanding_nodedscr; /* node dscr */
	+ int32_t uncommitted_lbs; /* in UBC */
	+
	+ /* references to associated nodes */
	+ struct udf_node *extattr;
	+ struct udf_node *streamdir;
	+ struct udf_node my_parent; / if extended attr. */
	+};
	+
	+
	+/* misc. flags stored in i_flags (XXX needs cleaning up) */
	+#define IN_ACCESS 0x0001 /* Inode access time update request */
	+#define IN_CHANGE 0x0002 /* Inode change time update request */
	+#define IN_UPDATE 0x0004 /* Inode was written to; update mtime*/
	+#define IN_MODIFY 0x0008 /* Modification time update request */
	+#define IN_MODIFIED 0x0010 /* node has been modified */
	+#define IN_ACCESSED 0x0020 /* node has been accessed */
	+#define IN_RENAME 0x0040 /* node is being renamed. XXX ?? */
	+#define IN_DELETED 0x0080 /* node is unlinked, no FID reference*/
	+#define IN_LOCKED 0x0100 /* node is locked by condvar */
	+#define IN_SYNCED 0x0200 /* node is being used by sync */
	+#define IN_CALLBACK_ULK 0x0400 /* node will be unlocked by callback */
	+#define IN_NODE_REBUILD 0x0800 /* node is rebuild */
	+
	+
	+#define IN_FLAGBITS \
	+ "\10\1IN_ACCESS\2IN_CHANGE\3IN_UPDATE\4IN_MODIFY\5IN_MODIFIED" \
	+ "\6IN_ACCESSED\7IN_RENAME\10IN_DELETED\11IN_LOCKED\12IN_SYNCED" \
	+ "\13IN_CALLBACK_ULK\14IN_NODE_REBUILD"
	+
	+struct udf_fid {
	+ u_short len; /* length of data in bytes */
	+ u_short padding; /* force longword alignment */
	+ ino_t ino;
	+};
	+
	+#endif /* !_FS_UDF_UDF_H_ */
	Index: sys/fs/udf2/udf_allocation.c
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_allocation.c
	@@ -0,0 +1,3310 @@
	+/*-
	+ * Copyright (c) 2012 Oleksandr Dudinskyi
	+ * Copyright (c) 2012 Will DeVries
	+ * Copyright (c) 2006, 2008 Reinoud Zandijk
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ */
	+
	+#include <sys/cdefs.h>
	+#include <sys/endian.h>
	+#include <sys/param.h>
	+#include <sys/systm.h>
	+#include <sys/limits.h>
	+#include <sys/malloc.h>
	+
	+#include "ecma167-udf.h"
	+#include "udf.h"
	+#include "udf_subr.h"
	+
	+
	+#if 0
	+static void udf_record_allocation_in_node(struct udf_mount *ump,
	+ struct buf buf, uint16_t vpart_num, uint64_t mapping,
	+ struct long_ad *node_ad_cpy);
	+
	+static void udf_collect_free_space_for_vpart(struct udf_mount *ump,
	+ uint16_t vpart_num, uint32_t num_lb);
	+
	+static void udf_wipe_adslots(struct udf_node *udf_node);
	+static void udf_count_alloc_exts(struct udf_node *udf_node);
	+
	+/*
	+ * IDEA/BUSY: Each udf_node gets its own extentwalker state for all operations;
	+ * this will hopefully/likely reduce O(nlog(n)) to O(1) for most functionality
	+ * since actions are most likely sequential and thus seeking doesn't need
	+ * searching for the same or adjacent position again.
	+ */
	+
	+/* --------------------------------------------------------------------- */
	+
	+#if 0
	+#if 1
	+static void
	+udf_node_dump(struct udf_node *udf_node) {
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct icb_tag *icbtag;
	+ struct long_ad s_ad;
	+ uint64_t inflen;
	+ uint32_t icbflags, addr_type;
	+ uint32_t len, lb_num;
	+ uint32_t flags;
	+ int part_num;
	+ int lb_size, eof, slot;
	+
	+ if ((udf_verbose & UDF_DEBUG_NODEDUMP) == 0)
	+ return;
	+
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+ if (fe) {
	+ icbtag = &fe->icbtag;
	+ inflen = le64toh(fe->inf_len);
	+ } else {
	+ icbtag = &efe->icbtag;
	+ inflen = le64toh(efe->inf_len);
	+ }
	+
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ printf("udf_node_dump %p :\n", udf_node);
	+
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ printf("\tIntern alloc, len = %"PRIu64"\n", inflen);
	+ return;
	+ }
	+
	+ printf("\tInflen = %"PRIu64"\n", inflen);
	+ printf("\t\t");
	+
	+ slot = 0;
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ if (eof)
	+ break;
	+ part_num = le16toh(s_ad.loc.part_num);
	+ lb_num = le32toh(s_ad.loc.lb_num);
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ printf("[");
	+ if (part_num >= 0)
	+ printf("part %d, ", part_num);
	+ printf("lb_num %d, len %d", lb_num, len);
	+ if (flags)
	+ printf(", flags %d", flags>>30);
	+ printf("] ");
	+
	+ if (flags == UDF_EXT_REDIRECT) {
	+ printf("\n\textent END\n\tallocation extent\n\t\t");
	+ }
	+
	+ slot++;
	+ }
	+ printf("\n\tl_ad END\n\n");
	+}
	+#else
	+#define udf_node_dump(a)
	+#endif
	+
	+
	+static void
	+udf_assert_allocated(struct udf_mount *ump, uint16_t vpart_num,
	+ uint32_t lb_num, uint32_t num_lb)
	+{
	+ struct udf_bitmap *bitmap;
	+ struct part_desc *pdesc;
	+ uint32_t ptov;
	+ uint32_t bitval;
	+ uint8_t *bpos;
	+ int bit;
	+ int phys_part;
	+ int ok;
	+
	+ DPRINTF(PARANOIA, ("udf_assert_allocated: check virt lbnum %d "
	+ "part %d + %d sect\n", lb_num, vpart_num, num_lb));
	+
	+ /* get partition backing up this vpart_num */
	+ pdesc = ump->partitions[ump->vtop[vpart_num]];
	+
	+ switch (ump->vtop_tp[vpart_num]) {
	+ case UDF_VTOP_TYPE_PHYS :
	+ case UDF_VTOP_TYPE_SPARABLE :
	+ /* free space to freed or unallocated space bitmap */
	+ ptov = le32toh(pdesc->start_loc);
	+ phys_part = ump->vtop[vpart_num];
	+
	+ /* use unallocated bitmap */
	+ bitmap = &ump->part_unalloc_bits[phys_part];
	+
	+ /* if no bitmaps are defined, bail out */
	+ if (bitmap->bits == NULL)
	+ break;
	+
	+ /* check bits */
	+ KASSERT(bitmap->bits);
	+ ok = 1;
	+ bpos = bitmap->bits + lb_num/8;
	+ bit = lb_num % 8;
	+ while (num_lb > 0) {
	+ bitval = (1 << bit);
	+ DPRINTF(PARANOIA, ("XXX : check %d, %p, bit %d\n",
	+ lb_num, bpos, bit));
	+ KASSERT(bitmap->bits + lb_num/8 == bpos);
	+ if (*bpos & bitval) {
	+ printf("\tlb_num %d is NOT marked busy\n",
	+ lb_num);
	+ ok = 0;
	+ }
	+ lb_num++; num_lb--;
	+ bit = (bit + 1) % 8;
	+ if (bit == 0)
	+ bpos++;
	+ }
	+ if (!ok) {
	+ /* KASSERT(0); */
	+ }
	+
	+ break;
	+ case UDF_VTOP_TYPE_VIRT :
	+ /* TODO check space */
	+ KASSERT(num_lb == 1);
	+ break;
	+ case UDF_VTOP_TYPE_META :
	+ /* TODO check space in the metadata bitmap */
	+ default:
	+ /* not implemented */
	+ break;
	+ }
	+}
	+
	+
	+static void
	+udf_node_sanity_check(struct udf_node *udf_node,
	+ uint64_t cnt_inflen, uint64_t cnt_logblksrec)
	+{
	+ union dscrptr *dscr;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct icb_tag *icbtag;
	+ struct long_ad s_ad;
	+ uint64_t inflen, logblksrec;
	+ uint32_t icbflags, addr_type;
	+ uint32_t len, lb_num, l_ea, l_ad, max_l_ad;
	+ uint16_t part_num;
	+ uint8_t *data_pos;
	+ int dscr_size, lb_size, flags, whole_lb;
	+ int i, slot, eof;
	+
	+ KASSERT(mutex_owned(&udf_node->ump->allocate_mutex));
	+
	+ if (1)
	+ udf_node_dump(udf_node);
	+
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+ if (fe) {
	+ dscr = (union dscrptr *) fe;
	+ icbtag = &fe->icbtag;
	+ inflen = le64toh(fe->inf_len);
	+ dscr_size = sizeof(struct file_entry) -1;
	+ logblksrec = le64toh(fe->logblks_rec);
	+ l_ad = le32toh(fe->l_ad);
	+ l_ea = le32toh(fe->l_ea);
	+ } else {
	+ dscr = (union dscrptr *) efe;
	+ icbtag = &efe->icbtag;
	+ inflen = le64toh(efe->inf_len);
	+ dscr_size = sizeof(struct extfile_entry) -1;
	+ logblksrec = le64toh(efe->logblks_rec);
	+ l_ad = le32toh(efe->l_ad);
	+ l_ea = le32toh(efe->l_ea);
	+ }
	+ data_pos = (uint8_t *) dscr + dscr_size + l_ea;
	+ max_l_ad = lb_size - dscr_size - l_ea;
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ /* check if tail is zero */
	+ DPRINTF(PARANOIA, ("Sanity check blank tail\n"));
	+ for (i = l_ad; i < max_l_ad; i++) {
	+ if (data_pos[i] != 0)
	+ printf( "sanity_check: violation: node byte %d "
	+ "has value %d\n", i, data_pos[i]);
	+ }
	+
	+ /* reset counters */
	+ *cnt_inflen = 0;
	+ *cnt_logblksrec = 0;
	+
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ KASSERT(l_ad <= max_l_ad);
	+ KASSERT(l_ad == inflen);
	+ *cnt_inflen = inflen;
	+ return;
	+ }
	+
	+ /* start counting */
	+ whole_lb = 1;
	+ slot = 0;
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ if (eof)
	+ break;
	+ KASSERT(whole_lb == 1);
	+
	+ part_num = le16toh(s_ad.loc.part_num);
	+ lb_num = le32toh(s_ad.loc.lb_num);
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ if (flags != UDF_EXT_REDIRECT) {
	+ *cnt_inflen += len;
	+ if (flags == UDF_EXT_ALLOCATED) {
	+ *cnt_logblksrec += (len + lb_size -1) / lb_size;
	+ }
	+ } else {
	+ KASSERT(len == lb_size);
	+ }
	+ /* check allocation */
	+ if (flags == UDF_EXT_ALLOCATED)
	+ udf_assert_allocated(udf_node->ump, part_num, lb_num,
	+ (len + lb_size - 1) / lb_size);
	+
	+ /* check whole lb */
	+ whole_lb = ((len % lb_size) == 0);
	+
	+ slot++;
	+ }
	+ /* rest should be zero (ad_off > l_ad < max_l_ad - adlen) */
	+
	+ KASSERT(*cnt_inflen == inflen);
	+ KASSERT(*cnt_logblksrec == logblksrec);
	+
	+ KASSERT(mutex_owned(&udf_node->ump->allocate_mutex));
	+}
	+#else
	+static void
	+udf_node_sanity_check(struct udf_node *udf_node,
	+ uint64_t cnt_inflen, uint64_t cnt_logblksrec) {
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct icb_tag *icbtag;
	+ uint64_t inflen, logblksrec;
	+ int dscr_size, lb_size;
	+
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+ if (fe) {
	+ icbtag = &fe->icbtag;
	+ inflen = le64toh(fe->inf_len);
	+ dscr_size = sizeof(struct file_entry) -1;
	+ logblksrec = le64toh(fe->logblks_rec);
	+ } else {
	+ icbtag = &efe->icbtag;
	+ inflen = le64toh(efe->inf_len);
	+ dscr_size = sizeof(struct extfile_entry) -1;
	+ logblksrec = le64toh(efe->logblks_rec);
	+ }
	+ *cnt_logblksrec = logblksrec;
	+ *cnt_inflen = inflen;
	+}
	+#endif
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	+void
	+udf_calc_freespace(struct udf_mount ump, uint64_t sizeblks, uint64_t *freeblks)
	+{
	+ struct logvol_int_desc *lvid;
	+ uint32_t pos1, pos2;
	+ int vpart, num_vpart;
	+
	+ lvid = ump->logvol_integrity;
	+ freeblks = sizeblks = 0;
	+
	+ /*
	+ * Sequentials media report free space directly (CD/DVD/BD-R), for the
	+ * other media we need the logical volume integrity.
	+ *
	+ * We sum all free space up here regardless of type.
	+ */
	+
	+ KASSERT(lvid, ("lvid is null"));
	+ num_vpart = le32toh(lvid->num_part);
	+
	+#if 0
	+ if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
	+ /* use track info directly summing if there are 2 open */
	+ /* XXX assumption at most two tracks open */
	+ *freeblks = ump->data_track.free_blocks;
	+ if (ump->data_track.tracknr != ump->metadata_track.tracknr)
	+ *freeblks += ump->metadata_track.free_blocks;
	+ *sizeblks = ump->discinfo.last_possible_lba;
	+ } else {
	+#endif
	+ /* free and used space for mountpoint based on logvol integrity */
	+ for (vpart = 0; vpart < num_vpart; vpart++) {
	+ pos1 = &lvid->tables[0] + vpart;
	+ pos2 = &lvid->tables[0] + num_vpart + vpart;
	+ if (le32toh(*pos1) != (uint32_t) -1) {
	+ freeblks += le32toh(pos1);
	+ sizeblks += le32toh(pos2);
	+ }
	+ }
	+#if 0
	+ }
	+#endif
	+ /* adjust for accounted uncommitted blocks */
	+ for (vpart = 0; vpart < num_vpart; vpart++)
	+ *freeblks -= ump->uncommitted_lbs[vpart];
	+
	+ if (*freeblks > UDF_DISC_SLACK) {
	+ *freeblks -= UDF_DISC_SLACK;
	+ } else {
	+ *freeblks = 0;
	+ }
	+}
	+
	+#if 0
	+static void
	+udf_calc_vpart_freespace(struct udf_mount ump, uint16_t vpart_num, uint64_t freeblks)
	+{
	+ struct logvol_int_desc *lvid;
	+ uint32_t *pos1;
	+
	+ lvid = ump->logvol_integrity;
	+ *freeblks = 0;
	+
	+ /*
	+ * Sequentials media report free space directly (CD/DVD/BD-R), for the
	+ * other media we need the logical volume integrity.
	+ *
	+ * We sum all free space up here regardless of type.
	+ */
	+
	+ KASSERT(lvid);
	+ if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
	+ /* XXX assumption at most two tracks open */
	+ if (vpart_num == ump->data_part) {
	+ *freeblks = ump->data_track.free_blocks;
	+ } else {
	+ *freeblks = ump->metadata_track.free_blocks;
	+ }
	+ } else {
	+ /* free and used space for mountpoint based on logvol integrity */
	+ pos1 = &lvid->tables[0] + vpart_num;
	+ if (le32toh(*pos1) != (uint32_t) -1)
	+ freeblks += le32toh(pos1);
	+ }
	+
	+ /* adjust for accounted uncommitted blocks */
	+ if (*freeblks > ump->uncommitted_lbs[vpart_num]) {
	+ *freeblks -= ump->uncommitted_lbs[vpart_num];
	+ } else {
	+ *freeblks = 0;
	+ }
	+}
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_translate_vtop(struct udf_mount ump, struct long_ad icb_loc,
	+ uint32_t lb_numres, uint32_t extres)
	+{
	+ struct part_desc *pdesc;
	+ struct spare_map_entry *sme;
	+ struct long_ad s_icb_loc;
	+ uint64_t foffset, end_foffset;
	+ int rel, part, error, eof, slot, flags;
	+ uint32_t lb_size, len, lb_num, lb_rel, lb_packet;
	+ uint32_t udf_rw32_lbmap, ext_offset;
	+ uint16_t vpart;
	+
	+ KASSERT(ump && icb_loc && lb_numres,("ump && icb_loc && lb_numres"));
	+
	+ vpart = le16toh(icb_loc->loc.part_num);
	+ lb_num = le32toh(icb_loc->loc.lb_num);
	+ if (vpart > UDF_VTOP_RAWPART)
	+ return (EINVAL);
	+
	+translate_again:
	+ part = ump->vtop[vpart];
	+ pdesc = ump->partitions[part];
	+
	+ switch (ump->vtop_tp[vpart]) {
	+ case UDF_VTOP_TYPE_RAW :
	+ /* 1:1 to the end of the device */
	+ *lb_numres = lb_num;
	+ *extres = INT_MAX;
	+ return (0);
	+ case UDF_VTOP_TYPE_PHYS :
	+ /* transform into its disc logical block */
	+ if (lb_num > le32toh(pdesc->part_len))
	+ return (EINVAL);
	+ *lb_numres = lb_num + le32toh(pdesc->start_loc);
	+
	+ /* extent from here to the end of the partition */
	+ *extres = le32toh(pdesc->part_len) - lb_num;
	+ return (0);
	+ case UDF_VTOP_TYPE_VIRT :
	+ /* only maps one logical block, lookup in VAT */
	+ if (lb_num >= ump->vat_entries) /* XXX > or >= ? */
	+ return (EINVAL);
	+
	+ /* lookup in virtual allocation table file */
	+ /* mutex_enter(&ump->allocate_mutex); */
	+ error = udf_vat_read(ump->vat_node,
	+ (uint8_t *) &udf_rw32_lbmap, 4,
	+ ump->vat_offset + lb_num * 4);
	+ /* mutex_exit(&ump->allocate_mutex); */
	+
	+ if (error)
	+ return (error);
	+
	+ lb_num = le32toh(udf_rw32_lbmap);
	+
	+ /* transform into its disc logical block */
	+ if (lb_num > le32toh(pdesc->part_len))
	+ return (EINVAL);
	+ *lb_numres = lb_num + le32toh(pdesc->start_loc);
	+
	+ /* just one logical block */
	+ *extres = 1;
	+ return (0);
	+ case UDF_VTOP_TYPE_SPARABLE :
	+ /* check if the packet containing the lb_num is remapped */
	+ lb_packet = lb_num / ump->sparable_packet_size;
	+ lb_rel = lb_num % ump->sparable_packet_size;
	+
	+ for (rel = 0; rel < le16toh(ump->sparing_table->rt_l); rel++) {
	+ sme = &ump->sparing_table->entries[rel];
	+ if (lb_packet == le32toh(sme->org)) {
	+ /* NOTE maps to absolute disc logical block! */
	+ *lb_numres = le32toh(sme->map) + lb_rel;
	+ *extres = ump->sparable_packet_size - lb_rel;
	+ return (0);
	+ }
	+ }
	+
	+ /* transform into its disc logical block */
	+ if (lb_num > le32toh(pdesc->part_len))
	+ return (EINVAL);
	+ *lb_numres = lb_num + le32toh(pdesc->start_loc);
	+
	+ /* rest of block */
	+ *extres = ump->sparable_packet_size - lb_rel;
	+ return (0);
	+ case UDF_VTOP_TYPE_META :
	+ /* printf("Metadata Partition Translated\n"); */
	+ /* we have to look into the file's allocation descriptors */
	+
	+ /* use metadatafile allocation mutex */
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+
	+ UDF_LOCK_NODE(ump->metadata_node, 0);
	+
	+ /* get first overlapping extent */
	+ foffset = 0;
	+ slot = 0;
	+ for (;;) {
	+ udf_get_adslot(ump->metadata_node,
	+ slot, &s_icb_loc, &eof);
	+ DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, "
	+ "len = %d, lb_num = %d, part = %d\n",
	+ slot, eof,
	+ UDF_EXT_FLAGS(le32toh(s_icb_loc.len)),
	+ UDF_EXT_LEN(le32toh(s_icb_loc.len)),
	+ le32toh(s_icb_loc.loc.lb_num),
	+ le16toh(s_icb_loc.loc.part_num)));
	+ if (eof) {
	+ DPRINTF(TRANSLATE,
	+ ("Meta partition translation "
	+ "failed: can't seek location\n"));
	+ UDF_UNLOCK_NODE(ump->metadata_node, 0);
	+ return (EINVAL);
	+ }
	+ len = le32toh(s_icb_loc.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ if (flags == UDF_EXT_REDIRECT) {
	+ slot++;
	+ continue;
	+ }
	+
	+ end_foffset = foffset + len;
	+
	+ if (end_foffset > lb_num * lb_size)
	+ break; /* found */
	+ foffset = end_foffset;
	+ slot++;
	+ }
	+ /* found overlapping slot */
	+ ext_offset = lb_num * lb_size - foffset;
	+
	+ /* process extent offset */
	+ lb_num = le32toh(s_icb_loc.loc.lb_num);
	+ vpart = le16toh(s_icb_loc.loc.part_num);
	+ lb_num += (ext_offset + lb_size -1) / lb_size;
	+ ext_offset = 0;
	+
	+ UDF_UNLOCK_NODE(ump->metadata_node, 0);
	+ if (flags != UDF_EXT_ALLOCATED) {
	+ DPRINTF(TRANSLATE, ("Metadata partion translation "
	+ "failed: not allocated\n"));
	+ return (EINVAL);
	+ }
	+
	+ /*
	+ * vpart and lb_num are updated, translate again since we
	+ * might be mapped on sparable media
	+ */
	+ goto translate_again;
	+ default:
	+ printf("UDF vtop translation scheme %d unimplemented yet\n",
	+ ump->vtop_tp[vpart]);
	+ }
	+
	+ return (EINVAL);
	+}
	+
	+
	+/* XXX provisional primitive braindead version */
	+/* TODO use ext_res */
	+#if 0
	+void
	+udf_translate_vtop_list(struct udf_mount *ump, uint32_t sectors,
	+ uint16_t vpart_num, uint64_t lmapping, uint64_t pmapping)
	+{
	+ struct long_ad loc;
	+ uint32_t lb_numres, ext_res;
	+ int sector;
	+
	+ for (sector = 0; sector < sectors; sector++) {
	+ memset(&loc, 0, sizeof(struct long_ad));
	+ loc.loc.part_num = le16toh(vpart_num);
	+ loc.loc.lb_num = le32toh(*lmapping);
	+ udf_translate_vtop(ump, &loc, &lb_numres, &ext_res);
	+ *pmapping = lb_numres;
	+ lmapping++; pmapping++;
	+ }
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+/*
	+ *This is a simplified version of the following function. It is used in
	+ * bmap.
	+ */
	+int
	+udf_bmap_translate(struct udf_node *udf_node, uint32_t block,
	+ uint64_t lsector, uint32_t maxblks)
	+{
	+ struct udf_mount *ump;
	+ struct icb_tag *icbtag;
	+ struct long_ad t_ad, s_ad;
	+ uint64_t foffset, new_foffset;
	+ int eof, error, flags, slot, addr_type, icbflags;
	+ uint32_t transsec32, lb_size, ext_offset, lb_num, len;
	+ uint32_t ext_remain, translen;
	+ uint16_t vpart_num;
	+
	+ if (!udf_node)
	+ return (ENOENT);
	+
	+ KASSERT(num_lb > 0,("num_lb > 0"));
	+
	+ UDF_LOCK_NODE(udf_node, 0);
	+
	+ /* initialise derivative vars */
	+ ump = udf_node->ump;
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+
	+ if (udf_node->fe) {
	+ icbtag = &udf_node->fe->icbtag;
	+ } else {
	+ icbtag = &udf_node->efe->icbtag;
	+ }
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ /* do the work */
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ *lsector = UDF_TRANS_INTERN;
	+ *maxblks = 1;
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return (0);
	+ }
	+
	+ /* find first overlapping extent */
	+ foffset = 0;
	+ slot = 0;
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, len = %d, "
	+ "lb_num = %d, part = %d\n", slot, eof,
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ le32toh(s_ad.loc.lb_num),
	+ le16toh(s_ad.loc.part_num)));
	+ if (eof) {
	+ DPRINTF(TRANSLATE,
	+ ("Translate file extent "
	+ "failed: can't seek location\n"));
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return (EINVAL);
	+ }
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ if (flags == UDF_EXT_REDIRECT) {
	+ slot++;
	+ continue;
	+ }
	+
	+ new_foffset = foffset + len;
	+
	+ if (new_foffset > block * lb_size)
	+ break; /* found */
	+ foffset = new_foffset;
	+ slot++;
	+ }
	+ /* found overlapping slot */
	+
	+ lb_num = le32toh(s_ad.loc.lb_num);
	+ vpart_num = le16toh(s_ad.loc.part_num);
	+
	+ ext_offset = block * lb_size - foffset;
	+
	+ /* process extent, don't forget to advance on ext_offset! */
	+ lb_num += (ext_offset + lb_size -1) / lb_size;
	+ ext_remain = (len - ext_offset + lb_size -1) / lb_size;
	+
	+ /*
	+ * note that the while(){} is nessisary for the extent that
	+ * the udf_translate_vtop() returns doens't have to span the
	+ * whole extent.
	+ */
	+ switch (flags) {
	+ case UDF_EXT_FREE :
	+ case UDF_EXT_ALLOCATED_BUT_NOT_USED :
	+ *lsector = UDF_TRANS_ZERO;
	+ *maxblks = ext_remain;
	+ break;
	+ case UDF_EXT_ALLOCATED :
	+ t_ad.loc.lb_num = htole32(lb_num);
	+ t_ad.loc.part_num = htole16(vpart_num);
	+ error = udf_translate_vtop(ump,
	+ &t_ad, &transsec32, &translen);
	+ if (error) {
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return (error);
	+ }
	+ *lsector = transsec32;
	+ *maxblks = MIN(ext_remain, translen);
	+ break;
	+ default:
	+ DPRINTF(TRANSLATE, ("Translate file extend "
	+ "failed: bad flags %x\n", flags));
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return (EINVAL);
	+ }
	+
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ return (0);
	+}
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Translate an extent (in logical_blocks) into logical block numbers; used
	+ * for read and write operations. DOESNT't check extents.
	+ */
	+int
	+udf_translate_file_extent(struct udf_node *udf_node,
	+ uint32_t from, uint32_t num_lb,
	+ uint64_t *map)
	+{
	+ struct udf_mount *ump;
	+ struct icb_tag *icbtag;
	+ struct long_ad t_ad, s_ad;
	+ uint64_t transsec;
	+ uint64_t foffset, end_foffset;
	+ uint32_t transsec32;
	+ uint32_t lb_size;
	+ uint32_t ext_offset;
	+ uint32_t lb_num, len;
	+ uint32_t overlap, translen;
	+ uint16_t vpart_num;
	+ int eof, error, flags;
	+ int slot, addr_type, icbflags;
	+
	+ if (!udf_node)
	+ return (ENOENT);
	+
	+ KASSERT(num_lb > 0, "num_lb > 0");
	+
	+ UDF_LOCK_NODE(udf_node, 0);
	+
	+ /* initialise derivative vars */
	+ ump = udf_node->ump;
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+
	+ if (udf_node->fe) {
	+ icbtag = &udf_node->fe->icbtag;
	+ } else {
	+ icbtag = &udf_node->efe->icbtag;
	+ }
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ /* do the work */
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ *map = UDF_TRANS_INTERN;
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return (0);
	+ }
	+
	+ /* find first overlapping extent */
	+ foffset = 0;
	+ slot = 0;
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, len = %d, "
	+ "lb_num = %d, part = %d\n", slot, eof,
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ le32toh(s_ad.loc.lb_num),
	+ le16toh(s_ad.loc.part_num)));
	+ if (eof) {
	+ DPRINTF(TRANSLATE,
	+ ("Translate file extent "
	+ "failed: can't seek location\n"));
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return (EINVAL);
	+ }
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+ lb_num = le32toh(s_ad.loc.lb_num);
	+
	+ if (flags == UDF_EXT_REDIRECT) {
	+ slot++;
	+ continue;
	+ }
	+
	+ end_foffset = foffset + len;
	+
	+ if (end_foffset > from * lb_size)
	+ break; /* found */
	+ foffset = end_foffset;
	+ slot++;
	+ }
	+ /* found overlapping slot */
	+ ext_offset = from * lb_size - foffset;
	+
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, len = %d, "
	+ "lb_num = %d, part = %d\n", slot, eof,
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ le32toh(s_ad.loc.lb_num),
	+ le16toh(s_ad.loc.part_num)));
	+ if (eof) {
	+ DPRINTF(TRANSLATE,
	+ ("Translate file extent "
	+ "failed: past eof\n"));
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return (EINVAL);
	+ }
	+
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ lb_num = le32toh(s_ad.loc.lb_num);
	+ vpart_num = le16toh(s_ad.loc.part_num);
	+
	+ end_foffset = foffset + len;
	+
	+ /* process extent, don't forget to advance on ext_offset! */
	+ lb_num += (ext_offset + lb_size -1) / lb_size;
	+ overlap = (len - ext_offset + lb_size -1) / lb_size;
	+ ext_offset = 0;
	+
	+ /*
	+ * note that the while(){} is nessisary for the extent that
	+ * the udf_translate_vtop() returns doens't have to span the
	+ * whole extent.
	+ */
	+
	+ overlap = MIN(overlap, num_lb);
	+ while (overlap && (flags != UDF_EXT_REDIRECT)) {
	+ switch (flags) {
	+ case UDF_EXT_FREE :
	+ case UDF_EXT_ALLOCATED_BUT_NOT_USED :
	+ transsec = UDF_TRANS_ZERO;
	+ translen = overlap;
	+ while (overlap && num_lb && translen) {
	+ *map++ = transsec;
	+ lb_num++;
	+ overlap--; num_lb--; translen--;
	+ }
	+ break;
	+ case UDF_EXT_ALLOCATED :
	+ t_ad.loc.lb_num = le32toh(lb_num);
	+ t_ad.loc.part_num = le16toh(vpart_num);
	+ error = udf_translate_vtop(ump,
	+ &t_ad, &transsec32, &translen);
	+ transsec = transsec32;
	+ if (error) {
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return (error);
	+ }
	+ while (overlap && num_lb && translen) {
	+ *map++ = transsec;
	+ lb_num++; transsec++;
	+ overlap--; num_lb--; translen--;
	+ }
	+ break;
	+ default:
	+ DPRINTF(TRANSLATE,
	+ ("Translate file extent "
	+ "failed: bad flags %x\n", flags));
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return (EINVAL);
	+ }
	+ }
	+ if (num_lb == 0)
	+ break;
	+
	+ if (flags != UDF_EXT_REDIRECT)
	+ foffset = end_foffset;
	+ slot++;
	+ }
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ return (0);
	+}
	+
	+#if 0
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_search_free_vatloc(struct udf_mount ump, uint32_t lbnumres)
	+{
	+ uint32_t lb_size, lb_num, lb_map, le32toh_lbmap;
	+ uint8_t *blob;
	+ int entry, chunk, found, error;
	+
	+ KASSERT(ump, ("ump is NULL"));
	+ KASSERT(ump->logical_vol, ("ump->logical_vol is NULL"));
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ blob = malloc(lb_size, M_UDFTEMP, M_WAITOK);
	+
	+ /* TODO static allocation of search chunk */
	+
	+ lb_num = MIN(ump->vat_entries, ump->vat_last_free_lb);
	+ found = 0;
	+ error = 0;
	+ entry = 0;
	+ do {
	+ chunk = MIN(lb_size, (ump->vat_entries - lb_num) * 4);
	+ if (chunk <= 0)
	+ break;
	+ /* load in chunk */
	+ error = udf_vat_read(ump->vat_node, blob, chunk,
	+ ump->vat_offset + lb_num * 4);
	+
	+ if (error)
	+ break;
	+
	+ /* search this chunk */
	+ for (entry=0; entry < chunk /4; entry++, lb_num++) {
	+ le32toh_lbmap = ((uint32_t ) (blob + entry * 4));
	+ lb_map = le32toh(le32toh_lbmap);
	+ if (lb_map == 0xffffffff) {
	+ found = 1;
	+ break;
	+ }
	+ }
	+ } while (!found);
	+ if (error) {
	+ printf("udf_search_free_vatloc: error reading in vat chunk "
	+ "(lb %d, size %d)\n", lb_num, chunk);
	+ }
	+
	+ if (!found) {
	+ /* extend VAT */
	+ DPRINTF(WRITE, ("udf_search_free_vatloc: extending\n"));
	+ lb_num = ump->vat_entries;
	+ ump->vat_entries++;
	+ }
	+
	+ /* mark entry with initialiser just in case */
	+ lb_map = le32toh(0xfffffffe);
	+ udf_vat_write(ump->vat_node, (uint8_t *) &lb_map, 4,
	+ ump->vat_offset + lb_num *4);
	+ ump->vat_last_free_lb = lb_num;
	+
	+ free(blob, M_UDFTEMP);
	+ *lbnumres = lb_num;
	+ return (0);
	+}
	+
	+
	+static void
	+udf_bitmap_allocate(struct udf_bitmap *bitmap, int ismetadata,
	+ uint32_t num_lb, uint64_t lmappos)
	+{
	+ uint32_t offset, lb_num, bit;
	+ int32_t diff;
	+ uint8_t *bpos;
	+ int pass;
	+
	+ if (!ismetadata) {
	+ /* heuristic to keep the two pointers not too close */
	+ diff = bitmap->data_pos - bitmap->metadata_pos;
	+ if ((diff >= 0) && (diff < 1024))
	+ bitmap->data_pos = bitmap->metadata_pos + 1024;
	+ }
	+ offset = ismetadata ? bitmap->metadata_pos : bitmap->data_pos;
	+ offset &= ~7;
	+ for (pass = 0; pass < 2; pass++) {
	+ if (offset >= bitmap->max_offset)
	+ offset = 0;
	+
	+ while (offset < bitmap->max_offset) {
	+ if (*num_lb == 0)
	+ break;
	+
	+ /* use first bit not set */
	+ bpos = bitmap->bits + offset/8;
	+ bit = ffs(bpos); / returns 0 or 1..8 */
	+ if (bit == 0) {
	+ offset += 8;
	+ continue;
	+ }
	+
	+ /* check for ffs overshoot */
	+ if (offset + bit-1 >= bitmap->max_offset) {
	+ offset = bitmap->max_offset;
	+ break;
	+ }
	+
	+ DPRINTF(PARANOIA, ("XXX : allocate %d, %p, bit %d\n",
	+ offset + bit -1, bpos, bit-1));
	+ *bpos &= ~(1 << (bit-1));
	+ lb_num = offset + bit-1;
	+ *lmappos++ = lb_num;
	+ num_lb = num_lb - 1;
	+ /* offset = (offset & ~7); */
	+ }
	+ }
	+
	+ if (ismetadata) {
	+ bitmap->metadata_pos = offset;
	+ } else {
	+ bitmap->data_pos = offset;
	+ }
	+}
	+
	+
	+static void
	+udf_bitmap_free(struct udf_bitmap *bitmap, uint32_t lb_num, uint32_t num_lb)
	+{
	+ uint32_t offset;
	+ uint32_t bit, bitval;
	+ uint8_t *bpos;
	+
	+ offset = lb_num;
	+
	+ /* starter bits */
	+ bpos = bitmap->bits + offset/8;
	+ bit = offset % 8;
	+ while ((bit != 0) && (num_lb > 0)) {
	+ bitval = (1 << bit);
	+ KASSERT((*bpos & bitval) == 0);
	+ DPRINTF(PARANOIA, ("XXX : free %d, %p, %d\n",
	+ offset, bpos, bit));
	+ *bpos \|= bitval;
	+ offset++; num_lb--;
	+ bit = (bit + 1) % 8;
	+ }
	+ if (num_lb == 0)
	+ return;
	+
	+ /* whole bytes */
	+ KASSERT(bit == 0);
	+ bpos = bitmap->bits + offset / 8;
	+ while (num_lb >= 8) {
	+ KASSERT((*bpos == 0));
	+ DPRINTF(PARANOIA, ("XXX : free %d + 8, %p\n", offset, bpos));
	+ *bpos = 255;
	+ offset += 8; num_lb -= 8;
	+ bpos++;
	+ }
	+
	+ /* stop bits */
	+ KASSERT(num_lb < 8);
	+ bit = 0;
	+ while (num_lb > 0) {
	+ bitval = (1 << bit);
	+ KASSERT((*bpos & bitval) == 0);
	+ DPRINTF(PARANOIA, ("XXX : free %d, %p, %d\n",
	+ offset, bpos, bit));
	+ *bpos \|= bitval;
	+ offset++; num_lb--;
	+ bit = (bit + 1) % 8;
	+ }
	+}
	+
	+
	+static uint32_t
	+udf_bitmap_check_trunc_free(struct udf_bitmap *bitmap, uint32_t to_trunc)
	+{
	+ uint32_t seq_free, offset;
	+ uint8_t *bpos;
	+ uint8_t bit, bitval;
	+
	+ DPRINTF(RESERVE, ("\ttrying to trunc %d bits from bitmap\n", to_trunc));
	+ offset = bitmap->max_offset - to_trunc;
	+
	+ /* starter bits (if any) */
	+ bpos = bitmap->bits + offset/8;
	+ bit = offset % 8;
	+ seq_free = 0;
	+ while (to_trunc > 0) {
	+ seq_free++;
	+ bitval = (1 << bit);
	+ if (!(*bpos & bitval))
	+ seq_free = 0;
	+ offset++; to_trunc--;
	+ bit++;
	+ if (bit == 8) {
	+ bpos++;
	+ bit = 0;
	+ }
	+ }
	+
	+ DPRINTF(RESERVE, ("\tfound %d sequential free bits in bitmap\n", seq_free));
	+ return (seq_free);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * We check for overall disc space with a margin to prevent critical
	+ * conditions. If disc space is low we try to force a sync() to improve our
	+ * estimates. When confronted with meta-data partition size shortage we know
	+ * we have to check if it can be extended and we need to extend it when
	+ * needed.
	+ *
	+ * A 2nd strategy we could use when disc space is getting low on a disc
	+ * formatted with a meta-data partition is to see if there are sparse areas in
	+ * the meta-data partition and free blocks there for extra data.
	+ */
	+
	+void
	+udf_do_reserve_space(struct udf_mount ump, struct udf_node udf_node,
	+ uint16_t vpart_num, uint32_t num_lb)
	+{
	+ ump->uncommitted_lbs[vpart_num] += num_lb;
	+ if (udf_node)
	+ udf_node->uncommitted_lbs += num_lb;
	+}
	+
	+
	+void
	+udf_do_unreserve_space(struct udf_mount ump, struct udf_node udf_node,
	+ uint16_t vpart_num, uint32_t num_lb)
	+{
	+ ump->uncommitted_lbs[vpart_num] -= num_lb;
	+ if (ump->uncommitted_lbs[vpart_num] < 0) {
	+ DPRINTF(RESERVE, ("UDF: underflow on partition reservation, "
	+ "part %d: %d\n", vpart_num,
	+ ump->uncommitted_lbs[vpart_num]));
	+ ump->uncommitted_lbs[vpart_num] = 0;
	+ }
	+ if (udf_node) {
	+ udf_node->uncommitted_lbs -= num_lb;
	+ if (udf_node->uncommitted_lbs < 0) {
	+ DPRINTF(RESERVE, ("UDF: underflow of node "
	+ "reservation : %d\n",
	+ udf_node->uncommitted_lbs));
	+ udf_node->uncommitted_lbs = 0;
	+ }
	+ }
	+}
	+
	+
	+int
	+udf_reserve_space(struct udf_mount ump, struct udf_node udf_node,
	+ int udf_c_type, uint16_t vpart_num, uint32_t num_lb, int can_fail)
	+{
	+ uint64_t freeblks;
	+ uint64_t slack;
	+ int i, error;
	+
	+ slack = 0;
	+ if (can_fail)
	+ slack = UDF_DISC_SLACK;
	+
	+ error = 0;
	+ mutex_enter(&ump->allocate_mutex);
	+
	+ /* check if there is enough space available */
	+ for (i = 0; i < 3; i++) { /* XXX arbitrary number */
	+ udf_calc_vpart_freespace(ump, vpart_num, &freeblks);
	+ if (num_lb + slack < freeblks)
	+ break;
	+ /* issue SYNC */
	+ DPRINTF(RESERVE, ("udf_reserve_space: issuing sync\n"));
	+ mutex_exit(&ump->allocate_mutex);
	+ udf_do_sync(ump, FSCRED, 0);
	+ mutex_enter(&mntvnode_lock);
	+ /* 1/8 second wait */
	+ cv_timedwait(&ump->dirtynodes_cv, &mntvnode_lock,
	+ hz/8);
	+ mutex_exit(&mntvnode_lock);
	+ mutex_enter(&ump->allocate_mutex);
	+ }
	+
	+ /* check if there is enough space available now */
	+ udf_calc_vpart_freespace(ump, vpart_num, &freeblks);
	+ if (num_lb + slack >= freeblks) {
	+ DPRINTF(RESERVE, ("udf_reserve_space: try to redistribute "
	+ "partition space\n"));
	+ DPRINTF(RESERVE, ("\tvpart %d, type %d is full\n",
	+ vpart_num, ump->vtop_alloc[vpart_num]));
	+ /* Try to redistribute space if possible */
	+ udf_collect_free_space_for_vpart(ump, vpart_num, num_lb + slack);
	+ }
	+
	+ /* check if there is enough space available now */
	+ udf_calc_vpart_freespace(ump, vpart_num, &freeblks);
	+ if (num_lb + slack <= freeblks) {
	+ udf_do_reserve_space(ump, udf_node, vpart_num, num_lb);
	+ } else {
	+ DPRINTF(RESERVE, ("udf_reserve_space: out of disc space\n"));
	+ error = ENOSPC;
	+ }
	+
	+ mutex_exit(&ump->allocate_mutex);
	+ return (error);
	+}
	+
	+
	+void
	+udf_cleanup_reservation(struct udf_node *udf_node)
	+{
	+ struct udf_mount *ump = udf_node->ump;
	+ int vpart_num;
	+
	+ mutex_enter(&ump->allocate_mutex);
	+
	+ /* compensate for overlapping blocks */
	+ DPRINTF(RESERVE, ("UDF: overlapped %d blocks in count\n", udf_node->uncommitted_lbs));
	+
	+ vpart_num = udf_get_record_vpart(ump, udf_get_c_type(udf_node));
	+ udf_do_unreserve_space(ump, udf_node, vpart_num, udf_node->uncommitted_lbs);
	+
	+ DPRINTF(RESERVE, ("\ttotal now %d\n", ump->uncommitted_lbs[vpart_num]));
	+
	+ /* sanity */
	+ if (ump->uncommitted_lbs[vpart_num] < 0)
	+ ump->uncommitted_lbs[vpart_num] = 0;
	+
	+ mutex_exit(&ump->allocate_mutex);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Allocate an extent of given length on given virt. partition. It doesn't
	+ * have to be one stretch.
	+ */
	+
	+int
	+udf_allocate_space(struct udf_mount ump, struct udf_node udf_node,
	+ int udf_c_type, uint16_t vpart_num, uint32_t num_lb, uint64_t *lmapping)
	+{
	+ struct mmc_trackinfo alloc_track, other_track;
	+ struct udf_bitmap *bitmap;
	+ struct part_desc *pdesc;
	+ struct logvol_int_desc *lvid;
	+ uint64_t *lmappos;
	+ uint32_t ptov, lb_num, *freepos, free_lbs;
	+ int lb_size, alloc_num_lb;
	+ int alloc_type, error;
	+ int is_node;
	+
	+ DPRINTF(CALL, ("udf_allocate_space(ctype %d, vpart %d, num_lb %d\n",
	+ udf_c_type, vpart_num, num_lb));
	+ mutex_enter(&ump->allocate_mutex);
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ KASSERT(lb_size == ump->discinfo.sector_size);
	+
	+ alloc_type = ump->vtop_alloc[vpart_num];
	+ is_node = (udf_c_type == UDF_C_NODE);
	+
	+ lmappos = lmapping;
	+ error = 0;
	+ switch (alloc_type) {
	+ case UDF_ALLOC_VAT :
	+ /* search empty slot in VAT file */
	+ KASSERT(num_lb == 1);
	+ error = udf_search_free_vatloc(ump, &lb_num);
	+ if (!error) {
	+ *lmappos = lb_num;
	+
	+ /* reserve on the backing sequential partition since
	+ * that partition is credited back later */
	+ udf_do_reserve_space(ump, udf_node,
	+ ump->vtop[vpart_num], num_lb);
	+ }
	+ break;
	+ case UDF_ALLOC_SEQUENTIAL :
	+ /* sequential allocation on recordable media */
	+ /* get partition backing up this vpart_num_num */
	+ pdesc = ump->partitions[ump->vtop[vpart_num]];
	+
	+ /* calculate offset from physical base partition */
	+ ptov = le32toh(pdesc->start_loc);
	+
	+ /* get our track descriptors */
	+ if (vpart_num == ump->node_part) {
	+ alloc_track = &ump->metadata_track;
	+ other_track = &ump->data_track;
	+ } else {
	+ alloc_track = &ump->data_track;
	+ other_track = &ump->metadata_track;
	+ }
	+
	+ /* allocate */
	+ for (lb_num = 0; lb_num < num_lb; lb_num++) {
	+ *lmappos++ = alloc_track->next_writable - ptov;
	+ alloc_track->next_writable++;
	+ alloc_track->free_blocks--;
	+ }
	+
	+ /* keep other track up-to-date */
	+ if (alloc_track->tracknr == other_track->tracknr)
	+ memcpy(other_track, alloc_track,
	+ sizeof(struct mmc_trackinfo));
	+ break;
	+ case UDF_ALLOC_SPACEMAP :
	+ /* try to allocate on unallocated bits */
	+ alloc_num_lb = num_lb;
	+ bitmap = &ump->part_unalloc_bits[vpart_num];
	+ udf_bitmap_allocate(bitmap, is_node, &alloc_num_lb, lmappos);
	+ ump->lvclose \|= UDF_WRITE_PART_BITMAPS;
	+
	+ /* have we allocated all? */
	+ if (alloc_num_lb) {
	+ /* TODO convert freed to unalloc and try again */
	+ /* free allocated piece for now */
	+ lmappos = lmapping;
	+ for (lb_num=0; lb_num < num_lb-alloc_num_lb; lb_num++) {
	+ udf_bitmap_free(bitmap, *lmappos++, 1);
	+ }
	+ error = ENOSPC;
	+ }
	+ if (!error) {
	+ /* adjust freecount */
	+ lvid = ump->logvol_integrity;
	+ freepos = &lvid->tables[0] + vpart_num;
	+ free_lbs = le32toh(*freepos);
	+ *freepos = le32toh(free_lbs - num_lb);
	+ }
	+ break;
	+ case UDF_ALLOC_METABITMAP : /* UDF 2.50, 2.60 BluRay-RE */
	+ /* allocate on metadata unallocated bits */
	+ alloc_num_lb = num_lb;
	+ bitmap = &ump->metadata_unalloc_bits;
	+ udf_bitmap_allocate(bitmap, is_node, &alloc_num_lb, lmappos);
	+ ump->lvclose \|= UDF_WRITE_PART_BITMAPS;
	+
	+ /* have we allocated all? */
	+ if (alloc_num_lb) {
	+ /* YIKES! TODO we need to extend the metadata partition */
	+ /* free allocated piece for now */
	+ lmappos = lmapping;
	+ for (lb_num=0; lb_num < num_lb-alloc_num_lb; lb_num++) {
	+ udf_bitmap_free(bitmap, *lmappos++, 1);
	+ }
	+ error = ENOSPC;
	+ }
	+ if (!error) {
	+ /* adjust freecount */
	+ lvid = ump->logvol_integrity;
	+ freepos = &lvid->tables[0] + vpart_num;
	+ free_lbs = le32toh(*freepos);
	+ *freepos = le32toh(free_lbs - num_lb);
	+ }
	+ break;
	+ case UDF_ALLOC_METASEQUENTIAL : /* UDF 2.60 BluRay-R */
	+ case UDF_ALLOC_RELAXEDSEQUENTIAL : /* UDF 2.50/~meta BluRay-R */
	+ printf("ALERT: udf_allocate_space : allocation %d "
	+ "not implemented yet!\n", alloc_type);
	+ /* TODO implement, doesn't have to be contiguous */
	+ error = ENOSPC;
	+ break;
	+ }
	+
	+ if (!error) {
	+ /* credit our partition since we have committed the space */
	+ udf_do_unreserve_space(ump, udf_node, vpart_num, num_lb);
	+ }
	+
	+#ifdef DEBUG
	+ if (udf_verbose & UDF_DEBUG_ALLOC) {
	+ lmappos = lmapping;
	+ printf("udf_allocate_space, allocated logical lba :\n");
	+ for (lb_num = 0; lb_num < num_lb; lb_num++) {
	+ printf("%s %"PRIu64, (lb_num > 0)?",":"",
	+ *lmappos++);
	+ }
	+ printf("\n");
	+ }
	+#endif
	+ mutex_exit(&ump->allocate_mutex);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+void
	+udf_free_allocated_space(struct udf_mount *ump, uint32_t lb_num,
	+ uint16_t vpart_num, uint32_t num_lb)
	+{
	+ struct udf_bitmap *bitmap;
	+ struct part_desc *pdesc;
	+ struct logvol_int_desc *lvid;
	+ uint32_t ptov, lb_map, udf_rw32_lbmap;
	+ uint32_t *freepos, free_lbs;
	+ int phys_part;
	+ int error;
	+
	+ DPRINTF(ALLOC, ("udf_free_allocated_space: freeing virt lbnum %d "
	+ "part %d + %d sect\n", lb_num, vpart_num, num_lb));
	+
	+ /* no use freeing zero length */
	+ if (num_lb == 0)
	+ return;
	+
	+ mutex_enter(&ump->allocate_mutex);
	+
	+ /* get partition backing up this vpart_num */
	+ pdesc = ump->partitions[ump->vtop[vpart_num]];
	+
	+ switch (ump->vtop_tp[vpart_num]) {
	+ case UDF_VTOP_TYPE_PHYS :
	+ case UDF_VTOP_TYPE_SPARABLE :
	+ /* free space to freed or unallocated space bitmap */
	+ ptov = le32toh(pdesc->start_loc);
	+ phys_part = ump->vtop[vpart_num];
	+
	+ /* first try freed space bitmap */
	+ bitmap = &ump->part_freed_bits[phys_part];
	+
	+ /* if not defined, use unallocated bitmap */
	+ if (bitmap->bits == NULL)
	+ bitmap = &ump->part_unalloc_bits[phys_part];
	+
	+ /* if no bitmaps are defined, bail out; XXX OK? */
	+ if (bitmap->bits == NULL)
	+ break;
	+
	+ /* free bits if its defined */
	+ KASSERT(bitmap->bits);
	+ ump->lvclose \|= UDF_WRITE_PART_BITMAPS;
	+ udf_bitmap_free(bitmap, lb_num, num_lb);
	+
	+ /* adjust freecount */
	+ lvid = ump->logvol_integrity;
	+ freepos = &lvid->tables[0] + vpart_num;
	+ free_lbs = le32toh(*freepos);
	+ *freepos = le32toh(free_lbs + num_lb);
	+ break;
	+ case UDF_VTOP_TYPE_VIRT :
	+ /* free this VAT entry */
	+ KASSERT(num_lb == 1);
	+
	+ lb_map = 0xffffffff;
	+ udf_rw32_lbmap = le32toh(lb_map);
	+ error = udf_vat_write(ump->vat_node,
	+ (uint8_t *) &udf_rw32_lbmap, 4,
	+ ump->vat_offset + lb_num * 4);
	+ KASSERT(error == 0);
	+ ump->vat_last_free_lb = MIN(ump->vat_last_free_lb, lb_num);
	+ break;
	+ case UDF_VTOP_TYPE_META :
	+ /* free space in the metadata bitmap */
	+ bitmap = &ump->metadata_unalloc_bits;
	+ KASSERT(bitmap->bits);
	+
	+ ump->lvclose \|= UDF_WRITE_PART_BITMAPS;
	+ udf_bitmap_free(bitmap, lb_num, num_lb);
	+
	+ /* adjust freecount */
	+ lvid = ump->logvol_integrity;
	+ freepos = &lvid->tables[0] + vpart_num;
	+ free_lbs = le32toh(*freepos);
	+ *freepos = le32toh(free_lbs + num_lb);
	+ break;
	+ default:
	+ printf("ALERT: udf_free_allocated_space : allocation %d "
	+ "not implemented yet!\n", ump->vtop_tp[vpart_num]);
	+ break;
	+ }
	+
	+ mutex_exit(&ump->allocate_mutex);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Special function to synchronise the metadatamirror file when they change on
	+ * resizing. When the metadatafile is actually duplicated, this action is a
	+ * no-op since they describe different extents on the disc.
	+ */
	+
	+void udf_synchronise_metadatamirror_node(struct udf_mount *ump)
	+{
	+ struct udf_node meta_node, metamirror_node;
	+ struct long_ad s_ad;
	+ int slot, cpy_slot;
	+ int error, eof;
	+
	+ if (ump->metadata_flags & METADATA_DUPLICATED)
	+ return;
	+
	+ meta_node = ump->metadata_node;
	+ metamirror_node = ump->metadatamirror_node;
	+
	+ /* 1) wipe mirror node */
	+ udf_wipe_adslots(metamirror_node);
	+
	+ /* 2) copy all node descriptors from the meta_node */
	+ slot = 0;
	+ cpy_slot = 0;
	+ for (;;) {
	+ udf_get_adslot(meta_node, slot, &s_ad, &eof);
	+ if (eof)
	+ break;
	+ error = udf_append_adslot(metamirror_node, &cpy_slot, &s_ad);
	+ if (error) {
	+ /* WTF, this shouldn't happen, what to do now? */
	+ panic("udf_synchronise_metadatamirror_node failed!");
	+ }
	+ slot++;
	+ }
	+
	+ /* 3) adjust metamirror_node size */
	+ if (meta_node->fe) {
	+ KASSERT(metamirror_node->fe);
	+ metamirror_node->fe->inf_len = meta_node->fe->inf_len;
	+ } else {
	+ KASSERT(meta_node->efe);
	+ KASSERT(metamirror_node->efe);
	+ metamirror_node->efe->inf_len = meta_node->efe->inf_len;
	+ metamirror_node->efe->obj_size = meta_node->efe->obj_size;
	+ }
	+
	+ /* for sanity */
	+ udf_count_alloc_exts(metamirror_node);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * When faced with an out of space but there is still space available on other
	+ * partitions, try to redistribute the space. This is only defined for media
	+ * using Metadata partitions.
	+ *
	+ * There are two formats to deal with. Either its a `normal' metadata
	+ * partition and we can move blocks between a metadata bitmap and its
	+ * companion data spacemap OR its a UDF 2.60 formatted BluRay-R disc with POW
	+ * and a metadata partition.
	+ */
	+
	+static uint32_t
	+udf_trunc_metadatapart(struct udf_mount *ump, uint32_t num_lb)
	+{
	+ struct udf_node *bitmap_node;
	+ struct udf_bitmap *bitmap;
	+ struct space_bitmap_desc sbd, new_sbd;
	+ struct logvol_int_desc *lvid;
	+ uint64_t inf_len;
	+ uint64_t meta_free_lbs, data_free_lbs;
	+ uint32_t freepos, sizepos;
	+ uint32_t unit, lb_size, to_trunc;
	+ uint16_t meta_vpart_num, data_vpart_num, num_vpart;
	+ int err;
	+
	+ unit = ump->metadata_alloc_unit_size;
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ lvid = ump->logvol_integrity;
	+
	+ /* lookup vpart for metadata partition */
	+ meta_vpart_num = ump->node_part;
	+ KASSERT(ump->vtop_alloc[meta_vpart_num] == UDF_ALLOC_METABITMAP);
	+
	+ /* lookup vpart for data partition */
	+ data_vpart_num = ump->data_part;
	+ KASSERT(ump->vtop_alloc[data_vpart_num] == UDF_ALLOC_SPACEMAP);
	+
	+ udf_calc_vpart_freespace(ump, data_vpart_num, &data_free_lbs);
	+ udf_calc_vpart_freespace(ump, meta_vpart_num, &meta_free_lbs);
	+
	+ DPRINTF(RESERVE, ("\tfree space on data partition %"PRIu64" blks\n", data_free_lbs));
	+ DPRINTF(RESERVE, ("\tfree space on metadata partition %"PRIu64" blks\n", meta_free_lbs));
	+
	+ /* give away some of the free meta space, in unit block sizes */
	+ to_trunc = meta_free_lbs/4; /* give out a quarter */
	+ to_trunc = MAX(to_trunc, num_lb);
	+ to_trunc = unit * ((to_trunc + unit-1) / unit); /* round up */
	+
	+ /* scale down if needed and bail out when out of space */
	+ if (to_trunc >= meta_free_lbs)
	+ return (num_lb);
	+
	+ /* check extent of bits marked free at the end of the map */
	+ bitmap = &ump->metadata_unalloc_bits;
	+ to_trunc = udf_bitmap_check_trunc_free(bitmap, to_trunc);
	+ to_trunc = unit * (to_trunc / unit); /* round down again */
	+ if (to_trunc == 0)
	+ return (num_lb);
	+
	+ DPRINTF(RESERVE, ("\ttruncating %d lbs from the metadata bitmap\n",
	+ to_trunc));
	+
	+ /* get length of the metadata bitmap node file */
	+ bitmap_node = ump->metadatabitmap_node;
	+ if (bitmap_node->fe) {
	+ inf_len = le64toh(bitmap_node->fe->inf_len);
	+ } else {
	+ KASSERT(bitmap_node->efe);
	+ inf_len = le64toh(bitmap_node->efe->inf_len);
	+ }
	+ inf_len -= to_trunc/8;
	+
	+ /* as per [UDF 2.60/2.2.13.6] : */
	+ /* 1) update the SBD in the metadata bitmap file */
	+ sbd = (struct space_bitmap_desc *) bitmap->blob;
	+ sbd->num_bits = le32toh(sbd->num_bits) - to_trunc;
	+ sbd->num_bytes = le32toh(sbd->num_bytes) - to_trunc/8;
	+ bitmap->max_offset = le32toh(sbd->num_bits);
	+
	+ num_vpart = le32toh(lvid->num_part);
	+ freepos = &lvid->tables[0] + meta_vpart_num;
	+ sizepos = &lvid->tables[0] + num_vpart + meta_vpart_num;
	+ freepos = le32toh(freepos) - to_trunc;
	+ sizepos = le32toh(sizepos) - to_trunc;
	+
	+ /* realloc bitmap for better memory usage */
	+ new_sbd = realloc(sbd, inf_len, M_UDFTEMP,
	+ M_CANFAIL \| M_WAITOK);
	+ if (new_sbd) {
	+ /* update pointers */
	+ ump->metadata_unalloc_dscr = new_sbd;
	+ bitmap->blob = (uint8_t *) new_sbd;
	+ }
	+ ump->lvclose \|= UDF_WRITE_PART_BITMAPS;
	+
	+ /*
	+ * The truncated space is secured now and can't be allocated anymore. Release
	+ * the allocate mutex so we can shrink the nodes the normal way.
	+ */
	+ mutex_exit(&ump->allocate_mutex);
	+
	+ /* 2) trunc the metadata bitmap information file, freeing blocks */
	+ err = udf_shrink_node(bitmap_node, inf_len);
	+ KASSERT(err == 0);
	+
	+ /* 3) trunc the metadata file and mirror file, freeing blocks */
	+ inf_len = le32toh(sbd->num_bits) * lb_size; /* [4/14.12.4] */
	+ err = udf_shrink_node(ump->metadata_node, inf_len);
	+ KASSERT(err == 0);
	+ if (ump->metadatamirror_node && (ump->metadata_flags & METADATA_DUPLICATED)) {
	+ err = udf_shrink_node(ump->metadatamirror_node, inf_len);
	+ KASSERT(err == 0);
	+ }
	+ ump->lvclose \|= UDF_WRITE_METAPART_NODES;
	+
	+ /* relock before exit */
	+ mutex_enter(&ump->allocate_mutex);
	+
	+ if (to_trunc > num_lb)
	+ return (0);
	+ return (num_lb - to_trunc);
	+}
	+
	+
	+static void
	+udf_sparsify_metadatapart(struct udf_mount *ump, uint32_t num_lb)
	+{
	+ /* NOT IMPLEMENTED, fail */
	+}
	+
	+
	+static void
	+udf_collect_free_space_for_vpart(struct udf_mount *ump,
	+ uint16_t vpart_num, uint32_t num_lb)
	+{
	+ /* allocate mutex is helt */
	+
	+ /* only defined for metadata partitions */
	+ if (ump->vtop_tp[ump->node_part] != UDF_VTOP_TYPE_META) {
	+ DPRINTF(RESERVE, ("\tcan't grow/shrink; no metadata partitioning\n"));
	+ return;
	+ }
	+
	+ /* UDF 2.60 BD-R+POW? */
	+ if (ump->vtop_alloc[ump->node_part] == UDF_ALLOC_METASEQUENTIAL) {
	+ DPRINTF(RESERVE, ("\tUDF 2.60 BD-R+POW track grow not implemented yet\n"));
	+ return;
	+ }
	+
	+ if (ump->vtop_tp[vpart_num] == UDF_VTOP_TYPE_META) {
	+ /* try to grow the meta partition */
	+ DPRINTF(RESERVE, ("\ttrying to grow the meta partition\n"));
	+ /* as per [UDF 2.60/2.2.13.5] : extend bitmap and metadata file(s) */
	+ } else {
	+ /* try to shrink the metadata partition */
	+ DPRINTF(RESERVE, ("\ttrying to shrink the meta partition\n"));
	+ /* as per [UDF 2.60/2.2.13.6] : either trunc or make sparse */
	+ num_lb = udf_trunc_metadatapart(ump, num_lb);
	+ if (num_lb)
	+ udf_sparsify_metadatapart(ump, num_lb);
	+ }
	+
	+ /* allocate mutex should still be helt */
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Allocate a buf on disc for direct write out. The space doesn't have to be
	+ * contiguous as the caller takes care of this.
	+ */
	+
	+void
	+udf_late_allocate_buf(struct udf_mount ump, struct buf buf,
	+ uint64_t lmapping, struct long_ad node_ad_cpy, uint16_t *vpart_nump)
	+{
	+ struct udf_node *udf_node = VTOI(buf->b_vp);
	+ int lb_size, blks, udf_c_type;
	+ int vpart_num, num_lb;
	+ int error, s;
	+
	+ /*
	+ * for each sector in the buf, allocate a sector on disc and record
	+ * its position in the provided mapping array.
	+ *
	+ * If its userdata or FIDs, record its location in its node.
	+ */
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ num_lb = (buf->b_bcount + lb_size -1) / lb_size;
	+ blks = lb_size / DEV_BSIZE;
	+ udf_c_type = buf->b_udf_c_type;
	+
	+ KASSERT(lb_size == ump->discinfo.sector_size);
	+
	+ /* select partition to record the buffer on */
	+ vpart_num = *vpart_nump = udf_get_record_vpart(ump, udf_c_type);
	+
	+ if (udf_c_type == UDF_C_NODE) {
	+ /* if not VAT, its allready allocated */
	+ if (ump->vtop_alloc[ump->node_part] != UDF_ALLOC_VAT)
	+ return;
	+
	+ /* allocate on its backing sequential partition */
	+ vpart_num = ump->data_part;
	+ }
	+
	+ /* XXX can this still happen? */
	+ /* do allocation on the selected partition */
	+ error = udf_allocate_space(ump, udf_node, udf_c_type,
	+ vpart_num, num_lb, lmapping);
	+ if (error) {
	+ /*
	+ * ARGH! we haven't done our accounting right! it should
	+ * allways succeed.
	+ */
	+ panic("UDF disc allocation accounting gone wrong");
	+ }
	+
	+ /* If its userdata or FIDs, record its allocation in its node. */
	+ if ((udf_c_type == UDF_C_USERDATA) \|\|
	+ (udf_c_type == UDF_C_FIDS) \|\|
	+ (udf_c_type == UDF_C_METADATA_SBM))
	+ {
	+ udf_record_allocation_in_node(ump, buf, vpart_num, lmapping,
	+ node_ad_cpy);
	+ /* decrement our outstanding bufs counter */
	+ s = splbio();
	+ udf_node->outstanding_bufs--;
	+ splx(s);
	+ }
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Try to merge a1 with the new piece a2. udf_ads_merge returns error when not
	+ * possible (anymore); a2 returns the rest piece.
	+ */
	+
	+static int
	+udf_ads_merge(uint32_t lb_size, struct long_ad a1, struct long_ad a2)
	+{
	+ uint32_t max_len, merge_len;
	+ uint32_t a1_len, a2_len;
	+ uint32_t a1_flags, a2_flags;
	+ uint32_t a1_lbnum, a2_lbnum;
	+ uint16_t a1_part, a2_part;
	+
	+ max_len = ((UDF_EXT_MAXLEN / lb_size) * lb_size);
	+
	+ a1_flags = UDF_EXT_FLAGS(le32toh(a1->len));
	+ a1_len = UDF_EXT_LEN(le32toh(a1->len));
	+ a1_lbnum = le32toh(a1->loc.lb_num);
	+ a1_part = le16toh(a1->loc.part_num);
	+
	+ a2_flags = UDF_EXT_FLAGS(le32toh(a2->len));
	+ a2_len = UDF_EXT_LEN(le32toh(a2->len));
	+ a2_lbnum = le32toh(a2->loc.lb_num);
	+ a2_part = le16toh(a2->loc.part_num);
	+
	+ /* defines same space */
	+ if (a1_flags != a2_flags)
	+ return (1);
	+
	+ if (a1_flags != UDF_EXT_FREE) {
	+ /* the same partition */
	+ if (a1_part != a2_part)
	+ return (1);
	+
	+ /* a2 is successor of a1 */
	+ if (a1_lbnum * lb_size + a1_len != a2_lbnum * lb_size)
	+ return (1);
	+ }
	+
	+ /* merge as most from a2 if possible */
	+ merge_len = MIN(a2_len, max_len - a1_len);
	+ a1_len += merge_len;
	+ a2_len -= merge_len;
	+ a2_lbnum += merge_len/lb_size;
	+
	+ a1->len = le32toh(a1_len \| a1_flags);
	+ a2->len = le32toh(a2_len \| a2_flags);
	+ a2->loc.lb_num = le32toh(a2_lbnum);
	+
	+ if (a2_len > 0)
	+ return (1);
	+
	+ /* there is space over to merge */
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static void
	+udf_wipe_adslots(struct udf_node *udf_node)
	+{
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct alloc_ext_entry *ext;
	+ uint64_t inflen, objsize;
	+ uint32_t lb_size, dscr_size, l_ea, l_ad, max_l_ad, crclen;
	+ uint8_t *data_pos;
	+ int extnr;
	+
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+ if (fe) {
	+ inflen = le64toh(fe->inf_len);
	+ objsize = inflen;
	+ dscr_size = sizeof(struct file_entry) -1;
	+ l_ea = le32toh(fe->l_ea);
	+ l_ad = le32toh(fe->l_ad);
	+ data_pos = (uint8_t *) fe + dscr_size + l_ea;
	+ } else {
	+ inflen = le64toh(efe->inf_len);
	+ objsize = le64toh(efe->obj_size);
	+ dscr_size = sizeof(struct extfile_entry) -1;
	+ l_ea = le32toh(efe->l_ea);
	+ l_ad = le32toh(efe->l_ad);
	+ data_pos = (uint8_t *) efe + dscr_size + l_ea;
	+ }
	+ max_l_ad = lb_size - dscr_size - l_ea;
	+
	+ /* wipe fe/efe */
	+ memset(data_pos, 0, max_l_ad);
	+ crclen = dscr_size - UDF_DESC_TAG_LENGTH + l_ea;
	+ if (fe) {
	+ fe->l_ad = le32toh(0);
	+ fe->logblks_rec = le64toh(0);
	+ fe->tag.desc_crc_len = le16toh(crclen);
	+ } else {
	+ efe->l_ad = le32toh(0);
	+ efe->logblks_rec = le64toh(0);
	+ efe->tag.desc_crc_len = le16toh(crclen);
	+ }
	+
	+ /* wipe all allocation extent entries */
	+ for (extnr = 0; extnr < udf_node->num_extensions; extnr++) {
	+ ext = udf_node->ext[extnr];
	+ dscr_size = sizeof(struct alloc_ext_entry) -1;
	+ data_pos = (uint8_t *) ext->data;
	+ max_l_ad = lb_size - dscr_size;
	+ memset(data_pos, 0, max_l_ad);
	+ ext->l_ad = le32toh(0);
	+
	+ crclen = dscr_size - UDF_DESC_TAG_LENGTH;
	+ ext->tag.desc_crc_len = le16toh(crclen);
	+ }
	+ udf_node->i_flags \|= IN_NODE_REBUILD;
	+}
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	+void
	+udf_get_adslot(struct udf_node udf_node, int slot, struct long_ad icb,
	+ int *eof) {
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct alloc_ext_entry *ext;
	+ struct icb_tag *icbtag;
	+ struct short_ad *short_ad;
	+ struct long_ad *long_ad, l_icb;
	+ int icbflags, addr_type, adlen, extnr;
	+ uint32_t offset, lb_size, dscr_size, l_ea, l_ad, flags;
	+ uint8_t *data_pos;
	+
	+ /* determine what descriptor we are in */
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+ if (fe) {
	+ icbtag = &fe->icbtag;
	+ dscr_size = sizeof(struct file_entry) -1;
	+ l_ea = le32toh(fe->l_ea);
	+ l_ad = le32toh(fe->l_ad);
	+ data_pos = (uint8_t *) fe + dscr_size + l_ea;
	+ } else {
	+ icbtag = &efe->icbtag;
	+ dscr_size = sizeof(struct extfile_entry) -1;
	+ l_ea = le32toh(efe->l_ea);
	+ l_ad = le32toh(efe->l_ad);
	+ data_pos = (uint8_t *) efe + dscr_size + l_ea;
	+ }
	+
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ /* just in case we're called on an intern, its EOF */
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ memset(icb, 0, sizeof(struct long_ad));
	+ *eof = 1;
	+ return;
	+ }
	+
	+ adlen = 0;
	+ if (addr_type == UDF_ICB_SHORT_ALLOC) {
	+ adlen = sizeof(struct short_ad);
	+ } else if (addr_type == UDF_ICB_LONG_ALLOC) {
	+ adlen = sizeof(struct long_ad);
	+ }
	+
	+ /* if offset too big, we go to the allocation extensions */
	+ offset = slot * adlen;
	+ extnr = -1;
	+ while (offset >= l_ad) {
	+ /* check if our last entry is a redirect */
	+ if (addr_type == UDF_ICB_SHORT_ALLOC) {
	+ short_ad = (struct short_ad *) (data_pos + l_ad-adlen);
	+ l_icb.len = short_ad->len;
	+ l_icb.loc.part_num = udf_node->loc.loc.part_num;
	+ l_icb.loc.lb_num = short_ad->lb_num;
	+ } else {
	+ KASSERT(addr_type == UDF_ICB_LONG_ALLOC,("addr_type != UDF_ICB_LONG_ALLOC"));
	+ long_ad = (struct long_ad *) (data_pos + l_ad-adlen);
	+ l_icb = *long_ad;
	+ }
	+ flags = UDF_EXT_FLAGS(le32toh(l_icb.len));
	+ if (flags != UDF_EXT_REDIRECT) {
	+ l_ad = 0; /* force EOF */
	+ break;
	+ }
	+
	+ /* advance to next extent */
	+ extnr++;
	+ if (extnr >= udf_node->num_extensions) {
	+ l_ad = 0; /* force EOF */
	+ break;
	+ }
	+ offset = offset - l_ad;
	+ ext = udf_node->ext[extnr];
	+ dscr_size = sizeof(struct alloc_ext_entry) -1;
	+ l_ad = le32toh(ext->l_ad);
	+ data_pos = (uint8_t *) ext + dscr_size;
	+ }
	+
	+ /* XXX l_ad == 0 should be enough to check */
	+ *eof = (offset >= l_ad) \|\| (l_ad == 0);
	+ if (*eof) {
	+ DPRINTF(PARANOIDADWLK, ("returning EOF, extnr %d, offset %d, "
	+ "l_ad %d\n", extnr, offset, l_ad));
	+ memset(icb, 0, sizeof(struct long_ad));
	+ return;
	+ }
	+
	+ /* get the element */
	+ if (addr_type == UDF_ICB_SHORT_ALLOC) {
	+ short_ad = (struct short_ad *) (data_pos + offset);
	+ icb->len = short_ad->len;
	+ icb->loc.part_num = udf_node->loc.loc.part_num;
	+ icb->loc.lb_num = short_ad->lb_num;
	+ } else if (addr_type == UDF_ICB_LONG_ALLOC) {
	+ long_ad = (struct long_ad *) (data_pos + offset);
	+ icb = long_ad;
	+ }
	+ DPRINTF(PARANOIDADWLK, ("returning element : v %d, lb %d, len %d, "
	+ "flags %d\n", icb->loc.part_num, icb->loc.lb_num,
	+ UDF_EXT_LEN(icb->len), UDF_EXT_FLAGS(icb->len)));
	+}
	+
	+/* --------------------------------------------------------------------- */
	+#if 0
	+int
	+udf_append_adslot(struct udf_node udf_node, int slot, struct long_ad *icb) {
	+ struct udf_mount *ump = udf_node->ump;
	+ union dscrptr dscr, extdscr;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct alloc_ext_entry *ext;
	+ struct icb_tag *icbtag;
	+ struct short_ad *short_ad;
	+ struct long_ad *long_ad, o_icb, l_icb;
	+ uint64_t logblks_rec, *logblks_rec_p;
	+ uint64_t lmapping;
	+ uint32_t offset, rest, len, lb_num;
	+ uint32_t lb_size, dscr_size, l_ea, l_ad, *l_ad_p, max_l_ad, crclen;
	+ uint32_t flags;
	+ uint16_t vpart_num;
	+ uint8_t *data_pos;
	+ int icbflags, addr_type, adlen, extnr;
	+ int error;
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ vpart_num = le16toh(udf_node->loc.loc.part_num);
	+
	+ /* determine what descriptor we are in */
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+ if (fe) {
	+ icbtag = &fe->icbtag;
	+ dscr = (union dscrptr *) fe;
	+ dscr_size = sizeof(struct file_entry) -1;
	+
	+ l_ea = le32toh(fe->l_ea);
	+ l_ad_p = &fe->l_ad;
	+ logblks_rec_p = &fe->logblks_rec;
	+ } else {
	+ icbtag = &efe->icbtag;
	+ dscr = (union dscrptr *) efe;
	+ dscr_size = sizeof(struct extfile_entry) -1;
	+
	+ l_ea = le32toh(efe->l_ea);
	+ l_ad_p = &efe->l_ad;
	+ logblks_rec_p = &efe->logblks_rec;
	+ }
	+ data_pos = (uint8_t *) dscr + dscr_size + l_ea;
	+ max_l_ad = lb_size - dscr_size - l_ea;
	+
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ /* just in case we're called on an intern, its EOF */
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ panic("udf_append_adslot on UDF_ICB_INTERN_ALLOC\n");
	+ }
	+
	+ adlen = 0;
	+ if (addr_type == UDF_ICB_SHORT_ALLOC) {
	+ adlen = sizeof(struct short_ad);
	+ } else if (addr_type == UDF_ICB_LONG_ALLOC) {
	+ adlen = sizeof(struct long_ad);
	+ }
	+
	+ /* clean up given long_ad since it can be a synthesized one */
	+ flags = UDF_EXT_FLAGS(le32toh(icb->len));
	+ if (flags == UDF_EXT_FREE) {
	+ icb->loc.part_num = le16toh(0);
	+ icb->loc.lb_num = le32toh(0);
	+ }
	+
	+ /* if offset too big, we go to the allocation extensions */
	+ l_ad = le32toh(*l_ad_p);
	+ offset = (slot) adlen;
	+ extnr = -1;
	+ while (offset >= l_ad) {
	+ /* check if our last entry is a redirect */
	+ if (addr_type == UDF_ICB_SHORT_ALLOC) {
	+ short_ad = (struct short_ad *) (data_pos + l_ad-adlen);
	+ l_icb.len = short_ad->len;
	+ l_icb.loc.part_num = udf_node->loc.loc.part_num;
	+ l_icb.loc.lb_num = short_ad->lb_num;
	+ } else {
	+ KASSERT(addr_type == UDF_ICB_LONG_ALLOC);
	+ long_ad = (struct long_ad *) (data_pos + l_ad-adlen);
	+ l_icb = *long_ad;
	+ }
	+ flags = UDF_EXT_FLAGS(le32toh(l_icb.len));
	+ if (flags != UDF_EXT_REDIRECT) {
	+ /* only one past the last one is adressable */
	+ break;
	+ }
	+
	+ /* advance to next extent */
	+ extnr++;
	+ KASSERT(extnr < udf_node->num_extensions);
	+ offset = offset - l_ad;
	+
	+ ext = udf_node->ext[extnr];
	+ dscr = (union dscrptr *) ext;
	+ dscr_size = sizeof(struct alloc_ext_entry) -1;
	+ max_l_ad = lb_size - dscr_size;
	+ l_ad_p = &ext->l_ad;
	+ l_ad = le32toh(*l_ad_p);
	+ data_pos = (uint8_t *) ext + dscr_size;
	+ }
	+ DPRINTF(PARANOIDADWLK, ("append, ext %d, offset %d, l_ad %d\n",
	+ extnr, offset, le32toh(*l_ad_p)));
	+ KASSERT(l_ad == le32toh(*l_ad_p));
	+
	+ /* offset is offset within the current (E)FE/AED */
	+ l_ad = le32toh(*l_ad_p);
	+ crclen = le16toh(dscr->tag.desc_crc_len);
	+ logblks_rec = le64toh(*logblks_rec_p);
	+
	+ /* overwriting old piece? */
	+ if (offset < l_ad) {
	+ /* overwrite entry; compensate for the old element */
	+ if (addr_type == UDF_ICB_SHORT_ALLOC) {
	+ short_ad = (struct short_ad *) (data_pos + offset);
	+ o_icb.len = short_ad->len;
	+ o_icb.loc.part_num = le16toh(0); /* ignore */
	+ o_icb.loc.lb_num = short_ad->lb_num;
	+ } else if (addr_type == UDF_ICB_LONG_ALLOC) {
	+ long_ad = (struct long_ad *) (data_pos + offset);
	+ o_icb = *long_ad;
	+ } else {
	+ panic("Invalid address type in udf_append_adslot\n");
	+ }
	+
	+ len = le32toh(o_icb.len);
	+ if (UDF_EXT_FLAGS(len) == UDF_EXT_ALLOCATED) {
	+ /* adjust counts */
	+ len = UDF_EXT_LEN(len);
	+ logblks_rec -= (len + lb_size -1) / lb_size;
	+ }
	+ }
	+
	+ /* check if we're not appending a redirection */
	+ flags = UDF_EXT_FLAGS(le32toh(icb->len));
	+ KASSERT(flags != UDF_EXT_REDIRECT);
	+
	+ /* round down available space */
	+ rest = adlen * ((max_l_ad - offset) / adlen);
	+ if (rest <= adlen) {
	+ /* have to append aed, see if we already have a spare one */
	+ extnr++;
	+ ext = udf_node->ext[extnr];
	+ l_icb = udf_node->ext_loc[extnr];
	+ if (ext == NULL) {
	+ DPRINTF(ALLOC,("adding allocation extent %d\n", extnr));
	+
	+ error = udf_reserve_space(ump, NULL, UDF_C_NODE,
	+ vpart_num, 1, /* can fail */ false);
	+ if (error) {
	+ printf("UDF: couldn't reserve space for AED!\n");
	+ return error;
	+ }
	+ error = udf_allocate_space(ump, NULL, UDF_C_NODE,
	+ vpart_num, 1, &lmapping);
	+ lb_num = lmapping;
	+ if (error)
	+ panic("UDF: couldn't allocate AED!\n");
	+
	+ /* initialise pointer to location */
	+ memset(&l_icb, 0, sizeof(struct long_ad));
	+ l_icb.len = le32toh(lb_size \| UDF_EXT_REDIRECT);
	+ l_icb.loc.lb_num = le32toh(lb_num);
	+ l_icb.loc.part_num = le16toh(vpart_num);
	+
	+ /* create new aed descriptor */
	+ udf_create_logvol_dscr(ump, udf_node, &l_icb, &extdscr);
	+ ext = &extdscr->aee;
	+
	+ udf_inittag(ump, &ext->tag, TAGID_ALLOCEXTENT, lb_num);
	+ dscr_size = sizeof(struct alloc_ext_entry) -1;
	+ max_l_ad = lb_size - dscr_size;
	+ memset(ext->data, 0, max_l_ad);
	+ ext->l_ad = le32toh(0);
	+ ext->tag.desc_crc_len =
	+ le16toh(dscr_size - UDF_DESC_TAG_LENGTH);
	+
	+ /* declare aed */
	+ udf_node->num_extensions++;
	+ udf_node->ext_loc[extnr] = l_icb;
	+ udf_node->ext[extnr] = ext;
	+ }
	+ /* add redirect and adjust l_ad and crclen for old descr */
	+ if (addr_type == UDF_ICB_SHORT_ALLOC) {
	+ short_ad = (struct short_ad *) (data_pos + offset);
	+ short_ad->len = l_icb.len;
	+ short_ad->lb_num = l_icb.loc.lb_num;
	+ } else if (addr_type == UDF_ICB_LONG_ALLOC) {
	+ long_ad = (struct long_ad *) (data_pos + offset);
	+ *long_ad = l_icb;
	+ }
	+ l_ad += adlen;
	+ crclen += adlen;
	+ dscr->tag.desc_crc_len = le16toh(crclen);
	+ *l_ad_p = le32toh(l_ad);
	+
	+ /* advance to the new extension */
	+ KASSERT(ext != NULL);
	+ dscr = (union dscrptr *) ext;
	+ dscr_size = sizeof(struct alloc_ext_entry) -1;
	+ max_l_ad = lb_size - dscr_size;
	+ data_pos = (uint8_t *) dscr + dscr_size;
	+
	+ l_ad_p = &ext->l_ad;
	+ l_ad = le32toh(*l_ad_p);
	+ crclen = le16toh(dscr->tag.desc_crc_len);
	+ offset = 0;
	+
	+ /* adjust callees slot count for link insert */
	+ *slot += 1;
	+ }
	+
	+ /* write out the element */
	+ DPRINTF(PARANOIDADWLK, ("adding element : %p : v %d, lb %d, "
	+ "len %d, flags %d\n", data_pos + offset,
	+ icb->loc.part_num, icb->loc.lb_num,
	+ UDF_EXT_LEN(icb->len), UDF_EXT_FLAGS(icb->len)));
	+ if (addr_type == UDF_ICB_SHORT_ALLOC) {
	+ short_ad = (struct short_ad *) (data_pos + offset);
	+ short_ad->len = icb->len;
	+ short_ad->lb_num = icb->loc.lb_num;
	+ } else if (addr_type == UDF_ICB_LONG_ALLOC) {
	+ long_ad = (struct long_ad *) (data_pos + offset);
	+ long_ad = icb;
	+ }
	+
	+ /* adjust logblks recorded count */
	+ len = le32toh(icb->len);
	+ flags = UDF_EXT_FLAGS(len);
	+ if (flags == UDF_EXT_ALLOCATED)
	+ logblks_rec += (UDF_EXT_LEN(len) + lb_size -1) / lb_size;
	+ *logblks_rec_p = le64toh(logblks_rec);
	+
	+ /* adjust l_ad and crclen when needed */
	+ if (offset >= l_ad) {
	+ l_ad += adlen;
	+ crclen += adlen;
	+ dscr->tag.desc_crc_len = le16toh(crclen);
	+ *l_ad_p = le32toh(l_ad);
	+ }
	+
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static void
	+udf_count_alloc_exts(struct udf_node *udf_node)
	+{
	+ struct long_ad s_ad;
	+ uint32_t lb_num, len, flags;
	+ uint16_t vpart_num;
	+ int slot, eof;
	+ int num_extents, extnr;
	+ int lb_size;
	+
	+ if (udf_node->num_extensions == 0)
	+ return;
	+
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+ /* count number of allocation extents in use */
	+ num_extents = 0;
	+ slot = 0;
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ if (eof)
	+ break;
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+
	+ if (flags == UDF_EXT_REDIRECT)
	+ num_extents++;
	+
	+ slot++;
	+ }
	+
	+ DPRINTF(ALLOC, ("udf_count_alloc_ext counted %d live extents\n",
	+ num_extents));
	+
	+ /* XXX choice: we could delay freeing them on node writeout */
	+ /* free excess entries */
	+ extnr = num_extents;
	+ for (;extnr < udf_node->num_extensions; extnr++) {
	+ DPRINTF(ALLOC, ("freeing alloc ext %d\n", extnr));
	+ /* free dscriptor */
	+ s_ad = udf_node->ext_loc[extnr];
	+ udf_free_logvol_dscr(udf_node->ump, &s_ad,
	+ udf_node->ext[extnr]);
	+ udf_node->ext[extnr] = NULL;
	+
	+ /* free disc space */
	+ lb_num = le32toh(s_ad.loc.lb_num);
	+ vpart_num = le16toh(s_ad.loc.part_num);
	+ udf_free_allocated_space(udf_node->ump, lb_num, vpart_num, 1);
	+
	+ memset(&udf_node->ext_loc[extnr], 0, sizeof(struct long_ad));
	+ }
	+
	+ /* set our new number of allocation extents */
	+ udf_node->num_extensions = num_extents;
	+}
	+
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Adjust the node's allocation descriptors to reflect the new mapping; do
	+ * take note that we might glue to existing allocation descriptors.
	+ *
	+ * XXX Note there can only be one allocation being recorded/mount; maybe
	+ * explicit allocation in shedule thread?
	+ */
	+
	+static void
	+udf_record_allocation_in_node(struct udf_mount ump, struct buf buf,
	+ uint16_t vpart_num, uint64_t mapping, struct long_ad node_ad_cpy)
	+{
	+ struct vnode *vp = buf->b_vp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct icb_tag *icbtag;
	+ struct long_ad s_ad, c_ad;
	+ uint64_t inflen, from, till;
	+ uint64_t foffset, end_foffset, restart_foffset;
	+ uint64_t orig_inflen, orig_lbrec, new_inflen, new_lbrec;
	+ uint32_t num_lb, len, flags, lb_num;
	+ uint32_t run_start;
	+ uint32_t slot_offset, replace_len, replace;
	+ int addr_type, icbflags;
	+/* int udf_c_type = buf->b_udf_c_type; */
	+ int lb_size, run_length, eof;
	+ int slot, cpy_slot, cpy_slots, restart_slot;
	+ int error;
	+
	+ DPRINTF(ALLOC, ("udf_record_allocation_in_node\n"));
	+
	+#if 0
	+ /* XXX disable sanity check for now */
	+ /* sanity check ... should be panic ? */
	+ if ((udf_c_type != UDF_C_USERDATA) && (udf_c_type != UDF_C_FIDS))
	+ return;
	+#endif
	+
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+
	+ /* do the job */
	+ UDF_LOCK_NODE(udf_node, 0); /* XXX can deadlock ? */
	+ udf_node_sanity_check(udf_node, &orig_inflen, &orig_lbrec);
	+
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+ if (fe) {
	+ icbtag = &fe->icbtag;
	+ inflen = le64toh(fe->inf_len);
	+ } else {
	+ icbtag = &efe->icbtag;
	+ inflen = le64toh(efe->inf_len);
	+ }
	+
	+ /* do check if `till' is not past file information length */
	+ from = buf->b_lblkno * lb_size;
	+ till = MIN(inflen, from + buf->b_resid);
	+
	+ num_lb = (till - from + lb_size -1) / lb_size;
	+
	+ DPRINTF(ALLOC, ("record allocation from %"PRIu64" + %d\n", from, buf->b_bcount));
	+
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ /* nothing to do */
	+ /* XXX clean up rest of node? just in case? */
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ return;
	+ }
	+
	+ slot = 0;
	+ cpy_slot = 0;
	+ foffset = 0;
	+
	+ /* 1) copy till first overlap piece to the rewrite buffer */
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ if (eof) {
	+ DPRINTF(WRITE,
	+ ("Record allocation in node "
	+ "failed: encountered EOF\n"));
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ buf->b_error = EINVAL;
	+ return;
	+ }
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ if (flags == UDF_EXT_REDIRECT) {
	+ slot++;
	+ continue;
	+ }
	+
	+ end_foffset = foffset + len;
	+ if (end_foffset > from)
	+ break; /* found */
	+
	+ node_ad_cpy[cpy_slot++] = s_ad;
	+
	+ DPRINTF(ALLOC, ("\t1: vp %d, lb %d, len %d, flags %d "
	+ "-> stack\n",
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+
	+ foffset = end_foffset;
	+ slot++;
	+ }
	+ restart_slot = slot;
	+ restart_foffset = foffset;
	+
	+ /* 2) trunc overlapping slot at overlap and copy it */
	+ slot_offset = from - foffset;
	+ if (slot_offset > 0) {
	+ DPRINTF(ALLOC, ("\tslot_offset = %d, flags = %d (%d)\n",
	+ slot_offset, flags >> 30, flags));
	+
	+ s_ad.len = le32toh(slot_offset \| flags);
	+ node_ad_cpy[cpy_slot++] = s_ad;
	+
	+ DPRINTF(ALLOC, ("\t2: vp %d, lb %d, len %d, flags %d "
	+ "-> stack\n",
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+ }
	+ foffset += slot_offset;
	+
	+ /* 3) insert new mappings */
	+ memset(&s_ad, 0, sizeof(struct long_ad));
	+ lb_num = 0;
	+ for (lb_num = 0; lb_num < num_lb; lb_num++) {
	+ run_start = mapping[lb_num];
	+ run_length = 1;
	+ while (lb_num < num_lb-1) {
	+ if (mapping[lb_num+1] != mapping[lb_num]+1)
	+ if (mapping[lb_num+1] != mapping[lb_num])
	+ break;
	+ run_length++;
	+ lb_num++;
	+ }
	+ /* insert slot for this mapping */
	+ len = run_length * lb_size;
	+
	+ /* bounds checking */
	+ if (foffset + len > till)
	+ len = till - foffset;
	+ KASSERT(foffset + len <= inflen);
	+
	+ s_ad.len = le32toh(len \| UDF_EXT_ALLOCATED);
	+ s_ad.loc.part_num = le16toh(vpart_num);
	+ s_ad.loc.lb_num = le32toh(run_start);
	+
	+ foffset += len;
	+
	+ /* paranoia */
	+ if (len == 0) {
	+ DPRINTF(WRITE,
	+ ("Record allocation in node "
	+ "failed: insert failed\n"));
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+ buf->b_error = EINVAL;
	+ return;
	+ }
	+ node_ad_cpy[cpy_slot++] = s_ad;
	+
	+ DPRINTF(ALLOC, ("\t3: insert new mapping vp %d lb %d, len %d, "
	+ "flags %d -> stack\n",
	+ le16toh(s_ad.loc.part_num), le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+ }
	+
	+ /* 4) pop replaced length */
	+ slot = restart_slot;
	+ foffset = restart_foffset;
	+
	+ replace_len = till - foffset; /* total amount of bytes to pop */
	+ slot_offset = from - foffset; /* offset in first encounted slot */
	+ KASSERT((slot_offset % lb_size) == 0);
	+
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ if (eof)
	+ break;
	+
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+ lb_num = le32toh(s_ad.loc.lb_num);
	+
	+ if (flags == UDF_EXT_REDIRECT) {
	+ slot++;
	+ continue;
	+ }
	+
	+ DPRINTF(ALLOC, ("\t4i: got slot %d, slot_offset %d, "
	+ "replace_len %d, "
	+ "vp %d, lb %d, len %d, flags %d\n",
	+ slot, slot_offset, replace_len,
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+
	+ /* adjust for slot offset */
	+ if (slot_offset) {
	+ DPRINTF(ALLOC, ("\t4s: skipping %d\n", slot_offset));
	+ lb_num += slot_offset / lb_size;
	+ len -= slot_offset;
	+ foffset += slot_offset;
	+ replace_len -= slot_offset;
	+
	+ /* mark adjusted */
	+ slot_offset = 0;
	+ }
	+
	+ /* advance for (the rest of) this slot */
	+ replace = MIN(len, replace_len);
	+ DPRINTF(ALLOC, ("\t4d: replacing %d\n", replace));
	+
	+ /* advance for this slot */
	+ if (replace) {
	+ /* note: dont round DOWN on num_lb since we then
	+ * forget the last partial one */
	+ num_lb = (replace + lb_size - 1) / lb_size;
	+ if (flags != UDF_EXT_FREE) {
	+ udf_free_allocated_space(ump, lb_num,
	+ le16toh(s_ad.loc.part_num), num_lb);
	+ }
	+ lb_num += num_lb;
	+ len -= replace;
	+ foffset += replace;
	+ replace_len -= replace;
	+ }
	+
	+ /* do we have a slot tail ? */
	+ if (len) {
	+ KASSERT(foffset % lb_size == 0);
	+
	+ /* we arrived at our point, push remainder */
	+ s_ad.len = le32toh(len \| flags);
	+ s_ad.loc.lb_num = le32toh(lb_num);
	+ if (flags == UDF_EXT_FREE)
	+ s_ad.loc.lb_num = le32toh(0);
	+ node_ad_cpy[cpy_slot++] = s_ad;
	+ foffset += len;
	+ slot++;
	+
	+ DPRINTF(ALLOC, ("\t4: vp %d, lb %d, len %d, flags %d "
	+ "-> stack\n",
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+ break;
	+ }
	+
	+ slot++;
	+ }
	+
	+ /* 5) copy remainder */
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ if (eof)
	+ break;
	+
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ if (flags == UDF_EXT_REDIRECT) {
	+ slot++;
	+ continue;
	+ }
	+
	+ node_ad_cpy[cpy_slot++] = s_ad;
	+
	+ DPRINTF(ALLOC, ("\t5: insert new mapping "
	+ "vp %d lb %d, len %d, flags %d "
	+ "-> stack\n",
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+
	+ slot++;
	+ }
	+
	+ /* 6) reset node descriptors */
	+ udf_wipe_adslots(udf_node);
	+
	+ /* 7) copy back extents; merge when possible. Recounting on the fly */
	+ cpy_slots = cpy_slot;
	+
	+ c_ad = node_ad_cpy[0];
	+ slot = 0;
	+ DPRINTF(ALLOC, ("\t7s: stack -> got mapping vp %d "
	+ "lb %d, len %d, flags %d\n",
	+ le16toh(c_ad.loc.part_num),
	+ le32toh(c_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(c_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(c_ad.len)) >> 30));
	+
	+ for (cpy_slot = 1; cpy_slot < cpy_slots; cpy_slot++) {
	+ s_ad = node_ad_cpy[cpy_slot];
	+
	+ DPRINTF(ALLOC, ("\t7i: stack -> got mapping vp %d "
	+ "lb %d, len %d, flags %d\n",
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+
	+ /* see if we can merge */
	+ if (udf_ads_merge(lb_size, &c_ad, &s_ad)) {
	+ /* not mergable (anymore) */
	+ DPRINTF(ALLOC, ("\t7: appending vp %d lb %d, "
	+ "len %d, flags %d\n",
	+ le16toh(c_ad.loc.part_num),
	+ le32toh(c_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(c_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(c_ad.len)) >> 30));
	+
	+ error = udf_append_adslot(udf_node, &slot, &c_ad);
	+ if (error) {
	+ buf->b_error = error;
	+ goto out;
	+ }
	+ c_ad = s_ad;
	+ slot++;
	+ }
	+ }
	+
	+ /* 8) push rest slot (if any) */
	+ if (UDF_EXT_LEN(c_ad.len) > 0) {
	+ DPRINTF(ALLOC, ("\t8: last append vp %d lb %d, "
	+ "len %d, flags %d\n",
	+ le16toh(c_ad.loc.part_num),
	+ le32toh(c_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(c_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(c_ad.len)) >> 30));
	+
	+ error = udf_append_adslot(udf_node, &slot, &c_ad);
	+ if (error) {
	+ buf->b_error = error;
	+ goto out;
	+ }
	+ }
	+
	+out:
	+ udf_count_alloc_exts(udf_node);
	+
	+ /* the node's descriptors should now be sane */
	+ udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ KASSERT(orig_inflen == new_inflen);
	+ KASSERT(new_lbrec >= orig_lbrec);
	+
	+ return;
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_grow_node(struct udf_node *udf_node, uint64_t new_size)
	+{
	+ union dscrptr *dscr;
	+ struct vnode *vp = udf_node->vnode;
	+ struct udf_mount *ump = udf_node->ump;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct icb_tag *icbtag;
	+ struct long_ad c_ad, s_ad;
	+ uint64_t size_diff, old_size, inflen, objsize, chunk, append_len;
	+ uint64_t foffset, end_foffset;
	+ uint64_t orig_inflen, orig_lbrec, new_inflen, new_lbrec;
	+ uint32_t lb_size, dscr_size, crclen, lastblock_grow;
	+ uint32_t icbflags, len, flags, max_len;
	+ uint32_t max_l_ad, l_ad, l_ea;
	+ uint16_t my_part, dst_part;
	+ uint8_t data_pos, evacuated_data;
	+ int addr_type;
	+ int slot, cpy_slot;
	+ int eof, error;
	+
	+ DPRINTF(ALLOC, ("udf_grow_node\n"));
	+
	+ UDF_LOCK_NODE(udf_node, 0);
	+ udf_node_sanity_check(udf_node, &orig_inflen, &orig_lbrec);
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ max_len = ((UDF_EXT_MAXLEN / lb_size) * lb_size);
	+
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+ if (fe) {
	+ dscr = (union dscrptr *) fe;
	+ icbtag = &fe->icbtag;
	+ inflen = le64toh(fe->inf_len);
	+ objsize = inflen;
	+ dscr_size = sizeof(struct file_entry) -1;
	+ l_ea = le32toh(fe->l_ea);
	+ l_ad = le32toh(fe->l_ad);
	+ } else {
	+ dscr = (union dscrptr *) efe;
	+ icbtag = &efe->icbtag;
	+ inflen = le64toh(efe->inf_len);
	+ objsize = le64toh(efe->obj_size);
	+ dscr_size = sizeof(struct extfile_entry) -1;
	+ l_ea = le32toh(efe->l_ea);
	+ l_ad = le32toh(efe->l_ad);
	+ }
	+ data_pos = (uint8_t *) dscr + dscr_size + l_ea;
	+ max_l_ad = lb_size - dscr_size - l_ea;
	+
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ old_size = inflen;
	+ size_diff = new_size - old_size;
	+
	+ DPRINTF(ALLOC, ("\tfrom %"PRIu64" to %"PRIu64"\n", old_size, new_size));
	+
	+ evacuated_data = NULL;
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ if (l_ad + size_diff <= max_l_ad) {
	+ /* only reflect size change directly in the node */
	+ inflen += size_diff;
	+ objsize += size_diff;
	+ l_ad += size_diff;
	+ crclen = dscr_size - UDF_DESC_TAG_LENGTH + l_ea + l_ad;
	+ if (fe) {
	+ fe->inf_len = le64toh(inflen);
	+ fe->l_ad = le32toh(l_ad);
	+ fe->tag.desc_crc_len = le16toh(crclen);
	+ } else {
	+ efe->inf_len = le64toh(inflen);
	+ efe->obj_size = le64toh(objsize);
	+ efe->l_ad = le32toh(l_ad);
	+ efe->tag.desc_crc_len = le16toh(crclen);
	+ }
	+ error = 0;
	+
	+ /* set new size for uvm */
	+ uvm_vnp_setsize(vp, old_size);
	+ uvm_vnp_setwritesize(vp, new_size);
	+
	+#if 0
	+ /* zero append space in buffer */
	+ uvm_vnp_zerorange(vp, old_size, new_size - old_size);
	+#endif
	+
	+ udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
	+
	+ /* unlock */
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ KASSERT(new_inflen == orig_inflen + size_diff);
	+ KASSERT(new_lbrec == orig_lbrec);
	+ KASSERT(new_lbrec == 0);
	+ return (0);
	+ }
	+
	+ DPRINTF(ALLOC, ("\tCONVERT from internal\n"));
	+
	+ if (old_size > 0) {
	+ /* allocate some space and copy in the stuff to keep */
	+ evacuated_data = malloc(lb_size, M_UDFTEMP, M_WAITOK);
	+ memset(evacuated_data, 0, lb_size);
	+
	+ /* node is locked, so safe to exit mutex */
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ /* read in using the `normal' vn_rdwr() */
	+ error = vn_rdwr(UIO_READ, udf_node->vnode,
	+ evacuated_data, old_size, 0,
	+ UIO_SYSSPACE, IO_ALTSEMANTICS \| IO_NODELOCKED,
	+ FSCRED, NULL, NULL);
	+
	+ /* enter again */
	+ UDF_LOCK_NODE(udf_node, 0);
	+ }
	+
	+ /* convert to a normal alloc and select type */
	+ my_part = le16toh(udf_node->loc.loc.part_num);
	+ dst_part = udf_get_record_vpart(ump, udf_get_c_type(udf_node));
	+ addr_type = UDF_ICB_SHORT_ALLOC;
	+ if (dst_part != my_part)
	+ addr_type = UDF_ICB_LONG_ALLOC;
	+
	+ icbflags &= ~UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+ icbflags \|= addr_type;
	+ icbtag->flags = le16toh(icbflags);
	+
	+ /* wipe old descriptor space */
	+ udf_wipe_adslots(udf_node);
	+
	+ memset(&c_ad, 0, sizeof(struct long_ad));
	+ c_ad.len = le32toh(old_size \| UDF_EXT_FREE);
	+ c_ad.loc.part_num = le16toh(0); /* not relevant */
	+ c_ad.loc.lb_num = le32toh(0); /* not relevant */
	+
	+ slot = 0;
	+ } else {
	+ /* goto the last entry (if any) */
	+ slot = 0;
	+ cpy_slot = 0;
	+ foffset = 0;
	+ memset(&c_ad, 0, sizeof(struct long_ad));
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &c_ad, &eof);
	+ if (eof)
	+ break;
	+
	+ len = le32toh(c_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ end_foffset = foffset + len;
	+ if (flags != UDF_EXT_REDIRECT)
	+ foffset = end_foffset;
	+
	+ slot++;
	+ }
	+ /* at end of adslots */
	+
	+ /* special case if the old size was zero, then there is no last slot */
	+ if (old_size == 0) {
	+ c_ad.len = le32toh(0 \| UDF_EXT_FREE);
	+ c_ad.loc.part_num = le16toh(0); /* not relevant */
	+ c_ad.loc.lb_num = le32toh(0); /* not relevant */
	+ } else {
	+ /* refetch last slot */
	+ slot--;
	+ udf_get_adslot(udf_node, slot, &c_ad, &eof);
	+ }
	+ }
	+
	+ /*
	+ * If the length of the last slot is not a multiple of lb_size, adjust
	+ * length so that it is; don't forget to adjust `append_len'! relevant for
	+ * extending existing files
	+ */
	+ len = le32toh(c_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ lastblock_grow = 0;
	+ if (len % lb_size > 0) {
	+ lastblock_grow = lb_size - (len % lb_size);
	+ lastblock_grow = MIN(size_diff, lastblock_grow);
	+ len += lastblock_grow;
	+ c_ad.len = le32toh(len \| flags);
	+
	+ /* TODO zero appened space in buffer! */
	+ /* using uvm_vnp_zerorange(vp, old_size, new_size - old_size); ? */
	+ }
	+ memset(&s_ad, 0, sizeof(struct long_ad));
	+
	+ /* size_diff can be bigger than allowed, so grow in chunks */
	+ append_len = size_diff - lastblock_grow;
	+ while (append_len > 0) {
	+ chunk = MIN(append_len, max_len);
	+ s_ad.len = le32toh(chunk \| UDF_EXT_FREE);
	+ s_ad.loc.part_num = le16toh(0);
	+ s_ad.loc.lb_num = le32toh(0);
	+
	+ if (udf_ads_merge(lb_size, &c_ad, &s_ad)) {
	+ /* not mergable (anymore) */
	+ error = udf_append_adslot(udf_node, &slot, &c_ad);
	+ if (error)
	+ goto errorout;
	+ slot++;
	+ c_ad = s_ad;
	+ memset(&s_ad, 0, sizeof(struct long_ad));
	+ }
	+ append_len -= chunk;
	+ }
	+
	+ /* if there is a rest piece in the accumulator, append it */
	+ if (UDF_EXT_LEN(le32toh(c_ad.len)) > 0) {
	+ error = udf_append_adslot(udf_node, &slot, &c_ad);
	+ if (error)
	+ goto errorout;
	+ slot++;
	+ }
	+
	+ /* if there is a rest piece that didn't fit, append it */
	+ if (UDF_EXT_LEN(le32toh(s_ad.len)) > 0) {
	+ error = udf_append_adslot(udf_node, &slot, &s_ad);
	+ if (error)
	+ goto errorout;
	+ slot++;
	+ }
	+
	+ inflen += size_diff;
	+ objsize += size_diff;
	+ if (fe) {
	+ fe->inf_len = le64toh(inflen);
	+ } else {
	+ efe->inf_len = le64toh(inflen);
	+ efe->obj_size = le64toh(objsize);
	+ }
	+ error = 0;
	+
	+ if (evacuated_data) {
	+ /* set new write size for uvm */
	+ uvm_vnp_setwritesize(vp, old_size);
	+
	+ /* write out evacuated data */
	+ error = vn_rdwr(UIO_WRITE, udf_node->vnode,
	+ evacuated_data, old_size, 0,
	+ UIO_SYSSPACE, IO_ALTSEMANTICS \| IO_NODELOCKED,
	+ FSCRED, NULL, NULL);
	+ uvm_vnp_setsize(vp, old_size);
	+ }
	+
	+errorout:
	+ if (evacuated_data)
	+ free(evacuated_data, M_UDFTEMP);
	+
	+ udf_count_alloc_exts(udf_node);
	+
	+ udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ KASSERT(new_inflen == orig_inflen + size_diff);
	+ KASSERT(new_lbrec == orig_lbrec);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_shrink_node(struct udf_node *udf_node, uint64_t new_size)
	+{
	+ struct vnode *vp = udf_node->vnode;
	+ struct udf_mount *ump = udf_node->ump;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct icb_tag *icbtag;
	+ struct long_ad c_ad, s_ad, *node_ad_cpy;
	+ uint64_t size_diff, old_size, inflen, objsize;
	+ uint64_t foffset, end_foffset;
	+ uint64_t orig_inflen, orig_lbrec, new_inflen, new_lbrec;
	+ uint32_t lb_size, dscr_size, crclen;
	+ uint32_t slot_offset, slot_offset_lb;
	+ uint32_t len, flags, max_len;
	+ uint32_t num_lb, lb_num;
	+ uint32_t max_l_ad, l_ad, l_ea;
	+ uint16_t vpart_num;
	+ uint8_t *data_pos;
	+ int icbflags, addr_type;
	+ int slot, cpy_slot, cpy_slots;
	+ int eof, error;
	+
	+ DPRINTF(ALLOC, ("udf_shrink_node\n"));
	+
	+ UDF_LOCK_NODE(udf_node, 0);
	+ udf_node_sanity_check(udf_node, &orig_inflen, &orig_lbrec);
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ max_len = ((UDF_EXT_MAXLEN / lb_size) * lb_size);
	+
	+ /* do the work */
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+ if (fe) {
	+ icbtag = &fe->icbtag;
	+ inflen = le64toh(fe->inf_len);
	+ objsize = inflen;
	+ dscr_size = sizeof(struct file_entry) -1;
	+ l_ea = le32toh(fe->l_ea);
	+ l_ad = le32toh(fe->l_ad);
	+ data_pos = (uint8_t *) fe + dscr_size + l_ea;
	+ } else {
	+ icbtag = &efe->icbtag;
	+ inflen = le64toh(efe->inf_len);
	+ objsize = le64toh(efe->obj_size);
	+ dscr_size = sizeof(struct extfile_entry) -1;
	+ l_ea = le32toh(efe->l_ea);
	+ l_ad = le32toh(efe->l_ad);
	+ data_pos = (uint8_t *) efe + dscr_size + l_ea;
	+ }
	+ max_l_ad = lb_size - dscr_size - l_ea;
	+
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ old_size = inflen;
	+ size_diff = old_size - new_size;
	+
	+ DPRINTF(ALLOC, ("\tfrom %"PRIu64" to %"PRIu64"\n", old_size, new_size));
	+
	+ /* shrink the node to its new size */
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ /* only reflect size change directly in the node */
	+ KASSERT(new_size <= max_l_ad);
	+ inflen -= size_diff;
	+ objsize -= size_diff;
	+ l_ad -= size_diff;
	+ crclen = dscr_size - UDF_DESC_TAG_LENGTH + l_ea + l_ad;
	+ if (fe) {
	+ fe->inf_len = le64toh(inflen);
	+ fe->l_ad = le32toh(l_ad);
	+ fe->tag.desc_crc_len = le16toh(crclen);
	+ } else {
	+ efe->inf_len = le64toh(inflen);
	+ efe->obj_size = le64toh(objsize);
	+ efe->l_ad = le32toh(l_ad);
	+ efe->tag.desc_crc_len = le16toh(crclen);
	+ }
	+ error = 0;
	+
	+ /* clear the space in the descriptor */
	+ KASSERT(old_size > new_size);
	+ memset(data_pos + new_size, 0, old_size - new_size);
	+
	+ /* TODO zero appened space in buffer! */
	+ /* using uvm_vnp_zerorange(vp, old_size, old_size - new_size); ? */
	+
	+ /* set new size for uvm */
	+ uvm_vnp_setsize(vp, new_size);
	+
	+ udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ KASSERT(new_inflen == orig_inflen - size_diff);
	+ KASSERT(new_lbrec == orig_lbrec);
	+ KASSERT(new_lbrec == 0);
	+
	+ return (0);
	+ }
	+
	+ /* setup node cleanup extents copy space */
	+ node_ad_cpy = malloc(lb_size * UDF_MAX_ALLOC_EXTENTS,
	+ M_UDFTEMP, M_WAITOK);
	+ memset(node_ad_cpy, 0, lb_size * UDF_MAX_ALLOC_EXTENTS);
	+
	+ /*
	+ * Shrink the node by releasing the allocations and truncate the last
	+ * allocation to the new size. If the new size fits into the
	+ * allocation descriptor itself, transform it into an
	+ * UDF_ICB_INTERN_ALLOC.
	+ */
	+ slot = 0;
	+ cpy_slot = 0;
	+ foffset = 0;
	+
	+ /* 1) copy till first overlap piece to the rewrite buffer */
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ if (eof) {
	+ DPRINTF(WRITE,
	+ ("Shrink node failed: "
	+ "encountered EOF\n"));
	+ error = EINVAL;
	+ goto errorout; /* panic? */
	+ }
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ if (flags == UDF_EXT_REDIRECT) {
	+ slot++;
	+ continue;
	+ }
	+
	+ end_foffset = foffset + len;
	+ if (end_foffset > new_size)
	+ break; /* found */
	+
	+ node_ad_cpy[cpy_slot++] = s_ad;
	+
	+ DPRINTF(ALLOC, ("\t1: vp %d, lb %d, len %d, flags %d "
	+ "-> stack\n",
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+
	+ foffset = end_foffset;
	+ slot++;
	+ }
	+ slot_offset = new_size - foffset;
	+
	+ /* 2) trunc overlapping slot at overlap and copy it */
	+ if (slot_offset > 0) {
	+ lb_num = le32toh(s_ad.loc.lb_num);
	+ vpart_num = le16toh(s_ad.loc.part_num);
	+
	+ if (flags == UDF_EXT_ALLOCATED) {
	+ /* calculate extent in lb, and offset in lb */
	+ num_lb = (len + lb_size -1) / lb_size;
	+ slot_offset_lb = (slot_offset + lb_size -1) / lb_size;
	+
	+ /* adjust our slot */
	+ lb_num += slot_offset_lb;
	+ num_lb -= slot_offset_lb;
	+
	+ udf_free_allocated_space(ump, lb_num, vpart_num, num_lb);
	+ }
	+
	+ s_ad.len = le32toh(slot_offset \| flags);
	+ node_ad_cpy[cpy_slot++] = s_ad;
	+ slot++;
	+
	+ DPRINTF(ALLOC, ("\t2: vp %d, lb %d, len %d, flags %d "
	+ "-> stack\n",
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+ }
	+
	+ /* 3) delete remainder */
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
	+ if (eof)
	+ break;
	+
	+ len = le32toh(s_ad.len);
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ if (flags == UDF_EXT_REDIRECT) {
	+ slot++;
	+ continue;
	+ }
	+
	+ DPRINTF(ALLOC, ("\t3: delete remainder "
	+ "vp %d lb %d, len %d, flags %d\n",
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+
	+ if (flags == UDF_EXT_ALLOCATED) {
	+ lb_num = le32toh(s_ad.loc.lb_num);
	+ vpart_num = le16toh(s_ad.loc.part_num);
	+ num_lb = (len + lb_size - 1) / lb_size;
	+
	+ udf_free_allocated_space(ump, lb_num, vpart_num,
	+ num_lb);
	+ }
	+
	+ slot++;
	+ }
	+
	+ /* 4) if it will fit into the descriptor then convert */
	+ if (new_size < max_l_ad) {
	+ /*
	+ * resque/evacuate old piece by reading it in, and convert it
	+ * to internal alloc.
	+ */
	+ if (new_size == 0) {
	+ /* XXX/TODO only for zero sizing now */
	+ udf_wipe_adslots(udf_node);
	+
	+ icbflags &= ~UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+ icbflags \|= UDF_ICB_INTERN_ALLOC;
	+ icbtag->flags = le16toh(icbflags);
	+
	+ inflen -= size_diff; KASSERT(inflen == 0);
	+ objsize -= size_diff;
	+ l_ad = new_size;
	+ crclen = dscr_size - UDF_DESC_TAG_LENGTH + l_ea + l_ad;
	+ if (fe) {
	+ fe->inf_len = le64toh(inflen);
	+ fe->l_ad = le32toh(l_ad);
	+ fe->tag.desc_crc_len = le16toh(crclen);
	+ } else {
	+ efe->inf_len = le64toh(inflen);
	+ efe->obj_size = le64toh(objsize);
	+ efe->l_ad = le32toh(l_ad);
	+ efe->tag.desc_crc_len = le16toh(crclen);
	+ }
	+ /* eventually copy in evacuated piece */
	+ /* set new size for uvm */
	+ uvm_vnp_setsize(vp, new_size);
	+
	+ free(node_ad_cpy, M_UDFTEMP);
	+ udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
	+
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ KASSERT(new_inflen == orig_inflen - size_diff);
	+ KASSERT(new_inflen == 0);
	+ KASSERT(new_lbrec == 0);
	+
	+ return (0);
	+ }
	+
	+ printf("UDF_SHRINK_NODE: could convert to internal alloc!\n");
	+ }
	+
	+ /* 5) reset node descriptors */
	+ udf_wipe_adslots(udf_node);
	+
	+ /* 6) copy back extents; merge when possible. Recounting on the fly */
	+ cpy_slots = cpy_slot;
	+
	+ c_ad = node_ad_cpy[0];
	+ slot = 0;
	+ for (cpy_slot = 1; cpy_slot < cpy_slots; cpy_slot++) {
	+ s_ad = node_ad_cpy[cpy_slot];
	+
	+ DPRINTF(ALLOC, ("\t6: stack -> got mapping vp %d "
	+ "lb %d, len %d, flags %d\n",
	+ le16toh(s_ad.loc.part_num),
	+ le32toh(s_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(s_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(s_ad.len)) >> 30));
	+
	+ /* see if we can merge */
	+ if (udf_ads_merge(lb_size, &c_ad, &s_ad)) {
	+ /* not mergable (anymore) */
	+ DPRINTF(ALLOC, ("\t6: appending vp %d lb %d, "
	+ "len %d, flags %d\n",
	+ le16toh(c_ad.loc.part_num),
	+ le32toh(c_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(c_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(c_ad.len)) >> 30));
	+
	+ error = udf_append_adslot(udf_node, &slot, &c_ad);
	+ if (error)
	+ goto errorout; /* panic? */
	+ c_ad = s_ad;
	+ slot++;
	+ }
	+ }
	+
	+ /* 7) push rest slot (if any) */
	+ if (UDF_EXT_LEN(c_ad.len) > 0) {
	+ DPRINTF(ALLOC, ("\t7: last append vp %d lb %d, "
	+ "len %d, flags %d\n",
	+ le16toh(c_ad.loc.part_num),
	+ le32toh(c_ad.loc.lb_num),
	+ UDF_EXT_LEN(le32toh(c_ad.len)),
	+ UDF_EXT_FLAGS(le32toh(c_ad.len)) >> 30));
	+
	+ error = udf_append_adslot(udf_node, &slot, &c_ad);
	+ if (error)
	+ goto errorout; /* panic? */
	+ ;
	+ }
	+
	+ inflen -= size_diff;
	+ objsize -= size_diff;
	+ if (fe) {
	+ fe->inf_len = le64toh(inflen);
	+ } else {
	+ efe->inf_len = le64toh(inflen);
	+ efe->obj_size = le64toh(objsize);
	+ }
	+ error = 0;
	+
	+ /* set new size for uvm */
	+ uvm_vnp_setsize(vp, new_size);
	+
	+errorout:
	+ free(node_ad_cpy, M_UDFTEMP);
	+
	+ udf_count_alloc_exts(udf_node);
	+
	+ udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ KASSERT(new_inflen == orig_inflen - size_diff);
	+
	+ return (error);
	+}
	+#endif
	Index: sys/fs/udf2/udf_filenames.c
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_filenames.c
	@@ -0,0 +1,201 @@
	+/*-
	+ * Copyright (c) 2012 Will DeVries
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ */
	+
	+#include <sys/param.h>
	+#include <sys/malloc.h>
	+#include <sys/iconv.h>
	+#include <sys/systm.h> /* printf */
	+
	+#include "ecma167-udf.h"
	+#include "udf.h"
	+#include "udf_subr.h"
	+#include "udf_mount.h"
	+
	+extern struct iconv_functions *udf2_iconv;
	+
	+static int
	+udf_to_utf8(char *result, size_t rrem, uint32_t ch)
	+{
	+ int n = 0;
	+ char rp = result;
	+
	+ if ((ch & 0xFFFFFF80) == 0) {
	+ if (*rrem < 1)
	+ return (0);
	+
	+ n = 1;
	+ rp[0] = ch & 0x7F;
	+ } else if ((ch & 0xFFFFF800) == 0) {
	+ if (*rrem < 2)
	+ return (0);
	+
	+ n = 2;
	+ rp[0] = 0xC0 \| (ch >> 6);
	+ rp[1] = 0x80 \| (0x3F & ch);
	+ } else if ((ch & 0xFFFF0000) == 0) {
	+ if (*rrem < 3)
	+ return (0);
	+
	+ n = 3;
	+ rp[0] = 0xE0 \| (ch >> 12);
	+ rp[1] = 0x80 \| (0x3F & (ch >> 6));
	+ rp[2] = 0x80 \| (0x3F & ch);
	+ } else if ((ch & 0xFFE00000) == 0) {
	+ if (*rrem < 4)
	+ return (0);
	+
	+ n = 4;
	+ rp[0] = 0xF0 \| (ch >> 18);
	+ rp[1] = 0x80 \| (0x3F & (ch >> 12));
	+ rp[2] = 0x80 \| (0x3F & (ch >> 6));
	+ rp[3] = 0x80 \| (0x3F & ch);
	+ } else {
	+ /* do not convert points above 21 bits. */
	+ return (0);
	+ }
	+
	+ *rrem -= n;
	+ *result += n;
	+ return (n);
	+}
	+
	+static void
	+udf_convert_str(struct udf_mount ump, char result, size_t result_len, int *extloc,
	+ int eightbit, char *id, int id_len)
	+{
	+ size_t rrem, chrem;
	+ int i, endi, needsCRC, invalid;
	+ uint32_t uch;
	+ char *rp, ch[2];
	+ const char *chp;
	+ uint16_t *index;
	+
	+ index = malloc(id_len * sizeof(uint16_t), M_UDFTEMP, M_WAITOK);
	+
	+ if (eightbit)
	+ endi = id_len;
	+ else
	+ endi = (id_len - 1 > 0) ? id_len - 1 : 0;
	+
	+ invalid = 0;
	+ rp = result;
	+ rrem = (size_t)result_len - 1; /* for the null */
	+ for (i = 0; i < endi;) {
	+ if (eightbit)
	+ uch = id[i];
	+ else
	+ uch = id[i] << 8 \| id[i+1];
	+
	+ index[i] = result_len - rrem;
	+
	+ if (rrem == 0) {
	+ /* no more space, we need to truncate it. */
	+ needsCRC = 1;
	+ } else if (uch == 0 \|\| uch == 0x2F) {
	+ /* do not allow nulls or slashes */
	+ invalid++;
	+ } else if (ump->flags & UDFMNT_KICONV && udf2_iconv) {
	+ /* it might be a valid character */
	+ chrem = 2;
	+ chp = ch;
	+ ch[0] = uch >> 8;
	+ ch[1] = uch & 0x00FF;
	+ udf2_iconv->convchr(ump->iconv_d2l, &chp, &chrem, &rp, &rrem);
	+ if (chrem > 0) {
	+ /* not printable or doesn't fit */
	+ invalid++;
	+ needsCRC = 1;
	+ } else
	+ invalid = 0;
	+ } else {
	+ /* utf8 output */
	+ /* it is a valid character */
	+ if (udf_to_utf8(&rp, &rrem, uch) == 0) {
	+ /* doesn't fit or too large */
	+ invalid++;
	+ needsCRC = 1;
	+ } else
	+ invalid = 0;
	+ }
	+
	+ if (uch == 0x002E && i != 1) {
	+ /* record locations of periods where they occur within
	+ 5 char of the end, but not at the end or start */
	+ if (eightbit && id_len - 6 > i && i + 1 != endi) {
	+ *extloc = i;
	+ } else if (!eightbit && id_len - 11 > i && i + 2 != endi) {
	+ *extloc = i;
	+ }
	+ }
	+
	+ if (rrem > 0 && invalid == 1) {
	+ uch = 0x5F;
	+
	+ /* if the result doesn't have space this may not fit */
	+ if (ump->flags & UDFMNT_KICONV && udf2_iconv) {
	+ chrem = 2;
	+ chp = ch;
	+ ch[0] = uch >> 8;
	+ ch[1] = uch & 0x0F;
	+ udf2_iconv->convchr(ump->iconv_d2l, &chp, &chrem, &rp, &rrem);
	+ } else {
	+ /* utf8 output */
	+ udf_to_utf8(&rp, &rrem, uch);
	+ }
	+ invalid++;
	+ }
	+
	+ if (eightbit)
	+ i++;
	+ else
	+ i += 2;
	+ }
	+
	+ *rp = '\0';
	+
	+ free(index, M_UDFTEMP);
	+}
	+
	+void
	+udf_to_unix_name(struct udf_mount ump, char result, int result_len, char *id, int id_len) {
	+ int extloc, eightbit;
	+
	+ if (id[0] != 8 && id[0] != 16) {
	+ /* this is either invalid or an empty string */
	+ result_len = 0;
	+ return;
	+ }
	+
	+ if (id[0] == 8) {
	+ eightbit = 1;
	+ } else {
	+ eightbit = 0;
	+ }
	+
	+ udf_convert_str(ump, result, result_len, &extloc, eightbit, id+1, id_len-1);
	+
	+ return;
	+}
	Index: sys/fs/udf2/udf_iconv.c
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_iconv.c
	@@ -0,0 +1,36 @@
	+/*-
	+ * Copyright (c) 2003 Ryuichiro Imura
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+__FBSDID("$FreeBSD$");
	+
	+#include <sys/param.h>
	+#include <sys/iconv.h>
	+#include <sys/kernel.h>
	+#include <sys/module.h>
	+#include <sys/mount.h>
	+
	+VFS_DECLARE_ICONV(udf2);
	Index: sys/fs/udf2/udf_mount.h
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_mount.h
	@@ -0,0 +1,69 @@
	+/*-
	+ * Copyright (c) 2006 Reinoud Zandijk
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ * 3. All advertising materials mentioning features or use of this software
	+ * must display the following acknowledgement:
	+ * This product includes software developed for the
	+ * NetBSD Project. See http://www.NetBSD.org/ for
	+ * information about NetBSD.
	+ * 4. The name of the author may not be used to endorse or promote products
	+ * derived from this software without specific prior written permission.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ */
	+
	+
	+#ifndef _FS_UDF_UDF_MOUNT_H_
	+#define _FS_UDF_UDF_MOUNT_H_
	+
	+/*
	+ * Arguments to mount UDF filingsystem.
	+ */
	+
	+#define UDFMNT_VERSION 1
	+struct udf_args {
	+ uint32_t version; /* version of this structure */
	+ char fspec; / mount specifier */
	+ int32_t sessionnr; /* session specifier, rel of abs */
	+ uint32_t udfmflags; /* mount options */
	+ int32_t gmtoff; /* offset from UTC in seconds */
	+
	+ uid_t anon_uid; /* mapping of anonymous files uid */
	+ gid_t anon_gid; /* mapping of anonymous files gid */
	+ uid_t nobody_uid; /* nobody:nobody will map to -1:-1 */
	+ gid_t nobody_gid; /* nobody:nobody will map to -1:-1 */
	+
	+ uint32_t sector_size; /* for mounting dumps/files */
	+
	+ /* extendable */
	+ uint8_t reserved[32];
	+};
	+
	+
	+/* udf mount options */
	+
	+#define UDFMNT_CLOSESESSION 0x00000001 /* close session on dismount */
	+#define UDFMNT_BITS "\20\1CLOSESESSION"
	+#define UDFMNT_KICONV 100
	+
	+#endif /* !_FS_UDF_UDF_MOUNT_H_ */
	+
	Index: sys/fs/udf2/udf_osta.h
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_osta.h
	@@ -0,0 +1,15 @@
	+/*
	+ * Prototypes for the OSTA functions
	+ */
	+
	+
	+#ifndef _FS_UDF_OSTA_H_
	+#define _FS_UDF_OSTA_H_
	+
	+#include <sys/types.h>
	+
	+unsigned short udf_cksum(unsigned char *, int);
	+unsigned short udf_unicode_cksum(unsigned short *, int);
	+uint16_t udf_ea_cksum(uint8_t *data);
	+
	+#endif /* _FS_UDF_OSTA_H_ */
	Index: sys/fs/udf2/udf_osta.c
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_osta.c
	@@ -0,0 +1,108 @@
	+/*
	+ * Various routines from the OSTA 2.01 specs. Copyrights are included with
	+ * each code segment. Slight whitespace modifications have been made for
	+ * formatting purposes. Typos/bugs have been fixed.
	+ *
	+ * Copyright to this code held by AT&T.
	+ */
	+
	+#include "udf_osta.h"
	+
	+/*
	+ * CRC 010041
	+ */
	+static unsigned short crc_table[256] = {
	+ 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
	+ 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
	+ 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
	+ 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
	+ 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
	+ 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
	+ 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
	+ 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
	+ 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
	+ 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
	+ 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
	+ 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
	+ 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
	+ 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
	+ 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
	+ 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
	+ 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
	+ 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
	+ 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
	+ 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
	+ 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
	+ 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
	+ 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
	+ 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
	+ 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
	+ 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
	+ 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
	+ 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
	+ 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
	+ 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
	+ 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
	+ 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
	+};
	+
	+unsigned short
	+udf_cksum(unsigned char *s, int n)
	+{
	+ unsigned short crc=0;
	+
	+ while (n-- > 0)
	+ crc = crc_table[(crc>>8 ^ *s++) & 0xff] ^ (crc<<8);
	+ return (crc);
	+}
	+
	+/* UNICODE Checksum */
	+unsigned short
	+udf_unicode_cksum(unsigned short *s, int n)
	+{
	+ unsigned short crc=0;
	+
	+ while (n-- > 0) {
	+ /* Take high order byte first--corresponds to a big endian
	+ * byte stream.
	+ */
	+ crc = crc_table[(crc>>8 ^ (*s>>8)) & 0xff] ^ (crc<<8);
	+ crc = crc_table[(crc>>8 ^ (*s++ & 0xff)) & 0xff] ^ (crc<<8);
	+ }
	+ return (crc);
	+}
	+
	+
	+/*
	+ * Calculates a 16-bit checksum of the Implementation Use
	+ * Extended Attribute header or Application Use Extended Attribute
	+ * header. The fields AttributeType through ImplementationIdentifier
	+ * (or ApplicationIdentifier) inclusively represent the
	+ * data covered by the checksum (48 bytes).
	+ *
	+ */
	+uint16_t udf_ea_cksum(uint8_t *data) {
	+ uint16_t checksum = 0;
	+ int count;
	+
	+ for (count = 0; count < 48; count++) {
	+ checksum += *data++;
	+ }
	+
	+ return (checksum);
	+}
	+
	+
	+#ifdef MAIN
	+unsigned char bytes[] = { 0x70, 0x6A, 0x77 };
	+
	+main(void)
	+{
	+ unsigned short x;
	+ x = udf_cksum(bytes, sizeof bytes);
	+ printf("checksum: calculated=%4.4x, correct=%4.4x\en", x, 0x3299);
	+ exit(0);
	+}
	+#endif
	+
	+
	Index: sys/fs/udf2/udf_readwrite.c
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_readwrite.c
	@@ -0,0 +1,782 @@
	+/*-
	+ * Copyright (c) 2012 Oleksandr Dudinskyi
	+ * Copyright (c) 2012 Will DeVries
	+ * Copyright (c) 2007, 2008 Reinoud Zandijk
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ */
	+
	+#include <sys/cdefs.h>
	+#include <sys/endian.h>
	+#include <sys/param.h>
	+#include <sys/systm.h>
	+#include <sys/vnode.h>
	+#include <sys/buf.h>
	+#include <sys/malloc.h>
	+
	+#include "ecma167-udf.h"
	+#include "udf.h"
	+#include "udf_subr.h"
	+#include "udf_mount.h"
	+
	+static int udf_read_phys_sectors(struct udf_mount ump, int what, void blob,
	+ uint32_t start, uint32_t sectors);
	+/* --------------------------------------------------------------------- */
	+
	+#if 0
	+void
	+udf_fixup_fid_block(uint8_t *blob, int lb_size,
	+ int rfix_pos, int max_rfix_pos, uint32_t lb_num)
	+{
	+ struct fileid_desc *fid;
	+ uint8_t *fid_pos;
	+ int fid_len, found;
	+
	+ /* needs to be word aligned */
	+ KASSERT(rfix_pos % 4 == 0);
	+
	+ /* first resync with the FID stream !!! */
	+ found = 0;
	+ while (rfix_pos + sizeof(struct desc_tag) <= max_rfix_pos) {
	+ fid_pos = blob + rfix_pos;
	+ fid = (struct fileid_desc *) fid_pos;
	+ if (udf_rw16(fid->tag.id) == TAGID_FID) {
	+ if (udf_check_tag((union dscrptr *) fid) == 0)
	+ found = 1;
	+ }
	+ if (found)
	+ break;
	+ /* try next location; can only be 4 bytes aligned */
	+ rfix_pos += 4;
	+ }
	+
	+ /* walk over the fids */
	+ fid_pos = blob + rfix_pos;
	+ while (rfix_pos + sizeof(struct desc_tag) <= max_rfix_pos) {
	+ fid = (struct fileid_desc *) fid_pos;
	+ if (udf_rw16(fid->tag.id) != TAGID_FID) {
	+ /* end of FID stream; end of directory or currupted */
	+ break;
	+ }
	+
	+ /* update sector number and recalculate checkum */
	+ fid->tag.tag_loc = udf_rw32(lb_num);
	+ udf_validate_tag_sum((union dscrptr *) fid);
	+
	+ /* if the FID crosses the memory, we're done! */
	+ if (rfix_pos + UDF_FID_SIZE >= max_rfix_pos)
	+ break;
	+
	+ fid_len = udf_fidsize(fid);
	+ fid_pos += fid_len;
	+ rfix_pos += fid_len;
	+ }
	+}
	+
	+
	+void
	+udf_fixup_internal_extattr(uint8_t *blob, uint32_t lb_num)
	+{
	+ struct desc_tag *tag;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct extattrhdr_desc *eahdr;
	+ int l_ea;
	+
	+ /* get information from fe/efe */
	+ tag = (struct desc_tag *) blob;
	+ switch (udf_rw16(tag->id)) {
	+ case TAGID_FENTRY :
	+ fe = (struct file_entry *) blob;
	+ l_ea = udf_rw32(fe->l_ea);
	+ eahdr = (struct extattrhdr_desc *) fe->data;
	+ break;
	+ case TAGID_EXTFENTRY :
	+ efe = (struct extfile_entry *) blob;
	+ l_ea = udf_rw32(efe->l_ea);
	+ eahdr = (struct extattrhdr_desc *) efe->data;
	+ break;
	+ case TAGID_INDIRECTENTRY :
	+ case TAGID_ALLOCEXTENT :
	+ case TAGID_EXTATTR_HDR :
	+ return;
	+ default:
	+ panic("%s: passed bad tag\n", __func__);
	+ }
	+
	+ /* something recorded here? (why am i called?) */
	+ if (l_ea == 0)
	+ return;
	+
	+#if 0
	+ /* check extended attribute tag */
	+ /* TODO XXX what to do when we encounter an error here? */
	+ error = udf_check_tag(eahdr);
	+ if (error)
	+ return; /* for now */
	+ if (udf_rw16(eahdr->tag.id) != TAGID_EXTATTR_HDR)
	+ return; /* for now */
	+ error = udf_check_tag_payload(eahdr, sizeof(struct extattrhdr_desc));
	+ if (error)
	+ return; /* for now */
	+#endif
	+
	+ DPRINTF(EXTATTR, ("node fixup: found %d bytes of extended attributes\n",
	+ l_ea));
	+
	+ /* fixup eahdr tag */
	+ eahdr->tag.tag_loc = udf_rw32(lb_num);
	+ udf_validate_tag_and_crc_sums((union dscrptr *) eahdr);
	+}
	+
	+
	+void
	+udf_fixup_node_internals(struct udf_mount ump, uint8_t blob, int udf_c_type)
	+{
	+ struct desc_tag tag, sbm_tag;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct alloc_ext_entry *ext;
	+ uint32_t lb_size, lb_num;
	+ uint32_t intern_pos, max_intern_pos;
	+ int icbflags, addr_type, file_type, intern, has_fids, has_sbm, l_ea;
	+
	+ lb_size = udf_rw32(ump->logical_vol->lb_size);
	+ /* if its not a node we're done */
	+ if (udf_c_type != UDF_C_NODE)
	+ return;
	+
	+ /* NOTE this could also be done in write_internal */
	+ /* start of a descriptor */
	+ l_ea = 0;
	+ has_fids = 0;
	+ has_sbm = 0;
	+ intern = 0;
	+ file_type = 0;
	+ max_intern_pos = intern_pos = lb_num = 0; /* shut up gcc! */
	+
	+ tag = (struct desc_tag *) blob;
	+ switch (udf_rw16(tag->id)) {
	+ case TAGID_FENTRY :
	+ fe = (struct file_entry *) tag;
	+ l_ea = udf_rw32(fe->l_ea);
	+ icbflags = udf_rw16(fe->icbtag.flags);
	+ addr_type = (icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK);
	+ file_type = fe->icbtag.file_type;
	+ intern = (addr_type == UDF_ICB_INTERN_ALLOC);
	+ intern_pos = UDF_FENTRY_SIZE + l_ea;
	+ max_intern_pos = intern_pos + udf_rw64(fe->inf_len);
	+ lb_num = udf_rw32(fe->tag.tag_loc);
	+ break;
	+ case TAGID_EXTFENTRY :
	+ efe = (struct extfile_entry *) tag;
	+ l_ea = udf_rw32(efe->l_ea);
	+ icbflags = udf_rw16(efe->icbtag.flags);
	+ addr_type = (icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK);
	+ file_type = efe->icbtag.file_type;
	+ intern = (addr_type == UDF_ICB_INTERN_ALLOC);
	+ intern_pos = UDF_EXTFENTRY_SIZE + l_ea;
	+ max_intern_pos = intern_pos + udf_rw64(efe->inf_len);
	+ lb_num = udf_rw32(efe->tag.tag_loc);
	+ break;
	+ case TAGID_INDIRECTENTRY :
	+ case TAGID_EXTATTR_HDR :
	+ break;
	+ case TAGID_ALLOCEXTENT :
	+ /* force crclen to 8 for UDF version < 2.01 */
	+ ext = (struct alloc_ext_entry *) tag;
	+ if (udf_rw16(ump->logvol_info->min_udf_readver) <= 0x200)
	+ ext->tag.desc_crc_len = udf_rw16(8);
	+ break;
	+ default:
	+ panic("%s: passed bad tag\n", __func__);
	+ break;
	+ }
	+
	+ /* determine what to fix if its internally recorded */
	+ if (intern) {
	+ has_fids = (file_type == UDF_ICB_FILETYPE_DIRECTORY) \|\|
	+ (file_type == UDF_ICB_FILETYPE_STREAMDIR);
	+ has_sbm = (file_type == UDF_ICB_FILETYPE_META_BITMAP);
	+ }
	+
	+ /* fixup internal extended attributes if present */
	+ if (l_ea)
	+ udf_fixup_internal_extattr(blob, lb_num);
	+
	+ /* fixup fids lb numbers */
	+ if (has_fids)
	+ udf_fixup_fid_block(blob, lb_size, intern_pos,
	+ max_intern_pos, lb_num);
	+
	+ /* fixup space bitmap descriptor */
	+ if (has_sbm) {
	+ sbm_tag = (struct desc_tag *) (blob + intern_pos);
	+ sbm_tag->tag_loc = tag->tag_loc;
	+ udf_validate_tag_and_crc_sums((uint8_t *) sbm_tag);
	+ }
	+
	+ udf_validate_tag_and_crc_sums(blob);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Set of generic descriptor readers and writers and their helper functions.
	+ * Descriptors inside `logical space' i.e. inside logically mapped partitions
	+ * can never be longer than one logical sector.
	+ *
	+ * NOTE that these functions can be used by the sheduler backends to read
	+ * node descriptors too.
	+ *
	+ * For reading, the size of allocated piece is returned in multiple of sector
	+ * size due to udf_calc_udf_malloc_size().
	+ */
	+int
	+udf_read_node(struct udf_node unode, uint8_t blob, off_t start, int length)
	+{
	+ struct vnode *devvp = unode->ump->devvp;
	+ struct buf bp; / buf, nestbuf, ; */
	+ uint64_t file_size, lsect;
	+ int icbflags, addr_type, error = 0;
	+ uint32_t sector_size, blkinsect, fileblk, fileblkoff, numlsect, numb;
	+ uint8_t *pos;
	+
	+ sector_size = unode->ump->discinfo.sector_size;
	+ blkinsect = sector_size / DEV_BSIZE;
	+
	+ if (unode->fe) {
	+ pos = &unode->fe->data[0] + le32toh(unode->fe->l_ea);
	+ icbflags = le16toh(unode->fe->icbtag.flags);
	+ file_size = le64toh(unode->fe->inf_len);
	+ } else {
	+ pos = &unode->efe->data[0] + le32toh(unode->efe->l_ea);
	+ icbflags = le16toh(unode->efe->icbtag.flags);
	+ file_size = le64toh(unode->efe->inf_len);
	+ }
	+
	+ length = min(file_size - start, length);
	+ fileblk = start / sector_size;
	+ fileblkoff = start % sector_size;
	+
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ numb = min(length, file_size - fileblkoff);
	+ memcpy(blob, pos + fileblkoff, numb);
	+ return (error);
	+ }
	+
	+ while (length) {
	+ error = udf_bmap_translate(unode, fileblk, &lsect, &numlsect);
	+ if (error)
	+ return (error);
	+
	+ if (lsect == UDF_TRANS_ZERO) {
	+ numb = min(length, sector_size * numlsect - fileblkoff);
	+ memset(blob, 0, numb);
	+ length -= numb;
	+ blob += numb;
	+ fileblkoff = 0;
	+ } else if (lsect == UDF_TRANS_INTERN) {
	+ return (EDOOFUS);
	+ } else {
	+ while (numlsect > 0) {
	+ if ((error = bread(devvp, lsect*blkinsect, sector_size, NOCRED,
	+ &bp)) != 0) {
	+ if (buf != NULL)
	+ brelse(bp);
	+ return (error);
	+ }
	+
	+ numb = min(length, sector_size - fileblkoff);
	+ bcopy(bp->b_data + fileblkoff, blob, numb);
	+ brelse(bp);
	+ bp = NULL;
	+
	+ blob += numb;
	+ length -= numb;
	+ lsect++;
	+ numlsect--;
	+ fileblkoff = 0;
	+ }
	+ }
	+
	+ fileblk += numlsect;
	+ }
	+ return (0);
	+}
	+
	+/* SYNC reading of n blocks from specified sector */
	+static int
	+udf_read_phys_sectors(struct udf_mount ump, int what, void blob,
	+ uint32_t start, uint32_t sectors)
	+{
	+ struct buf bp; / buf, nestbuf, ; */
	+ int error = 0; /* piece; */
	+ /* off_t lblkno, rblkno; */
	+ uint32_t sector_size, blks; /* buf_offset; */
	+ struct vnode *devvp = ump->devvp;
	+
	+ sector_size = ump->discinfo.sector_size;
	+ blks = btodb(sector_size);
	+
	+ while (sectors > 0 && error == 0) {
	+ if ((error = bread(devvp, start*blks, sector_size, NOCRED,
	+ &bp)) != 0) {
	+ if (buf != NULL)
	+ brelse(bp);
	+ return (error);
	+ }
	+
	+ bcopy(bp->b_data, blob, sector_size);
	+ brelse(bp);
	+ bp = NULL;
	+
	+ blob = (void ) ((uint8_t )blob + sector_size);
	+ start++;
	+ sectors--;
	+ }
	+
	+ return (0);
	+#if 0
	+ DPRINTF(READ, ("udf_intbreadn() : sectors = %d, sector_size = %d\n",
	+ sectors, sector_size));
	+ buf = getiobuf(ump->devvp, true);
	+ buf->b_flags = B_READ;
	+ buf->b_cflags = BC_BUSY; /* needed? */
	+ buf->b_iodone = NULL;
	+ buf->b_data = blob;
	+ buf->b_bcount = sectors * sector_size;
	+ buf->b_resid = buf->b_bcount;
	+ buf->b_bufsize = buf->b_bcount;
	+ buf->b_private = NULL; /* not needed yet */
	+ BIO_SETPRIO(buf, BPRIO_DEFAULT);
	+ buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = start * blks;
	+ buf->b_proc = NULL;
	+
	+ error = 0;
	+ buf_offset = 0;
	+ rblkno = start;
	+ lblkno = 0;
	+ while ((sectors > 0) && (error == 0)) {
	+ piece = MIN(MAXPHYS/sector_size, sectors);
	+ DPRINTF(READ, ("read in %d + %d\n", (uint32_t) rblkno, piece));
	+
	+ nestbuf = getiobuf(NULL, true);
	+ nestiobuf_setup(buf, nestbuf, buf_offset, piece * sector_size);
	+ /* nestbuf is B_ASYNC */
	+
	+ /* identify this nestbuf */
	+ nestbuf->b_lblkno = lblkno;
	+
	+ /* CD shedules on raw blkno */
	+ nestbuf->b_blkno = rblkno * blks;
	+ nestbuf->b_proc = NULL;
	+ nestbuf->b_rawblkno = rblkno * blks;
	+ nestbuf->b_udf_c_type = what;
	+
	+ udf_discstrat_queuebuf(ump, nestbuf);
	+
	+ lblkno += piece;
	+ rblkno += piece;
	+ buf_offset += piece * sector_size;
	+ sectors -= piece;
	+ }
	+ error = biowait(buf);
	+ putiobuf(buf);
	+
	+ return error;
	+#endif
	+}
	+
	+
	+/* synchronous generic descriptor read */
	+int
	+udf_read_phys_dscr(struct udf_mount *ump, uint32_t sector,
	+ struct malloc_type mtype, union dscrptr *dstp)
	+{
	+ union dscrptr dst, new_dst;
	+ int sectors, dscrlen, i, error, sector_size;
	+ uint8_t *pos;
	+
	+ sector_size = ump->discinfo.sector_size;
	+
	+ *dstp = dst = NULL;
	+ dscrlen = sector_size;
	+
	+ /* read initial piece */
	+ dst = malloc(sector_size, mtype, M_WAITOK);
	+ error = udf_read_phys_sectors(ump, UDF_C_DSCR, dst, sector, 1);
	+
	+ if (!error) {
	+ /* check if its a valid tag */
	+ error = udf_check_tag(dst);
	+ if (error) {
	+ /* check if its an empty block */
	+ pos = (uint8_t *) dst;
	+ for (i = 0; i < sector_size; i++, pos++) {
	+ if (*pos) break;
	+ }
	+ if (i == sector_size) {
	+ /* return no error but with no dscrptr */
	+ /* dispose first block */
	+ free(dst, mtype);
	+ return (0);
	+ }
	+ }
	+ /* calculate descriptor size */
	+ dscrlen = udf_tagsize(dst, sector_size);
	+ }
	+
	+ if (!error && (dscrlen > sector_size)) {
	+ /*
	+ * Read the rest of descriptor. Since it is only used at mount
	+ * time its overdone to define and use a specific udf_intbreadn
	+ * for this alone.
	+ */
	+
	+ new_dst = realloc(dst, dscrlen, mtype, M_WAITOK);
	+ if (new_dst == NULL) {
	+ free(dst, mtype);
	+ return (ENOMEM);
	+ }
	+ dst = new_dst;
	+
	+ sectors = (dscrlen + sector_size -1) / sector_size;
	+
	+ pos = (uint8_t *) dst + sector_size;
	+ error = udf_read_phys_sectors(ump, UDF_C_DSCR, pos,
	+ sector + 1, sectors-1);
	+ }
	+ if (!error)
	+ error = udf_check_tag_payload(dst, dscrlen);
	+ if (error && dst) {
	+ free(dst, mtype);
	+ dst = NULL;
	+ }
	+ *dstp = dst;
	+
	+ return (error);
	+}
	+
	+
	+#if 0
	+static void
	+udf_write_phys_buf(struct udf_mount ump, int what, struct buf buf)
	+{
	+ struct buf *nestbuf;
	+ uint32_t buf_offset;
	+ off_t lblkno, rblkno;
	+ int sector_size = ump->discinfo.sector_size;
	+ int blks = sector_size / DEV_BSIZE;
	+ uint32_t sectors;
	+ int piece;
	+ int error;
	+
	+ sectors = buf->b_bcount / sector_size;
	+ DPRINTF(WRITE, ("udf_intbwriten() : sectors = %d, sector_size = %d\n",
	+ sectors, sector_size));
	+
	+ /* don't forget to increase pending count for the bwrite itself */
	+/* panic("NO WRITING\n"); */
	+ if (buf->b_vp) {
	+ mutex_enter(&buf->b_vp->v_interlock);
	+ buf->b_vp->v_numoutput++;
	+ mutex_exit(&buf->b_vp->v_interlock);
	+ }
	+
	+ error = 0;
	+ buf_offset = 0;
	+ rblkno = buf->b_blkno / blks;
	+ lblkno = 0;
	+ while ((sectors > 0) && (error == 0)) {
	+ piece = MIN(MAXPHYS/sector_size, sectors);
	+ DPRINTF(WRITE, ("write out %d + %d\n",
	+ (uint32_t) rblkno, piece));
	+
	+ nestbuf = getiobuf(NULL, true);
	+ nestiobuf_setup(buf, nestbuf, buf_offset, piece * sector_size);
	+ /* nestbuf is B_ASYNC */
	+
	+ /* identify this nestbuf */
	+ nestbuf->b_lblkno = lblkno;
	+
	+ /* CD shedules on raw blkno */
	+ nestbuf->b_blkno = rblkno * blks;
	+ nestbuf->b_proc = NULL;
	+ nestbuf->b_rawblkno = rblkno * blks;
	+ nestbuf->b_udf_c_type = what;
	+
	+ udf_discstrat_queuebuf(ump, nestbuf);
	+
	+ lblkno += piece;
	+ rblkno += piece;
	+ buf_offset += piece * sector_size;
	+ sectors -= piece;
	+ }
	+}
	+
	+
	+/* SYNC writing of n blocks from specified sector */
	+int
	+udf_write_phys_sectors(struct udf_mount ump, int what, void blob,
	+ uint32_t start, uint32_t sectors)
	+{
	+ struct vnode *vp;
	+ struct buf *buf;
	+ int sector_size = ump->discinfo.sector_size;
	+ int blks = sector_size / DEV_BSIZE;
	+ int error;
	+
	+ /* get transfer buffer */
	+ vp = ump->devvp;
	+ buf = getiobuf(vp, true);
	+ buf->b_flags = B_WRITE;
	+ buf->b_cflags = BC_BUSY; /* needed? */
	+ buf->b_iodone = NULL;
	+ buf->b_data = blob;
	+ buf->b_bcount = sectors * sector_size;
	+ buf->b_resid = buf->b_bcount;
	+ buf->b_bufsize = buf->b_bcount;
	+ buf->b_private = NULL; /* not needed yet */
	+ BIO_SETPRIO(buf, BPRIO_DEFAULT);
	+ buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = start * blks;
	+ buf->b_proc = NULL;
	+
	+ /* do the write, wait and return error */
	+ udf_write_phys_buf(ump, what, buf);
	+ error = biowait(buf);
	+ putiobuf(buf);
	+
	+ return (error);
	+}
	+
	+
	+/* synchronous generic descriptor write */
	+int
	+udf_write_phys_dscr_sync(struct udf_mount ump, struct udf_node udf_node, int what,
	+ union dscrptr *dscr, uint32_t sector, uint32_t logsector)
	+{
	+ struct vnode *vp;
	+ struct buf *buf;
	+ int sector_size = ump->discinfo.sector_size;
	+ int blks = sector_size / DEV_BSIZE;
	+ int dscrlen;
	+ int error;
	+
	+ /* set sector number in the descriptor and validate */
	+ dscr->tag.tag_loc = udf_rw32(logsector);
	+ udf_validate_tag_and_crc_sums(dscr);
	+
	+ /* calculate descriptor size */
	+ dscrlen = udf_tagsize(dscr, sector_size);
	+
	+ /* get transfer buffer */
	+ vp = udf_node ? udf_node->vnode : ump->devvp;
	+ buf = getiobuf(vp, true);
	+ buf->b_flags = B_WRITE;
	+ buf->b_cflags = BC_BUSY; /* needed? */
	+ buf->b_iodone = NULL;
	+ buf->b_data = (void *) dscr;
	+ buf->b_bcount = dscrlen;
	+ buf->b_resid = buf->b_bcount;
	+ buf->b_bufsize = buf->b_bcount;
	+ buf->b_private = NULL; /* not needed yet */
	+ BIO_SETPRIO(buf, BPRIO_DEFAULT);
	+ buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = sector * blks;
	+ buf->b_proc = NULL;
	+
	+ /* do the write, wait and return error */
	+ udf_write_phys_buf(ump, what, buf);
	+ error = biowait(buf);
	+ putiobuf(buf);
	+
	+ return (error);
	+}
	+
	+
	+/* asynchronous generic descriptor write */
	+int
	+udf_write_phys_dscr_async(struct udf_mount ump, struct udf_node udf_node,
	+ int what, union dscrptr *dscr,
	+ uint32_t sector, uint32_t logsector,
	+ void (dscrwr_callback)(struct buf ))
	+{
	+ struct vnode *vp;
	+ struct buf *buf;
	+ int dscrlen;
	+ int sector_size = ump->discinfo.sector_size;
	+ int blks = sector_size / DEV_BSIZE;
	+
	+ KASSERT(dscrwr_callback);
	+ DPRINTF(NODE, ("udf_write_phys_dscr_async() called\n"));
	+
	+ /* set sector number in the descriptor and validate */
	+ dscr->tag.tag_loc = udf_rw32(logsector);
	+ udf_validate_tag_and_crc_sums(dscr);
	+
	+ /* calculate descriptor size */
	+ dscrlen = udf_tagsize(dscr, sector_size);
	+
	+ /* get transfer buffer */
	+ vp = udf_node ? udf_node->vnode : ump->devvp;
	+ buf = getiobuf(vp, true);
	+ buf->b_flags = B_WRITE \| B_ASYNC;
	+ buf->b_cflags = BC_BUSY;
	+ buf->b_iodone = dscrwr_callback;
	+ buf->b_data = dscr;
	+ buf->b_bcount = dscrlen;
	+ buf->b_resid = buf->b_bcount;
	+ buf->b_bufsize = buf->b_bcount;
	+ buf->b_private = NULL; /* not needed yet */
	+ BIO_SETPRIO(buf, BPRIO_DEFAULT);
	+ buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = sector * blks;
	+ buf->b_proc = NULL;
	+
	+ /* do the write and return no error */
	+ udf_write_phys_buf(ump, what, buf);
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* disc strategy dispatchers */
	+
	+int
	+udf_create_logvol_dscr(struct udf_mount ump, struct udf_node udf_node, struct long_ad *icb,
	+ union dscrptr **dscrptr)
	+{
	+ struct udf_strategy *strategy = ump->strategy;
	+ struct udf_strat_args args;
	+ int error;
	+
	+ KASSERT(strategy);
	+ args.ump = ump;
	+ args.udf_node = udf_node;
	+ args.icb = icb;
	+ args.dscr = NULL;
	+
	+ error = (strategy->create_logvol_dscr)(&args);
	+ *dscrptr = args.dscr;
	+
	+ return (error);
	+}
	+
	+
	+void
	+udf_free_logvol_dscr(struct udf_mount ump, struct long_ad icb,
	+ void *dscr)
	+{
	+ struct udf_strategy *strategy = ump->strategy;
	+ struct udf_strat_args args;
	+
	+ KASSERT(strategy,("Strategy not specified."));
	+ args.ump = ump;
	+ args.icb = icb;
	+ args.dscr = dscr;
	+
	+ (strategy->free_logvol_dscr)(&args);
	+}
	+
	+
	+int
	+udf_read_logvol_dscr(struct udf_mount ump, struct long_ad icb,
	+ union dscrptr **dscrptr)
	+{
	+ struct udf_strategy *strategy = ump->strategy;
	+ struct udf_strat_args args;
	+ int error;
	+
	+ KASSERT(strategy);
	+ args.ump = ump;
	+ args.icb = icb;
	+ args.dscr = NULL;
	+
	+ error = (strategy->read_logvol_dscr)(&args);
	+ *dscrptr = args.dscr;
	+
	+ return (error);
	+}
	+
	+
	+int
	+udf_write_logvol_dscr(struct udf_node udf_node, union dscrptr dscr,
	+ struct long_ad *icb, int waitfor)
	+{
	+ struct udf_strategy *strategy = udf_node->ump->strategy;
	+ struct udf_strat_args args;
	+ int error;
	+
	+ KASSERT(strategy);
	+ args.ump = udf_node->ump;
	+ args.udf_node = udf_node;
	+ args.icb = icb;
	+ args.dscr = dscr;
	+ args.waitfor = waitfor;
	+
	+ error = (strategy->write_logvol_dscr)(&args);
	+ return (error);
	+}
	+
	+
	+void
	+udf_discstrat_queuebuf(struct udf_mount ump, struct buf nestbuf)
	+{
	+ struct udf_strategy *strategy = ump->strategy;
	+ struct udf_strat_args args;
	+
	+ KASSERT(strategy);
	+ args.ump = ump;
	+ args.nestbuf = nestbuf;
	+
	+ (strategy->queuebuf)(&args);
	+}
	+
	+
	+void
	+udf_discstrat_init(struct udf_mount *ump)
	+{
	+ struct udf_strategy *strategy = ump->strategy;
	+ struct udf_strat_args args;
	+
	+ KASSERT(strategy);
	+ args.ump = ump;
	+ (strategy->discstrat_init)(&args);
	+}
	+
	+
	+void udf_discstrat_finish(struct udf_mount *ump)
	+{
	+ struct udf_strategy *strategy = ump->strategy;
	+ struct udf_strat_args args;
	+
	+ /* strategy might not have been set, so ignore if not set */
	+ if (strategy) {
	+ args.ump = ump;
	+ (strategy->discstrat_finish)(&args);
	+ }
	+}
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	Index: sys/fs/udf2/udf_subr.h
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_subr.h
	@@ -0,0 +1,210 @@
	+/*-
	+ * Copyright (c) 2006, 2008 Reinoud Zandijk
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ */
	+
	+#ifndef _FS_UDF_UDF_SUBR_H_
	+#define _FS_UDF_UDF_SUBR_H_
	+
	+/* handies */
	+#define VFSTOUDF(mp) ((struct udf_mount *)mp->mnt_data)
	+#define VTOI(vnode) ((struct udf_node *) (vnode)->v_data)
	+
	+
	+/* device information updating */
	+int udf_update_trackinfo(struct udf_mount ump, struct mmc_trackinfo trackinfo);
	+int udf_update_discinfo(struct udf_mount *ump, uint32_t sector_size, uint32_t psize);
	+int udf_search_tracks(struct udf_mount ump, struct udf_args args,
	+ int first_tracknr, int last_tracknr);
	+//int udf_search_writing_tracks(struct udf_mount *ump);
	+//int udf_setup_writeparams(struct udf_mount *ump);
	+int udf_synchronise_caches(struct udf_mount *ump);
	+
	+/* tags operations */
	+int udf_fidsize(struct fileid_desc *fid);
	+int udf_check_tag(void *blob);
	+int udf_check_tag_payload(void *blob, uint32_t max_length);
	+void udf_validate_tag_sum(void *blob);
	+void udf_validate_tag_and_crc_sums(void *blob);
	+int udf_tagsize(union dscrptr *dscr, uint32_t udf_sector_size);
	+
	+/* read/write descriptors */
	+//int udf_write_phys_sectors(struct udf_mount ump, int what, void blob,
	+// uint32_t start, uint32_t sectors);
	+int udf_read_phys_dscr(
	+ struct udf_mount *ump,
	+ uint32_t sector,
	+ struct malloc_type mtype, / where to allocate */
	+ union dscrptr *dstp); / out */
	+
	+//int udf_write_phys_dscr_sync(struct udf_mount ump, struct udf_node udf_node,
	+// int what, union dscrptr *dscr,
	+// uint32_t sector, uint32_t logsector);
	+//int udf_write_phys_dscr_async(struct udf_mount ump, struct udf_node udf_node,
	+// int what, union dscrptr *dscr,
	+// uint32_t sector, uint32_t logsector,
	+// void (dscrwr_callback)(struct buf ));
	+
	+/* read/write node descriptors */
	+//int udf_create_logvol_dscr(struct udf_mount ump, struct udf_node udf_node,
	+// struct long_ad icb, union dscrptr *dscrptr);
	+//void udf_free_logvol_dscr(struct udf_mount ump, struct long_ad icb_loc,
	+// void *dscr);
	+//int udf_read_logvol_dscr(struct udf_mount ump, struct long_ad icb,
	+// union dscrptr **dscrptr);
	+//int udf_write_logvol_dscr(struct udf_node udf_node, union dscrptr dscr,
	+// struct long_ad *icb, int waitfor);
	+
	+
	+/* volume descriptors readers and checkers */
	+int udf_read_anchors(struct udf_mount *ump);
	+int udf_read_vds_space(struct udf_mount *ump);
	+int udf_process_vds(struct udf_mount *ump);
	+int udf_read_vds_tables(struct udf_mount *ump);
	+int udf_read_rootdirs(struct udf_mount *ump);
	+
	+/* open/close and sync volumes */
	+int udf_open_logvol(struct udf_mount *ump);
	+int udf_close_logvol(struct udf_mount *ump, int mntflags);
	+//int udf_writeout_vat(struct udf_mount *ump);
	+//int udf_write_physical_partition_spacetables(struct udf_mount *ump, int waitfor);
	+//int udf_write_metadata_partition_spacetable(struct udf_mount *ump, int waitfor);
	+//void udf_do_sync(struct udf_mount *ump, kauth_cred_t cred, int waitfor);
	+//void udf_synchronise_metadatamirror_node(struct udf_mount *ump);
	+
	+/* translation services */
	+int udf_translate_vtop(struct udf_mount ump, struct long_ad icb_loc,
	+ uint32_t lb_numres, uint32_t extres);
	+//void udf_translate_vtop_list(struct udf_mount *ump, uint32_t sectors,
	+// uint16_t vpart_num, uint64_t lmapping, uint64_t pmapping);
	+int udf_bmap_translate(struct udf_node *udf_node, uint32_t block,
	+ uint64_t lsector, uint32_t maxblks);
	+int udf_translate_file_extent(struct udf_node *node,
	+ uint32_t from, uint32_t num_lb, uint64_t *map);
	+void udf_get_adslot(struct udf_node udf_node, int slot, struct long_ad icb, int *eof);
	+int udf_append_adslot(struct udf_node udf_node, int slot, struct long_ad *icb);
	+
	+int udf_vat_read(struct udf_node vat_node, uint8_t blob, int size, uint32_t offset);
	+//int udf_vat_write(struct udf_node vat_node, uint8_t blob, int size, uint32_t offset);
	+
	+/* disc allocation */
	+int udf_get_c_type(struct udf_node *udf_node);
	+int udf_get_record_vpart(struct udf_mount *ump, int udf_c_type);
	+//void udf_do_reserve_space(struct udf_mount ump, struct udf_node udf_node, uint16_t vpart_num, uint32_t num_lb);
	+//void udf_do_unreserve_space(struct udf_mount ump, struct udf_node udf_node, uint16_t vpart_num, uint32_t num_lb);
	+//int udf_reserve_space(struct udf_mount ump, struct udf_node udf_node, int udf_c_type, uint16_t vpart_num, uint32_t num_lb, int can_fail);
	+//void udf_cleanup_reservation(struct udf_node *udf_node);
	+//int udf_allocate_space(struct udf_mount ump, struct udf_node udf_node, int udf_c_type, uint16_t vpart_num, uint32_t num_lb, uint64_t *lmapping);
	+//void udf_free_allocated_space(struct udf_mount *ump, uint32_t lb_num, uint16_t vpart_num, uint32_t num_lb);
	+//void udf_late_allocate_buf(struct udf_mount ump, struct buf buf, uint64_t lmapping, struct long_ad node_ad_cpy, uint16_t *vpart_num);
	+//int udf_grow_node(struct udf_node *node, uint64_t new_size);
	+//int udf_shrink_node(struct udf_node *node, uint64_t new_size);
	+void udf_calc_freespace(struct udf_mount ump, uint64_t sizeblks, uint64_t *freeblks);
	+
	+/* node readers and writers */
	+//uint64_t udf_advance_uniqueid(struct udf_mount *ump);
	+
	+#define UDF_LOCK_NODE(udf_node, flag) udf_lock_node(udf_node, (flag), __FILE__, __LINE__)
	+#define UDF_UNLOCK_NODE(udf_node, flag) udf_unlock_node(udf_node, (flag))
	+void udf_lock_node(struct udf_node udf_node, int flag, char const fname, const int lineno);
	+void udf_unlock_node(struct udf_node *udf_node, int flag);
	+
	+int udf_get_node(struct udf_mount ump, ino_t ino, struct udf_node *ppunode);
	+//int udf_writeout_node(struct udf_node *udf_node, int waitfor);
	+int udf_dispose_node(struct udf_node *node);
	+
	+/* node ops */
	+//int udf_resize_node(struct udf_node node, uint64_t new_size, int extended);
	+int udf_extattr_search_intern(struct udf_node node, uint32_t sattr, char const sattrname, uint32_t offsetp, uint32_t lengthp);
	+
	+/* node data buffer read/write */
	+void udf_read_filebuf(struct udf_node node, struct buf buf);
	+//void udf_write_filebuf(struct udf_node node, struct buf buf);
	+//void udf_fixup_fid_block(uint8_t *blob, int lb_size, int rfix_pos, int max_rfix_pos, uint32_t lb_num);
	+//void udf_fixup_internal_extattr(uint8_t *blob, uint32_t lb_num);
	+//void udf_fixup_node_internals(struct udf_mount ump, uint8_t blob, int udf_c_type);
	+
	+/* device strategy */
	+//void udf_discstrat_init(struct udf_mount *ump);
	+//void udf_discstrat_finish(struct udf_mount *ump);
	+//void udf_discstrat_queuebuf(struct udf_mount ump, struct buf nestbuf);
	+
	+/* structure writers */
	+//int udf_write_terminator(struct udf_mount *ump, uint32_t sector);
	+
	+/* structure creators */
	+//void udf_inittag(struct udf_mount ump, struct desc_tag tag, int tagid, uint32_t sector);
	+//void udf_set_regid(struct regid regid, char const name);
	+//void udf_add_domain_regid(struct udf_mount ump, struct regid regid);
	+//void udf_add_udf_regid(struct udf_mount ump, struct regid regid);
	+//void udf_add_impl_regid(struct udf_mount ump, struct regid regid);
	+//void udf_add_app_regid(struct udf_mount ump, struct regid regid);
	+
	+/* directory operations and helpers */
	+void udf_osta_charset(struct charspec *charspec);
	+int udf_read_fid_stream(struct vnode vp, uint64_t offset, struct fileid_desc *fid);
	+int udf_lookup_name_in_dir(struct vnode vp, const char name, int namelen, struct long_ad icb_loc, int found);
	+//int udf_create_node(struct vnode dvp, struct vnode vpp, struct vattr vap, struct componentname *cnp);
	+//void udf_delete_node(struct udf_node *udf_node);
	+
	+//int udf_chsize(struct vnode *vp, u_quad_t newsize, kauth_cred_t cred);
	+//int udf_dir_detach(struct udf_mount ump, struct udf_node dir_node, struct udf_node udf_node, struct componentname cnp);
	+//int udf_dir_attach(struct udf_mount ump, struct udf_node dir_node, struct udf_node udf_node, struct vattr vap, struct componentname *cnp);
	+//int udf_dir_update_rootentry(struct udf_mount ump, struct udf_node dir_node, struct udf_node *new_parent_node);
	+
	+/* update and times */
	+//void udf_add_to_dirtylist(struct udf_node *udf_node);
	+//void udf_remove_from_dirtylist(struct udf_node *udf_node);
	+//void udf_itimes(struct udf_node udf_node, struct timespec acc,
	+// struct timespec mod, struct timespec birth);
	+//int udf_update(struct vnode node, struct timespec acc,
	+// struct timespec mod, struct timespec birth, int updflags);
	+
	+/* helpers and converters */
	+//void udf_init_nodes_tree(struct udf_mount *ump);
	+long udf_get_node_id(const struct long_ad icbptr); / for `inode' numbering */
	+int udf_get_node_longad(const ino_t ino, struct long_ad *icbptr);
	+//int udf_compare_icb(const struct long_ad a, const struct long_ad b);
	+uint32_t udf_getaccessmode(struct udf_node *node);
	+//void udf_setaccessmode(struct udf_node *udf_node, mode_t mode);
	+//void udf_getownership(struct udf_node udf_node, uid_t uidp, gid_t *gidp);
	+//void udf_setownership(struct udf_node *udf_node, uid_t uid, gid_t gid);
	+
	+void udf_to_unix_name(struct udf_mount ump, char result, int result_len, char *id, int len);
	+//void unix_to_udf_name(char result, uint8_t result_len, char const name, int name_len, struct charspec chsp);
	+
	+void udf_timestamp_to_timespec(struct udf_mount ump, struct timestamp timestamp, struct timespec *timespec);
	+//void udf_timespec_to_timestamp(struct timespec timespec, struct timestamp timestamp);
	+
	+/* vnode operations */
	+int udf_getanode(struct mount mp, struct vnode *vpp);
	+int udf_read_internal(struct udf_node node, uint8_t blob);
	+
	+/* Created by for testing */
	+void udf_print_anchors(struct udf_mount *ump);
	+struct udf_node * udf_alloc_node(void);
	+void udf_free_node(struct udf_node *unode);
	+int udf_vget(struct mount mp, ino_t ino, int flags, struct vnode *vpp);
	+int udf_read_node(struct udf_node unode, uint8_t blob, off_t start, int length);
	+#endif /* !_FS_UDF_UDF_SUBR_H_ */
	Index: sys/fs/udf2/udf_subr.c
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_subr.c
	@@ -0,0 +1,6742 @@
	+/*-
	+ * Copyright (c) 2012 Oleksandr Dudinskyi
	+ * Copyright (c) 2012 Will DeVries
	+ * Copyright (c) 2006, 2008 Reinoud Zandijk
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ */
	+
	+
	+#include <machine/_inttypes.h>
	+#include <sys/cdefs.h>
	+#include <sys/endian.h>
	+#include <sys/param.h>
	+#include <sys/systm.h>
	+#include <sys/vnode.h>
	+#include <sys/malloc.h>
	+#include <sys/stat.h>
	+#include <sys/mount.h>
	+#include <sys/iconv.h>
	+#include "ecma167-udf.h"
	+#include "udf.h"
	+#include "udf_subr.h"
	+#include "udf_mount.h"
	+#include "udfio.h"
	+
	+#define VTOI(vnode) ((struct udf_node *) (vnode)->v_data)
	+
	+#define UDF_SET_SYSTEMFILE(vp) \
	+ /* XXXAD Is the vnode locked? */ \
	+ (vp)->v_vflag \|= VV_SYSTEM; \
	+ vref(vp); \
	+ vput(vp); \
	+
	+extern struct iconv_functions *udf2_iconv;
	+extern int syncer_maxdelay; /* maximum delay time */
	+extern int (*udf_vnodeop_p)(void );
	+
	+/* --------------------------------------------------------------------- */
	+
	+#if 1
	+
	+static void
	+udf_dump_discinfo(struct udf_mount *ump)
	+{
	+ char bits[128];
	+ struct mmc_discinfo *di = &ump->discinfo;
	+
	+ if ((udf_verbose & UDF_DEBUG_VOLUMES) == 0)
	+ return;
	+
	+ printf("Device/media info :\n");
	+ printf("\tMMC profile 0x%02x\n", di->mmc_profile);
	+ printf("\tderived class %d\n", di->mmc_class);
	+ printf("\tsector size %d\n", di->sector_size);
	+ printf("\tdisc state %d\n", di->disc_state);
	+ printf("\tlast ses state %d\n", di->last_session_state);
	+ printf("\tbg format state %d\n", di->bg_format_state);
	+ printf("\tfrst track %d\n", di->first_track);
	+ printf("\tfst on last ses %d\n", di->first_track_last_session);
	+ printf("\tlst on last ses %d\n", di->last_track_last_session);
	+ printf("\tlink block penalty %d\n", di->link_block_penalty);
	+ snprintf(bits, sizeof(bits), "%b\n", di->disc_flags, MMC_DFLAGS_FLAGBITS);
	+ printf("\tdisc flags %s\n", bits);
	+ printf("\tdisc id %x\n", di->disc_id);
	+ printf("\tdisc barcode %"PRIx64"\n", di->disc_barcode);
	+
	+ printf("\tnum sessions %d\n", di->num_sessions);
	+ printf("\tnum tracks %d\n", di->num_tracks);
	+
	+ snprintf(bits, sizeof(bits), "%b\n", (int) di->mmc_cur, MMC_CAP_FLAGBITS);
	+ printf("\tcapabilities cur %s\n", bits);
	+ snprintf(bits, sizeof(bits), "%b\n", (int) di->mmc_cap, MMC_CAP_FLAGBITS);
	+ printf("\tcapabilities cap %s\n", bits);
	+}
	+
	+#if 0
	+static void
	+udf_dump_trackinfo(struct mmc_trackinfo *trackinfo)
	+{
	+ char bits[128];
	+
	+ if ((udf_verbose & UDF_DEBUG_VOLUMES) == 0)
	+ return;
	+
	+ printf("Trackinfo for track %d:\n", trackinfo->tracknr);
	+ printf("\tsessionnr %d\n", trackinfo->sessionnr);
	+ printf("\ttrack mode %d\n", trackinfo->track_mode);
	+ printf("\tdata mode %d\n", trackinfo->data_mode);
	+ snprintf(bits, sizeof(bits), "%b\n", trackinfo->flags, MMC_TRACKINFO_FLAGBITS);
	+ printf("\tflags %s\n", bits);
	+
	+ printf("\ttrack start %d\n", trackinfo->track_start);
	+ printf("\tnext_writable %d\n", trackinfo->next_writable);
	+ printf("\tfree_blocks %d\n", trackinfo->free_blocks);
	+ printf("\tpacket_size %d\n", trackinfo->packet_size);
	+ printf("\ttrack size %d\n", trackinfo->track_size);
	+ printf("\tlast recorded block %d\n", trackinfo->last_recorded);
	+}
	+
	+#endif
	+#else
	+#define udf_dump_discinfo(a);
	+#define udf_dump_trackinfo(a);
	+#endif
	+
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* not called often */
	+int
	+udf_update_discinfo(struct udf_mount *ump, uint32_t sector_size, uint32_t psize)
	+{
	+ struct vnode *devvp = ump->devvp;
	+ struct thread *td;
	+ struct mmc_discinfo *di;
	+ int error;
	+
	+ DPRINTF(VOLUMES, ("read/update disc info\n"));
	+ di = &ump->discinfo;
	+ td = curthread;
	+ memset(di, 0, sizeof(struct mmc_discinfo));
	+
	+ /* check if we're on a MMC capable device, i.e. CD/DVD */
	+ error = VOP_IOCTL(devvp, MMCGETDISCINFO, di, FKIOCTL, NOCRED, td);
	+ if (error == 0) {
	+ udf_dump_discinfo(ump);
	+ return (0);
	+ }
	+
	+ /* set up a disc info profile for partitions */
	+ di->mmc_profile = 0x01; /* disc type */
	+ di->mmc_class = MMC_CLASS_DISC;
	+ di->disc_state = MMC_STATE_CLOSED;
	+ di->last_session_state = MMC_STATE_CLOSED;
	+ di->bg_format_state = MMC_BGFSTATE_COMPLETED;
	+ di->link_block_penalty = 0;
	+
	+ di->mmc_cur = MMC_CAP_RECORDABLE \| MMC_CAP_REWRITABLE \|
	+ MMC_CAP_ZEROLINKBLK \| MMC_CAP_HW_DEFECTFREE;
	+ di->mmc_cap = di->mmc_cur;
	+ di->disc_flags = MMC_DFLAGS_UNRESTRICTED;
	+
	+ /* TODO problem with last_possible_lba on resizable VND; request */
	+ di->last_possible_lba = psize/sector_size - 1;
	+ di->sector_size = sector_size;
	+
	+ di->num_sessions = 1;
	+ di->num_tracks = 1;
	+
	+ di->first_track = 1;
	+ di->first_track_last_session = di->last_track_last_session = 1;
	+
	+ udf_dump_discinfo(ump);
	+ return (0);
	+}
	+
	+
	+int
	+udf_update_trackinfo(struct udf_mount ump, struct mmc_trackinfo ti)
	+{
	+ struct vnode *devvp = ump->devvp;
	+ struct mmc_discinfo *di = &ump->discinfo;
	+ struct thread *td;
	+ int error, class;
	+
	+ DPRINTF(VOLUMES, ("read track info\n"));
	+
	+ td = curthread;
	+ class = di->mmc_class;
	+ if (class != MMC_CLASS_DISC) {
	+ /* tracknr specified in struct ti */
	+ error = VOP_IOCTL(devvp, MMCGETTRACKINFO, ti, FKIOCTL, NOCRED, td);
	+ return (error);
	+ }
	+
	+ /* disc partition support */
	+ if (ti->tracknr != 1)
	+ return (EIO);
	+
	+ /* create fake ti (TODO check for resized vnds) */
	+ ti->sessionnr = 1;
	+
	+ ti->track_mode = 0; /* XXX */
	+ ti->data_mode = 0; /* XXX */
	+ ti->flags = MMC_TRACKINFO_LRA_VALID \| MMC_TRACKINFO_NWA_VALID;
	+
	+ ti->track_start = 0;
	+ ti->packet_size = 1;
	+
	+ /* TODO support for resizable vnd */
	+ ti->track_size = di->last_possible_lba;
	+ ti->next_writable = di->last_possible_lba;
	+ ti->last_recorded = ti->next_writable;
	+ ti->free_blocks = 0;
	+
	+ return (0);
	+}
	+
	+#if 0
	+int
	+udf_setup_writeparams(struct udf_mount *ump)
	+{
	+ struct mmc_writeparams mmc_writeparams;
	+ int error;
	+
	+ if (ump->discinfo.mmc_class == MMC_CLASS_DISC)
	+ return (0);
	+
	+ /*
	+ * only CD burning normally needs setting up, but other disc types
	+ * might need other settings to be made. The MMC framework will set up
	+ * the nessisary recording parameters according to the disc
	+ * characteristics read in. Modifications can be made in the discinfo
	+ * structure passed to change the nature of the disc.
	+ */
	+
	+ memset(&mmc_writeparams, 0, sizeof(struct mmc_writeparams));
	+ mmc_writeparams.mmc_class = ump->discinfo.mmc_class;
	+ mmc_writeparams.mmc_cur = ump->discinfo.mmc_cur;
	+
	+ /*
	+ * UDF dictates first track to determine track mode for the whole
	+ * disc. [UDF 1.50/6.10.1.1, UDF 1.50/6.10.2.1]
	+ * To prevent problems with a `reserved' track in front we start with
	+ * the 2nd track and if that is not valid, go for the 1st.
	+ */
	+ mmc_writeparams.tracknr = 2;
	+ mmc_writeparams.data_mode = MMC_DATAMODE_DEFAULT; /* XA disc */
	+ mmc_writeparams.track_mode = MMC_TRACKMODE_DEFAULT; /* data */
	+
	+ error = VOP_IOCTL(ump->devvp, MMCSETUPWRITEPARAMS, &mmc_writeparams,
	+ FKIOCTL, NOCRED);
	+ if (error) {
	+ mmc_writeparams.tracknr = 1;
	+ error = VOP_IOCTL(ump->devvp, MMCSETUPWRITEPARAMS,
	+ &mmc_writeparams, FKIOCTL, NOCRED);
	+ }
	+ return (error);
	+}
	+
	+
	+#endif
	+int
	+udf_synchronise_caches(struct udf_mount *ump)
	+{
	+ struct mmc_op mmc_op;
	+
	+ DPRINTF(CALL, ("udf_synchronise_caches()\n"));
	+
	+ if (ump->vfs_mountp->mnt_flag & MNT_RDONLY)
	+ return (0);
	+
	+ /* discs are done now */
	+ if (ump->discinfo.mmc_class == MMC_CLASS_DISC)
	+ return (0);
	+
	+ memset(&mmc_op, 0, sizeof(struct mmc_op));
	+ mmc_op.operation = MMC_OP_SYNCHRONISECACHE;
	+
	+ /* ignore return code */
	+ (void) VOP_IOCTL(ump->devvp, MMCOP, &mmc_op, FKIOCTL, NOCRED, curthread);
	+
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* track/session searching for mounting */
	+int
	+udf_search_tracks(struct udf_mount ump, struct udf_args args,
	+ int first_tracknr, int last_tracknr)
	+{
	+ struct mmc_trackinfo trackinfo;
	+ uint32_t tracknr, start_track, num_tracks;
	+ int error;
	+
	+ /* if negative, sessionnr is relative to last session */
	+ if (args->sessionnr < 0) {
	+ args->sessionnr += ump->discinfo.num_sessions;
	+ }
	+
	+ /* sanity */
	+ if (args->sessionnr < 0)
	+ args->sessionnr = 0;
	+ if (args->sessionnr > ump->discinfo.num_sessions)
	+ args->sessionnr = ump->discinfo.num_sessions;
	+
	+ /* search the tracks for this session, zero session nr indicates last */
	+ if (args->sessionnr == 0)
	+ args->sessionnr = ump->discinfo.num_sessions;
	+ if (ump->discinfo.last_session_state == MMC_STATE_EMPTY)
	+ args->sessionnr--;
	+
	+ /* sanity again */
	+ if (args->sessionnr < 0)
	+ args->sessionnr = 0;
	+
	+ /* search the first and last track of the specified session */
	+ num_tracks = ump->discinfo.num_tracks;
	+ start_track = ump->discinfo.first_track;
	+
	+ /* search for first track of this session */
	+ for (tracknr = start_track; tracknr <= num_tracks; tracknr++) {
	+ /* get track info */
	+ trackinfo.tracknr = tracknr;
	+ error = udf_update_trackinfo(ump, &trackinfo);
	+ if (error)
	+ return (error);
	+
	+ if (trackinfo.sessionnr == args->sessionnr)
	+ break;
	+ }
	+ *first_tracknr = tracknr;
	+
	+ /* search for last track of this session */
	+ for (;tracknr <= num_tracks; tracknr++) {
	+ /* get track info */
	+ trackinfo.tracknr = tracknr;
	+ error = udf_update_trackinfo(ump, &trackinfo);
	+ if (error \|\| (trackinfo.sessionnr != args->sessionnr)) {
	+ tracknr--;
	+ break;
	+ }
	+ }
	+ if (tracknr > num_tracks)
	+ tracknr--;
	+
	+ *last_tracknr = tracknr;
	+
	+ if (last_tracknr < first_tracknr) {
	+ printf( "udf_search_tracks: sanity check on drive+disc failed, "
	+ "drive returned garbage\n");
	+ return (EINVAL);
	+ }
	+
	+ KASSERT(last_tracknr >= first_tracknr, ("udf_search_tracks: sanity check failed"));
	+ return (0);
	+}
	+
	+#if 0
	+/*
	+ * NOTE: this is the only routine in this file that directly peeks into the
	+ * metadata file but since its at a larval state of the mount it can't hurt.
	+ *
	+ * XXX candidate for udf_allocation.c
	+ * XXX clean me up!, change to new node reading code.
	+ */
	+
	+static void
	+udf_check_track_metadata_overlap(struct udf_mount *ump,
	+ struct mmc_trackinfo *trackinfo)
	+{
	+ struct part_desc *part;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct short_ad *s_ad;
	+ struct long_ad *l_ad;
	+ uint32_t track_start, track_end;
	+ uint32_t phys_part_start, phys_part_end, part_start, part_end;
	+ uint32_t sector_size, len, alloclen, plb_num;
	+ uint8_t *pos;
	+ int addr_type, icblen, icbflags, flags;
	+
	+ /* get our track extents */
	+ track_start = trackinfo->track_start;
	+ track_end = track_start + trackinfo->track_size;
	+
	+ /* get our base partition extent */
	+ KASSERT(ump->node_part == ump->fids_part);
	+ part = ump->partitions[ump->node_part];
	+ phys_part_start = le32toh(part->start_loc);
	+ phys_part_end = phys_part_start + le32toh(part->part_len);
	+
	+ /* no use if its outside the physical partition */
	+ if ((phys_part_start >= track_end) \|\| (phys_part_end < track_start))
	+ return;
	+
	+ /*
	+ * now follow all extents in the fe/efe to see if they refer to this
	+ * track
	+ */
	+
	+ sector_size = ump->discinfo.sector_size;
	+
	+ /* XXX should we claim exclusive access to the metafile ? */
	+ /* TODO: move to new node read code */
	+ fe = ump->metadata_node->fe;
	+ efe = ump->metadata_node->efe;
	+ if (fe) {
	+ alloclen = le32toh(fe->l_ad);
	+ pos = &fe->data[0] + le32toh(fe->l_ea);
	+ icbflags = le16toh(fe->icbtag.flags);
	+ } else {
	+ assert(efe);
	+ alloclen = le32toh(efe->l_ad);
	+ pos = &efe->data[0] + le32toh(efe->l_ea);
	+ icbflags = le16toh(efe->icbtag.flags);
	+ }
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ while (alloclen) {
	+ if (addr_type == UDF_ICB_SHORT_ALLOC) {
	+ icblen = sizeof(struct short_ad);
	+ s_ad = (struct short_ad *) pos;
	+ len = le32toh(s_ad->len);
	+ plb_num = le32toh(s_ad->lb_num);
	+ } else {
	+ /* should not be present, but why not */
	+ icblen = sizeof(struct long_ad);
	+ l_ad = (struct long_ad *) pos;
	+ len = le32toh(l_ad->len);
	+ plb_num = le32toh(l_ad->loc.lb_num);
	+ /* pvpart_num = le16toh(l_ad->loc.part_num); */
	+ }
	+ /* process extent */
	+ flags = UDF_EXT_FLAGS(len);
	+ len = UDF_EXT_LEN(len);
	+
	+ part_start = phys_part_start + plb_num;
	+ part_end = part_start + (len / sector_size);
	+
	+ if ((part_start >= track_start) && (part_end <= track_end)) {
	+ /* extent is enclosed within this track */
	+ ump->metadata_track = *trackinfo;
	+ return;
	+ }
	+
	+ pos += icblen;
	+ alloclen -= icblen;
	+ }
	+}
	+
	+
	+int
	+udf_search_writing_tracks(struct udf_mount *ump)
	+{
	+ struct vnode *devvp = ump->devvp;
	+ struct mmc_trackinfo trackinfo;
	+ struct mmc_op mmc_op;
	+ struct part_desc *part;
	+ uint32_t tracknr, start_track, num_tracks;
	+ uint32_t track_start, track_end, part_start, part_end;
	+ int node_alloc, error;
	+
	+ /*
	+ * in the CD/(HD)DVD/BD recordable device model a few tracks within
	+ * the last session might be open but in the UDF device model at most
	+ * three tracks can be open: a reserved track for delayed ISO VRS
	+ * writing, a data track and a metadata track. We search here for the
	+ * data track and the metadata track. Note that the reserved track is
	+ * troublesome but can be detected by its small size of < 512 sectors.
	+ */
	+
	+ /* update discinfo since it might have changed */
	+ error = udf_update_discinfo(ump);
	+ if (error)
	+ return (error);
	+
	+ num_tracks = ump->discinfo.num_tracks;
	+ start_track = ump->discinfo.first_track;
	+
	+ /* fetch info on first and possibly only track */
	+ trackinfo.tracknr = start_track;
	+ error = udf_update_trackinfo(ump, &trackinfo);
	+ if (error)
	+ return (error);
	+
	+ /* copy results to our mount point */
	+ ump->data_track = trackinfo;
	+ ump->metadata_track = trackinfo;
	+
	+ /* if not sequential, we're done */
	+ if (num_tracks == 1)
	+ return (0);
	+
	+ for (tracknr = start_track;tracknr <= num_tracks; tracknr++) {
	+ /* get track info */
	+ trackinfo.tracknr = tracknr;
	+ error = udf_update_trackinfo(ump, &trackinfo);
	+ if (error)
	+ return (error);
	+
	+ /*
	+ * If this track is marked damaged, ask for repair. This is an
	+ * optional command, so ignore its error but report warning.
	+ */
	+ if (trackinfo.flags & MMC_TRACKINFO_DAMAGED) {
	+ memset(&mmc_op, 0, sizeof(mmc_op));
	+ mmc_op.operation = MMC_OP_REPAIRTRACK;
	+ mmc_op.mmc_profile = ump->discinfo.mmc_profile;
	+ mmc_op.tracknr = tracknr;
	+ error = VOP_IOCTL(devvp, MMCOP, &mmc_op, FKIOCTL, NOCRED);
	+ if (error)
	+ (void)printf("Drive can't explicitly repair "
	+ "damaged track %d, but it might "
	+ "autorepair\n", tracknr);
	+
	+ /* reget track info */
	+ error = udf_update_trackinfo(ump, &trackinfo);
	+ if (error)
	+ return (error);
	+ }
	+ if ((trackinfo.flags & MMC_TRACKINFO_NWA_VALID) == 0)
	+ continue;
	+
	+ track_start = trackinfo.track_start;
	+ track_end = track_start + trackinfo.track_size;
	+
	+ /* check for overlap on data partition */
	+ part = ump->partitions[ump->data_part];
	+ part_start = le32toh(part->start_loc);
	+ part_end = part_start + le32toh(part->part_len);
	+ if ((part_start < track_end) && (part_end > track_start)) {
	+ ump->data_track = trackinfo;
	+ /* TODO check if UDF partition data_part is writable */
	+ }
	+
	+ /* check for overlap on metadata partition */
	+ node_alloc = ump->vtop_alloc[ump->node_part];
	+ if ((node_alloc == UDF_ALLOC_METASEQUENTIAL) \|\|
	+ (node_alloc == UDF_ALLOC_METABITMAP)) {
	+ udf_check_track_metadata_overlap(ump, &trackinfo);
	+ } else {
	+ ump->metadata_track = trackinfo;
	+ }
	+ }
	+
	+ if ((ump->data_track.flags & MMC_TRACKINFO_NWA_VALID) == 0)
	+ return (EROFS);
	+
	+ if ((ump->metadata_track.flags & MMC_TRACKINFO_NWA_VALID) == 0)
	+ return (EROFS);
	+
	+ return (0);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Check if the blob starts with a good UDF tag. Tags are protected by a
	+ * checksum over the reader except one byte at position 4 that is the checksum
	+ * itself.
	+ */
	+
	+int
	+udf_check_tag(void *blob)
	+{
	+ struct desc_tag *tag = blob;
	+ uint8_t *pos, sum, cnt;
	+
	+ /* check TAG header checksum */
	+ pos = (uint8_t *) tag;
	+ sum = 0;
	+
	+ for(cnt = 0; cnt < 16; cnt++) {
	+ if (cnt != 4)
	+ sum += *pos;
	+ pos++;
	+ }
	+ if (sum != tag->cksum) {
	+ /* bad tag header checksum; this is not a valid tag */
	+ return (EINVAL);
	+ }
	+
	+ return (0);
	+}
	+
	+
	+/*
	+ * check tag payload will check descriptor CRC as specified.
	+ * If the descriptor is too long, it will return EIO otherwise EINVAL.
	+ */
	+
	+int
	+udf_check_tag_payload(void *blob, uint32_t max_length)
	+{
	+ struct desc_tag *tag = blob;
	+ uint16_t crc, crc_len;
	+
	+ crc_len = le16toh(tag->desc_crc_len);
	+
	+ /* check payload CRC if applicable */
	+ if (crc_len == 0)
	+ return (0);
	+
	+ if (crc_len > max_length)
	+ return (EIO);
	+
	+ crc = udf_cksum(((uint8_t *) tag) + UDF_DESC_TAG_LENGTH, crc_len);
	+ if (crc != le16toh(tag->desc_crc)) {
	+ /* bad payload CRC; this is a broken tag */
	+ return (EINVAL);
	+ }
	+
	+ return (0);
	+}
	+
	+
	+void
	+udf_validate_tag_sum(void *blob)
	+{
	+ struct desc_tag *tag = blob;
	+ uint8_t *pos, sum, cnt;
	+
	+ /* calculate TAG header checksum */
	+ pos = (uint8_t *) tag;
	+ sum = 0;
	+
	+ for(cnt = 0; cnt < 16; cnt++) {
	+ if (cnt != 4) sum += *pos;
	+ pos++;
	+ }
	+ tag->cksum = sum; /* 8 bit */
	+}
	+
	+
	+/* assumes sector number of descriptor to be saved already present */
	+void
	+udf_validate_tag_and_crc_sums(void *blob)
	+{
	+ struct desc_tag *tag = blob;
	+ uint16_t crc, crc_len;
	+ uint8_t btag = (uint8_t ) tag;
	+
	+ crc_len = le16toh(tag->desc_crc_len);
	+
	+ /* check payload CRC if applicable */
	+ if (crc_len > 0) {
	+ crc = udf_cksum(btag + UDF_DESC_TAG_LENGTH, crc_len);
	+ tag->desc_crc = htole16(crc);
	+ }
	+
	+ /* calculate TAG header checksum */
	+ udf_validate_tag_sum(blob);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * XXX note the different semantics from udfclient: for FIDs it still rounds
	+ * up to sectors. Use udf_fidsize() for a correct length.
	+ */
	+
	+int
	+udf_tagsize(union dscrptr *dscr, uint32_t lb_size)
	+{
	+ uint32_t size, tag_id, num_lb, elmsz;
	+
	+ tag_id = le16toh(dscr->tag.id);
	+
	+ switch (tag_id) {
	+ case TAGID_LOGVOL :
	+ size = sizeof(struct logvol_desc) - 1;
	+ size += le32toh(dscr->lvd.mt_l);
	+ break;
	+ case TAGID_UNALLOC_SPACE :
	+ elmsz = sizeof(struct extent_ad);
	+ size = sizeof(struct unalloc_sp_desc) - elmsz;
	+ size += le32toh(dscr->usd.alloc_desc_num) * elmsz;
	+ break;
	+ case TAGID_FID :
	+ size = UDF_FID_SIZE + dscr->fid.l_fi + le16toh(dscr->fid.l_iu);
	+ size = (size + 3) & ~3;
	+ break;
	+ case TAGID_LOGVOL_INTEGRITY :
	+ size = sizeof(struct logvol_int_desc) - sizeof(uint32_t);
	+ size += le32toh(dscr->lvid.l_iu);
	+ size += (2 * le32toh(dscr->lvid.num_part) * sizeof(uint32_t));
	+ break;
	+ case TAGID_SPACE_BITMAP :
	+ size = sizeof(struct space_bitmap_desc) - 1;
	+ size += le32toh(dscr->sbd.num_bytes);
	+ break;
	+ case TAGID_SPARING_TABLE :
	+ elmsz = sizeof(struct spare_map_entry);
	+ size = sizeof(struct udf_sparing_table) - elmsz;
	+ size += le16toh(dscr->spt.rt_l) * elmsz;
	+ break;
	+ case TAGID_FENTRY :
	+ size = sizeof(struct file_entry);
	+ size += le32toh(dscr->fe.l_ea) + le32toh(dscr->fe.l_ad)-1;
	+ break;
	+ case TAGID_EXTFENTRY :
	+ size = sizeof(struct extfile_entry);
	+ size += le32toh(dscr->efe.l_ea) + le32toh(dscr->efe.l_ad)-1;
	+ break;
	+ case TAGID_FSD :
	+ size = sizeof(struct fileset_desc);
	+ break;
	+ default :
	+ size = sizeof(union dscrptr);
	+ break;
	+ }
	+
	+ if ((size == 0) \|\| (lb_size == 0))
	+ return (0);
	+
	+ if (lb_size == 1)
	+ return (size);
	+
	+ /* round up in sectors */
	+ num_lb = (size + lb_size -1) / lb_size;
	+ return (num_lb * lb_size);
	+}
	+
	+
	+int
	+udf_fidsize(struct fileid_desc *fid)
	+{
	+ uint32_t size;
	+
	+ if (le16toh(fid->tag.id) != TAGID_FID)
	+ panic("got udf_fidsize on non FID\n");
	+
	+ size = UDF_FID_SIZE + fid->l_fi + le16toh(fid->l_iu);
	+ size = (size + 3) & ~3;
	+
	+ return (size);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+void
	+udf_lock_node(struct udf_node udf_node, int flag, char const fname, const int lineno)
	+{
	+#if 0
	+ int ret;
	+
	+ mutex_enter(&udf_node->node_mutex);
	+ /* wait until free */
	+ while (udf_node->i_flags & IN_LOCKED) {
	+ ret = cv_timedwait(&udf_node->node_lock, &udf_node->node_mutex, hz/8);
	+ /* TODO check if we should return error; abort */
	+ if (ret == EWOULDBLOCK) {
	+ DPRINTF(LOCKING, ( "udf_lock_node: udf_node %p would block "
	+ "wanted at %s:%d, previously locked at %s:%d\n",
	+ udf_node, fname, lineno,
	+ udf_node->lock_fname, udf_node->lock_lineno));
	+ }
	+ }
	+ /* grab */
	+ udf_node->i_flags \|= IN_LOCKED \| flag;
	+ /* debug */
	+ udf_node->lock_fname = fname;
	+ udf_node->lock_lineno = lineno;
	+
	+ mutex_exit(&udf_node->node_mutex);
	+#endif
	+}
	+
	+
	+void
	+udf_unlock_node(struct udf_node *udf_node, int flag)
	+{
	+#if 0
	+ mutex_enter(&udf_node->node_mutex);
	+ udf_node->i_flags &= ~(IN_LOCKED \| flag);
	+ cv_broadcast(&udf_node->node_lock);
	+ mutex_exit(&udf_node->node_mutex);
	+#endif
	+}
	+
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_read_anchor(struct udf_mount ump, uint32_t sector, struct anchor_vdp *dst)
	+{
	+ int error;
	+
	+ error = udf_read_phys_dscr(ump, sector, M_UDFTEMP,
	+ (union dscrptr **) dst);
	+ if (!error) {
	+ /* blank terminator blocks are not allowed here */
	+ if (*dst == NULL)
	+ return (ENOENT);
	+ if (le16toh((*dst)->tag.id) != TAGID_ANCHOR) {
	+ error = ENOENT;
	+ free(*dst, M_UDFTEMP);
	+ *dst = NULL;
	+ }
	+ }
	+
	+ return (error);
	+}
	+
	+void
	+udf_print_anchors(struct udf_mount *ump)
	+{
	+ struct anchor_vdp *a;
	+ int i = 0;
	+
	+ for (i = 0; ump->anchors[i] != NULL; i++) ;
	+
	+ printf("Number of anchors: %d\n", i);
	+
	+ for (i = 0; i < UDF_ANCHORS && ump->anchors[i] != NULL; i++) {
	+ a = ump->anchors[i];
	+ printf("\tTag ID: %d\n",a->tag.id);
	+ printf("\tDescriptor Version: %d\n",a->tag.descriptor_ver);
	+ printf("\tTag Serial number: %d\n", a->tag.serial_num);
	+ printf("\tTag Location: %d\n", a->tag.tag_loc);
	+
	+ printf("\tmain volumn descriptor seq extent: %d, len: %d\n",
	+ a->main_vds_ex.loc, a->main_vds_ex.len);
	+
	+ printf("\tmain volumn descriptor seq extent: %d, len: %d\n",
	+ a->reserve_vds_ex.loc, a->reserve_vds_ex.len);
	+ }
	+}
	+
	+#if 0
	+int
	+udf_last_session_info()
	+{
	+ struct udf_args *args = &ump->mount_args;
	+ struct mmc_trackinfo first_track;
	+ struct mmc_trackinfo second_track;
	+ struct mmc_trackinfo last_track;
	+ uint32_t track_start;
	+ uint32_t track_end;
	+ int first_tracknr, last_tracknr;
	+ int error;
	+
	+ /* search the first and last track of the specified session */
	+ error = udf_search_tracks(ump, args, &first_tracknr, &last_tracknr);
	+ if (!error) {
	+ first_track.tracknr = first_tracknr;
	+ error = udf_update_trackinfo(ump, &first_track);
	+ }
	+ if (!error) {
	+ last_track.tracknr = last_tracknr;
	+ error = udf_update_trackinfo(ump, &last_track);
	+ }
	+ if ((!error) && (first_tracknr != last_tracknr)) {
	+ second_track.tracknr = first_tracknr+1;
	+ error = udf_update_trackinfo(ump, &second_track);
	+ }
	+ if (error) {
	+ printf("UDF mount: reading disc geometry failed\n");
	+ return (0);
	+ }
	+
	+ track_start = first_track.track_start;
	+
	+ /* `end' is not as straitforward as start. */
	+ track_end = last_track.track_start
	+ + last_track.track_size - last_track.free_blocks - 1;
	+
	+ if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
	+ /* end of track is not straitforward here */
	+ if (last_track.flags & MMC_TRACKINFO_LRA_VALID)
	+ track_end = last_track.last_recorded;
	+ else if (last_track.flags & MMC_TRACKINFO_NWA_VALID)
	+ track_end = last_track.next_writable
	+ - ump->discinfo.link_block_penalty;
	+ }
	+
	+ /* its no use reading a blank track */
	+ if (first_track.flags & MMC_TRACKINFO_BLANK)
	+ ump->first_trackblank = 1;
	+
	+ /* get our packet size */
	+ ump->packet_size = first_track.packet_size;
	+ if (first_track.flags & MMC_TRACKINFO_BLANK)
	+ ump->packet_size = second_track.packet_size;
	+
	+ if (ump->packet_size <= 1) {
	+ /* take max, but not bigger than 64 */
	+ ump->packet_size = MAXPHYS / ump->discinfo.sector_size;
	+ ump->packet_size = MIN(ump->packet_size, 64);
	+ }
	+ KASSERT(ump->packet_size >= 1);
	+
	+ /* VATs are only recorded on sequential media, but initialise */
	+ ump->first_possible_vat_location = track_start + 2;
	+ ump->last_possible_vat_location = track_end + last_track.packet_size;
	+ ump->session_start = track_start;
	+ ump->session_end = track_end
	+}
	+#endif
	+
	+int
	+udf_read_anchors(struct udf_mount *ump)
	+{
	+ struct udf_args *args = &ump->mount_args;
	+ struct mmc_trackinfo first_track;
	+ struct mmc_trackinfo second_track;
	+ struct mmc_trackinfo last_track;
	+ struct anchor_vdp **anchorsp;
	+ uint32_t track_start;
	+ uint32_t track_end;
	+ uint32_t positions[4];
	+ int first_tracknr, last_tracknr;
	+ int error, anch, ok, first_anchor;
	+
	+ /* search the first and last track of the specified session */
	+ error = udf_search_tracks(ump, args, &first_tracknr, &last_tracknr);
	+ if (!error) {
	+ first_track.tracknr = first_tracknr;
	+ error = udf_update_trackinfo(ump, &first_track);
	+ }
	+ if (!error) {
	+ last_track.tracknr = last_tracknr;
	+ error = udf_update_trackinfo(ump, &last_track);
	+ }
	+ if ((!error) && (first_tracknr != last_tracknr)) {
	+ second_track.tracknr = first_tracknr+1;
	+ error = udf_update_trackinfo(ump, &second_track);
	+ }
	+ if (error) {
	+ printf("UDF mount: reading disc geometry failed\n");
	+ return (0);
	+ }
	+
	+ track_start = first_track.track_start;
	+
	+ /* `end' is not as straitforward as start. */
	+ track_end = last_track.track_start
	+ + last_track.track_size - last_track.free_blocks - 1;
	+
	+ if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
	+ /* end of track is not straitforward here */
	+ if (last_track.flags & MMC_TRACKINFO_LRA_VALID)
	+ track_end = last_track.last_recorded;
	+ else if (last_track.flags & MMC_TRACKINFO_NWA_VALID)
	+ track_end = last_track.next_writable
	+ - ump->discinfo.link_block_penalty;
	+ }
	+
	+ /* its no use reading a blank track */
	+ first_anchor = 0;
	+ if (first_track.flags & MMC_TRACKINFO_BLANK)
	+ first_anchor = 1;
	+
	+ /* get our packet size */
	+ ump->packet_size = first_track.packet_size;
	+ if (first_track.flags & MMC_TRACKINFO_BLANK)
	+ ump->packet_size = second_track.packet_size;
	+
	+ if (ump->packet_size <= 1) {
	+ /* take max, but not bigger than 64 */
	+ ump->packet_size = MAXPHYS / ump->discinfo.sector_size;
	+ ump->packet_size = MIN(ump->packet_size, 64);
	+ }
	+ KASSERT(ump->packet_size >= 1, ("udf_read_anchors: packet size is less than one"));
	+
	+ /* read anchors start+256, start+512, end-256, end */
	+ positions[0] = track_start+256;
	+ positions[1] = track_end-256;
	+ positions[2] = track_end;
	+ positions[3] = track_start+512; /* [UDF 2.60/6.11.2] */
	+ /* XXX shouldn't +512 be preferred above +256 for compat with Roxio CD */
	+
	+ ok = 0;
	+ anchorsp = ump->anchors;
	+ for (anch = first_anchor; anch < 4; anch++) {
	+ DPRINTF(VOLUMES, ("Read anchor %d at sector %d\n", anch,
	+ positions[anch]));
	+ error = udf_read_anchor(ump, positions[anch], anchorsp);
	+ if (!error) {
	+ anchorsp++;
	+ ok++;
	+ }
	+ }
	+
	+ /* VATs are only recorded on sequential media, but initialise */
	+ ump->first_possible_vat_location = track_start + 2;
	+ ump->last_possible_vat_location = track_end + last_track.packet_size;
	+
	+ return (ok);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+#if 0
	+int
	+udf_get_c_type(struct udf_node *udf_node)
	+{
	+ int isdir, what;
	+
	+ isdir = (udf_node->vnode->v_type == VDIR);
	+ what = isdir ? UDF_C_FIDS : UDF_C_USERDATA;
	+
	+ if (udf_node->ump)
	+ if (udf_node == udf_node->ump->metadatabitmap_node)
	+ what = UDF_C_METADATA_SBM;
	+
	+ return (what);
	+}
	+
	+
	+int
	+udf_get_record_vpart(struct udf_mount *ump, int udf_c_type)
	+{
	+ int vpart_num;
	+
	+ vpart_num = ump->data_part;
	+ if (udf_c_type == UDF_C_NODE)
	+ vpart_num = ump->node_part;
	+ if (udf_c_type == UDF_C_FIDS)
	+ vpart_num = ump->fids_part;
	+
	+ return (vpart_num);
	+}
	+#endif
	+
	+/*
	+ * BUGALERT: some rogue implementations use random physical partition
	+ * numbers to break other implementations so lookup the number.
	+ */
	+
	+static uint16_t
	+udf_find_raw_phys(struct udf_mount *ump, uint16_t raw_phys_part)
	+{
	+ struct part_desc *part;
	+ uint16_t phys_part;
	+
	+ for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
	+ part = ump->partitions[phys_part];
	+ if (part == NULL)
	+ break;
	+ if (le16toh(part->part_num) == raw_phys_part)
	+ break;
	+ }
	+ return (phys_part);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* we dont try to be smart; we just record the parts */
	+#define UDF_UPDATE_DSCR(name, dscr) \
	+ if (name) \
	+ free(name, M_UDFTEMP); \
	+ name = dscr;
	+
	+static int
	+udf_process_vds_descriptor(struct udf_mount ump, union dscrptr dscr)
	+{
	+ uint16_t phys_part, raw_phys_part;
	+
	+ DPRINTF(VOLUMES, ("\tprocessing VDS descr %d\n",
	+ le16toh(dscr->tag.id)));
	+ switch (le16toh(dscr->tag.id)) {
	+ case TAGID_PRI_VOL : /* primary partition */
	+ UDF_UPDATE_DSCR(ump->primary_vol, &dscr->pvd);
	+ break;
	+ case TAGID_LOGVOL : /* logical volume */
	+ UDF_UPDATE_DSCR(ump->logical_vol, &dscr->lvd);
	+ break;
	+ case TAGID_UNALLOC_SPACE : /* unallocated space */
	+ UDF_UPDATE_DSCR(ump->unallocated, &dscr->usd);
	+ break;
	+ case TAGID_IMP_VOL : /* implementation */
	+ /* XXX do we care about multiple impl. descr ? */
	+ UDF_UPDATE_DSCR(ump->implementation, &dscr->ivd);
	+ break;
	+ case TAGID_PARTITION : /* physical partition */
	+ /* not much use if its not allocated */
	+ if ((le16toh(dscr->pd.flags) & UDF_PART_FLAG_ALLOCATED) == 0) {
	+ free(dscr, M_UDFTEMP);
	+ break;
	+ }
	+
	+ /*
	+ * BUGALERT: some rogue implementations use random physical
	+ * partition numbers to break other implementations so lookup
	+ * the number.
	+ */
	+ raw_phys_part = le16toh(dscr->pd.part_num);
	+ phys_part = udf_find_raw_phys(ump, raw_phys_part);
	+
	+ if (phys_part == UDF_PARTITIONS) {
	+ free(dscr, M_UDFTEMP);
	+ return (EINVAL);
	+ }
	+
	+ UDF_UPDATE_DSCR(ump->partitions[phys_part], &dscr->pd);
	+ break;
	+ case TAGID_VOL : /* volume space extender; rare */
	+ DPRINTF(VOLUMES, ("VDS extender ignored\n"));
	+ free(dscr, M_UDFTEMP);
	+ break;
	+ default :
	+ DPRINTF(VOLUMES, ("Unhandled VDS type %d\n",
	+ le16toh(dscr->tag.id)));
	+ free(dscr, M_UDFTEMP);
	+ }
	+
	+ return (0);
	+}
	+#undef UDF_UPDATE_DSCR
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_read_vds_extent(struct udf_mount *ump, uint32_t loc, uint32_t len)
	+{
	+ union dscrptr *dscr;
	+ uint32_t sector_size, dscr_size;
	+ int error;
	+
	+ sector_size = ump->discinfo.sector_size;
	+
	+ /* loc is sectornr, len is in bytes */
	+ error = EIO;
	+ while (len) {
	+ error = udf_read_phys_dscr(ump, loc, M_UDFTEMP, &dscr);
	+ if (error) {
	+ if (!dscr)
	+ free(dscr, M_UDFTEMP);
	+ return (error);
	+ }
	+
	+ /* blank block is a terminator */
	+ if (dscr == NULL)
	+ return (0);
	+
	+ /* TERM descriptor is a terminator */
	+ if (le16toh(dscr->tag.id) == TAGID_TERM) {
	+ free(dscr, M_UDFTEMP);
	+ return (0);
	+ }
	+
	+ /* process all others */
	+ dscr_size = udf_tagsize(dscr, sector_size);
	+
	+ /* dscr is assigned into ump */
	+ error = udf_process_vds_descriptor(ump, dscr);
	+ if (error) {
	+ free(dscr, M_UDFTEMP);
	+ break;
	+ }
	+ KASSERT(!(dscr_size % sector_size), ("udf_read_vds_extent:"
	+ "wrong descriptor sze"));
	+ len -= dscr_size;
	+ loc += dscr_size / sector_size;
	+ }
	+
	+ return (error);
	+}
	+
	+
	+int
	+udf_read_vds_space(struct udf_mount *ump)
	+{
	+ /* struct udf_args args = &ump->mount_args; /
	+ struct anchor_vdp anchor, anchor2;
	+ size_t size;
	+ int error;
	+ uint32_t main_loc, main_len, reserve_loc, reserve_len;
	+
	+ /*
	+ * read in VDS space provided by the anchors; if one descriptor read
	+ * fails, try the mirror sector.
	+ *
	+ * check if 2nd anchor is different from 1st; if so, go for 2nd. This
	+ * avoids the `compatibility features' of DirectCD that may confuse
	+ * stuff completely.
	+ */
	+
	+ anchor = ump->anchors[0];
	+ anchor2 = ump->anchors[1];
	+ KASSERT(anchor, ("udf_read_vds_space: anchor is not valid"));
	+
	+ if (anchor2) {
	+ size = sizeof(struct extent_ad);
	+ if (memcmp(&anchor->main_vds_ex, &anchor2->main_vds_ex, size))
	+ anchor = anchor2;
	+ /* reserve is specified to be a literal copy of main */
	+ }
	+
	+ main_loc = le32toh(anchor->main_vds_ex.loc);
	+ main_len = le32toh(anchor->main_vds_ex.len);
	+
	+ reserve_loc = le32toh(anchor->reserve_vds_ex.loc);
	+ reserve_len = le32toh(anchor->reserve_vds_ex.len);
	+
	+ error = udf_read_vds_extent(ump, main_loc, main_len);
	+ if (error) {
	+ printf("UDF mount: reading in reserve VDS extent\n");
	+ error = udf_read_vds_extent(ump, reserve_loc, reserve_len);
	+ }
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Read in the logical volume integrity sequence pointed to by our logical
	+ * volume descriptor. Its a sequence that can be extended using fields in the
	+ * integrity descriptor itself. On sequential media only one is found, on
	+ * rewritable media a sequence of descriptors can be found as a form of
	+ * history keeping and on non sequential write-once media the chain is vital
	+ * to allow more and more descriptors to be written. The last descriptor
	+ * written in an extent needs to claim space for a new extent.
	+ */
	+
	+static int
	+udf_retrieve_lvint(struct udf_mount *ump)
	+{
	+ union dscrptr *dscr;
	+ struct logvol_int_desc *lvint;
	+ struct udf_lvintq *trace;
	+ int dscr_type, error, trace_len;
	+ uint32_t lb_size, lbnum, len;
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ len = le32toh(ump->logical_vol->integrity_seq_loc.len);
	+ lbnum = le32toh(ump->logical_vol->integrity_seq_loc.loc);
	+
	+ /* clean trace */
	+ memset(ump->lvint_trace, 0,
	+ UDF_LVDINT_SEGMENTS * sizeof(struct udf_lvintq));
	+
	+ trace_len = 0;
	+ trace = ump->lvint_trace;
	+ trace->start = lbnum;
	+ trace->end = lbnum + len/lb_size;
	+ trace->pos = 0;
	+ trace->wpos = 0;
	+
	+ lvint = NULL;
	+ dscr = NULL;
	+ error = 0;
	+ while (len) {
	+ trace->pos = lbnum - trace->start;
	+ trace->wpos = trace->pos + 1;
	+
	+ /* read in our integrity descriptor */
	+ error = udf_read_phys_dscr(ump, lbnum, M_UDFTEMP, &dscr);
	+ if (!error) {
	+ if (dscr == NULL) {
	+ trace->wpos = trace->pos;
	+ break; /* empty terminates */
	+ }
	+ dscr_type = le16toh(dscr->tag.id);
	+ if (dscr_type == TAGID_TERM) {
	+ trace->wpos = trace->pos;
	+ break; /* clean terminator */
	+ }
	+ if (dscr_type != TAGID_LOGVOL_INTEGRITY) {
	+ /* fatal... corrupt disc */
	+ error = ENOENT;
	+ break;
	+ }
	+ if (lvint)
	+ free(lvint, M_UDFTEMP);
	+ lvint = &dscr->lvid;
	+ dscr = NULL;
	+ } /* else hope for the best... maybe the next is ok */
	+
	+ DPRINTFIF(VOLUMES, lvint, ("logvol integrity read, state %s\n",
	+ le32toh(lvint->integrity_type) ? "CLOSED" : "OPEN"));
	+
	+ /* proceed sequential */
	+ lbnum += 1;
	+ len -= lb_size;
	+
	+ /* are we linking to a new piece? */
	+ if (dscr && lvint->next_extent.len) {
	+ len = le32toh(lvint->next_extent.len);
	+ lbnum = le32toh(lvint->next_extent.loc);
	+
	+ if (trace_len >= UDF_LVDINT_SEGMENTS-1) {
	+ /* IEK! segment link full... */
	+ DPRINTF(VOLUMES, ("lvdint segments full\n"));
	+ error = EINVAL;
	+ } else {
	+ trace++;
	+ trace_len++;
	+
	+ trace->start = lbnum;
	+ trace->end = lbnum + len/lb_size;
	+ trace->pos = 0;
	+ trace->wpos = 0;
	+ }
	+ }
	+ }
	+
	+ /* clean up the mess, esp. when there is an error */
	+ if (dscr)
	+ free(dscr, M_UDFTEMP);
	+
	+ if (error && lvint) {
	+ free(lvint, M_UDFTEMP);
	+ lvint = NULL;
	+ }
	+
	+ if (!lvint)
	+ error = ENOENT;
	+
	+ ump->logvol_integrity = lvint;
	+ return (error);
	+}
	+
	+#if 0
	+static int
	+udf_loose_lvint_history(struct udf_mount *ump)
	+{
	+ union dscrptr *bufs, dscr, *last_dscr;
	+ struct udf_lvintq trace, in_trace, *out_trace;
	+ struct logvol_int_desc *lvint;
	+ uint32_t in_ext, in_pos, in_len;
	+ uint32_t out_ext, out_wpos, out_len;
	+ uint32_t lb_size, packet_size, lb_num;
	+ uint32_t len, start;
	+ int ext, minext, extlen, cnt, cpy_len, dscr_type;
	+ int losing;
	+ int error;
	+
	+ DPRINTF(VOLUMES, ("need to lose some lvint history\n"));
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ packet_size = ump->data_track.packet_size; /* XXX data track */
	+
	+ /* search smallest extent */
	+ trace = &ump->lvint_trace[0];
	+ minext = trace->end - trace->start;
	+ for (ext = 1; ext < UDF_LVDINT_SEGMENTS; ext++) {
	+ trace = &ump->lvint_trace[ext];
	+ extlen = trace->end - trace->start;
	+ if (extlen == 0)
	+ break;
	+ minext = MIN(minext, extlen);
	+ }
	+ losing = MIN(minext, UDF_LVINT_LOSSAGE);
	+ /* no sense wiping all */
	+ if (losing == minext)
	+ losing--;
	+
	+ DPRINTF(VOLUMES, ("\tlosing %d entries\n", losing));
	+
	+ /* get buffer for pieces */
	+ bufs = malloc(UDF_LVDINT_SEGMENTS * sizeof(void *), M_UDFTEMP, M_WAITOK);
	+
	+ in_ext = 0;
	+ in_pos = losing;
	+ in_trace = &ump->lvint_trace[in_ext];
	+ in_len = in_trace->end - in_trace->start;
	+ out_ext = 0;
	+ out_wpos = 0;
	+ out_trace = &ump->lvint_trace[out_ext];
	+ out_len = out_trace->end - out_trace->start;
	+
	+ last_dscr = NULL;
	+ for(;;) {
	+ out_trace->pos = out_wpos;
	+ out_trace->wpos = out_trace->pos;
	+ if (in_pos >= in_len) {
	+ in_ext++;
	+ in_pos = 0;
	+ in_trace = &ump->lvint_trace[in_ext];
	+ in_len = in_trace->end - in_trace->start;
	+ }
	+ if (out_wpos >= out_len) {
	+ out_ext++;
	+ out_wpos = 0;
	+ out_trace = &ump->lvint_trace[out_ext];
	+ out_len = out_trace->end - out_trace->start;
	+ }
	+ /* copy overlap contents */
	+ cpy_len = MIN(in_len - in_pos, out_len - out_wpos);
	+ cpy_len = MIN(cpy_len, in_len - in_trace->pos);
	+ if (cpy_len == 0)
	+ break;
	+
	+ /* copy */
	+ DPRINTF(VOLUMES, ("\treading %d lvid descriptors\n", cpy_len));
	+ for (cnt = 0; cnt < cpy_len; cnt++) {
	+ /* read in our integrity descriptor */
	+ lb_num = in_trace->start + in_pos + cnt;
	+ error = udf_read_phys_dscr(ump, lb_num, M_UDFTEMP,
	+ &dscr);
	+ if (error) {
	+ /* copy last one */
	+ dscr = last_dscr;
	+ }
	+ bufs[cnt] = dscr;
	+ if (!error) {
	+ if (dscr == NULL) {
	+ out_trace->pos = out_wpos + cnt;
	+ out_trace->wpos = out_trace->pos;
	+ break; /* empty terminates */
	+ }
	+ dscr_type = le16toh(dscr->tag.id);
	+ if (dscr_type == TAGID_TERM) {
	+ out_trace->pos = out_wpos + cnt;
	+ out_trace->wpos = out_trace->pos;
	+ break; /* clean terminator */
	+ }
	+ if (dscr_type != TAGID_LOGVOL_INTEGRITY) {
	+ panic( "UDF integrity sequence "
	+ "corrupted while mounted!\n");
	+ }
	+ last_dscr = dscr;
	+ }
	+ }
	+
	+ /* patch up if first entry was on error */
	+ if (bufs[0] == NULL) {
	+ for (cnt = 0; cnt < cpy_len; cnt++)
	+ if (bufs[cnt] != NULL)
	+ break;
	+ last_dscr = bufs[cnt];
	+ for (; cnt > 0; cnt--) {
	+ bufs[cnt] = last_dscr;
	+ }
	+ }
	+
	+ /* glue + write out */
	+ DPRINTF(VOLUMES, ("\twriting %d lvid descriptors\n", cpy_len));
	+ for (cnt = 0; cnt < cpy_len; cnt++) {
	+ lb_num = out_trace->start + out_wpos + cnt;
	+ lvint = &bufs[cnt]->lvid;
	+
	+ /* set continuation */
	+ len = 0;
	+ start = 0;
	+ if (out_wpos + cnt == out_len) {
	+ /* get continuation */
	+ trace = &ump->lvint_trace[out_ext+1];
	+ len = trace->end - trace->start;
	+ start = trace->start;
	+ }
	+ lvint->next_extent.len = htole32(len);
	+ lvint->next_extent.loc = htole32(start);
	+
	+ lb_num = trace->start + trace->wpos;
	+ error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
	+ bufs[cnt], lb_num, lb_num);
	+ DPRINTFIF(VOLUMES, error,
	+ ("error writing lvint lb_num\n"));
	+ }
	+
	+ /* free non repeating descriptors */
	+ last_dscr = NULL;
	+ for (cnt = 0; cnt < cpy_len; cnt++) {
	+ if (bufs[cnt] != last_dscr)
	+ free(bufs[cnt], M_UDFTEMP);
	+ last_dscr = bufs[cnt];
	+ }
	+
	+ /* advance */
	+ in_pos += cpy_len;
	+ out_wpos += cpy_len;
	+ }
	+
	+ free(bufs, M_UDFTEMP);
	+
	+ return (0);
	+}
	+
	+
	+static int
	+udf_writeout_lvint(struct udf_mount *ump, int lvflag)
	+{
	+ struct udf_lvintq *trace;
	+ struct timeval now_v;
	+ struct timespec now_s;
	+ uint32_t sector;
	+ int logvol_integrity;
	+ int space, error;
	+
	+ DPRINTF(VOLUMES, ("writing out logvol integrity descriptor\n"));
	+
	+again:
	+ /* get free space in last chunk */
	+ trace = ump->lvint_trace;
	+ while (trace->wpos > (trace->end - trace->start)) {
	+ DPRINTF(VOLUMES, ("skip : start = %d, end = %d, pos = %d, "
	+ "wpos = %d\n", trace->start, trace->end,
	+ trace->pos, trace->wpos));
	+ trace++;
	+ }
	+
	+ /* check if there is space to append */
	+ space = (trace->end - trace->start) - trace->wpos;
	+ DPRINTF(VOLUMES, ("write start = %d, end = %d, pos = %d, wpos = %d, "
	+ "space = %d\n", trace->start, trace->end, trace->pos,
	+ trace->wpos, space));
	+
	+ /* get state */
	+ logvol_integrity = le32toh(ump->logvol_integrity->integrity_type);
	+ if (logvol_integrity == UDF_INTEGRITY_CLOSED) {
	+ if ((space < 3) && (lvflag & UDF_APPENDONLY_LVINT)) {
	+ /* don't allow this logvol to be opened */
	+ /* TODO extent LVINT space if possible */
	+ return (EROFS);
	+ }
	+ }
	+
	+ if (space < 1) {
	+ if (lvflag & UDF_APPENDONLY_LVINT)
	+ return (EROFS);
	+ /* loose history by re-writing extents */
	+ error = udf_loose_lvint_history(ump);
	+ if (error)
	+ return (error);
	+ goto again;
	+ }
	+
	+ /* update our integrity descriptor to identify us and timestamp it */
	+ DPRINTF(VOLUMES, ("updating integrity descriptor\n"));
	+ microtime(&now_v);
	+ TIMEVAL_TO_TIMESPEC(&now_v, &now_s);
	+ udf_timespec_to_timestamp(&now_s, &ump->logvol_integrity->time);
	+ udf_set_regid(&ump->logvol_info->impl_id, IMPL_NAME);
	+ udf_add_impl_regid(ump, &ump->logvol_info->impl_id);
	+
	+ /* writeout integrity descriptor */
	+ sector = trace->start + trace->wpos;
	+ error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
	+ (union dscrptr *) ump->logvol_integrity,
	+ sector, sector);
	+ DPRINTF(VOLUMES, ("writeout lvint : error = %d\n", error));
	+ if (error)
	+ return (error);
	+
	+ /* advance write position */
	+ trace->wpos++; space--;
	+ if (space >= 1) {
	+ /* append terminator */
	+ sector = trace->start + trace->wpos;
	+ error = udf_write_terminator(ump, sector);
	+
	+ DPRINTF(VOLUMES, ("write terminator : error = %d\n", error));
	+ }
	+
	+ space = (trace->end - trace->start) - trace->wpos;
	+ DPRINTF(VOLUMES, ("write start = %d, end = %d, pos = %d, wpos = %d, "
	+ "space = %d\n", trace->start, trace->end, trace->pos,
	+ trace->wpos, space));
	+ DPRINTF(VOLUMES, ("finished writing out logvol integrity descriptor "
	+ "successfull\n"));
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_read_physical_partition_spacetables(struct udf_mount *ump)
	+{
	+ union dscrptr *dscr;
	+ /* struct udf_args args = &ump->mount_args; /
	+ struct part_desc *partd;
	+ struct part_hdr_desc *parthdr;
	+ struct udf_bitmap *bitmap;
	+ uint32_t phys_part;
	+ uint32_t lb_num, len;
	+ int error, dscr_type;
	+
	+ /* unallocated space map */
	+ for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
	+ partd = ump->partitions[phys_part];
	+ if (partd == NULL)
	+ continue;
	+ parthdr = &partd->_impl_use.part_hdr;
	+
	+ lb_num = le32toh(partd->start_loc);
	+ lb_num += le32toh(parthdr->unalloc_space_bitmap.lb_num);
	+ len = le32toh(parthdr->unalloc_space_bitmap.len);
	+ if (len == 0)
	+ continue;
	+
	+ DPRINTF(VOLUMES, ("Read unalloc. space bitmap %d\n", lb_num));
	+ error = udf_read_phys_dscr(ump, lb_num, M_UDFTEMP, &dscr);
	+ if (!error && dscr) {
	+ /* analyse */
	+ dscr_type = le16toh(dscr->tag.id);
	+ if (dscr_type == TAGID_SPACE_BITMAP) {
	+ DPRINTF(VOLUMES, ("Accepting space bitmap\n"));
	+ ump->part_unalloc_dscr[phys_part] = &dscr->sbd;
	+
	+ /* fill in ump->part_unalloc_bits */
	+ bitmap = &ump->part_unalloc_bits[phys_part];
	+ bitmap->blob = (uint8_t *) dscr;
	+ bitmap->bits = dscr->sbd.data;
	+ bitmap->max_offset = le32toh(dscr->sbd.num_bits);
	+ bitmap->pages = NULL; /* TODO */
	+ bitmap->data_pos = 0;
	+ bitmap->metadata_pos = 0;
	+ } else {
	+ free(dscr, M_UDFTEMP);
	+
	+ printf( "UDF mount: error reading unallocated "
	+ "space bitmap\n");
	+ return (EROFS);
	+ }
	+ } else {
	+ /* blank not allowed */
	+ printf("UDF mount: blank unallocated space bitmap\n");
	+ return (EROFS);
	+ }
	+ }
	+
	+ /* unallocated space table (not supported) */
	+ for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
	+ partd = ump->partitions[phys_part];
	+ if (partd == NULL)
	+ continue;
	+ parthdr = &partd->_impl_use.part_hdr;
	+
	+ len = le32toh(parthdr->unalloc_space_table.len);
	+ if (len) {
	+ printf("UDF mount: space tables not supported\n");
	+ return (EROFS);
	+ }
	+ }
	+
	+ /* freed space map */
	+ for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
	+ partd = ump->partitions[phys_part];
	+ if (partd == NULL)
	+ continue;
	+ parthdr = &partd->_impl_use.part_hdr;
	+
	+ /* freed space map */
	+ lb_num = le32toh(partd->start_loc);
	+ lb_num += le32toh(parthdr->freed_space_bitmap.lb_num);
	+ len = le32toh(parthdr->freed_space_bitmap.len);
	+ if (len == 0)
	+ continue;
	+
	+ DPRINTF(VOLUMES, ("Read unalloc. space bitmap %d\n", lb_num));
	+ error = udf_read_phys_dscr(ump, lb_num, M_UDFTEMP, &dscr);
	+ if (!error && dscr) {
	+ /* analyse */
	+ dscr_type = le16toh(dscr->tag.id);
	+ if (dscr_type == TAGID_SPACE_BITMAP) {
	+ DPRINTF(VOLUMES, ("Accepting space bitmap\n"));
	+ ump->part_freed_dscr[phys_part] = &dscr->sbd;
	+
	+ /* fill in ump->part_freed_bits */
	+ bitmap = &ump->part_unalloc_bits[phys_part];
	+ bitmap->blob = (uint8_t *) dscr;
	+ bitmap->bits = dscr->sbd.data;
	+ bitmap->max_offset = le32toh(dscr->sbd.num_bits);
	+ bitmap->pages = NULL; /* TODO */
	+ bitmap->data_pos = 0;
	+ bitmap->metadata_pos = 0;
	+ } else {
	+ free(dscr, M_UDFTEMP);
	+
	+ printf( "UDF mount: error reading freed "
	+ "space bitmap\n");
	+ return (EROFS);
	+ }
	+ } else {
	+ /* blank not allowed */
	+ printf("UDF mount: blank freed space bitmap\n");
	+ return (EROFS);
	+ }
	+ }
	+
	+ /* freed space table (not supported) */
	+ for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
	+ partd = ump->partitions[phys_part];
	+ if (partd == NULL)
	+ continue;
	+ parthdr = &partd->_impl_use.part_hdr;
	+
	+ len = le32toh(parthdr->freed_space_table.len);
	+ if (len) {
	+ printf("UDF mount: space tables not supported\n");
	+ return (EROFS);
	+ }
	+ }
	+
	+ return (0);
	+}
	+
	+
	+/* TODO implement async writeout */
	+int
	+udf_write_physical_partition_spacetables(struct udf_mount *ump, int waitfor)
	+{
	+ union dscrptr *dscr;
	+ /* struct udf_args args = &ump->mount_args; /
	+ struct part_desc *partd;
	+ struct part_hdr_desc *parthdr;
	+ uint32_t phys_part;
	+ uint32_t lb_num, len, ptov;
	+ int error_all, error;
	+
	+ error_all = 0;
	+ /* unallocated space map */
	+ for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
	+ partd = ump->partitions[phys_part];
	+ if (partd == NULL)
	+ continue;
	+ parthdr = &partd->_impl_use.part_hdr;
	+
	+ ptov = le32toh(partd->start_loc);
	+ lb_num = le32toh(parthdr->unalloc_space_bitmap.lb_num);
	+ len = le32toh(parthdr->unalloc_space_bitmap.len);
	+ if (len == 0)
	+ continue;
	+
	+ DPRINTF(VOLUMES, ("Write unalloc. space bitmap %d\n",
	+ lb_num + ptov));
	+ dscr = (union dscrptr *) ump->part_unalloc_dscr[phys_part];
	+ error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
	+ (union dscrptr *) dscr,
	+ ptov + lb_num, lb_num);
	+ if (error) {
	+ DPRINTF(VOLUMES, ("\tfailed!! (error %d)\n", error));
	+ error_all = error;
	+ }
	+ }
	+
	+ /* freed space map */
	+ for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
	+ partd = ump->partitions[phys_part];
	+ if (partd == NULL)
	+ continue;
	+ parthdr = &partd->_impl_use.part_hdr;
	+
	+ /* freed space map */
	+ ptov = le32toh(partd->start_loc);
	+ lb_num = le32toh(parthdr->freed_space_bitmap.lb_num);
	+ len = le32toh(parthdr->freed_space_bitmap.len);
	+ if (len == 0)
	+ continue;
	+
	+ DPRINTF(VOLUMES, ("Write freed space bitmap %d\n",
	+ lb_num + ptov));
	+ dscr = (union dscrptr *) ump->part_freed_dscr[phys_part];
	+ error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
	+ (union dscrptr *) dscr,
	+ ptov + lb_num, lb_num);
	+ if (error) {
	+ DPRINTF(VOLUMES, ("\tfailed!! (error %d)\n", error));
	+ error_all = error;
	+ }
	+ }
	+
	+ return (error_all);
	+}
	+#endif
	+
	+#if 0
	+static int
	+udf_read_metadata_partition_spacetable(struct udf_mount *ump)
	+{
	+ struct udf_node *bitmap_node;
	+ union dscrptr *dscr;
	+ struct udf_bitmap *bitmap;
	+ uint64_t inflen;
	+ int error, dscr_type;
	+
	+ bitmap_node = ump->metadatabitmap_node;
	+
	+ /* only read in when metadata bitmap node is read in */
	+ if (bitmap_node == NULL)
	+ return (0);
	+
	+ if (bitmap_node->fe) {
	+ inflen = le64toh(bitmap_node->fe->inf_len);
	+ } else {
	+ KASSERT(bitmap_node->efe, "error occured here");
	+ inflen = le64toh(bitmap_node->efe->inf_len);
	+ }
	+
	+ DPRINTF(VOLUMES, ("Reading metadata space bitmap for "
	+ "%"PRIu64" bytes\n", inflen));
	+
	+ /* allocate space for bitmap */
	+ dscr = malloc(inflen, M_UDFTEMP, M_WAITOK); /M_CANFAIL was removed from third param/
	+ if (!dscr)
	+ return (ENOMEM);
	+
	+ /* set vnode type to regular file or we can't read from it! */
	+ bitmap_node->vnode->v_type = VREG;
	+
	+ /* read in complete metadata bitmap file */
	+ error = udf_read_node(bitmap_node, (uint8_t *)dscr, 0, inflen);
	+ /*error = vn_rdwr(UIO_READ, bitmap_node->vnode,
	+ dscr,
	+ inflen, 0,
	+ UIO_SYSSPACE,
	+ IO_SYNC \| IO_NODELOCKED \| IO_ALTSEMANTICS, FSCRED,
	+ NULL, NULL);*/
	+ if (error) {
	+ DPRINTF(VOLUMES, ("Error reading metadata space bitmap\n"));
	+ goto errorout;
	+ }
	+
	+ /* analyse */
	+ dscr_type = le16toh(dscr->tag.id);
	+ if (dscr_type == TAGID_SPACE_BITMAP) {
	+ DPRINTF(VOLUMES, ("Accepting metadata space bitmap\n"));
	+ ump->metadata_unalloc_dscr = &dscr->sbd;
	+
	+ /* fill in bitmap bits */
	+ bitmap = &ump->metadata_unalloc_bits;
	+ bitmap->blob = (uint8_t *) dscr;
	+ bitmap->bits = dscr->sbd.data;
	+ bitmap->max_offset = le32toh(dscr->sbd.num_bits);
	+ bitmap->pages = NULL; /* TODO */
	+ bitmap->data_pos = 0;
	+ bitmap->metadata_pos = 0;
	+ } else {
	+ DPRINTF(VOLUMES, ("No valid bitmap found!\n"));
	+ goto errorout;
	+ }
	+
	+ return (0);
	+
	+errorout:
	+ free(dscr, M_UDFTEMP);
	+ printf( "UDF mount: error reading unallocated "
	+ "space bitmap for metadata partition\n");
	+ return (EROFS);
	+}
	+
	+
	+int
	+udf_write_metadata_partition_spacetable(struct udf_mount *ump, int waitfor)
	+{
	+ struct udf_node *bitmap_node;
	+ union dscrptr *dscr;
	+ uint64_t inflen, new_inflen;
	+ int dummy, error;
	+
	+ bitmap_node = ump->metadatabitmap_node;
	+
	+ /* only write out when metadata bitmap node is known */
	+ if (bitmap_node == NULL)
	+ return (0);
	+
	+ if (bitmap_node->fe) {
	+ inflen = le64toh(bitmap_node->fe->inf_len);
	+ } else {
	+ KASSERT(bitmap_node->efe);
	+ inflen = le64toh(bitmap_node->efe->inf_len);
	+ }
	+
	+ /* reduce length to zero */
	+ dscr = (union dscrptr *) ump->metadata_unalloc_dscr;
	+ new_inflen = udf_tagsize(dscr, 1);
	+
	+ DPRINTF(VOLUMES, ("Resize and write out metadata space bitmap from "
	+ "%"PRIu64" to %"PRIu64" bytes\n", inflen, new_inflen));
	+
	+ error = udf_resize_node(bitmap_node, new_inflen, &dummy);
	+ if (error)
	+ printf("Error resizing metadata space bitmap\n");
	+
	+ error = vn_rdwr(UIO_WRITE, bitmap_node->vnode,
	+ dscr,
	+ new_inflen, 0,
	+ UIO_SYSSPACE,
	+ IO_NODELOCKED \| IO_ALTSEMANTICS, FSCRED,
	+ NULL, NULL);
	+
	+ bitmap_node->i_flags \|= IN_MODIFIED;
	+ vflushbuf(bitmap_node->vnode, 1 /* sync */);
	+
	+ error = VOP_FSYNC(bitmap_node->vnode,
	+ FSCRED, FSYNC_WAIT, 0, 0);
	+
	+ if (error)
	+ printf( "Error writing out metadata partition unalloced "
	+ "space bitmap!\n");
	+
	+ return (error);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Checks if ump's vds information is correct and complete
	+ */
	+
	+int
	+udf_process_vds(struct udf_mount *ump) {
	+ /* struct udf_args args = &ump->mount_args; /
	+ union udf_pmap *mapping;
	+ struct logvol_int_desc *lvint;
	+ struct udf_logvol_info *lvinfo;
	+ int pmap_stype, pmap_size, pmap_type, log_part, phys_part, error;
	+ int raw_phys_part, maps_on, len;
	+ int n_phys, n_virt, n_spar, n_meta;
	+ uint32_t n_pm, mt_l;
	+ char domain_name, map_name; /* bits[128]; */
	+ const char *check_name;
	+ uint8_t *pmap_pos;
	+
	+ if (ump == NULL)
	+ return (ENOENT);
	+
	+ /* we need at least an anchor (trivial, but for safety) */
	+ if (ump->anchors[0] == NULL)
	+ return (EINVAL);
	+
	+ /* we need at least one primary and one logical volume descriptor */
	+ if ((ump->primary_vol == NULL) \|\| (ump->logical_vol) == NULL)
	+ return (EINVAL);
	+
	+ /* we need at least one partition descriptor */
	+ if (ump->partitions[0] == NULL)
	+ return (EINVAL);
	+
	+/*
	+Check that character set is correct?
	+
	+ chsp = &ump->logical_vol->desc_charset;
	+ is_osta_typ0 = (chsp->type == 0);
	+ is_osta_typ0 &= (strcmp((char *) chsp->inf, osta_id) == 0);
	+*/
	+
	+ /* check logical volume sector size verses device sector size */
	+ if (le32toh(ump->logical_vol->lb_size) != ump->discinfo.sector_size) {
	+ printf("UDF mount: format violation, lb_size != sector size\n");
	+ return (EINVAL);
	+ }
	+
	+ /* check domain name */
	+ domain_name = ump->logical_vol->domain_id.id;
	+ if (strncmp(domain_name, "*OSTA UDF Compliant", 20)) {
	+ printf("mount_udf: disc not OSTA UDF Compliant, aborting\n");
	+ return (EINVAL);
	+ }
	+
	+ /* retrieve logical volume integrity sequence */
	+ error = udf_retrieve_lvint(ump);
	+ if (error != 0)
	+ return (EINVAL); // previously it always returned this on error.
	+
	+ /*
	+ * We need at least one logvol integrity descriptor recorded. Note
	+ * that its OK to have an open logical volume integrity here. The VAT
	+ * will close/update the integrity.
	+ */
	+ if (ump->logvol_integrity == NULL)
	+ return (EINVAL);
	+
	+ /* process derived structures */
	+ n_pm = le32toh(ump->logical_vol->n_pm); /* num partmaps */
	+ lvint = ump->logvol_integrity;
	+ lvinfo = (struct udf_logvol_info ) (&lvint->tables[2 n_pm]);
	+ ump->logvol_info = lvinfo;
	+
	+ /* TODO check udf versions? */
	+
	+ /*
	+ * check logvol mappings: effective virt->log partmap translation
	+ * check and recording of the mapping results. Saves expensive
	+ * strncmp() in tight places.
	+ */
	+ DPRINTF(VOLUMES, ("checking logvol mappings\n"));
	+ n_pm = le32toh(ump->logical_vol->n_pm); /* num partmaps */
	+ mt_l = le32toh(ump->logical_vol->mt_l); /* partmaps data length */
	+ pmap_pos = ump->logical_vol->maps;
	+
	+ if (n_pm > UDF_PMAPS) {
	+ printf("UDF mount: too many mappings\n");
	+ return (EINVAL);
	+ }
	+
	+ /* count types and set partition numbers */
	+ ump->data_part = ump->node_part = ump->fids_part = 0;
	+ n_phys = n_virt = n_spar = n_meta = 0;
	+ for (log_part = 0; log_part < n_pm; log_part++) {
	+ mapping = (union udf_pmap *) pmap_pos;
	+ pmap_stype = pmap_pos[0];
	+ pmap_size = pmap_pos[1];
	+
	+ switch (pmap_stype) {
	+ case 1: /* physical mapping */
	+ /* volseq = le16toh(mapping->pm1.vol_seq_num); */
	+ raw_phys_part = le16toh(mapping->pm1.part_num);
	+ pmap_type = UDF_VTOP_TYPE_PHYS;
	+ n_phys++;
	+ ump->data_part = log_part;
	+ ump->node_part = log_part;
	+ ump->fids_part = log_part;
	+ break;
	+ case 2: /* virtual/sparable/meta mapping */
	+ map_name = mapping->pm2.part_id.id;
	+ /* volseq = le16toh(mapping->pm2.vol_seq_num); */
	+ raw_phys_part = le16toh(mapping->pm2.part_num);
	+ pmap_type = UDF_VTOP_TYPE_UNKNOWN;
	+ len = UDF_REGID_ID_SIZE;
	+
	+ check_name = "*UDF Virtual Partition";
	+ if (strncmp(map_name, check_name, len) == 0) {
	+ pmap_type = UDF_VTOP_TYPE_VIRT;
	+ n_virt++;
	+ ump->node_part = log_part;
	+ break;
	+ }
	+ check_name = "*UDF Sparable Partition";
	+ if (strncmp(map_name, check_name, len) == 0) {
	+ pmap_type = UDF_VTOP_TYPE_SPARABLE;
	+ n_spar++;
	+ ump->data_part = log_part;
	+ ump->node_part = log_part;
	+ ump->fids_part = log_part;
	+ break;
	+ }
	+ check_name = "*UDF Metadata Partition";
	+ if (strncmp(map_name, check_name, len) == 0) {
	+ /* printf("UDF Metadata Partition\n"); /
	+ pmap_type = UDF_VTOP_TYPE_META;
	+ n_meta++;
	+ ump->node_part = log_part;
	+ ump->fids_part = log_part;
	+ break;
	+ }
	+ break;
	+ default:
	+ return (EINVAL);
	+ }
	+
	+ /*
	+ * BUGALERT: some rogue implementations use random physical
	+ * partition numbers to break other implementations so lookup
	+ * the number.
	+ */
	+ phys_part = udf_find_raw_phys(ump, raw_phys_part);
	+
	+ DPRINTF(VOLUMES, ("\t%d -> %d(%d) type %d\n", log_part,
	+ raw_phys_part, phys_part, pmap_type));
	+
	+ if (phys_part == UDF_PARTITIONS)
	+ return (EINVAL);
	+ if (pmap_type == UDF_VTOP_TYPE_UNKNOWN)
	+ return (EINVAL);
	+
	+ ump->vtop [log_part] = phys_part;
	+ ump->vtop_tp[log_part] = pmap_type;
	+
	+ pmap_pos += pmap_size;
	+ }
	+ /* not winning the beauty contest */
	+ ump->vtop_tp[UDF_VTOP_RAWPART] = UDF_VTOP_TYPE_RAW;
	+
	+ /* test some basic UDF assertions/requirements */
	+ if ((n_virt > 1) \|\| (n_spar > 1) \|\| (n_meta > 1))
	+ return (EINVAL);
	+
	+ if (n_virt) {
	+ if ((n_phys == 0) \|\| n_spar \|\| n_meta)
	+ return (EINVAL);
	+ }
	+ if (n_spar + n_phys == 0)
	+ return (EINVAL);
	+
	+ /* select allocation type for each logical partition */
	+ for (log_part = 0; log_part < n_pm; log_part++) {
	+ maps_on = ump->vtop[log_part];
	+ switch (ump->vtop_tp[log_part]) {
	+ case UDF_VTOP_TYPE_PHYS :
	+ KASSERT(maps_on == log_part, ("udf_process_vds: logical"
	+ "partition do not equal vpartnr translations\n"));
	+ ump->vtop_alloc[log_part] = UDF_ALLOC_SPACEMAP;
	+ break;
	+ case UDF_VTOP_TYPE_VIRT :
	+ ump->vtop_alloc[log_part] = UDF_ALLOC_VAT;
	+ ump->vtop_alloc[maps_on] = UDF_ALLOC_SEQUENTIAL;
	+ break;
	+ case UDF_VTOP_TYPE_SPARABLE :
	+ KASSERT(maps_on == log_part, ("udf_process_vds: logical"
	+ "partition do not equal vpartnr translations\n"));
	+ ump->vtop_alloc[log_part] = UDF_ALLOC_SPACEMAP;
	+ break;
	+ case UDF_VTOP_TYPE_META :
	+ ump->vtop_alloc[log_part] = UDF_ALLOC_METABITMAP;
	+ if (ump->discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE) {
	+ /* special case for UDF 2.60 */
	+ ump->vtop_alloc[log_part] = UDF_ALLOC_METASEQUENTIAL;
	+ ump->vtop_alloc[maps_on] = UDF_ALLOC_SEQUENTIAL;
	+ }
	+ break;
	+ default:
	+ panic("bad alloction type in udf's ump->vtop\n");
	+ }
	+ }
	+
	+ /* determine logical volume open/closure actions */
	+#if 0
	+ if (n_virt) {
	+ ump->lvopen = 0;
	+ if (ump->discinfo.last_session_state == MMC_STATE_EMPTY)
	+ ump->lvopen \|= UDF_OPEN_SESSION ;
	+ ump->lvclose = UDF_WRITE_VAT;
	+ if (ump->mount_args.udfmflags & UDFMNT_CLOSESESSION)
	+ ump->lvclose \|= UDF_CLOSE_SESSION;
	+ } else {
	+ /* `normal' rewritable or non sequential media */
	+ ump->lvopen = UDF_WRITE_LVINT;
	+ ump->lvclose = UDF_WRITE_LVINT;
	+ if ((ump->discinfo.mmc_cur & MMC_CAP_REWRITABLE) == 0)
	+ ump->lvopen \|= UDF_APPENDONLY_LVINT;
	+ }
	+#endif
	+
	+ /*
	+ * Determine sheduler error behaviour. For virtual partitions, update
	+ * the trackinfo; for sparable partitions replace a whole block on the
	+ * sparable table. Allways requeue.
	+ */
	+ ump->lvreadwrite = 0;
	+ if (n_virt)
	+ ump->lvreadwrite = UDF_UPDATE_TRACKINFO;
	+ if (n_spar)
	+ ump->lvreadwrite = UDF_REMAP_BLOCK;
	+
	+#if 0
	+ /*
	+ * Select our scheduler
	+ */
	+ ump->strategy = &udf_strat_rmw;
	+ if (n_virt \|\| (ump->discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE))
	+ ump->strategy = &udf_strat_sequential;
	+ if ((ump->discinfo.mmc_class == MMC_CLASS_DISC) \|\|
	+ (ump->discinfo.mmc_class == MMC_CLASS_UNKN))
	+ ump->strategy = &udf_strat_direct;
	+ if (n_spar)
	+ ump->strategy = &udf_strat_rmw;
	+
	+ ump->strategy = &udf_strat_readonly;
	+
	+#if 0
	+ /* read-only access won't benefit from the other shedulers */
	+ if (ump->vfs_mountp->mnt_flag & MNT_RDONLY)
	+ ump->strategy = &udf_strat_direct;
	+#endif
	+ /print results /
	+ DPRINTF(VOLUMES, ("\tdata partition %d\n", ump->data_part));
	+ DPRINTF(VOLUMES, ("\t\talloc scheme %d\n", ump->vtop_alloc[ump->data_part]));
	+ DPRINTF(VOLUMES, ("\tnode partition %d\n", ump->node_part));
	+ DPRINTF(VOLUMES, ("\t\talloc scheme %d\n", ump->vtop_alloc[ump->node_part]));
	+ DPRINTF(VOLUMES, ("\tfids partition %d\n", ump->fids_part));
	+ DPRINTF(VOLUMES, ("\t\talloc scheme %d\n", ump->vtop_alloc[ump->fids_part]));
	+
	+ snprintb(bits, sizeof(bits), UDFLOGVOL_BITS, ump->lvopen);
	+ DPRINTF(VOLUMES, ("\tactions on logvol open %s\n", bits));
	+ snprintb(bits, sizeof(bits), UDFLOGVOL_BITS, ump->lvclose);
	+ DPRINTF(VOLUMES, ("\tactions on logvol close %s\n", bits));
	+ snprintb(bits, sizeof(bits), UDFONERROR_BITS, ump->lvreadwrite);
	+ DPRINTF(VOLUMES, ("\tactions on logvol errors %s\n", bits));
	+
	+ DPRINTF(VOLUMES, ("\tselected sheduler `%s`\n",
	+ (ump->strategy == &udf_strat_direct) ? "Direct" :
	+ (ump->strategy == &udf_strat_sequential) ? "Sequential" :
	+ (ump->strategy == &udf_strat_rmw) ? "RMW" : "UNKNOWN!"));
	+#endif
	+ /* signal its OK for now */
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Update logical volume name in all structures that keep a record of it. We
	+ * use memmove since each of them might be specified as a source.
	+ *
	+ * Note that it doesn't update the VAT structure!
	+ */
	+
	+static void
	+udf_update_logvolname(struct udf_mount ump, char logvol_id)
	+{
	+ struct logvol_desc *lvd = NULL;
	+ struct fileset_desc *fsd = NULL;
	+ struct udf_lv_info *lvi = NULL;
	+
	+ DPRINTF(VOLUMES, ("Updating logical volume name\n"));
	+ lvd = ump->logical_vol;
	+ fsd = ump->fileset_desc;
	+ if (ump->implementation)
	+ lvi = &ump->implementation->_impl_use.lv_info;
	+
	+ /* logvol's id might be specified as origional so use memmove here */
	+ memmove(lvd->logvol_id, logvol_id, 128);
	+ if (fsd)
	+ memmove(fsd->logvol_id, logvol_id, 128);
	+ if (lvi)
	+ memmove(lvi->logvol_id, logvol_id, 128);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+#if 0
	+void
	+udf_inittag(struct udf_mount ump, struct desc_tag tag, int tagid,
	+ uint32_t sector)
	+{
	+ assert(ump->logical_vol);
	+
	+ tag->id = htole16(tagid);
	+ tag->descriptor_ver = ump->logical_vol->tag.descriptor_ver;
	+ tag->cksum = 0;
	+ tag->reserved = 0;
	+ tag->serial_num = ump->logical_vol->tag.serial_num;
	+ tag->tag_loc = htole32(sector);
	+}
	+
	+
	+uint64_t
	+udf_advance_uniqueid(struct udf_mount *ump)
	+{
	+ uint64_t unique_id;
	+
	+ mutex_enter(&ump->logvol_mutex);
	+ unique_id = le64toh(ump->logvol_integrity->lvint_next_unique_id);
	+ if (unique_id < 0x10)
	+ unique_id = 0x10;
	+ ump->logvol_integrity->lvint_next_unique_id = htole64(unique_id + 1);
	+ mutex_exit(&ump->logvol_mutex);
	+
	+ return (unique_id);
	+}
	+
	+
	+static void
	+udf_adjust_filecount(struct udf_node *udf_node, int sign)
	+{
	+ struct udf_mount *ump = udf_node->ump;
	+ uint32_t num_dirs, num_files;
	+ int udf_file_type;
	+
	+ /* get file type */
	+ if (udf_node->fe) {
	+ udf_file_type = udf_node->fe->icbtag.file_type;
	+ } else {
	+ udf_file_type = udf_node->efe->icbtag.file_type;
	+ }
	+
	+ /* adjust file count */
	+ mutex_enter(&ump->allocate_mutex);
	+ if (udf_file_type == UDF_ICB_FILETYPE_DIRECTORY) {
	+ num_dirs = le32toh(ump->logvol_info->num_directories);
	+ ump->logvol_info->num_directories =
	+ htole32((num_dirs + sign));
	+ } else {
	+ num_files = le32toh(ump->logvol_info->num_files);
	+ ump->logvol_info->num_files =
	+ htole32((num_files + sign));
	+ }
	+ mutex_exit(&ump->allocate_mutex);
	+}
	+
	+
	+void
	+udf_osta_charset(struct charspec *charspec)
	+{
	+ memset(charspec, 0, sizeof(struct charspec));
	+ charspec->type = 0;
	+ strcpy((char *) charspec->inf, "OSTA Compressed Unicode");
	+}
	+
	+
	+/* first call udf_set_regid and then the suffix */
	+void
	+udf_set_regid(struct regid regid, char const name)
	+{
	+ memset(regid, 0, sizeof(struct regid));
	+ regid->flags = 0; /* not dirty and not protected */
	+ strcpy((char *) regid->id, name);
	+}
	+
	+
	+void
	+udf_add_domain_regid(struct udf_mount ump, struct regid regid)
	+{
	+ uint16_t *ver;
	+
	+ ver = (uint16_t *) regid->id_suffix;
	+ *ver = ump->logvol_info->min_udf_readver;
	+}
	+
	+
	+void
	+udf_add_udf_regid(struct udf_mount ump, struct regid regid)
	+{
	+ uint16_t *ver;
	+
	+ ver = (uint16_t *) regid->id_suffix;
	+ *ver = ump->logvol_info->min_udf_readver;
	+
	+ regid->id_suffix[2] = 4; /* unix */
	+ regid->id_suffix[3] = 8; /* NetBSD */
	+}
	+
	+
	+void
	+udf_add_impl_regid(struct udf_mount ump, struct regid regid)
	+{
	+ regid->id_suffix[0] = 4; /* unix */
	+ regid->id_suffix[1] = 8; /* NetBSD */
	+}
	+
	+
	+void
	+udf_add_app_regid(struct udf_mount ump, struct regid regid)
	+{
	+ regid->id_suffix[0] = APP_VERSION_MAIN;
	+ regid->id_suffix[1] = APP_VERSION_SUB;
	+}
	+
	+static int
	+udf_create_parentfid(struct udf_mount ump, struct fileid_desc fid,
	+ struct long_ad *parent, uint64_t unique_id)
	+{
	+ /* the size of an empty FID is 38 but needs to be a multiple of 4 */
	+ int fidsize = 40;
	+
	+ udf_inittag(ump, &fid->tag, TAGID_FID, le32toh(parent->loc.lb_num));
	+ fid->file_version_num = htole16(1); /* UDF 2.3.4.1 */
	+ fid->file_char = UDF_FILE_CHAR_DIR \| UDF_FILE_CHAR_PAR;
	+ fid->icb = *parent;
	+ fid->icb.longad_uniqueid = htole32((uint32_t) unique_id);
	+ fid->tag.desc_crc_len = htole16(fidsize - UDF_DESC_TAG_LENGTH);
	+ (void) udf_validate_tag_and_crc_sums((union dscrptr *) fid);
	+
	+ return (fidsize);
	+}
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Extended attribute support. UDF knows of 3 places for extended attributes:
	+ *
	+ * (a) inside the file's (e)fe in the length of the extended attribute area
	+ * before the allocation descriptors/filedata
	+ *
	+ * (b) in a file referenced by (e)fe->ext_attr_icb and
	+ *
	+ * (c) in the e(fe)'s associated stream directory that can hold various
	+ * sub-files. In the stream directory a few fixed named subfiles are reserved
	+ * for NT/Unix ACL's and OS/2 attributes.
	+ *
	+ * NOTE: Extended attributes are read randomly but allways written
	+ * atomicaly. For ACL's this interface is propably different but not known
	+ * to me yet.
	+ *
	+ * Order of extended attributes in a space :
	+ * ECMA 167 EAs
	+ * Non block aligned Implementation Use EAs
	+ * Block aligned Implementation Use EAs
	+ * Application Use EAs
	+ */
	+
	+static int
	+udf_impl_extattr_check(struct impl_extattr_entry *implext)
	+{
	+ uint16_t *spos;
	+
	+ if (strncmp(implext->imp_id.id, "*UDF", 4) == 0) {
	+ /* checksum valid? */
	+ spos = (uint16_t *) implext->data;
	+ if (le16toh(spos) != udf_ea_cksum((uint8_t ) implext))
	+ return (EINVAL);
	+ }
	+ return (0);
	+}
	+
	+static void
	+udf_calc_impl_extattr_checksum(struct impl_extattr_entry *implext)
	+{
	+ uint16_t *spos;
	+
	+ if (strncmp(implext->imp_id.id, "*UDF", 4) == 0) {
	+ /* set checksum */
	+ spos = (uint16_t *) implext->data;
	+ spos = le16toh(udf_ea_cksum((uint8_t ) implext));
	+ }
	+}
	+
	+
	+int
	+udf_extattr_search_intern(struct udf_node *node,
	+ uint32_t sattr, char const *sattrname,
	+ uint32_t offsetp, uint32_t lengthp)
	+{
	+ struct extattrhdr_desc *eahdr;
	+ struct extattr_entry *attrhdr;
	+ struct impl_extattr_entry *implext;
	+ int error;
	+ int32_t l_ea;
	+ uint32_t offset, a_l, sector_size;
	+ uint8_t *pos;
	+
	+ /* get mountpoint */
	+ sector_size = node->ump->discinfo.sector_size;
	+
	+ /* get information from fe/efe */
	+ if (node->fe) {
	+ l_ea = le32toh(node->fe->l_ea);
	+ eahdr = (struct extattrhdr_desc *) node->fe->data;
	+ } else {
	+ KASSERT(node->efe, ("Extended File Entry is null"));
	+ l_ea = le32toh(node->efe->l_ea);
	+ eahdr = (struct extattrhdr_desc *) node->efe->data;
	+ }
	+
	+ /* something recorded here? */
	+ if (l_ea == 0)
	+ return (ENOENT);
	+
	+ /* check extended attribute tag; what to do if it fails? */
	+ error = udf_check_tag(eahdr);
	+ if (error)
	+ return (EINVAL);
	+ if (le16toh(eahdr->tag.id) != TAGID_EXTATTR_HDR)
	+ return (EINVAL);
	+ error = udf_check_tag_payload(eahdr, sizeof(struct extattrhdr_desc));
	+ if (error)
	+ return (EINVAL);
	+
	+ DPRINTF(EXTATTR, ("Found %d bytes of extended attributes\n", l_ea));
	+
	+ /* looking for Ecma-167 attributes? */
	+ offset = sizeof(struct extattrhdr_desc);
	+
	+ /* looking for either implemenation use or application use */
	+ if (sattr == 2048) { /* [4/48.10.8] */
	+ offset = le32toh(eahdr->impl_attr_loc);
	+ if (offset == UDF_IMPL_ATTR_LOC_NOT_PRESENT)
	+ return (ENOENT);
	+ }
	+ if (sattr == 65536) { /* [4/48.10.9] */
	+ offset = le32toh(eahdr->appl_attr_loc);
	+ if (offset == UDF_APPL_ATTR_LOC_NOT_PRESENT)
	+ return (ENOENT);
	+ }
	+
	+ /* paranoia check offset and l_ea */
	+ if (l_ea + offset >= sector_size - sizeof(struct extattr_entry))
	+ return (EINVAL);
	+
	+ DPRINTF(EXTATTR, ("Starting at offset %d\n", offset));
	+
	+ /* find our extended attribute */
	+ l_ea -= offset;
	+ pos = (uint8_t *) eahdr + offset;
	+
	+ while (l_ea >= sizeof(struct extattr_entry)) {
	+ DPRINTF(EXTATTR, ("%d extended attr bytes left\n", l_ea));
	+ attrhdr = (struct extattr_entry *) pos;
	+ implext = (struct impl_extattr_entry *) pos;
	+
	+ /* get complete attribute length and check for roque values */
	+ a_l = le32toh(attrhdr->a_l);
	+ DPRINTF(EXTATTR, ("attribute %d:%d, len %d/%d\n",
	+ le32toh(attrhdr->type),
	+ attrhdr->subtype, a_l, l_ea));
	+ if ((a_l == 0) \|\| (a_l > l_ea))
	+ return (EINVAL);
	+
	+ if (attrhdr->type != sattr)
	+ goto next_attribute;
	+
	+ /* we might have found it! */
	+ if (attrhdr->type < 2048) { /* Ecma-167 attribute */
	+ *offsetp = offset;
	+ *lengthp = a_l;
	+ return (0); /* success */
	+ }
	+
	+ /*
	+ * Implementation use and application use extended attributes
	+ * have a name to identify. They share the same structure only
	+ * UDF implementation use extended attributes have a checksum
	+ * we need to check
	+ */
	+
	+ DPRINTF(EXTATTR, ("named attribute %s\n", implext->imp_id.id));
	+ if (strcmp(implext->imp_id.id, sattrname) == 0) {
	+ /* we have found our appl/implementation attribute */
	+ *offsetp = offset;
	+ *lengthp = a_l;
	+ return (0); /* success */
	+ }
	+
	+next_attribute:
	+ /* next attribute */
	+ pos += a_l;
	+ l_ea -= a_l;
	+ offset += a_l;
	+ }
	+ /* not found */
	+ return (ENOENT);
	+}
	+
	+
	+#if 0
	+static void
	+udf_extattr_insert_internal(struct udf_mount ump, union dscrptr dscr,
	+ struct extattr_entry *extattr)
	+{
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct extattrhdr_desc *extattrhdr;
	+ struct impl_extattr_entry *implext;
	+ uint32_t impl_attr_loc, appl_attr_loc, l_ea, a_l, exthdr_len;
	+ uint32_t *l_eap, l_ad;
	+ uint16_t *spos;
	+ uint8_t bpos, data;
	+
	+ if (le16toh(dscr->tag.id) == TAGID_FENTRY) {
	+ fe = &dscr->fe;
	+ data = fe->data;
	+ l_eap = &fe->l_ea;
	+ l_ad = le32toh(fe->l_ad);
	+ } else if (le16toh(dscr->tag.id) == TAGID_EXTFENTRY) {
	+ efe = &dscr->efe;
	+ data = efe->data;
	+ l_eap = &efe->l_ea;
	+ l_ad = le32toh(efe->l_ad);
	+ } else {
	+ panic("Bad tag passed to udf_extattr_insert_internal");
	+ }
	+
	+ /* can't append already written to file descriptors yet */
	+ assert(l_ad == 0);
	+
	+ /* should have a header! */
	+ extattrhdr = (struct extattrhdr_desc *) data;
	+ l_ea = le32toh(*l_eap);
	+ if (l_ea == 0) {
	+ /* create empty extended attribute header */
	+ exthdr_len = sizeof(struct extattrhdr_desc);
	+
	+ udf_inittag(ump, &extattrhdr->tag, TAGID_EXTATTR_HDR,
	+ /* loc */ 0);
	+ extattrhdr->impl_attr_loc = htole32(exthdr_len);
	+ extattrhdr->appl_attr_loc = htole32(exthdr_len);
	+ extattrhdr->tag.desc_crc_len = htole16(8);
	+
	+ /* record extended attribute header length */
	+ l_ea = exthdr_len;
	+ *l_eap = htole32(l_ea);
	+ }
	+
	+ /* extract locations */
	+ impl_attr_loc = le32toh(extattrhdr->impl_attr_loc);
	+ appl_attr_loc = le32toh(extattrhdr->appl_attr_loc);
	+ if (impl_attr_loc == UDF_IMPL_ATTR_LOC_NOT_PRESENT)
	+ impl_attr_loc = l_ea;
	+ if (appl_attr_loc == UDF_IMPL_ATTR_LOC_NOT_PRESENT)
	+ appl_attr_loc = l_ea;
	+
	+ /* Ecma 167 EAs */
	+ if (le32toh(extattr->type) < 2048) {
	+ assert(impl_attr_loc == l_ea);
	+ assert(appl_attr_loc == l_ea);
	+ }
	+
	+ /* implementation use extended attributes */
	+ if (le32toh(extattr->type) == 2048) {
	+ assert(appl_attr_loc == l_ea);
	+
	+ /* calculate and write extended attribute header checksum */
	+ implext = (struct impl_extattr_entry *) extattr;
	+ assert(le32toh(implext->iu_l) == 4); /* [UDF 3.3.4.5] */
	+ spos = (uint16_t *) implext->data;
	+ spos = htole16(udf_ea_cksum((uint8_t ) implext));
	+ }
	+
	+ /* application use extended attributes */
	+ assert(le32toh(extattr->type) != 65536);
	+ assert(appl_attr_loc == l_ea);
	+
	+ /* append the attribute at the end of the current space */
	+ bpos = data + le32toh(*l_eap);
	+ a_l = le32toh(extattr->a_l);
	+
	+ /* update impl. attribute locations */
	+ if (le32toh(extattr->type) < 2048) {
	+ impl_attr_loc = l_ea + a_l;
	+ appl_attr_loc = l_ea + a_l;
	+ }
	+ if (le32toh(extattr->type) == 2048) {
	+ appl_attr_loc = l_ea + a_l;
	+ }
	+
	+ /* copy and advance */
	+ memcpy(bpos, extattr, a_l);
	+ l_ea += a_l;
	+ *l_eap = htole32(l_ea);
	+
	+ /* do the `dance` again backwards */
	+ if (le16toh(ump->logical_vol->tag.descriptor_ver) != 2) {
	+ if (impl_attr_loc == l_ea)
	+ impl_attr_loc = UDF_IMPL_ATTR_LOC_NOT_PRESENT;
	+ if (appl_attr_loc == l_ea)
	+ appl_attr_loc = UDF_APPL_ATTR_LOC_NOT_PRESENT;
	+ }
	+
	+ /* store offsets */
	+ extattrhdr->impl_attr_loc = htole32(impl_attr_loc);
	+ extattrhdr->appl_attr_loc = htole32(appl_attr_loc);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_update_lvid_from_vat_extattr(struct udf_node *vat_node)
	+{
	+ struct impl_extattr_entry *implext;
	+ struct vatlvext_extattr_entry lvext;
	+ struct udf_mount *ump;
	+ struct udf_logvol_info *lvinfo;
	+ uint64_t vat_uniqueid;
	+ int error;
	+ uint32_t offset, a_l;
	+ const char extstr = "UDF VAT LVExtension";
	+ uint8_t ea_start, lvextpos;
	+
	+ /* get mountpoint and lvinfo */
	+ ump = vat_node->ump;
	+ lvinfo = ump->logvol_info;
	+
	+ /* get information from fe/efe */
	+ if (vat_node->fe) {
	+ vat_uniqueid = le64toh(vat_node->fe->unique_id);
	+ ea_start = vat_node->fe->data;
	+ } else {
	+ vat_uniqueid = le64toh(vat_node->efe->unique_id);
	+ ea_start = vat_node->efe->data;
	+ }
	+
	+ error = udf_extattr_search_intern(vat_node, 2048, extstr, &offset, &a_l);
	+ if (error)
	+ return (error);
	+
	+ implext = (struct impl_extattr_entry *) (ea_start + offset);
	+ error = udf_impl_extattr_check(implext);
	+ if (error)
	+ return (error);
	+
	+ /* paranoia */
	+ if (a_l != sizeof(*implext) -1 + le32toh(implext->iu_l) + sizeof(lvext))
	+ DPRINTF(VOLUMES, ("VAT LVExtension size doens't compute\n"));
	+ return (EINVAL);
	+
	+ /*
	+ * we have found our "VAT LVExtension attribute. BUT due to a
	+ * bug in the specification it might not be word aligned so
	+ * copy first to avoid panics on some machines (!!)
	+ */
	+ DPRINTF(VOLUMES, ("Found VAT LVExtension attr\n"));
	+ lvextpos = implext->data + le32toh(implext->iu_l);
	+ memcpy(&lvext, lvextpos, sizeof(lvext));
	+
	+ /* check if it was updated the last time */
	+ if (le64toh(lvext.unique_id_chk) == vat_uniqueid) {
	+ lvinfo->num_files = lvext.num_files;
	+ lvinfo->num_directories = lvext.num_directories;
	+ udf_update_logvolname(ump, lvext.logvol_id);
	+ } else {
	+ DPRINTF(VOLUMES, ("VAT LVExtension out of date"));
	+ /* replace VAT LVExt by free space EA */
	+ memset(implext->imp_id.id, 0, UDF_REGID_ID_SIZE);
	+ strcpy(implext->imp_id.id, "*UDF FreeEASpace");
	+ udf_calc_impl_extattr_checksum(implext);
	+ }
	+
	+ return (0);
	+}
	+
	+#if 0
	+static int
	+udf_update_vat_extattr_from_lvid(struct udf_node *vat_node)
	+{
	+ struct udf_mount *ump;
	+ struct udf_logvol_info *lvinfo;
	+ struct impl_extattr_entry *implext;
	+ struct vatlvext_extattr_entry lvext;
	+ const char extstr = "UDF VAT LVExtension";
	+ uint64_t vat_uniqueid;
	+ uint32_t offset, a_l;
	+ uint8_t ea_start, lvextpos;
	+ int error;
	+
	+ /* get mountpoint and lvinfo */
	+ ump = vat_node->ump;
	+ lvinfo = ump->logvol_info;
	+
	+ /* get information from fe/efe */
	+ if (vat_node->fe) {
	+ vat_uniqueid = le64toh(vat_node->fe->unique_id);
	+ ea_start = vat_node->fe->data;
	+ } else {
	+ vat_uniqueid = le64toh(vat_node->efe->unique_id);
	+ ea_start = vat_node->efe->data;
	+ }
	+
	+ error = udf_extattr_search_intern(vat_node, 2048, extstr, &offset, &a_l);
	+ if (error)
	+ return (error);
	+ /* found, it existed */
	+
	+ /* paranoia */
	+ implext = (struct impl_extattr_entry *) (ea_start + offset);
	+ error = udf_impl_extattr_check(implext);
	+ if (error) {
	+ DPRINTF(VOLUMES, ("VAT LVExtension bad on update\n"));
	+ return (error);
	+ }
	+ /* it is correct */
	+
	+ /*
	+ * we have found our "VAT LVExtension attribute. BUT due to a
	+ * bug in the specification it might not be word aligned so
	+ * copy first to avoid panics on some machines (!!)
	+ */
	+ DPRINTF(VOLUMES, ("Updating VAT LVExtension attr\n"));
	+ lvextpos = implext->data + le32toh(implext->iu_l);
	+
	+ lvext.unique_id_chk = vat_uniqueid;
	+ lvext.num_files = lvinfo->num_files;
	+ lvext.num_directories = lvinfo->num_directories;
	+ memmove(lvext.logvol_id, ump->logical_vol->logvol_id, 128);
	+
	+ memcpy(lvextpos, &lvext, sizeof(lvext));
	+
	+ return (0);
	+}
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_vat_read(struct udf_node vat_node, uint8_t blob, int size, uint32_t offset)
	+{
	+ struct udf_mount *ump = vat_node->ump;
	+
	+ if (offset + size > ump->vat_offset + ump->vat_entries * 4)
	+ return (EINVAL);
	+
	+ memcpy(blob, ump->vat_table + offset, size);
	+ return (0);
	+}
	+
	+#if 0
	+int
	+udf_vat_write(struct udf_node vat_node, uint8_t blob, int size, uint32_t offset)
	+{
	+ struct udf_mount *ump = vat_node->ump;
	+ uint32_t offset_high;
	+ uint8_t *new_vat_table;
	+
	+ /* extent VAT allocation if needed */
	+ offset_high = offset + size;
	+ if (offset_high >= ump->vat_table_alloc_len) {
	+ /* realloc */
	+ new_vat_table = realloc(ump->vat_table,
	+ ump->vat_table_alloc_len + UDF_VAT_CHUNKSIZE,
	+ M_UDFTEMP, M_WAITOK \| M_CANFAIL);
	+ if (!new_vat_table) {
	+ printf("udf_vat_write: can't extent VAT, out of mem\n");
	+ return (ENOMEM);
	+ }
	+ ump->vat_table = new_vat_table;
	+ ump->vat_table_alloc_len += UDF_VAT_CHUNKSIZE;
	+ }
	+ ump->vat_table_len = MAX(ump->vat_table_len, offset_high);
	+
	+ memcpy(ump->vat_table + offset, blob, size);
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* TODO support previous VAT location writeout */
	+static int
	+udf_update_vat_descriptor(struct udf_mount *ump)
	+{
	+ struct udf_node *vat_node = ump->vat_node;
	+ struct udf_logvol_info *lvinfo = ump->logvol_info;
	+ struct icb_tag *icbtag;
	+ struct udf_oldvat_tail *oldvat_tl;
	+ struct udf_vat *vat;
	+ uint64_t unique_id;
	+ uint32_t lb_size;
	+ uint8_t *raw_vat;
	+ int filetype, error;
	+
	+ KASSERT(vat_node);
	+ KASSERT(lvinfo);
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+
	+ /* get our new unique_id */
	+ unique_id = udf_advance_uniqueid(ump);
	+
	+ /* get information from fe/efe */
	+ if (vat_node->fe) {
	+ icbtag = &vat_node->fe->icbtag;
	+ vat_node->fe->unique_id = htole64(unique_id);
	+ } else {
	+ icbtag = &vat_node->efe->icbtag;
	+ vat_node->efe->unique_id = htole64(unique_id);
	+ }
	+
	+ /* Check icb filetype! it has to be 0 or UDF_ICB_FILETYPE_VAT */
	+ filetype = icbtag->file_type;
	+ KASSERT((filetype == 0) \|\| (filetype == UDF_ICB_FILETYPE_VAT));
	+
	+ /* allocate piece to process head or tail of VAT file */
	+ raw_vat = malloc(lb_size, M_UDFTEMP, M_WAITOK);
	+
	+ if (filetype == 0) {
	+ /*
	+ * Update "*UDF VAT LVExtension" extended attribute from the
	+ * lvint if present.
	+ */
	+ udf_update_vat_extattr_from_lvid(vat_node);
	+
	+ /* setup identifying regid */
	+ oldvat_tl = (struct udf_oldvat_tail *) raw_vat;
	+ memset(oldvat_tl, 0, sizeof(struct udf_oldvat_tail));
	+
	+ udf_set_regid(&oldvat_tl->id, "*UDF Virtual Alloc Tbl");
	+ udf_add_udf_regid(ump, &oldvat_tl->id);
	+ oldvat_tl->prev_vat = htole32(0xffffffff);
	+
	+ /* write out new tail of virtual allocation table file */
	+ error = udf_vat_write(vat_node, raw_vat,
	+ sizeof(struct udf_oldvat_tail), ump->vat_entries * 4);
	+ } else {
	+ /* compose the VAT2 header */
	+ vat = (struct udf_vat *) raw_vat;
	+ memset(vat, 0, sizeof(struct udf_vat));
	+
	+ vat->header_len = htole16(152); /* as per spec */
	+ vat->impl_use_len = htole16(0);
	+ memmove(vat->logvol_id, ump->logical_vol->logvol_id, 128);
	+ vat->prev_vat = htole32(0xffffffff);
	+ vat->num_files = lvinfo->num_files;
	+ vat->num_directories = lvinfo->num_directories;
	+ vat->min_udf_readver = lvinfo->min_udf_readver;
	+ vat->min_udf_writever = lvinfo->min_udf_writever;
	+ vat->max_udf_writever = lvinfo->max_udf_writever;
	+
	+ error = udf_vat_write(vat_node, raw_vat,
	+ sizeof(struct udf_vat), 0);
	+ }
	+ free(raw_vat, M_UDFTEMP);
	+
	+ return (error); /* success! */
	+}
	+
	+
	+int
	+udf_writeout_vat(struct udf_mount *ump)
	+{
	+ struct udf_node *vat_node = ump->vat_node;
	+ uint32_t vat_length;
	+ int error;
	+
	+ KASSERT(vat_node);
	+
	+ DPRINTF(CALL, ("udf_writeout_vat\n"));
	+
	+/* mutex_enter(&ump->allocate_mutex); */
	+ udf_update_vat_descriptor(ump);
	+
	+ /* write out the VAT contents ; TODO intelligent writing */
	+ vat_length = ump->vat_table_len;
	+ error = vn_rdwr(UIO_WRITE, vat_node->vnode,
	+ ump->vat_table, ump->vat_table_len, 0,
	+ UIO_SYSSPACE, IO_NODELOCKED, FSCRED, NULL, NULL);
	+ if (error) {
	+ printf("udf_writeout_vat: failed to write out VAT contents\n");
	+ goto out;
	+ }
	+
	+/* mutex_exit(&ump->allocate_mutex); */
	+
	+ vflushbuf(ump->vat_node->vnode, 1 /* sync */);
	+ error = VOP_FSYNC(ump->vat_node->vnode,
	+ FSCRED, FSYNC_WAIT, 0, 0);
	+ if (error)
	+ printf("udf_writeout_vat: error writing VAT node!\n");
	+out:
	+
	+ return (error);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Read in relevant pieces of VAT file and check if its indeed a VAT file
	+ * descriptor. If OK, read in complete VAT file.
	+ */
	+
	+static int
	+udf_check_for_vat(struct udf_node *vat_node)
	+{
	+ struct udf_mount *ump;
	+ struct icb_tag *icbtag;
	+ struct timestamp *mtime;
	+ struct udf_vat *vat;
	+ struct udf_oldvat_tail *oldvat_tl;
	+ struct udf_logvol_info *lvinfo;
	+ uint64_t unique_id;
	+ int filetype, error;
	+ uint32_t vat_length, vat_offset, vat_entries, vat_table_alloc_len;
	+ uint32_t sector_size, *raw_vat;
	+ char *regid_name;
	+ uint8_t *vat_table;
	+
	+ /* vat_length is really 64 bits though impossible */
	+
	+ DPRINTF(VOLUMES, ("Checking for VAT\n"));
	+ if (!vat_node)
	+ return (ENOENT);
	+
	+ /* get mount info */
	+ ump = vat_node->ump;
	+ sector_size = le32toh(ump->logical_vol->lb_size);
	+
	+ /* check assertions */
	+ KASSERT(vat_node->fe \|\| vat_node->efe, ("udf_check_for_vat:"
	+ "Extended File Entry or File Entry is null\n"));
	+ KASSERT(ump->logvol_integrity, ("udf_check_for_vat: invalid current integrity"));
	+
	+ /* set vnode type to regular file or we can't read from it! */
	+ /* vat_node->vnode->v_type = VREG; */
	+
	+ /* get information from fe/efe */
	+ if (vat_node->fe) {
	+ vat_length = le64toh(vat_node->fe->inf_len);
	+ icbtag = &vat_node->fe->icbtag;
	+ mtime = &vat_node->fe->mtime;
	+ unique_id = le64toh(vat_node->fe->unique_id);
	+ } else {
	+ vat_length = le64toh(vat_node->efe->inf_len);
	+ icbtag = &vat_node->efe->icbtag;
	+ mtime = &vat_node->efe->mtime;
	+ unique_id = le64toh(vat_node->efe->unique_id);
	+ }
	+
	+ /* Check icb filetype! it has to be 0 or UDF_ICB_FILETYPE_VAT */
	+ filetype = icbtag->file_type;
	+ if ((filetype != 0) && (filetype != UDF_ICB_FILETYPE_VAT))
	+ return (ENOENT);
	+
	+ DPRINTF(VOLUMES, ("\tPossible VAT length %d\n", vat_length));
	+
	+ vat_table_alloc_len =
	+ ((vat_length + UDF_VAT_CHUNKSIZE-1) / UDF_VAT_CHUNKSIZE)
	+ * UDF_VAT_CHUNKSIZE;
	+
	+ vat_table = malloc(vat_table_alloc_len, M_UDFTEMP, M_WAITOK);
	+#if 0
	+ /M_CANFAIL was removed from third arg /
	+ if (vat_table == NULL) {
	+ printf("allocation of %d bytes failed for VAT\n",
	+ vat_table_alloc_len);
	+ return (ENOMEM);
	+ }
	+#endif
	+
	+ /* allocate piece to read in head or tail of VAT file */
	+ raw_vat = malloc(sector_size, M_UDFTEMP, M_WAITOK);
	+
	+ /*
	+ * check contents of the file if its the old 1.50 VAT table format.
	+ * Its notoriously broken and allthough some implementations support an
	+ * extension as defined in the UDF 1.50 errata document, its doubtfull
	+ * to be useable since a lot of implementations don't maintain it.
	+ */
	+ lvinfo = ump->logvol_info;
	+
	+ if (filetype == 0) {
	+ /* definition */
	+ vat_offset = 0;
	+ vat_entries = (vat_length-36)/4;
	+
	+ /* read in tail of virtual allocation table file */
	+ error = udf_read_node(vat_node, (uint8_t *)raw_vat,
	+ vat_entries * 4, sizeof(struct udf_oldvat_tail));
	+ /*error = vn_rdwr(UIO_READ, vat_node->vnode,
	+ (uint8_t *) raw_vat,
	+ sizeof(struct udf_oldvat_tail),
	+ vat_entries * 4,
	+ UIO_SYSSPACE, IO_SYNC \| IO_NODELOCKED, FSCRED,
	+ NULL, NULL, curthread);*/
	+ if (error)
	+ goto out;
	+
	+ /* check 1.50 VAT */
	+ oldvat_tl = (struct udf_oldvat_tail *) raw_vat;
	+ regid_name = (char *) oldvat_tl->id.id;
	+ error = strncmp(regid_name, "*UDF Virtual Alloc Tbl", 22);
	+ if (error) {
	+ DPRINTF(VOLUMES, ("VAT format 1.50 rejected\n"));
	+ error = ENOENT;
	+ goto out;
	+ }
	+
	+ /*
	+ * update LVID from "*UDF VAT LVExtension" extended attribute
	+ * if present.
	+ */
	+ udf_update_lvid_from_vat_extattr(vat_node);
	+ } else {
	+ /* read in head of virtual allocation table file */
	+ error = udf_read_node(vat_node, (uint8_t *)raw_vat,
	+ 0, sizeof(struct udf_vat));
	+ /*error = vn_rdwr(UIO_READ, vat_node->vnode,
	+ (uint8_t *) raw_vat,
	+ sizeof(struct udf_vat), 0,
	+ UIO_SYSSPACE, IO_SYNC \| IO_NODELOCKED, FSCRED,
	+ NULL, NULL, curthread);*/
	+ if (error)
	+ goto out;
	+
	+ /* definition */
	+ vat = (struct udf_vat *) raw_vat;
	+ vat_offset = vat->header_len;
	+ vat_entries = (vat_length - vat_offset)/4;
	+
	+ KASSERT(lvinfo, ("udf_check_for_vat: invalid integrity descriptor"));
	+ lvinfo->num_files = vat->num_files;
	+ lvinfo->num_directories = vat->num_directories;
	+ lvinfo->min_udf_readver = vat->min_udf_readver;
	+ lvinfo->min_udf_writever = vat->min_udf_writever;
	+ lvinfo->max_udf_writever = vat->max_udf_writever;
	+
	+ udf_update_logvolname(ump, vat->logvol_id);
	+ }
	+
	+ /* read in complete VAT file */
	+ error = udf_read_node(vat_node, vat_table, 0, vat_length);
	+ /*error = vn_rdwr(UIO_READ, vat_node->vnode,
	+ vat_table,
	+ vat_length, 0,
	+ UIO_SYSSPACE, IO_SYNC \| IO_NODELOCKED, FSCRED,
	+ NULL, NULL, curthread);*/
	+ if (error)
	+ printf("read in of complete VAT file failed (error %d)\n",
	+ error);
	+ if (error)
	+ goto out;
	+
	+ DPRINTF(VOLUMES, ("VAT format accepted, marking it closed\n"));
	+ ump->logvol_integrity->lvint_next_unique_id = htole64(unique_id);
	+ ump->logvol_integrity->integrity_type = htole32(UDF_INTEGRITY_CLOSED);
	+ ump->logvol_integrity->time = *mtime;
	+
	+ ump->vat_table_len = vat_length;
	+ ump->vat_table_alloc_len = vat_table_alloc_len;
	+ ump->vat_table = vat_table;
	+ ump->vat_offset = vat_offset;
	+ ump->vat_entries = vat_entries;
	+ ump->vat_last_free_lb = 0; /* start at beginning */
	+
	+out:
	+ if (error) {
	+ if (vat_table)
	+ free(vat_table, M_UDFTEMP);
	+ }
	+ free(raw_vat, M_UDFTEMP);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_search_vat(struct udf_mount ump, union udf_pmap mapping __unused)
	+{
	+ union dscrptr *dscr;
	+ /* struct vnode vp; /
	+ struct long_ad icb_loc;
	+ struct udf_node *vat_node;
	+ ino_t ino;
	+ int error;
	+ uint32_t early_vat_loc, late_vat_loc, vat_loc;
	+ uint16_t tagid;
	+ uint8_t file_type;
	+
	+ vat_node = NULL;
	+
	+ /* mapping info not needed */
	+ /* mapping = mapping; / / XXX */
	+
	+ vat_loc = ump->last_possible_vat_location;
	+ early_vat_loc = vat_loc - 256; /* 8 blocks of 32 sectors */
	+
	+ DPRINTF(VOLUMES, ("1) last possible %d, early_vat_loc %d \n",
	+ vat_loc, early_vat_loc));
	+ early_vat_loc = MAX(early_vat_loc, ump->first_possible_vat_location);
	+
	+ early_vat_loc = MAX(early_vat_loc, ump->first_possible_vat_location);
	+ late_vat_loc = vat_loc + 1024;
	+
	+ DPRINTF(VOLUMES, ("2) last possible %d, early_vat_loc %d \n",
	+ vat_loc, early_vat_loc));
	+
	+ /* start looking from the end of the range */
	+ do {
	+ if (vat_node) {
	+ udf_dispose_node(vat_node);
	+ vat_node = NULL;
	+ }
	+
	+ error = udf_read_phys_dscr(ump, vat_loc, M_UDFTEMP, &dscr);
	+ if (!error && dscr) { /* dscr will be null if zeros were read */
	+ tagid = le16toh(dscr->tag.id);
	+ file_type = 0;
	+ if (tagid == TAGID_FENTRY)
	+ file_type = dscr->fe.icbtag.file_type;
	+ else if (tagid == TAGID_EXTFENTRY)
	+ file_type = dscr->efe.icbtag.file_type;
	+ free(dscr, M_UDFTEMP);
	+
	+ if (file_type == 248)
	+ {
	+ DPRINTF(VOLUMES, ("Checking for VAT at sector %d\n", vat_loc));
	+ icb_loc.loc.part_num = htole16(UDF_VTOP_RAWPART);
	+ icb_loc.loc.lb_num = htole32(vat_loc);
	+ ino = udf_get_node_id(&icb_loc);
	+
	+ error = udf_get_node(ump, ino, &vat_node);
	+ if (!error) {
	+ error = udf_check_for_vat(vat_node);
	+ DPRINTFIF(VOLUMES, !error,
	+ ("VAT accepted at %d\n", vat_loc));
	+ if (!error)
	+ break;
	+ }
	+ }
	+ }
	+
	+ vat_loc--; /* walk backwards */
	+ } while (vat_loc >= early_vat_loc);
	+
	+ /* keep our VAT node around */
	+ ump->vat_node = vat_node;
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_read_sparables(struct udf_mount ump, union udf_pmap mapping)
	+{
	+ union dscrptr *dscr;
	+ struct part_map_spare *pms = &mapping->pms;
	+ int spar, error;
	+ uint32_t lb_num;
	+
	+ /*
	+ * The partition mapping passed on to us specifies the information we
	+ * need to locate and initialise the sparable partition mapping
	+ * information we need.
	+ */
	+
	+ ump->sparable_packet_size = le16toh(pms->packet_len);
	+ KASSERT(ump->sparable_packet_size >= ump->packet_size,
	+ ("udf_read_sparables: sparable packet size is less than packet size"));
	+
	+ for (spar = 0; spar < pms->n_st; spar++) {
	+ lb_num = pms->st_loc[spar];
	+ error = udf_read_phys_dscr(ump, lb_num, M_UDFTEMP, &dscr);
	+ if (!error && dscr) {
	+ if (le16toh(dscr->tag.id) == TAGID_SPARING_TABLE) {
	+ if (ump->sparing_table)
	+ free(ump->sparing_table, M_UDFTEMP);
	+ ump->sparing_table = &dscr->spt;
	+ dscr = NULL;
	+ break; /* we're done */
	+ }
	+ }
	+ if (dscr)
	+ free(dscr, M_UDFTEMP);
	+ }
	+
	+ if (ump->sparing_table)
	+ return (0);
	+
	+ return (ENOENT);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+static int
	+udf_read_metadata_nodes(struct udf_mount ump, union udf_pmap mapping)
	+{
	+ struct part_map_meta *pmm = &mapping->pmm;
	+ struct long_ad icb_loc;
	+#if 0
	+ struct vnode *vp;
	+#endif
	+ int error;
	+ ino_t ino;
	+
	+ /* extract our allocation parameters set up on format */
	+ ump->metadata_alloc_unit_size = le32toh(mapping->pmm.alloc_unit_size);
	+ ump->metadata_alignment_unit_size = le16toh(mapping->pmm.alignment_unit_size);
	+ ump->metadata_flags = mapping->pmm.flags;
	+
	+ /* DPRINTF(VOLUMES, ("Reading in Metadata files\n")); */
	+ icb_loc.loc.part_num = pmm->part_num;
	+ icb_loc.loc.lb_num = pmm->meta_file_lbn;
	+ /* DPRINTF(VOLUMES, ("Metadata file\n")); */
	+ ino = udf_get_node_id(&icb_loc);
	+ error = udf_get_node(ump, ino, &ump->metadata_node);
	+#if 0
	+ if (ump->metadata_node) {
	+ vp = ump->metadata_node->vnode;
	+ UDF_SET_SYSTEMFILE(vp);
	+ }
	+#endif
	+
	+ icb_loc.loc.lb_num = pmm->meta_mirror_file_lbn;
	+ if (icb_loc.loc.lb_num != -1) {
	+ /* DPRINTF(VOLUMES, ("Metadata copy file\n")); */
	+ ino = udf_get_node_id(&icb_loc);
	+ error = udf_get_node(ump, ino, &ump->metadatamirror_node);
	+#if 0
	+ if (ump->metadatamirror_node) {
	+ vp = ump->metadatamirror_node->vnode;
	+ UDF_SET_SYSTEMFILE(vp);
	+ }
	+#endif
	+ }
	+
	+ icb_loc.loc.lb_num = pmm->meta_bitmap_file_lbn;
	+ if (icb_loc.loc.lb_num != -1) {
	+ /* DPRINTF(VOLUMES, ("Metadata bitmap file\n")); */
	+ ino = udf_get_node_id(&icb_loc);
	+ error = udf_get_node(ump, ino, &ump->metadatabitmap_node);
	+#if 0
	+ if (ump->metadatabitmap_node) {
	+ vp = ump->metadatabitmap_node->vnode;
	+ UDF_SET_SYSTEMFILE(vp);
	+ }
	+#endif
	+ }
	+
	+ /* if we're mounting read-only we relax the requirements */
	+ if (ump->vfs_mountp->mnt_flag & MNT_RDONLY) {
	+ error = EFAULT;
	+ if (ump->metadata_node)
	+ error = 0;
	+ if ((ump->metadata_node == NULL) && (ump->metadatamirror_node)) {
	+ printf( "udf mount: Metadata file not readable, "
	+ "substituting Metadata copy file\n");
	+ ump->metadata_node = ump->metadatamirror_node;
	+ ump->metadatamirror_node = NULL;
	+ error = 0;
	+ }
	+ } else {
	+ /* mounting read/write */
	+ /* XXX DISABLED! metadata writing is not working yet XXX */
	+ if (error)
	+ error = EROFS;
	+ }
	+ DPRINTFIF(VOLUMES, error, ("udf mount: failed to read "
	+ "metadata files\n"));
	+ return (error);
	+}
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_read_vds_tables(struct udf_mount *ump)
	+{
	+ union udf_pmap *mapping;
	+ int pmap_size;
	+ int error = 0;
	+ uint32_t n_pm, mt_l, log_part;
	+ uint8_t *pmap_pos;
	+
	+ /* Iterate (again) over the part mappings for locations */
	+ n_pm = le32toh(ump->logical_vol->n_pm); /* num partmaps */
	+ mt_l = le32toh(ump->logical_vol->mt_l); /* partmaps data length */
	+ pmap_pos = ump->logical_vol->maps;
	+
	+ for (log_part = 0; log_part < n_pm; log_part++) {
	+ mapping = (union udf_pmap *) pmap_pos;
	+ switch (ump->vtop_tp[log_part]) {
	+ case UDF_VTOP_TYPE_PHYS :
	+ /* nothing */
	+ break;
	+ case UDF_VTOP_TYPE_VIRT :
	+ /* search and load VAT */
	+ error = udf_search_vat(ump, mapping);
	+ if (error)
	+ return (ENOENT);
	+ break;
	+ case UDF_VTOP_TYPE_SPARABLE :
	+ /* load one of the sparable tables */
	+ error = udf_read_sparables(ump, mapping);
	+ if (error)
	+ return (ENOENT);
	+ break;
	+ case UDF_VTOP_TYPE_META :
	+ /* load the associated file descriptors */
	+ error = udf_read_metadata_nodes(ump, mapping);
	+ if (error)
	+ return (ENOENT);
	+ break;
	+ default:
	+ break;
	+ }
	+ pmap_size = pmap_pos[1];
	+ pmap_pos += pmap_size;
	+ }
	+
	+ /* read in and check unallocated and free space info if writing */
	+#if 0
	+ if ((ump->vfs_mountp->mnt_flag & MNT_RDONLY) == 0) {
	+ error = udf_read_physical_partition_spacetables(ump);
	+ if (error)
	+ return (error);
	+
	+ /* also read in metadata partition spacebitmap if defined */
	+ error = udf_read_metadata_partition_spacetable(ump);
	+ return (error);
	+ }
	+#endif
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_read_rootdirs(struct udf_mount *ump)
	+{
	+ union dscrptr *dscr;
	+ struct mount *mp;
	+ struct vnode rootdir_node, streamdir_node;
	+ struct long_ad fsd_loc, *dir_loc;
	+ ino_t ino;
	+ int dscr_type, error;
	+ uint32_t lb_num, dummy, fsd_len;
	+
	+ mp = ump->vfs_mountp;
	+
	+ /* TODO implement FSD reading in separate function like integrity? */
	+ /* get fileset descriptor sequence */
	+ fsd_loc = ump->logical_vol->lv_fsd_loc;
	+ fsd_len = le32toh(fsd_loc.len);
	+
	+ dscr = NULL;
	+ error = 0;
	+ while (fsd_len \|\| error) {
	+ DPRINTF(VOLUMES, ("fsd_len = %d\n", fsd_len));
	+ /* translate fsd_loc to lb_num */
	+ error = udf_translate_vtop(ump, &fsd_loc, &lb_num, &dummy);
	+ if (error)
	+ break;
	+ error = udf_read_phys_dscr(ump, lb_num, M_UDFTEMP, &dscr);
	+ /* end markers */
	+ if (error \|\| (dscr == NULL))
	+ break;
	+
	+ /* analyse */
	+ dscr_type = le16toh(dscr->tag.id);
	+ if (dscr_type == TAGID_TERM)
	+ break;
	+ if (dscr_type != TAGID_FSD) {
	+ free(dscr, M_UDFTEMP);
	+ return (ENOENT);
	+ }
	+
	+ /*
	+ * TODO check for multiple fileset descriptors; its only
	+ * picking the last now. Also check for FSD
	+ * correctness/interpretability
	+ */
	+
	+ /* update */
	+ if (ump->fileset_desc) {
	+ free(ump->fileset_desc, M_UDFTEMP);
	+ }
	+ ump->fileset_desc = &dscr->fsd;
	+ dscr = NULL;
	+
	+ /* continue to the next fsd */
	+ fsd_len -= ump->discinfo.sector_size;
	+ fsd_loc.loc.lb_num = htole32(le32toh(fsd_loc.loc.lb_num)+1);
	+
	+ /* follow up to fsd->next_ex (long_ad) if its not null */
	+ if (le32toh(ump->fileset_desc->next_ex.len)) {
	+ DPRINTF(VOLUMES, ("follow up FSD extent\n"));
	+ fsd_loc = ump->fileset_desc->next_ex;
	+ fsd_len = le32toh(ump->fileset_desc->next_ex.len);
	+ }
	+ }
	+ if (dscr)
	+ free(dscr, M_UDFTEMP);
	+
	+ /* there has to be one */
	+ if (ump->fileset_desc == NULL)
	+ return (ENOENT);
	+
	+ DPRINTF(VOLUMES, ("FSD read in fine\n"));
	+ DPRINTF(VOLUMES, ("Updating fsd logical volume id\n"));
	+ udf_update_logvolname(ump, ump->logical_vol->logvol_id);
	+
	+ /*
	+ * Now the FSD is known, read in the rootdirectory and if one exists,
	+ * the system stream dir. Some files in the system streamdir are not
	+ * wanted in this implementation since they are not maintained. If
	+ * writing is enabled we'll delete these files if they exist.
	+ */
	+
	+ rootdir_node = streamdir_node = NULL;
	+ dir_loc = NULL;
	+
	+ /* try to read in the rootdir */
	+ dir_loc = &ump->fileset_desc->rootdir_icb;
	+ ino = udf_get_node_id(dir_loc);
	+ error = udf_vget(mp, ino, LK_EXCLUSIVE, &rootdir_node);
	+ if (error)
	+ return (ENOENT);
	+
	+ /* apparently it read in fine */
	+
	+ /*
	+ * Try the system stream directory; not very likely in the ones we
	+ * test, but for completeness.
	+ */
	+ dir_loc = &ump->fileset_desc->streamdir_icb;
	+ if (le32toh(dir_loc->len)) {
	+ ino = udf_get_node_id(dir_loc);
	+ error = udf_vget(mp, ino, LK_EXCLUSIVE, &streamdir_node);
	+ if (error) {
	+ printf("udf_read_rootdirs: streamdir defined: but error in streamdir reading\n");
	+ } else {
	+ /*
	+ * printf("udf_read_rootdirs: streamdir defined: but ignored");
	+ * TODO process streamdir `baddies' i.e. files we dont
	+ * want if R/W
	+ */
	+ }
	+ }
	+
	+ /* release the vnodes again; they'll be auto-recycled later */
	+ if (streamdir_node) {
	+ vput(streamdir_node);
	+ }
	+ if (rootdir_node) {
	+ vput(rootdir_node);
	+ }
	+
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* To make absolutely sure we are NOT returning zero, add one :) */
	+
	+long
	+udf_get_node_id(const struct long_ad *icbptr)
	+{
	+ /* this can fail, but in final version should never fail. */
	+ uint32_t blkn, ino;
	+ uint16_t part;
	+
	+ /* Just for now, this should be done in another way. */
	+ blkn = le32toh(icbptr->loc.lb_num);
	+ part = le16toh(icbptr->loc.part_num);
	+
	+ if ((blkn + 1) & 0xE0000000) {
	+ printf("block number too large to convert to inode number.\n");
	+ }
	+ if (part & 0xFFF8) {
	+ printf("partition number too large to convert to inode number.\n");
	+ }
	+
	+ ino = (blkn + 1) \| (part << 29);
	+ return (ino);
	+}
	+
	+int
	+udf_get_node_longad(const ino_t ino, struct long_ad *icbptr)
	+{
	+ uint32_t blkn, ino2;
	+ uint16_t part;
	+
	+ /* Just for now, this should be done in another way. */
	+ ino2 = ino;
	+ blkn = (ino2 & 0x1FFFFFFF) - 1;
	+ part = (ino2 & 0xE0000000) >> 29;
	+
	+ icbptr->loc.lb_num = htole32(blkn);
	+ icbptr->loc.part_num = htole16(part);
	+
	+ return (0);
	+}
	+
	+#if 0
	+int
	+udf_compare_icb(const struct long_ad a, const struct long_ad b)
	+{
	+ if (le16toh(a->loc.part_num) < le16toh(b->loc.part_num))
	+ return (-1);
	+ if (le16toh(a->loc.part_num) > le16toh(b->loc.part_num))
	+ return (1);
	+
	+ if (le32toh(a->loc.lb_num) < le32toh(b->loc.lb_num))
	+ return (-1);
	+ if (le32toh(a->loc.lb_num) > le32toh(b->loc.lb_num))
	+ return (1);
	+
	+ return (0);
	+}
	+
	+
	+static int
	+udf_compare_rbnodes(const struct rb_node a, const struct rb_node b)
	+{
	+ struct udf_node *a_node = RBTOUDFNODE(a);
	+ struct udf_node *b_node = RBTOUDFNODE(b);
	+
	+ return (udf_compare_icb(&a_node->loc, &b_node->loc));
	+}
	+
	+
	+static int
	+udf_compare_rbnode_icb(const struct rb_node a, const void key)
	+{
	+ struct udf_node *a_node = RBTOUDFNODE(a);
	+ const struct long_ad * const icb = key;
	+
	+ return (udf_compare_icb(&a_node->loc, icb));
	+}
	+
	+
	+static const struct rb_tree_ops udf_node_rbtree_ops = {
	+ .rbto_compare_nodes = udf_compare_rbnodes,
	+ .rbto_compare_key = udf_compare_rbnode_icb,
	+};
	+
	+
	+void
	+udf_init_nodes_tree(struct udf_mount *ump)
	+{
	+ rb_tree_init(&ump->udf_node_tree, &udf_node_rbtree_ops);
	+}
	+
	+
	+static struct udf_node *
	+udf_node_lookup(struct udf_mount ump, struct long_ad icbptr)
	+{
	+ struct rb_node *rb_node;
	+ struct udf_node *udf_node;
	+ struct vnode *vp;
	+
	+loop:
	+ mutex_enter(&ump->ihash_lock);
	+
	+ rb_node = rb_tree_find_node(&ump->udf_node_tree, icbptr);
	+ if (rb_node) {
	+ udf_node = RBTOUDFNODE(rb_node);
	+ vp = udf_node->vnode;
	+ assert(vp);
	+ mutex_enter(&vp->v_interlock);
	+ mutex_exit(&ump->ihash_lock);
	+ if (vget(vp, LK_EXCLUSIVE))
	+ goto loop;
	+ return (udf_node);
	+ }
	+ mutex_exit(&ump->ihash_lock);
	+
	+ return (NULL);
	+}
	+
	+
	+static void
	+udf_register_node(struct udf_node *udf_node)
	+{
	+ struct udf_mount *ump = udf_node->ump;
	+
	+ /* add node to the rb tree */
	+ mutex_enter(&ump->ihash_lock);
	+ rb_tree_insert_node(&ump->udf_node_tree, &udf_node->rbnode);
	+ mutex_exit(&ump->ihash_lock);
	+}
	+
	+
	+static void
	+udf_deregister_node(struct udf_node *udf_node)
	+{
	+ struct udf_mount *ump = udf_node->ump;
	+
	+ /* remove node from the rb tree */
	+ mutex_enter(&ump->ihash_lock);
	+ rb_tree_remove_node(&ump->udf_node_tree, &udf_node->rbnode);
	+ mutex_exit(&ump->ihash_lock);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_validate_session_start(struct udf_mount *ump)
	+{
	+ struct mmc_trackinfo trackinfo;
	+ struct vrs_desc *vrs;
	+ uint32_t tracknr, sessionnr, sector, sector_size;
	+ uint32_t iso9660_vrs, write_track_start;
	+ uint8_t buffer, blank, *pos;
	+ int blks, max_sectors, vrs_len;
	+ int error;
	+
	+ /* disc appendable? */
	+ if (ump->discinfo.disc_state == MMC_STATE_FULL)
	+ return (EROFS);
	+
	+ /* already written here? if so, there should be an ISO VDS */
	+ if (ump->discinfo.last_session_state == MMC_STATE_INCOMPLETE)
	+ return (0);
	+
	+ /*
	+ * Check if the first track of the session is blank and if so, copy or
	+ * create a dummy ISO descriptor so the disc is valid again.
	+ */
	+
	+ tracknr = ump->discinfo.first_track_last_session;
	+ memset(&trackinfo, 0, sizeof(struct mmc_trackinfo));
	+ trackinfo.tracknr = tracknr;
	+ error = udf_update_trackinfo(ump, &trackinfo);
	+ if (error)
	+ return (error);
	+
	+ udf_dump_trackinfo(&trackinfo);
	+ KASSERT(trackinfo.flags & (MMC_TRACKINFO_BLANK \| MMC_TRACKINFO_RESERVED));
	+ KASSERT(trackinfo.sessionnr > 1);
	+
	+ KASSERT(trackinfo.flags & MMC_TRACKINFO_NWA_VALID);
	+ write_track_start = trackinfo.next_writable;
	+
	+ /* we have to copy the ISO VRS from a former session */
	+
	+ /* sessionnr should be the session we're mounting */
	+ sessionnr = ump->mount_args.sessionnr;
	+
	+ /* start at the first track */
	+ tracknr = ump->discinfo.first_track;
	+ while (tracknr <= ump->discinfo.num_tracks) {
	+ trackinfo.tracknr = tracknr;
	+ error = udf_update_trackinfo(ump, &trackinfo);
	+ if (error)
	+ return (error);
	+ if (trackinfo.sessionnr == sessionnr)
	+ break;
	+ tracknr++;
	+ }
	+ if (trackinfo.sessionnr != sessionnr)
	+ return (ENOENT);
	+
	+ udf_dump_trackinfo(&trackinfo);
	+
	+ /*
	+ * location of iso9660 vrs is defined as first sector AFTER 32kb,
	+ * minimum ISO `sector size' 2048
	+ */
	+ sector_size = ump->discinfo.sector_size;
	+ iso9660_vrs = ((32*1024 + sector_size - 1) / sector_size)
	+ + trackinfo.track_start;
	+
	+ buffer = malloc(UDF_ISO_VRS_SIZE, M_UDFTEMP, M_WAITOK);
	+ max_sectors = UDF_ISO_VRS_SIZE / sector_size;
	+ blks = MAX(1, 2048 / sector_size);
	+
	+ error = 0;
	+ for (sector = 0; sector < max_sectors; sector += blks) {
	+ pos = buffer + sector * sector_size;
	+ error = udf_read_phys_sectors(ump, UDF_C_DSCR, pos,
	+ iso9660_vrs + sector, blks);
	+ if (error)
	+ break;
	+ /* check this ISO descriptor */
	+ vrs = (struct vrs_desc *) pos;
	+ if (strncmp(vrs->identifier, VRS_CD001, 5) == 0)
	+ continue;
	+ if (strncmp(vrs->identifier, VRS_CDW02, 5) == 0)
	+ continue;
	+ if (strncmp(vrs->identifier, VRS_BEA01, 5) == 0)
	+ continue;
	+ if (strncmp(vrs->identifier, VRS_NSR02, 5) == 0)
	+ continue;
	+ if (strncmp(vrs->identifier, VRS_NSR03, 5) == 0)
	+ continue;
	+ if (strncmp(vrs->identifier, VRS_TEA01, 5) == 0)
	+ break;
	+ /* now what? for now, end of sequence */
	+ break;
	+ }
	+ vrs_len = sector + blks;
	+ if (error) {
	+ memset(buffer, 0, UDF_ISO_VRS_SIZE);
	+
	+ vrs = (struct vrs_desc *) (buffer);
	+ vrs->struct_type = 0;
	+ vrs->version = 1;
	+ memcpy(vrs->identifier,VRS_BEA01, 5);
	+
	+ vrs = (struct vrs_desc *) (buffer + 2048);
	+ vrs->struct_type = 0;
	+ vrs->version = 1;
	+ if (le16toh(ump->logical_vol->tag.descriptor_ver) == 2) {
	+ memcpy(vrs->identifier,VRS_NSR02, 5);
	+ } else {
	+ memcpy(vrs->identifier,VRS_NSR03, 5);
	+ }
	+
	+ vrs = (struct vrs_desc *) (buffer + 4096);
	+ vrs->struct_type = 0;
	+ vrs->version = 1;
	+ memcpy(vrs->identifier, VRS_TEA01, 5);
	+
	+ vrs_len = 3*blks;
	+ }
	+
	+ /*
	+ * location of iso9660 vrs is defined as first sector AFTER 32kb,
	+ * minimum ISO `sector size' 2048
	+ */
	+ sector_size = ump->discinfo.sector_size;
	+ iso9660_vrs = ((32*1024 + sector_size - 1) / sector_size)
	+ + write_track_start;
	+
	+ /* write out 32 kb */
	+ blank = malloc(sector_size, M_UDFTEMP, M_WAITOK);
	+ memset(blank, 0, sector_size);
	+ error = 0;
	+ for (sector = write_track_start; sector < iso9660_vrs; sector ++) {
	+ error = udf_write_phys_sectors(ump, UDF_C_ABSOLUTE,
	+ blank, sector, 1);
	+ if (error)
	+ break;
	+ }
	+ if (!error) {
	+ /* write out our ISO VRS */
	+ KASSERT(sector == iso9660_vrs);
	+ error = udf_write_phys_sectors(ump, UDF_C_ABSOLUTE, buffer,
	+ sector, vrs_len);
	+ sector += vrs_len;
	+ }
	+ if (!error) {
	+ /* fill upto the first anchor at S+256 */
	+ for (; sector < write_track_start+256; sector++) {
	+ error = udf_write_phys_sectors(ump, UDF_C_ABSOLUTE,
	+ blank, sector, 1);
	+ if (error)
	+ break;
	+ }
	+ }
	+ if (!error) {
	+ /* write out anchor; write at ABSOLUTE place! */
	+ error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_ABSOLUTE,
	+ (union dscrptr *) ump->anchors[0], sector, sector);
	+ if (error)
	+ printf("writeout of anchor failed!\n");
	+ }
	+
	+ free(blank, M_UDFTEMP);
	+ free(buffer, M_UDFTEMP);
	+
	+ if (error)
	+ printf("udf_open_session: error writing iso vrs! : "
	+ "leaving disc in compromised state!\n");
	+
	+ /* synchronise device caches */
	+ (void) udf_synchronise_caches(ump);
	+
	+ return (error);
	+}
	+
	+
	+int
	+udf_open_logvol(struct udf_mount *ump)
	+{
	+ int logvol_integrity;
	+ int error;
	+
	+ /* already/still open? */
	+ logvol_integrity = le32toh(ump->logvol_integrity->integrity_type);
	+ if (logvol_integrity == UDF_INTEGRITY_OPEN)
	+ return (0);
	+
	+ /* can we open it ? */
	+ if (ump->vfs_mountp->mnt_flag & MNT_RDONLY)
	+ return (EROFS);
	+
	+ /* setup write parameters */
	+ if ((error = udf_setup_writeparams(ump)) != 0)
	+ return (error);
	+
	+ /* determine data and metadata tracks (most likely same) */
	+ error = udf_search_writing_tracks(ump);
	+ if (error) {
	+ /* most likely lack of space */
	+ printf("udf_open_logvol: error searching writing tracks\n");
	+ return (EROFS);
	+ }
	+
	+ /* writeout/update lvint on disc or only in memory */
	+ if (ump->lvopen & UDF_OPEN_SESSION) {
	+ /* TODO optional track reservation opening */
	+ error = udf_validate_session_start(ump);
	+ if (error)
	+ return (error);
	+
	+ /* determine data and metadata tracks again */
	+ error = udf_search_writing_tracks(ump);
	+ }
	+
	+ /* mark it open */
	+ ump->logvol_integrity->integrity_type = htole32(UDF_INTEGRITY_OPEN);
	+
	+ /* do we need to write it out? */
	+ if (ump->lvopen & UDF_WRITE_LVINT) {
	+ error = udf_writeout_lvint(ump, ump->lvopen);
	+ /* if we couldn't write it mark it closed again */
	+ if (error) {
	+ ump->logvol_integrity->integrity_type =
	+ htole32(UDF_INTEGRITY_CLOSED);
	+ return (error);
	+ }
	+ }
	+
	+ return (0);
	+}
	+#endif
	+
	+#if 0
	+int
	+udf_close_logvol(struct udf_mount *ump, int mntflags)
	+{
	+ struct vnode *devvp = ump->devvp;
	+ struct mmc_op mmc_op;
	+ int logvol_integrity;
	+ int error = 0, error1 = 0, error2 = 0;
	+ int tracknr;
	+ int nvats, n, nok;
	+
	+ /* already/still closed? */
	+ logvol_integrity = le32toh(ump->logvol_integrity->integrity_type);
	+ if (logvol_integrity == UDF_INTEGRITY_CLOSED)
	+ return (0);
	+
	+ /* writeout/update lvint or write out VAT */
	+ DPRINTF(VOLUMES, ("udf_close_logvol: closing logical volume\n"));
	+#ifdef DIAGNOSTIC
	+ if (ump->lvclose & UDF_CLOSE_SESSION)
	+ KASSERT(ump->lvclose & UDF_WRITE_VAT);
	+#endif
	+
	+ if (ump->lvclose & UDF_WRITE_VAT) {
	+ DPRINTF(VOLUMES, ("lvclose & UDF_WRITE_VAT\n"));
	+
	+ /* write out the VAT data and all its descriptors */
	+ DPRINTF(VOLUMES, ("writeout vat_node\n"));
	+ udf_writeout_vat(ump);
	+ vflushbuf(ump->vat_node->vnode, 1 /* sync */);
	+
	+ (void) VOP_FSYNC(ump->vat_node->vnode,
	+ FSCRED, FSYNC_WAIT, 0, 0);
	+
	+ if (ump->lvclose & UDF_CLOSE_SESSION) {
	+ DPRINTF(VOLUMES, ("udf_close_logvol: closing session "
	+ "as requested\n"));
	+ }
	+
	+ /* at least two DVD packets and 3 CD-R packets */
	+ nvats = 32;
	+
	+#if notyet
	+ /*
	+ * TODO calculate the available space and if the disc is
	+ * allmost full, write out till end-256-1 with banks, write
	+ * AVDP and fill up with VATs, then close session and close
	+ * disc.
	+ */
	+ if (ump->lvclose & UDF_FINALISE_DISC) {
	+ error = udf_write_phys_dscr_sync(ump, NULL,
	+ UDF_C_FLOAT_DSCR,
	+ (union dscrptr *) ump->anchors[0],
	+ 0, 0);
	+ if (error)
	+ printf("writeout of anchor failed!\n");
	+
	+ /* pad space with VAT ICBs */
	+ nvats = 256;
	+ }
	+#endif
	+
	+ /* write out a number of VAT nodes */
	+ nok = 0;
	+ for (n = 0; n < nvats; n++) {
	+ /* will now only write last FE/EFE */
	+ ump->vat_node->i_flags \|= IN_MODIFIED;
	+ error = VOP_FSYNC(ump->vat_node->vnode,
	+ FSCRED, FSYNC_WAIT, 0, 0);
	+ if (!error)
	+ nok++;
	+ }
	+ if (nok < 14) {
	+ /* arbitrary; but at least one or two CD frames */
	+ printf("writeout of at least 14 VATs failed\n");
	+ return (error);
	+ }
	+ }
	+
	+ /* NOTE the disc is in a (minimal) valid state now; no erroring out */
	+
	+ /* finish closing of session */
	+ if (ump->lvclose & UDF_CLOSE_SESSION) {
	+ error = udf_validate_session_start(ump);
	+ if (error)
	+ return (error);
	+
	+ (void) udf_synchronise_caches(ump);
	+
	+ /* close all associated tracks */
	+ tracknr = ump->discinfo.first_track_last_session;
	+ error = 0;
	+ while (tracknr <= ump->discinfo.last_track_last_session) {
	+ DPRINTF(VOLUMES, ("\tclosing possible open "
	+ "track %d\n", tracknr));
	+ memset(&mmc_op, 0, sizeof(mmc_op));
	+ mmc_op.operation = MMC_OP_CLOSETRACK;
	+ mmc_op.mmc_profile = ump->discinfo.mmc_profile;
	+ mmc_op.tracknr = tracknr;
	+ error = VOP_IOCTL(devvp, MMCOP, &mmc_op,
	+ FKIOCTL, NOCRED);
	+ if (error)
	+ printf("udf_close_logvol: closing of "
	+ "track %d failed\n", tracknr);
	+ tracknr ++;
	+ }
	+ if (!error) {
	+ DPRINTF(VOLUMES, ("closing session\n"));
	+ memset(&mmc_op, 0, sizeof(mmc_op));
	+ mmc_op.operation = MMC_OP_CLOSESESSION;
	+ mmc_op.mmc_profile = ump->discinfo.mmc_profile;
	+ mmc_op.sessionnr = ump->discinfo.num_sessions;
	+ error = VOP_IOCTL(devvp, MMCOP, &mmc_op,
	+ FKIOCTL, NOCRED);
	+ if (error)
	+ printf("udf_close_logvol: closing of session"
	+ "failed\n");
	+ }
	+ if (!error)
	+ ump->lvopen \|= UDF_OPEN_SESSION;
	+ if (error) {
	+ printf("udf_close_logvol: leaving disc as it is\n");
	+ ump->lvclose &= ~UDF_FINALISE_DISC;
	+ }
	+ }
	+
	+ if (ump->lvclose & UDF_FINALISE_DISC) {
	+ memset(&mmc_op, 0, sizeof(mmc_op));
	+ mmc_op.operation = MMC_OP_FINALISEDISC;
	+ mmc_op.mmc_profile = ump->discinfo.mmc_profile;
	+ mmc_op.sessionnr = ump->discinfo.num_sessions;
	+ error = VOP_IOCTL(devvp, MMCOP, &mmc_op,
	+ FKIOCTL, NOCRED);
	+ if (error)
	+ printf("udf_close_logvol: finalising disc"
	+ "failed\n");
	+ }
	+
	+ /* write out partition bitmaps if requested */
	+ if (ump->lvclose & UDF_WRITE_PART_BITMAPS) {
	+ /* sync writeout metadata spacetable if existing */
	+ error1 = udf_write_metadata_partition_spacetable(ump, true);
	+ if (error1)
	+ printf( "udf_close_logvol: writeout of metadata space "
	+ "bitmap failed\n");
	+
	+ /* sync writeout partition spacetables */
	+ error2 = udf_write_physical_partition_spacetables(ump, true);
	+ if (error2)
	+ printf( "udf_close_logvol: writeout of space tables "
	+ "failed\n");
	+
	+ if (error1 \|\| error2)
	+ return (error1 \| error2);
	+
	+ ump->lvclose &= ~UDF_WRITE_PART_BITMAPS;
	+ }
	+
	+ /* write out metadata partition nodes if requested */
	+ if (ump->lvclose & UDF_WRITE_METAPART_NODES) {
	+ /* sync writeout metadata descriptor node */
	+ error1 = udf_writeout_node(ump->metadata_node, FSYNC_WAIT);
	+ if (error1)
	+ printf( "udf_close_logvol: writeout of metadata partition "
	+ "node failed\n");
	+
	+ /* duplicate metadata partition descriptor if needed */
	+ udf_synchronise_metadatamirror_node(ump);
	+
	+ /* sync writeout metadatamirror descriptor node */
	+ error2 = udf_writeout_node(ump->metadatamirror_node, FSYNC_WAIT);
	+ if (error2)
	+ printf( "udf_close_logvol: writeout of metadata partition "
	+ "mirror node failed\n");
	+
	+ if (error1 \|\| error2)
	+ return (error1 \| error2);
	+
	+ ump->lvclose &= ~UDF_WRITE_METAPART_NODES;
	+ }
	+
	+ /* mark it closed */
	+ ump->logvol_integrity->integrity_type = htole32(UDF_INTEGRITY_CLOSED);
	+
	+ /* do we need to write out the logical volume integrity? */
	+ if (ump->lvclose & UDF_WRITE_LVINT)
	+ error = udf_writeout_lvint(ump, ump->lvopen);
	+ if (error) {
	+ /* HELP now what? mark it open again for now */
	+ ump->logvol_integrity->integrity_type =
	+ htole32(UDF_INTEGRITY_OPEN);
	+ return (error);
	+ }
	+
	+ (void) udf_synchronise_caches(ump);
	+
	+ return (0);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Genfs interfacing
	+ *
	+ * static const struct genfs_ops udf_genfsops = {
	+ * .gop_size = genfs_size,
	+ * size of transfers
	+ * .gop_alloc = udf_gop_alloc,
	+ * allocate len bytes at offset
	+ * .gop_write = genfs_gop_write,
	+ * putpages interface code
	+ * .gop_markupdate = udf_gop_markupdate,
	+ * set update/modify flags etc.
	+ * }
	+ */
	+
	+/*
	+ * Genfs interface. These four functions are the only ones defined though not
	+ * documented... great....
	+ */
	+
	+/*
	+ * Called for allocating an extent of the file either by VOP_WRITE() or by
	+ * genfs filling up gaps.
	+ */
	+#if 0
	+static int
	+udf_gop_alloc(struct vnode *vp, off_t off,
	+ off_t len, int flags, kauth_cred_t cred)
	+{
	+ struct udf_node *udf_node = VTOI(vp);
	+ struct udf_mount *ump = udf_node->ump;
	+ uint64_t lb_start, lb_end;
	+ uint32_t lb_size, num_lb;
	+ int udf_c_type, vpart_num, can_fail;
	+ int error;
	+
	+ DPRINTF(ALLOC, ("udf_gop_alloc called for offset %"PRIu64" for %"PRIu64" bytes, %s\n",
	+ off, len, flags? "SYNC":"NONE"));
	+
	+ /*
	+ * request the pages of our vnode and see how many pages will need to
	+ * be allocated and reserve that space
	+ */
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+ lb_start = off / lb_size;
	+ lb_end = (off + len + lb_size -1) / lb_size;
	+ num_lb = lb_end - lb_start;
	+
	+ udf_c_type = udf_get_c_type(udf_node);
	+ vpart_num = udf_get_record_vpart(ump, udf_c_type);
	+
	+ /* all requests can fail */
	+ can_fail = true;
	+
	+ /* fid's (directories) can't fail */
	+ if (udf_c_type == UDF_C_FIDS)
	+ can_fail = false;
	+
	+ /* system files can't fail */
	+ if (vp->v_vflag & VV_SYSTEM)
	+ can_fail = false;
	+
	+ error = udf_reserve_space(ump, udf_node, udf_c_type,
	+ vpart_num, num_lb, can_fail);
	+
	+ DPRINTF(ALLOC, ("\tlb_start %"PRIu64", lb_end %"PRIu64", num_lb %d\n",
	+ lb_start, lb_end, num_lb));
	+
	+ return (error);
	+}
	+
	+
	+/*
	+ * callback from genfs to update our flags
	+ */
	+static void
	+udf_gop_markupdate(struct vnode *vp, int flags)
	+{
	+ struct udf_node *udf_node = VTOI(vp);
	+ u_long mask = 0;
	+
	+ if ((flags & GOP_UPDATE_ACCESSED) != 0) {
	+ mask = IN_ACCESS;
	+ }
	+ if ((flags & GOP_UPDATE_MODIFIED) != 0) {
	+ if (vp->v_type == VREG) {
	+ mask \|= IN_CHANGE \| IN_UPDATE;
	+ } else {
	+ mask \|= IN_MODIFY;
	+ }
	+ }
	+ if (mask) {
	+ udf_node->i_flags \|= mask;
	+ }
	+}
	+
	+
	+static const struct genfs_ops udf_genfsops = {
	+ .gop_size = genfs_size,
	+ .gop_alloc = udf_gop_alloc,
	+ .gop_write = genfs_gop_write_rwmap,
	+ .gop_markupdate = udf_gop_markupdate,
	+};
	+
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_write_terminator(struct udf_mount *ump, uint32_t sector)
	+{
	+ union dscrptr *dscr;
	+ int error;
	+
	+ dscr = malloc(ump->discinfo.sector_size, M_UDFTEMP, M_WAITOK\|M_ZERO);
	+ udf_inittag(ump, &dscr->tag, TAGID_TERM, sector);
	+
	+ /* CRC length for an anchor is 512 - tag length; defined in Ecma 167 */
	+ dscr->tag.desc_crc_len = le16toh(512-UDF_DESC_TAG_LENGTH);
	+ (void) udf_validate_tag_and_crc_sums(dscr);
	+
	+ error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
	+ dscr, sector, sector);
	+
	+ free(dscr, M_UDFTEMP);
	+
	+ return (error);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* UDF<->unix converters */
	+
	+/* --------------------------------------------------------------------- */
	+
	+static mode_t
	+udf_perm_to_unix_mode(uint32_t perm)
	+{
	+ mode_t mode;
	+
	+ mode = ((perm & UDF_FENTRY_PERM_USER_MASK) );
	+ mode \|= ((perm & UDF_FENTRY_PERM_GRP_MASK ) >> 2);
	+ mode \|= ((perm & UDF_FENTRY_PERM_OWNER_MASK) >> 4);
	+
	+ return (mode);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+#if 0
	+static uint32_t
	+unix_mode_to_udf_perm(mode_t mode)
	+{
	+ uint32_t perm;
	+
	+ perm = ((mode & S_IRWXO) );
	+ perm \|= ((mode & S_IRWXG) << 2);
	+ perm \|= ((mode & S_IRWXU) << 4);
	+ perm \|= ((mode & S_IWOTH) << 3);
	+ perm \|= ((mode & S_IWGRP) << 5);
	+ perm \|= ((mode & S_IWUSR) << 7);
	+
	+ return (perm);
	+}
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	+static uint32_t
	+udf_icb_to_unix_filetype(uint32_t icbftype)
	+{
	+ switch (icbftype) {
	+ case UDF_ICB_FILETYPE_DIRECTORY :
	+ case UDF_ICB_FILETYPE_STREAMDIR :
	+ return (S_IFDIR);
	+ case UDF_ICB_FILETYPE_FIFO :
	+ return (S_IFIFO);
	+ case UDF_ICB_FILETYPE_CHARDEVICE :
	+ return (S_IFCHR);
	+ case UDF_ICB_FILETYPE_BLOCKDEVICE :
	+ return (S_IFBLK);
	+ case UDF_ICB_FILETYPE_RANDOMACCESS :
	+ case UDF_ICB_FILETYPE_REALTIME :
	+ return (S_IFREG);
	+ case UDF_ICB_FILETYPE_SYMLINK :
	+ return (S_IFLNK);
	+ case UDF_ICB_FILETYPE_SOCKET :
	+ return (S_IFSOCK);
	+ }
	+ /* no idea what this is */
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+/* These timestamp_to_timespec functions are done. */
	+static const int days_to_mon[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
	+static int udf_leapyear(int year) {
	+ int i;
	+ i = (year % 400 == 0) ? 1 : 0;
	+ i \|= (year % 100 == 0) ? 0 : 1;
	+ i &= (year % 4 == 0) ? 1 : 0;
	+ return (i);
	+}
	+void
	+udf_timestamp_to_timespec(struct udf_mount *ump,
	+ struct timestamp *timestamp,
	+ struct timespec *timespec)
	+{
	+ time_t secs;
	+ uint32_t usecs, nsecs;
	+ uint16_t tz, year;
	+
	+ year = le16toh(timestamp->year);
	+ if (year < 1970 \|\| timestamp->month < 1 \|\| timestamp->month > 12) {
	+ timespec->tv_sec = 0;
	+ timespec->tv_nsec = 0;
	+ return;
	+ }
	+
	+ secs = timestamp->second;
	+ secs += timestamp->minute * 60;
	+ secs += timestamp->hour * 3600;
	+ secs += (timestamp->day - 1) * 3600 * 24;
	+ secs += days_to_mon[timestamp->month - 1] * 3600 * 24;
	+
	+ secs += (year - 1970) * 365 * 3600 * 24;
	+ secs += ((year - 1 - 1968) / 4) * 3600 * 24;
	+
	+ if (year > 2100) {
	+ secs -= (((year - 1 - 2100) / 100) + 1) * 3600 * 24;
	+ }
	+ if (year > 2400) {
	+ secs += (((year - 1 - 2400) / 400) + 1) * 3600 * 24;
	+ }
	+ if (timestamp->month > 2) {
	+ secs += (time_t)udf_leapyear(year) * 3600 * 24;
	+ }
	+
	+ usecs = timestamp->usec +
	+ 100timestamp->hund_usec + 10000timestamp->centisec;
	+ nsecs = usecs * 1000;
	+
	+ /*
	+ * Calculate the time zone. The timezone is 12 bit signed 2's
	+ * compliment, so we gotta do some extra magic to handle it right.
	+ */
	+ tz = le16toh(timestamp->type_tz);
	+ tz &= 0x0fff; /* only lower 12 bits are significant */
	+ if (tz & 0x0800) /* sign extension */
	+ tz \|= 0xf000;
	+
	+ /*
	+ * TODO check timezone conversion
	+ * check if we are specified a timezone to convert
	+ */
	+ if (le16toh(timestamp->type_tz) & 0x1000) {
	+ if ((int16_t) tz != -2047)
	+ secs -= (int16_t) tz * 60;
	+ } /* else {
	+ secs -= ump->mount_args.gmtoff;
	+ } */
	+
	+ timespec->tv_sec = secs;
	+ timespec->tv_nsec = nsecs;
	+
	+ return;
	+}
	+#if 0
	+
	+void
	+udf_timespec_to_timestamp(struct timespec timespec, struct timestamp timestamp)
	+{
	+ struct clock_ymdhms ymdhms;
	+ uint32_t husec, usec, csec;
	+
	+ (void) clock_secs_to_ymdhms(timespec->tv_sec, &ymdhms);
	+
	+ usec = timespec->tv_nsec / 1000;
	+ husec = usec / 100;
	+ usec -= husec * 100; /* only 0-99 in usec */
	+ csec = husec / 100; /* only 0-99 in csec */
	+ husec -= csec * 100; /* only 0-99 in husec */
	+
	+ /* set method 1 for CUT/GMT */
	+ timestamp->type_tz = htole16((1<<12) + 0);
	+ timestamp->year = htole16(ymdhms.dt_year);
	+ timestamp->month = ymdhms.dt_mon;
	+ timestamp->day = ymdhms.dt_day;
	+ timestamp->hour = ymdhms.dt_hour;
	+ timestamp->minute = ymdhms.dt_min;
	+ timestamp->second = ymdhms.dt_sec;
	+ timestamp->centisec = csec;
	+ timestamp->hund_usec = husec;
	+ timestamp->usec = usec;
	+}
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Attribute and filetypes converters with get/set pairs
	+ */
	+
	+uint32_t
	+udf_getaccessmode(struct udf_node *udf_node)
	+{
	+ struct file_entry *fe = udf_node->fe;
	+ struct extfile_entry *efe = udf_node->efe;
	+ uint32_t udf_perm, icbftype, mode, ftype;
	+ uint16_t icbflags;
	+
	+/* UDF_LOCK_NODE(udf_node, 0); */
	+ if (fe) {
	+ udf_perm = le32toh(fe->perm);
	+ icbftype = fe->icbtag.file_type;
	+ icbflags = le16toh(fe->icbtag.flags);
	+ } else {
	+ KASSERT(udf_node->efe, ("Extended File Entry is null"));
	+ udf_perm = le32toh(efe->perm);
	+ icbftype = efe->icbtag.file_type;
	+ icbflags = le16toh(efe->icbtag.flags);
	+ }
	+
	+ mode = udf_perm_to_unix_mode(udf_perm);
	+ ftype = udf_icb_to_unix_filetype(icbftype);
	+
	+ /* set suid, sgid, sticky from flags in fe/efe */
	+ if (icbflags & UDF_ICB_TAG_FLAGS_SETUID)
	+ mode \|= S_ISUID;
	+ if (icbflags & UDF_ICB_TAG_FLAGS_SETGID)
	+ mode \|= S_ISGID;
	+ if (icbflags & UDF_ICB_TAG_FLAGS_STICKY)
	+ mode \|= S_ISVTX;
	+
	+/* UDF_UNLOCK_NODE(udf_node, 0); */
	+
	+ return (mode \| ftype);
	+}
	+
	+#if 0
	+void
	+udf_setaccessmode(struct udf_node *udf_node, mode_t mode)
	+{
	+ struct file_entry *fe = udf_node->fe;
	+ struct extfile_entry *efe = udf_node->efe;
	+ uint32_t udf_perm;
	+ uint16_t icbflags;
	+
	+ UDF_LOCK_NODE(udf_node, 0);
	+ udf_perm = unix_mode_to_udf_perm(mode & ALLPERMS);
	+ if (fe) {
	+ icbflags = le16toh(fe->icbtag.flags);
	+ } else {
	+ icbflags = le16toh(efe->icbtag.flags);
	+ }
	+
	+ icbflags &= ~UDF_ICB_TAG_FLAGS_SETUID;
	+ icbflags &= ~UDF_ICB_TAG_FLAGS_SETGID;
	+ icbflags &= ~UDF_ICB_TAG_FLAGS_STICKY;
	+ if (mode & S_ISUID)
	+ icbflags \|= UDF_ICB_TAG_FLAGS_SETUID;
	+ if (mode & S_ISGID)
	+ icbflags \|= UDF_ICB_TAG_FLAGS_SETGID;
	+ if (mode & S_ISVTX)
	+ icbflags \|= UDF_ICB_TAG_FLAGS_STICKY;
	+
	+ if (fe) {
	+ fe->perm = htole32(udf_perm);
	+ fe->icbtag.flags = htole16(icbflags);
	+ } else {
	+ efe->perm = htole32(udf_perm);
	+ efe->icbtag.flags = htole16(icbflags);
	+ }
	+
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+}
	+
	+
	+void
	+udf_getownership(struct udf_node udf_node, uid_t uidp, gid_t *gidp)
	+{
	+ struct udf_mount *ump = udf_node->ump;
	+ struct file_entry *fe = udf_node->fe;
	+ struct extfile_entry *efe = udf_node->efe;
	+ uid_t uid;
	+ gid_t gid;
	+
	+ UDF_LOCK_NODE(udf_node, 0);
	+ if (fe) {
	+ uid = (uid_t)le32toh(fe->uid);
	+ gid = (gid_t)le32toh(fe->gid);
	+ } else {
	+ assert(udf_node->efe);
	+ uid = (uid_t)le32toh(efe->uid);
	+ gid = (gid_t)le32toh(efe->gid);
	+ }
	+
	+ /* do the uid/gid translation game */
	+ if (uid == (uid_t) -1)
	+ uid = ump->mount_args.anon_uid;
	+ if (gid == (gid_t) -1)
	+ gid = ump->mount_args.anon_gid;
	+
	+ *uidp = uid;
	+ *gidp = gid;
	+
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+}
	+
	+
	+void
	+udf_setownership(struct udf_node *udf_node, uid_t uid, gid_t gid)
	+{
	+ struct udf_mount *ump = udf_node->ump;
	+ struct file_entry *fe = udf_node->fe;
	+ struct extfile_entry *efe = udf_node->efe;
	+ uid_t nobody_uid;
	+ gid_t nobody_gid;
	+
	+ UDF_LOCK_NODE(udf_node, 0);
	+
	+ /* do the uid/gid translation game */
	+ nobody_uid = ump->mount_args.nobody_uid;
	+ nobody_gid = ump->mount_args.nobody_gid;
	+ if (uid == nobody_uid)
	+ uid = (uid_t) -1;
	+ if (gid == nobody_gid)
	+ gid = (gid_t) -1;
	+
	+ if (fe) {
	+ fe->uid = htole32((uint32_t) uid);
	+ fe->gid = htole32((uint32_t) gid);
	+ } else {
	+ efe->uid = htole32((uint32_t) uid);
	+ efe->gid = htole32((uint32_t) gid);
	+ }
	+
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+}
	+
	+
	+/* --------------------------------------------------------------------- */
	+
	+
	+static int
	+dirhash_fill(struct udf_node *dir_node)
	+{
	+ struct vnode *dvp = dir_node->vnode;
	+ struct dirhash *dirh;
	+ struct file_entry *fe = dir_node->fe;
	+ struct extfile_entry *efe = dir_node->efe;
	+ struct fileid_desc *fid;
	+ struct dirent *dirent;
	+ uint64_t file_size, pre_diroffset, diroffset = 0;
	+ uint32_t lb_size;
	+ int error = 0;
	+
	+ /* make sure we have a dirhash to work on */
	+ dirh = dir_node->dir_hash;
	+ KASSERT(dirh, ("dirhash_fill: dirhash is null"));
	+ KASSERT(dirh->dn_refcount > 0, ("dirhash_fill: dirhash does not have reference"));
	+
	+#if 0
	+ if (dirh->flags & DIRH_BROKEN)
	+ return (EIO);
	+ if (dirh->flags & DIRH_COMPLETE)
	+ return (0);
	+
	+ /* make sure we have a clean dirhash to add to */
	+ dirhash_purge_entries(dirh);
	+#endif
	+
	+ /* get directory filesize */
	+ if (fe) {
	+ file_size = le64toh(fe->inf_len);
	+ } else {
	+ KASSERT(node->efe, ("Extended File Entry is null"));
	+ file_size = le64toh(efe->inf_len);
	+ }
	+
	+ /* allocate temporary space for fid */
	+ lb_size = le32toh(dir_node->ump->logical_vol->lb_size);
	+ fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
	+
	+ /* allocate temporary space for dirent */
	+ dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
	+
	+ while (diroffset < file_size) {
	+ /* transfer a new fid/dirent */
	+ pre_diroffset = diroffset;
	+ error = udf_read_fid_stream(dvp, &diroffset, fid, dirent);
	+ if (error) {
	+ /* TODO what to do? continue but not add? */
	+ dirh->flags \|= DIRH_BROKEN;
	+ dirhash_purge_entries(dirh);
	+ break;
	+ }
	+
	+ if ((fid->file_char & UDF_FILE_CHAR_DEL)) {
	+ /* register deleted extent for reuse */
	+ dirhash_enter_freed(dirh, pre_diroffset,
	+ udf_fidsize(fid));
	+ } else {
	+ /* append to the dirhash */
	+ dirhash_enter(dirh, dirent, pre_diroffset,
	+ udf_fidsize(fid), 0);
	+ }
	+ }
	+ dirh->flags \|= DIRH_COMPLETE;
	+
	+ free(fid, M_UDFTEMP);
	+ free(dirent, M_UDFTEMP);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Directory read and manipulation functions.
	+ *
	+ */
	+
	+int
	+udf_lookup_name_in_dir(struct vnode vp, const char name, int namelen,
	+ struct long_ad icb_loc, int found)
	+{
	+ struct udf_node *dir_node = VTOI(vp);
	+ struct dirhash *dirh;
	+ struct dirhash_entry *dirh_ep;
	+ struct fileid_desc *fid;
	+ struct dirent *dirent;
	+ uint64_t diroffset;
	+ uint32_t lb_size;
	+ int hit, error;
	+
	+ /* set default return */
	+ *found = 0;
	+
	+ /* get our dirhash and make sure its read in */
	+ dirhash_get(&dir_node->dir_hash);
	+ error = dirhash_fill(dir_node);
	+ if (error) {
	+ dirhash_put(dir_node->dir_hash);
	+ return (error);
	+ }
	+ dirh = dir_node->dir_hash;
	+
	+ /* allocate temporary space for fid */
	+ lb_size = le32toh(dir_node->ump->logical_vol->lb_size);
	+ fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
	+ dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
	+
	+ /* search our dirhash hits */
	+ memset(icb_loc, 0, sizeof(*icb_loc));
	+ dirh_ep = NULL;
	+ for (;;) {
	+ hit = dirhash_lookup(dirh, name, namelen, &dirh_ep);
	+ /* if no hit, abort the search */
	+ if (!hit)
	+ break;
	+
	+ /* check this hit */
	+ diroffset = dirh_ep->offset;
	+
	+ /* transfer a new fid/dirent */
	+ error = udf_read_fid_stream(vp, &diroffset, fid, dirent);
	+ if (error)
	+ break;
	+
	+ /* see if its our entry */
	+ KASSERT(dirent->d_namlen == namelen);
	+ if (strncmp(dirent->d_name, name, namelen) == 0) {
	+ *found = 1;
	+ *icb_loc = fid->icb;
	+ break;
	+ }
	+ }
	+ free(fid, M_UDFTEMP);
	+ free(dirent, M_UDFTEMP);
	+
	+ dirhash_put(dir_node->dir_hash);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_create_new_fe(struct udf_mount ump, struct file_entry fe, int file_type,
	+ struct long_ad node_icb, struct long_ad parent_icb,
	+ uint64_t parent_unique_id)
	+{
	+ struct timespec now;
	+ struct icb_tag *icb;
	+ struct filetimes_extattr_entry *ft_extattr;
	+ uint64_t unique_id;
	+ uint32_t fidsize, lb_num;
	+ uint8_t *bpos;
	+ int crclen, attrlen;
	+
	+ lb_num = le32toh(node_icb->loc.lb_num);
	+ udf_inittag(ump, &fe->tag, TAGID_FENTRY, lb_num);
	+ icb = &fe->icbtag;
	+
	+ /*
	+ * Always use strategy type 4 unless on WORM wich we don't support
	+ * (yet). Fill in defaults and set for internal allocation of data.
	+ */
	+ icb->strat_type = htole16(4);
	+ icb->max_num_entries = htole16(1);
	+ icb->file_type = file_type; /* 8 bit */
	+ icb->flags = htole16(UDF_ICB_INTERN_ALLOC);
	+
	+ fe->perm = htole32(0x7fff); /* all is allowed */
	+ fe->link_cnt = htole16(0); /* explicit setting */
	+
	+ fe->ckpoint = htole32(1); /* user supplied file version */
	+
	+ vfs_timestamp(&now);
	+ udf_timespec_to_timestamp(&now, &fe->atime);
	+ udf_timespec_to_timestamp(&now, &fe->attrtime);
	+ udf_timespec_to_timestamp(&now, &fe->mtime);
	+
	+ udf_set_regid(&fe->imp_id, IMPL_NAME);
	+ udf_add_impl_regid(ump, &fe->imp_id);
	+
	+ unique_id = udf_advance_uniqueid(ump);
	+ fe->unique_id = htole64(unique_id);
	+ fe->l_ea = htole32(0);
	+
	+ /* create extended attribute to record our creation time */
	+ attrlen = UDF_FILETIMES_ATTR_SIZE(1);
	+ ft_extattr = malloc(attrlen, M_UDFTEMP, M_WAITOK);
	+ memset(ft_extattr, 0, attrlen);
	+ ft_extattr->hdr.type = htole32(UDF_FILETIMES_ATTR_NO);
	+ ft_extattr->hdr.subtype = 1; /* [4/48.10.5] */
	+ ft_extattr->hdr.a_l = htole32(UDF_FILETIMES_ATTR_SIZE(1));
	+ ft_extattr->d_l = htole32(UDF_TIMESTAMP_SIZE); /* one item */
	+ ft_extattr->existence = UDF_FILETIMES_FILE_CREATION;
	+ udf_timespec_to_timestamp(&now, &ft_extattr->times[0]);
	+
	+ udf_extattr_insert_internal(ump, (union dscrptr *) fe,
	+ (struct extattr_entry *) ft_extattr);
	+ free(ft_extattr, M_UDFTEMP);
	+
	+ /* if its a directory, create '..' */
	+ bpos = (uint8_t *) fe->data + le32toh(fe->l_ea);
	+ fidsize = 0;
	+ if (file_type == UDF_ICB_FILETYPE_DIRECTORY) {
	+ fidsize = udf_create_parentfid(ump,
	+ (struct fileid_desc *) bpos, parent_icb,
	+ parent_unique_id);
	+ }
	+
	+ /* record fidlength information */
	+ fe->inf_len = htole64(fidsize);
	+ fe->l_ad = htole32(fidsize);
	+ fe->logblks_rec = htole64(0); /* intern */
	+
	+ crclen = sizeof(struct file_entry) - 1 - UDF_DESC_TAG_LENGTH;
	+ crclen += le32toh(fe->l_ea) + fidsize;
	+ fe->tag.desc_crc_len = htole16(crclen);
	+
	+ (void) udf_validate_tag_and_crc_sums((union dscrptr *) fe);
	+
	+ return (fidsize);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_create_new_efe(struct udf_mount ump, struct extfile_entry efe,
	+ int file_type, struct long_ad node_icb, struct long_ad parent_icb,
	+ uint64_t parent_unique_id)
	+{
	+ struct timespec now;
	+ struct icb_tag *icb;
	+ uint64_t unique_id;
	+ uint32_t fidsize, lb_num;
	+ uint8_t *bpos;
	+ int crclen;
	+
	+ lb_num = le32toh(node_icb->loc.lb_num);
	+ udf_inittag(ump, &efe->tag, TAGID_EXTFENTRY, lb_num);
	+ icb = &efe->icbtag;
	+
	+ /*
	+ * Always use strategy type 4 unless on WORM wich we don't support
	+ * (yet). Fill in defaults and set for internal allocation of data.
	+ */
	+ icb->strat_type = htole16(4);
	+ icb->max_num_entries = htole16(1);
	+ icb->file_type = file_type; /* 8 bit */
	+ icb->flags = htole16(UDF_ICB_INTERN_ALLOC);
	+
	+ efe->perm = htole32(0x7fff); /* all is allowed */
	+ efe->link_cnt = htole16(0); /* explicit setting */
	+
	+ efe->ckpoint = htole32(1); /* user supplied file version */
	+
	+ vfs_timestamp(&now);
	+ udf_timespec_to_timestamp(&now, &efe->ctime);
	+ udf_timespec_to_timestamp(&now, &efe->atime);
	+ udf_timespec_to_timestamp(&now, &efe->attrtime);
	+ udf_timespec_to_timestamp(&now, &efe->mtime);
	+
	+ udf_set_regid(&efe->imp_id, IMPL_NAME);
	+ udf_add_impl_regid(ump, &efe->imp_id);
	+
	+ unique_id = udf_advance_uniqueid(ump);
	+ efe->unique_id = htole64(unique_id);
	+ efe->l_ea = htole32(0);
	+
	+ /* if its a directory, create '..' */
	+ bpos = (uint8_t *) efe->data + le32toh(efe->l_ea);
	+ fidsize = 0;
	+ if (file_type == UDF_ICB_FILETYPE_DIRECTORY) {
	+ fidsize = udf_create_parentfid(ump,
	+ (struct fileid_desc *) bpos, parent_icb,
	+ parent_unique_id);
	+ }
	+
	+ /* record fidlength information */
	+ efe->obj_size = htole64(fidsize);
	+ efe->inf_len = htole64(fidsize);
	+ efe->l_ad = htole32(fidsize);
	+ efe->logblks_rec = htole64(0); /* intern */
	+
	+ crclen = sizeof(struct extfile_entry) - 1 - UDF_DESC_TAG_LENGTH;
	+ crclen += le32toh(efe->l_ea) + fidsize;
	+ efe->tag.desc_crc_len = htole16(crclen);
	+
	+ (void) udf_validate_tag_and_crc_sums((union dscrptr *) efe);
	+
	+ return (fidsize);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_dir_detach(struct udf_mount ump, struct udf_node dir_node,
	+ struct udf_node udf_node, struct componentname cnp)
	+{
	+ struct vnode *dvp = dir_node->vnode;
	+ struct dirhash *dirh;
	+ struct dirhash_entry *dirh_ep;
	+ struct file_entry *fe = dir_node->fe;
	+ struct extfile_entry *efe = dir_node->efe;
	+ struct fileid_desc *fid;
	+ struct dirent *dirent;
	+ uint64_t file_size, diroffset;
	+ uint32_t lb_size, fidsize;
	+ int found, error;
	+ char const *name = cnp->cn_nameptr;
	+ int namelen = cnp->cn_namelen;
	+ int hit, refcnt;
	+
	+ /* get our dirhash and make sure its read in */
	+ dirhash_get(&dir_node->dir_hash);
	+ error = dirhash_fill(dir_node);
	+ if (error) {
	+ dirhash_put(dir_node->dir_hash);
	+ return (error);
	+ }
	+ dirh = dir_node->dir_hash;
	+
	+ /* get directory filesize */
	+ if (fe) {
	+ file_size = le64toh(fe->inf_len);
	+ } else {
	+ assert(efe);
	+ file_size = le64toh(efe->inf_len);
	+ }
	+
	+ /* allocate temporary space for fid */
	+ lb_size = le32toh(dir_node->ump->logical_vol->lb_size);
	+ fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
	+ dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
	+
	+ /* search our dirhash hits */
	+ found = 0;
	+ dirh_ep = NULL;
	+ for (;;) {
	+ hit = dirhash_lookup(dirh, name, namelen, &dirh_ep);
	+ /* if no hit, abort the search */
	+ if (!hit)
	+ break;
	+
	+ /* check this hit */
	+ diroffset = dirh_ep->offset;
	+
	+ /* transfer a new fid/dirent */
	+ error = udf_read_fid_stream(dvp, &diroffset, fid, dirent);
	+ if (error)
	+ break;
	+
	+ /* see if its our entry */
	+ KASSERT(dirent->d_namlen == namelen);
	+ if (strncmp(dirent->d_name, name, namelen) == 0) {
	+ found = 1;
	+ break;
	+ }
	+ }
	+
	+ if (!found)
	+ error = ENOENT;
	+ if (error)
	+ goto error_out;
	+
	+ /* mark deleted */
	+ fid->file_char \|= UDF_FILE_CHAR_DEL;
	+#ifdef UDF_COMPLETE_DELETE
	+ memset(&fid->icb, 0, sizeof(fid->icb));
	+#endif
	+ (void) udf_validate_tag_and_crc_sums((union dscrptr *) fid);
	+
	+ /* get size of fid and compensate for the read_fid_stream advance */
	+ fidsize = udf_fidsize(fid);
	+ diroffset -= fidsize;
	+
	+ /* write out */
	+ error = vn_rdwr(UIO_WRITE, dir_node->vnode,
	+ fid, fidsize, diroffset,
	+ UIO_SYSSPACE, IO_ALTSEMANTICS \| IO_NODELOCKED,
	+ FSCRED, NULL, NULL);
	+ if (error)
	+ goto error_out;
	+
	+ /* get reference count of attached node */
	+ if (udf_node->fe) {
	+ refcnt = le16toh(udf_node->fe->link_cnt);
	+ } else {
	+ KASSERT(udf_node->efe);
	+ refcnt = le16toh(udf_node->efe->link_cnt);
	+ }
	+#ifdef UDF_COMPLETE_DELETE
	+ /* substract reference counter in attached node */
	+ refcnt -= 1;
	+ if (udf_node->fe) {
	+ udf_node->fe->link_cnt = htole16(refcnt);
	+ } else {
	+ udf_node->efe->link_cnt = htole16(refcnt);
	+ }
	+
	+ /* prevent writeout when refcnt == 0 */
	+ if (refcnt == 0)
	+ udf_node->i_flags \|= IN_DELETED;
	+
	+ if (fid->file_char & UDF_FILE_CHAR_DIR) {
	+ int drefcnt;
	+
	+ /* substract reference counter in directory node */
	+ /* note subtract 2 (?) for its was also backreferenced */
	+ if (dir_node->fe) {
	+ drefcnt = le16toh(dir_node->fe->link_cnt);
	+ drefcnt -= 1;
	+ dir_node->fe->link_cnt = htole16(drefcnt);
	+ } else {
	+ KASSERT(dir_node->efe);
	+ drefcnt = le16toh(dir_node->efe->link_cnt);
	+ drefcnt -= 1;
	+ dir_node->efe->link_cnt = htole16(drefcnt);
	+ }
	+ }
	+
	+ udf_node->i_flags \|= IN_MODIFIED;
	+ dir_node->i_flags \|= IN_MODIFIED;
	+#endif
	+ /* if it is/was a hardlink adjust the file count */
	+ if (refcnt > 0)
	+ udf_adjust_filecount(udf_node, -1);
	+
	+ /* remove from the dirhash */
	+ dirhash_remove(dirh, dirent, diroffset,
	+ udf_fidsize(fid));
	+
	+error_out:
	+ free(fid, M_UDFTEMP);
	+ free(dirent, M_UDFTEMP);
	+
	+ dirhash_put(dir_node->dir_hash);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_dir_update_rootentry(struct udf_mount ump, struct udf_node dir_node,
	+ struct udf_node *new_parent_node)
	+{
	+ struct vnode *dvp = dir_node->vnode;
	+ struct dirhash *dirh;
	+ struct dirhash_entry *dirh_ep;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct fileid_desc *fid;
	+ struct dirent *dirent;
	+ uint64_t file_size, diroffset;
	+ uint64_t new_parent_unique_id;
	+ uint32_t lb_size, fidsize;
	+ int found, error;
	+ char const *name = "..";
	+ int namelen = 2;
	+ int hit;
	+
	+ /* get our dirhash and make sure its read in */
	+ dirhash_get(&dir_node->dir_hash);
	+ error = dirhash_fill(dir_node);
	+ if (error) {
	+ dirhash_put(dir_node->dir_hash);
	+ return (error);
	+ }
	+ dirh = dir_node->dir_hash;
	+
	+ /* get new parent's unique ID */
	+ fe = new_parent_node->fe;
	+ efe = new_parent_node->efe;
	+ if (fe) {
	+ new_parent_unique_id = le64toh(fe->unique_id);
	+ } else {
	+ assert(efe);
	+ new_parent_unique_id = le64toh(efe->unique_id);
	+ }
	+
	+ /* get directory filesize */
	+ fe = dir_node->fe;
	+ efe = dir_node->efe;
	+ if (fe) {
	+ file_size = le64toh(fe->inf_len);
	+ } else {
	+ assert(efe);
	+ file_size = le64toh(efe->inf_len);
	+ }
	+
	+ /* allocate temporary space for fid */
	+ lb_size = le32toh(dir_node->ump->logical_vol->lb_size);
	+ fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
	+ dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
	+
	+ /*
	+ * NOTE the standard does not dictate the FID entry '..' should be
	+ * first, though in practice it will most likely be.
	+ */
	+
	+ /* search our dirhash hits */
	+ found = 0;
	+ dirh_ep = NULL;
	+ for (;;) {
	+ hit = dirhash_lookup(dirh, name, namelen, &dirh_ep);
	+ /* if no hit, abort the search */
	+ if (!hit)
	+ break;
	+
	+ /* check this hit */
	+ diroffset = dirh_ep->offset;
	+
	+ /* transfer a new fid/dirent */
	+ error = udf_read_fid_stream(dvp, &diroffset, fid, dirent);
	+ if (error)
	+ break;
	+
	+ /* see if its our entry */
	+ KASSERT(dirent->d_namlen == namelen);
	+ if (strncmp(dirent->d_name, name, namelen) == 0) {
	+ found = 1;
	+ break;
	+ }
	+ }
	+
	+ if (!found)
	+ error = ENOENT;
	+ if (error)
	+ goto error_out;
	+
	+ /* update our ICB to the new parent, hit of lower 32 bits of uniqueid */
	+ fid->icb = new_parent_node->write_loc;
	+ fid->icb.longad_uniqueid = htole32(new_parent_unique_id);
	+
	+ (void) udf_validate_tag_and_crc_sums((union dscrptr *) fid);
	+
	+ /* get size of fid and compensate for the read_fid_stream advance */
	+ fidsize = udf_fidsize(fid);
	+ diroffset -= fidsize;
	+
	+ /* write out */
	+ error = vn_rdwr(UIO_WRITE, dir_node->vnode,
	+ fid, fidsize, diroffset,
	+ UIO_SYSSPACE, IO_ALTSEMANTICS \| IO_NODELOCKED,
	+ FSCRED, NULL, NULL);
	+
	+ /* nothing to be done in the dirhash */
	+
	+error_out:
	+ free(fid, M_UDFTEMP);
	+ free(dirent, M_UDFTEMP);
	+
	+ dirhash_put(dir_node->dir_hash);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * We are not allowed to split the fid tag itself over an logical block so
	+ * check the space remaining in the logical block.
	+ *
	+ * We try to select the smallest candidate for recycling or when none is
	+ * found, append a new one at the end of the directory.
	+ */
	+
	+int
	+udf_dir_attach(struct udf_mount ump, struct udf_node dir_node,
	+ struct udf_node udf_node, struct vattr vap, struct componentname *cnp)
	+{
	+ struct vnode *dvp = dir_node->vnode;
	+ struct dirhash *dirh;
	+ struct dirhash_entry *dirh_ep;
	+ struct fileid_desc *fid;
	+ struct icb_tag *icbtag;
	+ struct charspec osta_charspec;
	+ struct dirent dirent;
	+ uint64_t unique_id, dir_size;
	+ uint64_t fid_pos, end_fid_pos, chosen_fid_pos;
	+ uint32_t chosen_size, chosen_size_diff;
	+ int lb_size, lb_rest, fidsize, this_fidsize, size_diff;
	+ int file_char, refcnt, icbflags, addr_type, hit, error;
	+
	+ /* get our dirhash and make sure its read in */
	+ dirhash_get(&dir_node->dir_hash);
	+ error = dirhash_fill(dir_node);
	+ if (error) {
	+ dirhash_put(dir_node->dir_hash);
	+ return (error);
	+ }
	+ dirh = dir_node->dir_hash;
	+
	+ /* get info */
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ udf_osta_charset(&osta_charspec);
	+
	+ if (dir_node->fe) {
	+ dir_size = le64toh(dir_node->fe->inf_len);
	+ icbtag = &dir_node->fe->icbtag;
	+ } else {
	+ dir_size = le64toh(dir_node->efe->inf_len);
	+ icbtag = &dir_node->efe->icbtag;
	+ }
	+
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ if (udf_node->fe) {
	+ unique_id = le64toh(udf_node->fe->unique_id);
	+ refcnt = le16toh(udf_node->fe->link_cnt);
	+ } else {
	+ unique_id = le64toh(udf_node->efe->unique_id);
	+ refcnt = le16toh(udf_node->efe->link_cnt);
	+ }
	+
	+ if (refcnt > 0) {
	+ unique_id = udf_advance_uniqueid(ump);
	+ udf_adjust_filecount(udf_node, 1);
	+ }
	+
	+ /* determine file characteristics */
	+ file_char = 0; /* visible non deleted file and not stream metadata */
	+ if (vap->va_type == VDIR)
	+ file_char = UDF_FILE_CHAR_DIR;
	+
	+ /* malloc scrap buffer */
	+ fid = malloc(lb_size, M_UDFTEMP, M_WAITOK\|M_ZERO);
	+
	+ /* calculate _minimum_ fid size */
	+ unix_to_udf_name((char *) fid->data, &fid->l_fi,
	+ cnp->cn_nameptr, cnp->cn_namelen, &osta_charspec);
	+ fidsize = UDF_FID_SIZE + fid->l_fi;
	+ fidsize = (fidsize + 3) & ~3; /* multiple of 4 */
	+
	+ /* find position that will fit the FID */
	+ chosen_fid_pos = dir_size;
	+ chosen_size = 0;
	+ chosen_size_diff = UINT_MAX;
	+
	+ /* shut up gcc */
	+ dirent.d_namlen = 0;
	+
	+ /* search our dirhash hits */
	+ error = 0;
	+ dirh_ep = NULL;
	+ for (;;) {
	+ hit = dirhash_lookup_freed(dirh, fidsize, &dirh_ep);
	+ /* if no hit, abort the search */
	+ if (!hit)
	+ break;
	+
	+ /* check this hit for size */
	+ this_fidsize = dirh_ep->entry_size;
	+
	+ /* check this hit */
	+ fid_pos = dirh_ep->offset;
	+ end_fid_pos = fid_pos + this_fidsize;
	+ size_diff = this_fidsize - fidsize;
	+ lb_rest = lb_size - (end_fid_pos % lb_size);
	+
	+#ifndef UDF_COMPLETE_DELETE
	+ /* transfer a new fid/dirent */
	+ error = udf_read_fid_stream(vp, &fid_pos, fid, dirent);
	+ if (error)
	+ goto error_out;
	+
	+ /* only reuse entries that are wiped */
	+ /* check if the len + loc are marked zero */
	+ if (le32toh(fid->icb.len) != 0)
	+ continue;
	+ if (le32toh(fid->icb.loc.lb_num) != 0)
	+ continue;
	+ if (le16toh(fid->icb.loc.part_num) != 0)
	+ continue;
	+#endif /* UDF_COMPLETE_DELETE */
	+
	+ /* select if not splitting the tag and its smaller */
	+ if ((size_diff >= 0) &&
	+ (size_diff < chosen_size_diff) &&
	+ (lb_rest >= sizeof(struct desc_tag)))
	+ {
	+ /* UDF 2.3.4.2+3 specifies rules for iu size */
	+ if ((size_diff == 0) \|\| (size_diff >= 32)) {
	+ chosen_fid_pos = fid_pos;
	+ chosen_size = this_fidsize;
	+ chosen_size_diff = size_diff;
	+ }
	+ }
	+ }
	+
	+
	+ /* extend directory if no other candidate found */
	+ if (chosen_size == 0) {
	+ chosen_fid_pos = dir_size;
	+ chosen_size = fidsize;
	+ chosen_size_diff = 0;
	+
	+ /* special case UDF 2.00+ 2.3.4.4, no splitting up fid tag */
	+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
	+ /* pre-grow directory to see if we're to switch */
	+ udf_grow_node(dir_node, dir_size + chosen_size);
	+
	+ icbflags = le16toh(icbtag->flags);
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+ }
	+
	+ /* make sure the next fid desc_tag won't be split */
	+ if (addr_type != UDF_ICB_INTERN_ALLOC) {
	+ end_fid_pos = chosen_fid_pos + chosen_size;
	+ lb_rest = lb_size - (end_fid_pos % lb_size);
	+
	+ /* pad with implementation use regid if needed */
	+ if (lb_rest < sizeof(struct desc_tag))
	+ chosen_size += 32;
	+ }
	+ }
	+ chosen_size_diff = chosen_size - fidsize;
	+
	+ /* populate the FID */
	+ memset(fid, 0, lb_size);
	+ udf_inittag(ump, &fid->tag, TAGID_FID, 0);
	+ fid->file_version_num = htole16(1); /* UDF 2.3.4.1 */
	+ fid->file_char = file_char;
	+ fid->icb = udf_node->loc;
	+ fid->icb.longad_uniqueid = htole32((uint32_t) unique_id);
	+ fid->l_iu = htole16(0);
	+
	+ if (chosen_size > fidsize) {
	+ /* insert implementation-use regid to space it correctly */
	+ fid->l_iu = htole16(chosen_size_diff);
	+
	+ /* set implementation use */
	+ udf_set_regid((struct regid *) fid->data, IMPL_NAME);
	+ udf_add_impl_regid(ump, (struct regid *) fid->data);
	+ }
	+
	+ /* fill in name */
	+ unix_to_udf_name((char *) fid->data + le16toh(fid->l_iu),
	+ &fid->l_fi, cnp->cn_nameptr, cnp->cn_namelen, &osta_charspec);
	+
	+ fid->tag.desc_crc_len = htole16(chosen_size - UDF_DESC_TAG_LENGTH);
	+ (void) udf_validate_tag_and_crc_sums((union dscrptr *) fid);
	+
	+ /* writeout FID/update parent directory */
	+ error = vn_rdwr(UIO_WRITE, dvp,
	+ fid, chosen_size, chosen_fid_pos,
	+ UIO_SYSSPACE, IO_ALTSEMANTICS \| IO_NODELOCKED,
	+ FSCRED, NULL, NULL);
	+
	+ if (error)
	+ goto error_out;
	+
	+ /* add reference counter in attached node */
	+ if (udf_node->fe) {
	+ refcnt = le16toh(udf_node->fe->link_cnt);
	+ udf_node->fe->link_cnt = htole16(refcnt+1);
	+ } else {
	+ KASSERT(udf_node->efe);
	+ refcnt = le16toh(udf_node->efe->link_cnt);
	+ udf_node->efe->link_cnt = htole16(refcnt+1);
	+ }
	+
	+ /* mark not deleted if it was... just in case, but do warn */
	+ if (udf_node->i_flags & IN_DELETED) {
	+ printf("udf: warning, marking a file undeleted\n");
	+ udf_node->i_flags &= ~IN_DELETED;
	+ }
	+
	+ if (file_char & UDF_FILE_CHAR_DIR) {
	+ /* add reference counter in directory node for '..' */
	+ if (dir_node->fe) {
	+ refcnt = le16toh(dir_node->fe->link_cnt);
	+ refcnt++;
	+ dir_node->fe->link_cnt = htole16(refcnt);
	+ } else {
	+ KASSERT(dir_node->efe);
	+ refcnt = le16toh(dir_node->efe->link_cnt);
	+ refcnt++;
	+ dir_node->efe->link_cnt = htole16(refcnt);
	+ }
	+ }
	+
	+ /* append to the dirhash */
	+ dirent.d_namlen = cnp->cn_namelen;
	+ memcpy(dirent.d_name, cnp->cn_nameptr, cnp->cn_namelen);
	+ dirhash_enter(dirh, &dirent, chosen_fid_pos,
	+ udf_fidsize(fid), 1);
	+
	+ /* note updates */
	+ udf_node->i_flags \|= IN_CHANGE \| IN_MODIFY; /* \| IN_CREATE? */
	+ /* VN_KNOTE(udf_node, ...) */
	+ udf_update(udf_node->vnode, NULL, NULL, NULL, 0);
	+
	+error_out:
	+ free(fid, M_UDFTEMP);
	+
	+ dirhash_put(dir_node->dir_hash);
	+
	+ return (error);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Each node can have an attached streamdir node though not recursively. These
	+ * are otherwise known as named substreams/named extended attributes that have
	+ * no size limitations.
	+ *
	+ * `Normal' extended attributes are indicated with a number and are recorded
	+ * in either the fe/efe descriptor itself for small descriptors or recorded in
	+ * the attached extended attribute file. Since these spaces can get
	+ * fragmented, care ought to be taken.
	+ *
	+ * Since the size of the space reserved for allocation descriptors is limited,
	+ * there is a mechanim provided for extending this space; this is done by a
	+ * special extent to allow schrinking of the allocations without breaking the
	+ * linkage to the allocation extent descriptor.
	+ */
	+
	+int
	+udf_get_node(struct udf_mount ump, ino_t ino, struct udf_node *ppunode)
	+{
	+ union dscrptr *dscr;
	+ struct long_ad icb_loc, last_fe_icb_loc;
	+ struct udf_node *udf_node;
	+ uint64_t file_size;
	+ int dscr_type, strat, strat4096, needs_indirect, slot, eof, error;
	+ uint32_t lb_size, sector, dummy;
	+ uint8_t *file_data;
	+
	+ DPRINTF(NODE, ("udf_get_node called\n"));
	+
	+ udf_get_node_longad(ino, &icb_loc);
	+
	+
	+ /* garbage check: translate udf_node_icb_loc to sectornr */
	+ error = udf_translate_vtop(ump, &icb_loc, &sector, &dummy);
	+ if (error) {
	+ return (EINVAL);
	+ }
	+
	+ /* initialise crosslinks, note location of fe/efe for hashing */
	+ udf_node = udf_alloc_node();
	+ udf_node->hash_id = ino;
	+ udf_node->ump = ump;
	+ udf_node->loc = icb_loc;
	+ udf_node->lockf = 0;
	+/* mutex_init(&udf_node->node_mutex, MUTEX_DEFAULT, IPL_NONE); */
	+/* cv_init(&udf_node->node_lock, "udf_nlk"); */
	+ udf_node->outstanding_bufs = 0;
	+ udf_node->outstanding_nodedscr = 0;
	+ udf_node->uncommitted_lbs = 0;
	+
	+ /* safe to unlock, the entry is in the hash table, vnode is locked */
	+/* mutex_exit(&ump->get_node_lock); */
	+
	+ needs_indirect = 0;
	+ strat4096 = 0;
	+ file_size = 0;
	+ file_data = NULL;
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+
	+ do {
	+ /* try to read in fe/efe */
	+ /* error = udf_read_logvol_dscr(ump, &icb_loc, &dscr); */
	+ error = udf_translate_vtop(ump, &icb_loc, &sector, &dummy);
	+ if (!error)
	+ error = udf_read_phys_dscr(ump, sector, M_UDFTEMP,
	+ &dscr);
	+
	+ /* blank sector marks end of sequence, check this */
	+ if ((dscr == NULL) && (!strat4096))
	+ error = ENOENT;
	+
	+ /* break if read error or blank sector */
	+ if (error \|\| (dscr == NULL))
	+ break;
	+
	+ /* process descriptor based on the descriptor type */
	+ dscr_type = le16toh(dscr->tag.id);
	+
	+ /* if dealing with an indirect entry, follow the link */
	+ if (dscr_type == TAGID_INDIRECTENTRY) {
	+ needs_indirect = 0;
	+ /* udf_free_logvol_dscr(ump, &icb_loc, dscr); */
	+ free(dscr, M_UDFTEMP);
	+ /* end of udf_free_logvol_decr replacement */
	+ icb_loc = dscr->inde.indirect_icb;
	+ continue;
	+ }
	+
	+ /* only file entries and extended file entries allowed here */
	+ if ((dscr_type != TAGID_FENTRY) &&
	+ (dscr_type != TAGID_EXTFENTRY)) {
	+ /* udf_free_logvol_dscr(ump, &icb_loc, dscr); */
	+ free(dscr, M_UDFTEMP);
	+ /* end of udf_free_logvol_decr replacement */
	+ error = ENOENT;
	+ break;
	+ }
	+
	+ /* KASSERT(udf_tagsize(dscr, lb_size) == lb_size); */
	+
	+ /* choose this one */
	+ last_fe_icb_loc = icb_loc;
	+
	+ /* record and process/update (ext)fentry */
	+ file_data = NULL;
	+ if (dscr_type == TAGID_FENTRY) {
	+ /*if (udf_node->fe)
	+ udf_free_logvol_dscr(ump, &last_fe_icb_loc,
	+ udf_node->fe); */
	+ if (udf_node->fe)
	+ free(udf_node->fe, M_UDFTEMP);
	+ /* end of udf_free_logvol_decr replacement */
	+ udf_node->fe = &dscr->fe;
	+ strat = le16toh(udf_node->fe->icbtag.strat_type);
	+ file_size = le64toh(udf_node->fe->inf_len);
	+ file_data = udf_node->fe->data;
	+ } else {
	+ /*if (udf_node->efe)
	+ udf_free_logvol_dscr(ump, &last_fe_icb_loc,
	+ udf_node->efe); */
	+ if (udf_node->efe)
	+ free(udf_node->efe, M_UDFTEMP);
	+ /* end of udf_free_logvol_decr replacement */
	+ udf_node->efe = &dscr->efe;
	+ strat = le16toh(udf_node->efe->icbtag.strat_type);
	+ file_size = le64toh(udf_node->efe->inf_len);
	+ file_data = udf_node->efe->data;
	+ }
	+
	+ /* check recording strategy (structure) */
	+
	+ /*
	+ * Strategy 4096 is a daisy linked chain terminating with an
	+ * unrecorded sector or a TERM descriptor. The next
	+ * descriptor is to be found in the sector that follows the
	+ * current sector.
	+ */
	+ if (strat == 4096) {
	+ strat4096 = 1;
	+ needs_indirect = 1;
	+
	+ icb_loc.loc.lb_num = le32toh(icb_loc.loc.lb_num) + 1;
	+ }
	+
	+ /*
	+ * Strategy 4 is the normal strategy and terminates, but if
	+ * we're in strategy 4096, we can't have strategy 4 mixed in
	+ */
	+
	+ if (strat == 4) {
	+ if (strat4096) {
	+ error = EINVAL;
	+ break;
	+ }
	+ break; /* done */
	+ }
	+ } while (!error);
	+
	+ /* first round of cleanup code */
	+ if (error) {
	+ udf_dispose_node(udf_node);
	+ return (EINVAL);
	+ }
	+
	+ /* assert no references to dscr anymore beyong this point */
	+ /* assert((udf_node->fe) \|\| (udf_node->efe)); */
	+ dscr = NULL;
	+
	+ /*
	+ * Remember where to record an updated version of the descriptor. If
	+ * there is a sequence of indirect entries, icb_loc will have been
	+ * updated. Its the write disipline to allocate new space and to make
	+ * sure the chain is maintained.
	+ *
	+ * `needs_indirect' flags if the next location is to be filled with
	+ * with an indirect entry.
	+ */
	+ udf_node->write_loc = icb_loc;
	+ udf_node->needs_indirect = needs_indirect;
	+
	+ /*
	+ * Go trough all allocations extents of this descriptor and when
	+ * encountering a redirect read in the allocation extension. These are
	+ * daisy-chained.
	+ */
	+ UDF_LOCK_NODE(udf_node, 0);
	+ udf_node->num_extensions = 0;
	+
	+ error = 0;
	+ slot = 0;
	+ for (;;) {
	+ udf_get_adslot(udf_node, slot, &icb_loc, &eof);
	+ if (eof)
	+ break;
	+ slot++;
	+
	+ if (UDF_EXT_FLAGS(le32toh(icb_loc.len)) != UDF_EXT_REDIRECT)
	+ continue;
	+
	+ if (udf_node->num_extensions >= UDF_MAX_ALLOC_EXTENTS) {
	+ error = EINVAL;
	+ break;
	+ }
	+
	+ /* length can only be one lb : UDF 2.50/2.3.7.1 */
	+ if (UDF_EXT_LEN(le32toh(icb_loc.len)) != lb_size) {
	+ error = EINVAL;
	+ break;
	+ }
	+
	+ /* load in allocation extent */
	+ /* error = udf_read_logvol_dscr(ump, &icb_loc, &dscr); */
	+ error = udf_translate_vtop(ump, &icb_loc, &sector, &dummy);
	+ if (!error)
	+ error = udf_read_phys_dscr(ump, sector, M_UDFTEMP,
	+ &dscr);
	+ if (error \|\| (dscr == NULL))
	+ break;
	+
	+ /* process read-in descriptor */
	+ dscr_type = le16toh(dscr->tag.id);
	+
	+ if (dscr_type != TAGID_ALLOCEXTENT) {
	+ /* udf_free_logvol_dscr(ump, &icb_loc, dscr); */
	+ free(dscr, M_UDFTEMP);
	+ /* end of udf_free_logvol_decr replacement */
	+ error = ENOENT;
	+ break;
	+ }
	+
	+ udf_node->ext[udf_node->num_extensions] = &dscr->aee;
	+ udf_node->ext_loc[udf_node->num_extensions] = icb_loc;
	+
	+ udf_node->num_extensions++;
	+
	+ } /* while */
	+ UDF_UNLOCK_NODE(udf_node, 0);
	+
	+ /* second round of cleanup code */
	+ if (error) {
	+ /* recycle udf_node */
	+ udf_dispose_node(udf_node);
	+ return (EINVAL); /* error code ok? */
	+ }
	+
	+ /* TODO ext attr and streamdir udf_nodes */
	+
	+ *ppunode = udf_node;
	+
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+#if 0
	+int
	+udf_writeout_node(struct udf_node *udf_node, int waitfor)
	+{
	+ union dscrptr *dscr;
	+ struct long_ad *loc;
	+ int extnr, error;
	+
	+ DPRINTF(NODE, ("udf_writeout_node called\n"));
	+
	+ KASSERT(udf_node->outstanding_bufs == 0);
	+ KASSERT(udf_node->outstanding_nodedscr == 0);
	+
	+ KASSERT(LIST_EMPTY(&udf_node->vnode->v_dirtyblkhd));
	+
	+ if (udf_node->i_flags & IN_DELETED) {
	+ DPRINTF(NODE, ("\tnode deleted; not writing out\n"));
	+ udf_cleanup_reservation(udf_node);
	+ return (0);
	+ }
	+
	+ /* lock node; unlocked in callback */
	+ UDF_LOCK_NODE(udf_node, 0);
	+
	+ /* remove pending reservations, we're written out */
	+ udf_cleanup_reservation(udf_node);
	+
	+ /* at least one descriptor writeout */
	+ udf_node->outstanding_nodedscr = 1;
	+
	+ /* we're going to write out the descriptor so clear the flags */
	+ udf_node->i_flags &= ~(IN_MODIFIED \| IN_ACCESSED);
	+
	+ /* if we were rebuild, write out the allocation extents */
	+ if (udf_node->i_flags & IN_NODE_REBUILD) {
	+ /* mark outstanding node descriptors and issue them */
	+ udf_node->outstanding_nodedscr += udf_node->num_extensions;
	+ for (extnr = 0; extnr < udf_node->num_extensions; extnr++) {
	+ loc = &udf_node->ext_loc[extnr];
	+ dscr = (union dscrptr *) udf_node->ext[extnr];
	+ error = udf_write_logvol_dscr(udf_node, dscr, loc, 0);
	+ if (error)
	+ return (error);
	+ }
	+ /* mark allocation extents written out */
	+ udf_node->i_flags &= ~(IN_NODE_REBUILD);
	+ }
	+
	+ if (udf_node->fe) {
	+ KASSERT(udf_node->efe == NULL);
	+ dscr = (union dscrptr *) udf_node->fe;
	+ } else {
	+ KASSERT(udf_node->efe);
	+ KASSERT(udf_node->fe == NULL);
	+ dscr = (union dscrptr *) udf_node->efe;
	+ }
	+ KASSERT(dscr);
	+
	+ loc = &udf_node->write_loc;
	+ error = udf_write_logvol_dscr(udf_node, dscr, loc, waitfor);
	+
	+ return (error);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_dispose_node(struct udf_node *udf_node)
	+{
	+ //struct vnode *vp;
	+ int extnr;
	+
	+ DPRINTF(NODE, ("udf_dispose_node called on node %p\n", udf_node));
	+ if (!udf_node) {
	+ DPRINTF(NODE, ("UDF: Dispose node on node NULL, ignoring\n"));
	+ return (0);
	+ }
	+#if 0
	+ vp = udf_node->vnode;
	+#ifdef DIAGNOSTIC
	+ if (vp->v_numoutput)
	+ panic("disposing UDF node with pending I/O's, udf_node = %p, "
	+ "v_numoutput = %d", udf_node, vp->v_numoutput);
	+#endif
	+ udf_cleanup_reservation(udf_node);
	+
	+ /* TODO extended attributes and streamdir */
	+
	+ /* remove dirhash if present */
	+ dirhash_purge(&udf_node->dir_hash);
	+
	+ /* remove from our hash lookup table */
	+ udf_deregister_node(udf_node);
	+
	+ /* destroy our lock */
	+ mutex_destroy(&udf_node->node_mutex);
	+ cv_destroy(&udf_node->node_lock);
	+
	+ /* dissociate our udf_node from the vnode */
	+ genfs_node_destroy(udf_node->vnode);
	+ vp->v_data = NULL;
	+#endif
	+
	+ /* free associated memory and the node itself */
	+ for (extnr = 0; extnr < udf_node->num_extensions; extnr++) {
	+ /*udf_free_logvol_dscr(udf_node->ump, &udf_node->ext_loc[extnr],
	+ udf_node->ext[extnr]); */
	+ free(udf_node->ext[extnr], M_UDFTEMP);
	+ /end of udf_free_logvol_decr replacement /
	+ udf_node->ext[extnr] = (void *) 0xdeadcccc;
	+ }
	+
	+ /*if (udf_node->fe)
	+ udf_free_logvol_dscr(udf_node->ump, &udf_node->loc,
	+ udf_node->fe); */
	+ if (udf_node->fe)
	+ free(udf_node->fe, M_UDFTEMP);
	+ /end of udf_free_logvol_decr replacement /
	+
	+ /*if (udf_node->efe)
	+ udf_free_logvol_dscr(udf_node->ump, &udf_node->loc,
	+ udf_node->efe); */
	+ if (udf_node->efe)
	+ free(udf_node->efe, M_UDFTEMP);
	+ /end of udf_free_logvol_decr replacement /
	+
	+ udf_node->fe = (void *) 0xdeadaaaa;
	+ udf_node->efe = (void *) 0xdeadbbbb;
	+ udf_node->ump = (void *) 0xdeadbeef;
	+ udf_free_node(udf_node);
	+
	+ return (0);
	+}
	+
	+
	+/*
	+ * create a new node using the specified vnodeops, vap and cnp but with the
	+ * udf_file_type. This allows special files to be created. Use with care.
	+ */
	+
	+#if 0
	+static int
	+udf_create_node_raw(struct vnode dvp, struct vnode *vpp, int udf_file_type,
	+ int (*vnodeops)(void ), struct vattr vap, struct componentname cnp)
	+{
	+ union dscrptr *dscr;
	+ struct udf_node *dir_node = VTOI(dvp);
	+ struct udf_node *udf_node;
	+ struct udf_mount *ump = dir_node->ump;
	+ struct vnode *nvp;
	+ struct long_ad node_icb_loc;
	+ uint64_t parent_unique_id;
	+ uint64_t lmapping;
	+ uint32_t lb_size, lb_num;
	+ uint16_t vpart_num;
	+ uid_t uid;
	+ gid_t gid, parent_gid;
	+ int fid_size, error;
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ *vpp = NULL;
	+
	+ /* allocate vnode */
	+ error = getnewvnode(VT_UDF, ump->vfs_mountp, vnodeops, &nvp);
	+ if (error)
	+ return (error);
	+
	+ /* lock node */
	+ error = vn_lock(nvp, LK_EXCLUSIVE \| LK_RETRY);
	+ if (error)
	+ goto error_out_unget;
	+
	+ /* reserve space for one logical block */
	+ vpart_num = ump->node_part;
	+ error = udf_reserve_space(ump, NULL, UDF_C_NODE,
	+ vpart_num, 1, /* can_fail */ true);
	+ if (error)
	+ goto error_out_unlock;
	+
	+ /* allocate node */
	+ error = udf_allocate_space(ump, NULL, UDF_C_NODE,
	+ vpart_num, 1, &lmapping);
	+ if (error)
	+ goto error_out_unreserve;
	+ lb_num = lmapping;
	+
	+ /* initialise pointer to location */
	+ memset(&node_icb_loc, 0, sizeof(struct long_ad));
	+ node_icb_loc.len = htole32(lb_size);
	+ node_icb_loc.loc.lb_num = htole32(lb_num);
	+ node_icb_loc.loc.part_num = htole16(vpart_num);
	+
	+ /* build udf_node (do initialise!) */
	+ udf_node = pool_get(&udf_node_pool, PR_WAITOK);
	+ memset(udf_node, 0, sizeof(struct udf_node));
	+
	+ /* initialise crosslinks, note location of fe/efe for hashing */
	+ /* bugalert: synchronise with udf_get_node() */
	+ udf_node->ump = ump;
	+ udf_node->vnode = nvp;
	+ nvp->v_data = udf_node;
	+ udf_node->loc = node_icb_loc;
	+ udf_node->write_loc = node_icb_loc;
	+ udf_node->lockf = 0;
	+ mutex_init(&udf_node->node_mutex, MUTEX_DEFAULT, IPL_NONE);
	+ cv_init(&udf_node->node_lock, "udf_nlk");
	+ udf_node->outstanding_bufs = 0;
	+ udf_node->outstanding_nodedscr = 0;
	+ udf_node->uncommitted_lbs = 0;
	+
	+ /* initialise genfs */
	+ genfs_node_init(nvp, &udf_genfsops);
	+
	+ /* insert into the hash lookup */
	+ udf_register_node(udf_node);
	+
	+ /* get parent's unique ID for refering '..' if its a directory */
	+ if (dir_node->fe) {
	+ parent_unique_id = le64toh(dir_node->fe->unique_id);
	+ parent_gid = (gid_t) le32toh(dir_node->fe->gid);
	+ } else {
	+ parent_unique_id = le64toh(dir_node->efe->unique_id);
	+ parent_gid = (gid_t) le32toh(dir_node->efe->gid);
	+ }
	+
	+ /* get descriptor */
	+ udf_create_logvol_dscr(ump, udf_node, &node_icb_loc, &dscr);
	+
	+ /* choose a fe or an efe for it */
	+ if (le16toh(ump->logical_vol->tag.descriptor_ver) == 2) {
	+ udf_node->fe = &dscr->fe;
	+ fid_size = udf_create_new_fe(ump, udf_node->fe,
	+ udf_file_type, &udf_node->loc,
	+ &dir_node->loc, parent_unique_id);
	+ /* TODO add extended attribute for creation time */
	+ } else {
	+ udf_node->efe = &dscr->efe;
	+ fid_size = udf_create_new_efe(ump, udf_node->efe,
	+ udf_file_type, &udf_node->loc,
	+ &dir_node->loc, parent_unique_id);
	+ }
	+ KASSERT(dscr->tag.tag_loc == udf_node->loc.loc.lb_num);
	+
	+ /* update vnode's size and type */
	+ nvp->v_type = vap->va_type;
	+ uvm_vnp_setsize(nvp, fid_size);
	+
	+ /* set access mode */
	+ udf_setaccessmode(udf_node, vap->va_mode);
	+
	+ /* set ownership */
	+ uid = kauth_cred_geteuid(cnp->cn_cred);
	+ gid = parent_gid;
	+ udf_setownership(udf_node, uid, gid);
	+
	+ error = udf_dir_attach(ump, dir_node, udf_node, vap, cnp);
	+ if (error) {
	+ /* free disc allocation for node */
	+ udf_free_allocated_space(ump, lb_num, vpart_num, 1);
	+
	+ /* recycle udf_node */
	+ udf_dispose_node(udf_node);
	+ vput(nvp);
	+
	+ *vpp = NULL;
	+ return (error);
	+ }
	+
	+ /* adjust file count */
	+ udf_adjust_filecount(udf_node, 1);
	+
	+ /* return result */
	+ *vpp = nvp;
	+
	+ return (0);
	+
	+error_out_unreserve:
	+ udf_do_unreserve_space(ump, NULL, vpart_num, 1);
	+
	+error_out_unlock:
	+ VOP_UNLOCK(nvp);
	+
	+error_out_unget:
	+ nvp->v_data = NULL;
	+ ungetnewvnode(nvp);
	+
	+ return (error);
	+}
	+
	+
	+int
	+udf_create_node(struct vnode dvp, struct vnode vpp, struct vattr vap,
	+ struct componentname *cnp)
	+{
	+ int (*vnodeops)(void );
	+ int udf_file_type;
	+
	+ /* what type are we creating ? */
	+ vnodeops = udf_vnodeop_p;
	+ /* start with a default */
	+ udf_file_type = UDF_ICB_FILETYPE_RANDOMACCESS;
	+
	+ *vpp = NULL;
	+
	+ switch (vap->va_type) {
	+ case VREG :
	+ udf_file_type = UDF_ICB_FILETYPE_RANDOMACCESS;
	+ break;
	+ case VDIR :
	+ udf_file_type = UDF_ICB_FILETYPE_DIRECTORY;
	+ break;
	+ case VLNK :
	+ udf_file_type = UDF_ICB_FILETYPE_SYMLINK;
	+ break;
	+ case VBLK :
	+ udf_file_type = UDF_ICB_FILETYPE_BLOCKDEVICE;
	+ /* specfs */
	+ return (ENOTSUP);
	+ break;
	+ case VCHR :
	+ udf_file_type = UDF_ICB_FILETYPE_CHARDEVICE;
	+ /* specfs */
	+ return (ENOTSUP);
	+ break;
	+ case VFIFO :
	+ udf_file_type = UDF_ICB_FILETYPE_FIFO;
	+ /* specfs */
	+ return (ENOTSUP);
	+ break;
	+ case VSOCK :
	+ udf_file_type = UDF_ICB_FILETYPE_SOCKET;
	+ /* specfs */
	+ return (ENOTSUP);
	+ break;
	+ case VNON :
	+ case VBAD :
	+ default :
	+ /* nothing; can we even create these? */
	+ return (EINVAL);
	+ }
	+
	+ return (udf_create_node_raw(dvp, vpp, udf_file_type, vnodeops, vap, cnp));
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static void
	+udf_free_descriptor_space(struct udf_node udf_node, struct long_ad loc, void *mem)
	+{
	+ struct udf_mount *ump = udf_node->ump;
	+ uint32_t lb_size, lb_num, len, num_lb;
	+ uint16_t vpart_num;
	+
	+ /* is there really one? */
	+ if (mem == NULL)
	+ return;
	+
	+ /* got a descriptor here */
	+ len = UDF_EXT_LEN(le32toh(loc->len));
	+ lb_num = le32toh(loc->loc.lb_num);
	+ vpart_num = le16toh(loc->loc.part_num);
	+
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ num_lb = (len + lb_size -1) / lb_size;
	+
	+ udf_free_allocated_space(ump, lb_num, vpart_num, num_lb);
	+}
	+
	+void
	+udf_delete_node(struct udf_node *udf_node)
	+{
	+ void *dscr;
	+ struct udf_mount *ump;
	+ struct long_ad *loc;
	+ int extnr, lvint, dummy;
	+
	+ ump = udf_node->ump;
	+
	+ /* paranoia check on integrity; should be open!; we could panic */
	+ lvint = le32toh(udf_node->ump->logvol_integrity->integrity_type);
	+ if (lvint == UDF_INTEGRITY_CLOSED)
	+ printf("\tIntegrity was CLOSED!\n");
	+
	+ /* whatever the node type, change its size to zero */
	+ (void) udf_resize_node(udf_node, 0, &dummy);
	+
	+ /* force it to be `clean'; no use writing it out */
	+ udf_node->i_flags &= ~(IN_MODIFIED \| IN_ACCESSED \| IN_ACCESS \|
	+ IN_CHANGE \| IN_UPDATE \| IN_MODIFY);
	+
	+ /* adjust file count */
	+ udf_adjust_filecount(udf_node, -1);
	+
	+ /*
	+ * Free its allocated descriptors; memory will be released when
	+ * vop_reclaim() is called.
	+ */
	+ loc = &udf_node->loc;
	+
	+ dscr = udf_node->fe;
	+ udf_free_descriptor_space(udf_node, loc, dscr);
	+ dscr = udf_node->efe;
	+ udf_free_descriptor_space(udf_node, loc, dscr);
	+
	+ for (extnr = 0; extnr < UDF_MAX_ALLOC_EXTENTS; extnr++) {
	+ dscr = udf_node->ext[extnr];
	+ loc = &udf_node->ext_loc[extnr];
	+ udf_free_descriptor_space(udf_node, loc, dscr);
	+ }
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* set new filesize; node but be LOCKED on entry and is locked on exit */
	+int
	+udf_resize_node(struct udf_node udf_node, uint64_t new_size, int extended)
	+{
	+ struct file_entry *fe = udf_node->fe;
	+ struct extfile_entry *efe = udf_node->efe;
	+ uint64_t file_size;
	+ int error;
	+
	+ if (fe) {
	+ file_size = le64toh(fe->inf_len);
	+ } else {
	+ assert(udf_node->efe);
	+ file_size = le64toh(efe->inf_len);
	+ }
	+
	+ /* if not changing, we're done */
	+ if (file_size == new_size)
	+ return (0);
	+
	+ *extended = (new_size > file_size);
	+ if (*extended) {
	+ error = udf_grow_node(udf_node, new_size);
	+ } else {
	+ error = udf_shrink_node(udf_node, new_size);
	+ }
	+
	+ return (error);
	+}
	+
	+
	+/* --------------------------------------------------------------------- */
	+
	+void
	+udf_itimes(struct udf_node udf_node, struct timespec acc,
	+ struct timespec mod, struct timespec birth)
	+{
	+ struct timespec now;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct filetimes_extattr_entry *ft_extattr;
	+ struct timestamp atime, mtime, attrtime, ctime;
	+ struct timestamp fe_ctime;
	+ struct timespec cur_birth;
	+ uint32_t offset, a_l;
	+ uint8_t *filedata;
	+ int error;
	+
	+ /* protect against rogue values */
	+ if (!udf_node)
	+ return;
	+
	+ fe = udf_node->fe;
	+ efe = udf_node->efe;
	+
	+ if (!(udf_node->i_flags & (IN_ACCESS\|IN_CHANGE\|IN_UPDATE\|IN_MODIFY)))
	+ return;
	+
	+ /* get descriptor information */
	+ if (fe) {
	+ atime = &fe->atime;
	+ mtime = &fe->mtime;
	+ attrtime = &fe->attrtime;
	+ filedata = fe->data;
	+
	+ /* initial save dummy setting */
	+ ctime = &fe_ctime;
	+
	+ /* check our extended attribute if present */
	+ error = udf_extattr_search_intern(udf_node,
	+ UDF_FILETIMES_ATTR_NO, "", &offset, &a_l);
	+ if (!error) {
	+ ft_extattr = (struct filetimes_extattr_entry *)
	+ (filedata + offset);
	+ if (ft_extattr->existence & UDF_FILETIMES_FILE_CREATION)
	+ ctime = &ft_extattr->times[0];
	+ }
	+ /* TODO create the extended attribute if not found ? */
	+ } else {
	+ assert(udf_node->efe);
	+ atime = &efe->atime;
	+ mtime = &efe->mtime;
	+ attrtime = &efe->attrtime;
	+ ctime = &efe->ctime;
	+ }
	+
	+ vfs_timestamp(&now);
	+
	+ /* set access time */
	+ if (udf_node->i_flags & IN_ACCESS) {
	+ if (acc == NULL)
	+ acc = &now;
	+ udf_timespec_to_timestamp(acc, atime);
	+ }
	+
	+ /* set modification time */
	+ if (udf_node->i_flags & (IN_UPDATE \| IN_MODIFY)) {
	+ if (mod == NULL)
	+ mod = &now;
	+ udf_timespec_to_timestamp(mod, mtime);
	+
	+ /* ensure birthtime is older than set modification! */
	+ udf_timestamp_to_timespec(udf_node->ump, ctime, &cur_birth);
	+ if ((cur_birth.tv_sec > mod->tv_sec) \|\|
	+ ((cur_birth.tv_sec == mod->tv_sec) &&
	+ (cur_birth.tv_nsec > mod->tv_nsec))) {
	+ udf_timespec_to_timestamp(mod, ctime);
	+ }
	+ }
	+
	+ /* update birthtime if specified */
	+ /* XXX we asume here that given birthtime is older than mod */
	+ if (birth && (birth->tv_sec != VNOVAL)) {
	+ udf_timespec_to_timestamp(birth, ctime);
	+ }
	+
	+ /* set change time */
	+ if (udf_node->i_flags & (IN_CHANGE \| IN_MODIFY))
	+ udf_timespec_to_timestamp(&now, attrtime);
	+
	+ /* notify updates to the node itself */
	+ if (udf_node->i_flags & (IN_ACCESS \| IN_MODIFY))
	+ udf_node->i_flags \|= IN_ACCESSED;
	+ if (udf_node->i_flags & (IN_UPDATE \| IN_CHANGE))
	+ udf_node->i_flags \|= IN_MODIFIED;
	+
	+ /* clear modification flags */
	+ udf_node->i_flags &= ~(IN_ACCESS \| IN_CHANGE \| IN_UPDATE \| IN_MODIFY);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_update(struct vnode vp, struct timespec acc,
	+ struct timespec mod, struct timespec birth, int updflags)
	+{
	+ union dscrptr *dscrptr;
	+ struct udf_node *udf_node = VTOI(vp);
	+ struct udf_mount *ump = udf_node->ump;
	+ struct regid *impl_id;
	+ int mnt_async = (vp->v_mount->mnt_flag & MNT_ASYNC);
	+ int waitfor, flags;
	+
	+#ifdef DEBUG
	+ char bits[128];
	+ DPRINTF(CALL, ("udf_update(node, %p, %p, %p, %d)\n", acc, mod, birth,
	+ updflags));
	+ snprintb(bits, sizeof(bits), IN_FLAGBITS, udf_node->i_flags);
	+ DPRINTF(CALL, ("\tnode flags %s\n", bits));
	+ DPRINTF(CALL, ("\t\tmnt_async = %d\n", mnt_async));
	+#endif
	+
	+ /* set our times */
	+ udf_itimes(udf_node, acc, mod, birth);
	+
	+ /* set our implementation id */
	+ if (udf_node->fe) {
	+ dscrptr = (union dscrptr *) udf_node->fe;
	+ impl_id = &udf_node->fe->imp_id;
	+ } else {
	+ dscrptr = (union dscrptr *) udf_node->efe;
	+ impl_id = &udf_node->efe->imp_id;
	+ }
	+
	+ /* set our ID */
	+ udf_set_regid(impl_id, IMPL_NAME);
	+ udf_add_impl_regid(ump, impl_id);
	+
	+ /* update our crc! on RMW we are not allowed to change a thing */
	+ udf_validate_tag_and_crc_sums(dscrptr);
	+
	+ /* if called when mounted readonly, never write back */
	+ if (vp->v_mount->mnt_flag & MNT_RDONLY)
	+ return (0);
	+
	+ /* check if the node is dirty 'enough'*/
	+ if (updflags & UPDATE_CLOSE) {
	+ flags = udf_node->i_flags & (IN_MODIFIED \| IN_ACCESSED);
	+ } else {
	+ flags = udf_node->i_flags & IN_MODIFIED;
	+ }
	+ if (flags == 0)
	+ return (0);
	+
	+ /* determine if we need to write sync or async */
	+ waitfor = 0;
	+ if ((flags & IN_MODIFIED) && (mnt_async == 0)) {
	+ /* sync mounted */
	+ waitfor = updflags & UPDATE_WAIT;
	+ if (updflags & UPDATE_DIROP)
	+ waitfor \|= UPDATE_WAIT;
	+ }
	+ if (waitfor)
	+ return (VOP_FSYNC(vp, FSCRED, FSYNC_WAIT, 0,0));
	+
	+ return (0);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+
	+/*
	+ * Read one fid and process it into a dirent and advance to the next (*fid)
	+ * has to be allocated a logical block in size, (*dirent) struct dirent length
	+ */
	+
	+int
	+udf_read_fid_stream(struct vnode vp, uint64_t offset,
	+ struct fileid_desc *fid)
	+{
	+ struct udf_node *dir_node = VTOI(vp);
	+ struct udf_mount *ump = dir_node->ump;
	+ struct file_entry *fe = dir_node->fe;
	+ struct extfile_entry *efe = dir_node->efe;
	+ uint64_t file_size;
	+ int enough, error;
	+ uint32_t fid_size, lb_size;
	+
	+ KASSERT(fid, ("udf_read_fid_stream: File Identifier Descriptor is null"));
	+ /* KASSERT(dirent, ("dirent == null")); */
	+ KASSERT(dir_node, ("udf_read_fid_stream: udf_node is null"));
	+ KASSERT(offset, ("udf_read_fid_stream: offset == 0"));
	+ KASSERT(*offset != 1, ("udf_read_fid_stream: offset != 1"));
	+
	+ DPRINTF(FIDS, ("read_fid_stream called at offset %ju\n",
	+ (uintmax_t)*offset));
	+
	+ /* check if we're past the end of the directory */
	+ if (fe) {
	+ file_size = le64toh(fe->inf_len);
	+ } else {
	+ /* assert(dir_node->efe); */
	+ file_size = le64toh(efe->inf_len);
	+ }
	+ if (*offset >= file_size)
	+ return (EINVAL);
	+
	+ /* get maximum length of FID descriptor */
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+
	+ /* initialise return values */
	+ fid_size = 0;
	+ memset(fid, 0, lb_size);
	+
	+ enough = (file_size - (*offset) >= UDF_FID_SIZE);
	+ if (!enough) {
	+ /* short dir ... */
	+ return (EIO);
	+ }
	+
	+ error = udf_read_node(dir_node, (uint8_t )fid, offset,
	+ MIN(file_size - (*offset), lb_size));
	+ /*error = vn_rdwr(UIO_READ, vp,
	+ fid, MIN(file_size - (offset), lb_size), offset,
	+ UIO_SYSSPACE, IO_NODELOCKED, FSCRED, 0, // IO_ALTSEMANTICS \|
	+ NULL, curthread);*/
	+ if (error)
	+ return (error);
	+
	+ DPRINTF(FIDS, ("\tfid piece read in fine\n"));
	+ /*
	+ * Check if we got a whole descriptor.
	+ * TODO Try to `resync' directory stream when something is very wrong.
	+ */
	+
	+ /* check if our FID header is OK */
	+ error = udf_check_tag(fid);
	+ if (error) {
	+ goto brokendir;
	+ }
	+ DPRINTF(FIDS, ("\ttag check ok\n"));
	+
	+ if (le16toh(fid->tag.id) != TAGID_FID) {
	+ error = EIO;
	+ goto brokendir;
	+ }
	+ DPRINTF(FIDS, ("\ttag checked ok: got TAGID_FID\n"));
	+
	+ /* check for length */
	+ fid_size = udf_fidsize(fid);
	+ enough = (file_size - (*offset) >= fid_size);
	+ if (!enough) {
	+ error = EIO;
	+ goto brokendir;
	+ }
	+ DPRINTF(FIDS, ("\tthe complete fid is read in\n"));
	+
	+ /* check FID contents */
	+ error = udf_check_tag_payload((union dscrptr *) fid, lb_size);
	+brokendir:
	+ if (error) {
	+ /* note that is sometimes a bit quick to report */
	+ printf("UDF: BROKEN DIRECTORY ENTRY\n");
	+ /* RESYNC? */
	+ /* TODO: use udf_resync_fid_stream */
	+ return (EIO);
	+ }
	+ DPRINTF(FIDS, ("\tplayload checked ok\n"));
	+
	+ /* we got a whole and valid descriptor! */
	+ DPRINTF(FIDS, ("\tinterpret FID\n"));
	+
	+ /* advance */
	+ *offset += fid_size;
	+
	+ return (error);
	+return (0);
	+}
	+
	+
	+/* --------------------------------------------------------------------- */
	+#if 0
	+static void
	+udf_sync_pass(struct udf_mount *ump, kauth_cred_t cred, int waitfor,
	+ int pass, int *ndirty)
	+{
	+ struct udf_node udf_node, n_udf_node;
	+ struct vnode *vp;
	+ int vdirty, error;
	+ int on_type, on_flags, on_vnode;
	+
	+derailed:
	+ KASSERT(mutex_owned(&mntvnode_lock));
	+
	+ DPRINTF(SYNC, ("sync_pass %d\n", pass));
	+ udf_node = RBTOUDFNODE(RB_TREE_MIN(&ump->udf_node_tree));
	+ for (;udf_node; udf_node = n_udf_node) {
	+ DPRINTF(SYNC, ("."));
	+
	+ udf_node->i_flags &= ~IN_SYNCED;
	+ vp = udf_node->vnode;
	+
	+ mutex_enter(&vp->v_interlock);
	+ n_udf_node = RBTOUDFNODE(rb_tree_iterate(
	+ &ump->udf_node_tree, &udf_node->rbnode,
	+ RB_DIR_RIGHT));
	+
	+ if (n_udf_node)
	+ n_udf_node->i_flags \|= IN_SYNCED;
	+
	+ /* system nodes are not synced this way */
	+ if (vp->v_vflag & VV_SYSTEM) {
	+ mutex_exit(&vp->v_interlock);
	+ continue;
	+ }
	+
	+ /* check if its dirty enough to even try */
	+ on_type = (waitfor == MNT_LAZY \|\| vp->v_type == VNON);
	+ on_flags = ((udf_node->i_flags &
	+ (IN_ACCESSED \| IN_UPDATE \| IN_MODIFIED)) == 0);
	+ on_vnode = LIST_EMPTY(&vp->v_dirtyblkhd)
	+ && UVM_OBJ_IS_CLEAN(&vp->v_uobj);
	+ if (on_type \|\| (on_flags \|\| on_vnode)) { /* XXX */
	+ /* not dirty (enough?) */
	+ mutex_exit(&vp->v_interlock);
	+ continue;
	+ }
	+
	+ mutex_exit(&mntvnode_lock);
	+ error = vget(vp, LK_EXCLUSIVE \| LK_NOWAIT);
	+ if (error) {
	+ mutex_enter(&mntvnode_lock);
	+ if (error == ENOENT)
	+ goto derailed;
	+ *ndirty += 1;
	+ continue;
	+ }
	+
	+ switch (pass) {
	+ case 1:
	+ VOP_FSYNC(vp, cred, 0 \| FSYNC_DATAONLY,0,0);
	+ break;
	+ case 2:
	+ vdirty = vp->v_numoutput;
	+ if (vp->v_tag == VT_UDF)
	+ vdirty += udf_node->outstanding_bufs +
	+ udf_node->outstanding_nodedscr;
	+ if (vdirty == 0)
	+ VOP_FSYNC(vp, cred, 0,0,0);
	+ *ndirty += vdirty;
	+ break;
	+ case 3:
	+ vdirty = vp->v_numoutput;
	+ if (vp->v_tag == VT_UDF)
	+ vdirty += udf_node->outstanding_bufs +
	+ udf_node->outstanding_nodedscr;
	+ *ndirty += vdirty;
	+ break;
	+ }
	+
	+ vput(vp);
	+ mutex_enter(&mntvnode_lock);
	+ }
	+ DPRINTF(SYNC, ("END sync_pass %d\n", pass));
	+}
	+
	+
	+void
	+udf_do_sync(struct udf_mount *ump, kauth_cred_t cred, int waitfor)
	+{
	+ int dummy, ndirty;
	+
	+ mutex_enter(&mntvnode_lock);
	+recount:
	+ dummy = 0;
	+ DPRINTF(CALL, ("issue VOP_FSYNC(DATA only) on all nodes\n"));
	+ DPRINTF(SYNC, ("issue VOP_FSYNC(DATA only) on all nodes\n"));
	+ udf_sync_pass(ump, cred, waitfor, 1, &dummy);
	+
	+ DPRINTF(CALL, ("issue VOP_FSYNC(COMPLETE) on all finished nodes\n"));
	+ DPRINTF(SYNC, ("issue VOP_FSYNC(COMPLETE) on all finished nodes\n"));
	+ udf_sync_pass(ump, cred, waitfor, 2, &dummy);
	+
	+ if (waitfor == MNT_WAIT) {
	+ ndirty = ump->devvp->v_numoutput;
	+ DPRINTF(SYNC, ("counting pending blocks: on devvp %d\n",
	+ ndirty));
	+ udf_sync_pass(ump, cred, waitfor, 3, &ndirty);
	+ DPRINTF(SYNC, ("counted num dirty pending blocks %d\n",
	+ ndirty));
	+
	+ if (ndirty) {
	+ /* 1/4 second wait */
	+ cv_timedwait(&ump->dirtynodes_cv, &mntvnode_lock,
	+ hz/4);
	+ goto recount;
	+ }
	+ }
	+
	+ mutex_exit(&mntvnode_lock);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+#endif
	+/*
	+ * Read and write file extent in/from the buffer.
	+ *
	+ * The splitup of the extent into separate request-buffers is to minimise
	+ * copying around as much as possible.
	+ *
	+ * block based file reading and writing
	+ */
	+
	+int
	+udf_read_internal(struct udf_node node, uint8_t blob)
	+{
	+ struct file_entry *fe = node->fe;
	+ struct extfile_entry *efe = node->efe;
	+ struct udf_mount *ump;
	+ uint64_t inflen;
	+ int icbflags, addr_type;
	+ uint32_t sector_size;
	+ uint8_t *pos;
	+
	+ /* get extent and do some paranoia checks */
	+ ump = node->ump;
	+ sector_size = ump->discinfo.sector_size;
	+
	+ if (fe) {
	+ inflen = le64toh(fe->inf_len);
	+ pos = &fe->data[0] + le32toh(fe->l_ea);
	+ icbflags = le16toh(fe->icbtag.flags);
	+ } else {
	+ /assert(node->efe); /
	+ inflen = le64toh(efe->inf_len);
	+ pos = &efe->data[0] + le32toh(efe->l_ea);
	+ icbflags = le16toh(efe->icbtag.flags);
	+ }
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ /assert(addr_type == UDF_ICB_INTERN_ALLOC); /
	+ /assert(inflen < sector_size); /
	+
	+ /* copy out info */
	+ memset(blob, 0, sector_size);
	+ memcpy(blob, pos, inflen);
	+
	+ return (0);
	+}
	+
	+
	+#if 0
	+static int
	+udf_write_internal(struct udf_node node, uint8_t blob)
	+{
	+ struct udf_mount *ump;
	+ struct file_entry *fe = node->fe;
	+ struct extfile_entry *efe = node->efe;
	+ uint64_t inflen;
	+ uint32_t sector_size;
	+ uint8_t *pos;
	+ int icbflags, addr_type;
	+
	+ /* get extent and do some paranoia checks */
	+ ump = node->ump;
	+ sector_size = ump->discinfo.sector_size;
	+
	+ if (fe) {
	+ inflen = le64toh(fe->inf_len);
	+ pos = &fe->data[0] + le32toh(fe->l_ea);
	+ icbflags = le16toh(fe->icbtag.flags);
	+ } else {
	+ assert(node->efe);
	+ inflen = le64toh(efe->inf_len);
	+ pos = &efe->data[0] + le32toh(efe->l_ea);
	+ icbflags = le16toh(efe->icbtag.flags);
	+ }
	+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
	+
	+ assert(addr_type == UDF_ICB_INTERN_ALLOC);
	+ assert(inflen < sector_size);
	+
	+ /* copy in blob */
	+ /* memset(pos, 0, inflen); */
	+ memcpy(pos, blob, inflen);
	+
	+ return (0);
	+}
	+
	+
	+void
	+udf_read_filebuf(struct udf_node udf_node, struct buf buf)
	+{
	+ struct buf *nestbuf;
	+ struct udf_mount *ump = udf_node->ump;
	+ uint64_t *mapping;
	+ uint64_t run_start;
	+ uint32_t sector_size;
	+ uint32_t buf_offset, sector, rbuflen, rblk;
	+ uint32_t from, lblkno;
	+ uint32_t sectors;
	+ uint8_t *buf_pos;
	+ int error, run_length, what;
	+
	+ sector_size = udf_node->ump->discinfo.sector_size;
	+
	+ from = buf->b_blkno;
	+ sectors = buf->b_bcount / sector_size;
	+
	+ what = udf_get_c_type(udf_node);
	+
	+ /* assure we have enough translation slots */
	+ KASSERT(buf->b_bcount / sector_size <= UDF_MAX_MAPPINGS);
	+ KASSERT(MAXPHYS / sector_size <= UDF_MAX_MAPPINGS);
	+
	+ if (sectors > UDF_MAX_MAPPINGS) {
	+ printf("udf_read_filebuf: implementation limit on bufsize\n");
	+ buf->b_error = EIO;
	+ biodone(buf);
	+ return;
	+ }
	+
	+ mapping = malloc(sizeof(mapping) UDF_MAX_MAPPINGS, M_UDFTEMP, M_WAITOK);
	+
	+ error = 0;
	+ DPRINTF(READ, ("\ttranslate %d-%d\n", from, sectors));
	+ error = udf_translate_file_extent(udf_node, from, sectors, mapping);
	+ if (error) {
	+ buf->b_error = error;
	+ biodone(buf);
	+ goto out;
	+ }
	+ DPRINTF(READ, ("\ttranslate extent went OK\n"));
	+
	+ /* pre-check if its an internal */
	+ if (*mapping == UDF_TRANS_INTERN) {
	+ error = udf_read_internal(udf_node, (uint8_t *) buf->b_data);
	+ if (error)
	+ buf->b_error = error;
	+ biodone(buf);
	+ goto out;
	+ }
	+ DPRINTF(READ, ("\tnot intern\n"));
	+
	+#ifdef DEBUG
	+ if (udf_verbose & UDF_DEBUG_TRANSLATE) {
	+ printf("Returned translation table:\n");
	+ for (sector = 0; sector < sectors; sector++) {
	+ printf("%d : %"PRIu64"\n", sector, mapping[sector]);
	+ }
	+ }
	+#endif
	+
	+ /* request read-in of data from disc sheduler */
	+ buf->b_resid = buf->b_bcount;
	+ for (sector = 0; sector < sectors; sector++) {
	+ buf_offset = sector * sector_size;
	+ buf_pos = (uint8_t *) buf->b_data + buf_offset;
	+ DPRINTF(READ, ("\tprocessing rel sector %d\n", sector));
	+
	+ /* check if its zero or unmapped to stop reading */
	+ switch (mapping[sector]) {
	+ case UDF_TRANS_UNMAPPED:
	+ case UDF_TRANS_ZERO:
	+ /* copy zero sector TODO runlength like below */
	+ memset(buf_pos, 0, sector_size);
	+ DPRINTF(READ, ("\treturning zero sector\n"));
	+ nestiobuf_done(buf, sector_size, 0);
	+ break;
	+ default :
	+ DPRINTF(READ, ("\tread sector "
	+ "%"PRIu64"\n", mapping[sector]));
	+
	+ lblkno = from + sector;
	+ run_start = mapping[sector];
	+ run_length = 1;
	+ while (sector < sectors-1) {
	+ if (mapping[sector+1] != mapping[sector]+1)
	+ break;
	+ run_length++;
	+ sector++;
	+ }
	+
	+ /*
	+ * nest an iobuf and mark it for async reading. Since
	+ * we're using nested buffers, they can't be cached by
	+ * design.
	+ */
	+ rbuflen = run_length * sector_size;
	+ rblk = run_start * (sector_size/DEV_BSIZE);
	+
	+ nestbuf = getiobuf(NULL, true);
	+ nestiobuf_setup(buf, nestbuf, buf_offset, rbuflen);
	+ /* nestbuf is B_ASYNC */
	+
	+ /* identify this nestbuf */
	+ nestbuf->b_lblkno = lblkno;
	+ assert(nestbuf->b_vp == udf_node->vnode);
	+
	+ /* CD shedules on raw blkno */
	+ nestbuf->b_blkno = rblk;
	+ nestbuf->b_proc = NULL;
	+ nestbuf->b_rawblkno = rblk;
	+ nestbuf->b_udf_c_type = what;
	+
	+ udf_discstrat_queuebuf(ump, nestbuf);
	+ }
	+ }
	+out:
	+ /* if we're synchronously reading, wait for the completion */
	+ if ((buf->b_flags & B_ASYNC) == 0)
	+ biowait(buf);
	+
	+ DPRINTF(READ, ("\tend of read_filebuf\n"));
	+ free(mapping, M_UDFTEMP);
	+ return;
	+}
	+
	+
	+void
	+udf_write_filebuf(struct udf_node udf_node, struct buf buf)
	+{
	+ struct buf *nestbuf;
	+ struct udf_mount *ump = udf_node->ump;
	+ uint64_t *mapping;
	+ uint64_t run_start;
	+ uint32_t lb_size;
	+ uint32_t buf_offset, lb_num, rbuflen, rblk;
	+ uint32_t from, lblkno;
	+ uint32_t num_lb;
	+ int error, run_length, what, s;
	+
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+
	+ from = buf->b_blkno;
	+ num_lb = buf->b_bcount / lb_size;
	+
	+ what = udf_get_c_type(udf_node);
	+
	+ /* assure we have enough translation slots */
	+ KASSERT(buf->b_bcount / lb_size <= UDF_MAX_MAPPINGS);
	+ KASSERT(MAXPHYS / lb_size <= UDF_MAX_MAPPINGS);
	+
	+ if (num_lb > UDF_MAX_MAPPINGS) {
	+ printf("udf_write_filebuf: implementation limit on bufsize\n");
	+ buf->b_error = EIO;
	+ biodone(buf);
	+ return;
	+ }
	+
	+ mapping = malloc(sizeof(mapping) UDF_MAX_MAPPINGS, M_UDFTEMP, M_WAITOK);
	+
	+ error = 0;
	+ DPRINTF(WRITE, ("\ttranslate %d-%d\n", from, num_lb));
	+ error = udf_translate_file_extent(udf_node, from, num_lb, mapping);
	+ if (error) {
	+ buf->b_error = error;
	+ biodone(buf);
	+ goto out;
	+ }
	+ DPRINTF(WRITE, ("\ttranslate extent went OK\n"));
	+
	+ /* if its internally mapped, we can write it in the descriptor itself */
	+ if (*mapping == UDF_TRANS_INTERN) {
	+ /* TODO paranoia check if we ARE going to have enough space */
	+ error = udf_write_internal(udf_node, (uint8_t *) buf->b_data);
	+ if (error)
	+ buf->b_error = error;
	+ biodone(buf);
	+ goto out;
	+ }
	+ DPRINTF(WRITE, ("\tnot intern\n"));
	+
	+ /* request write out of data to disc sheduler */
	+ buf->b_resid = buf->b_bcount;
	+ for (lb_num = 0; lb_num < num_lb; lb_num++) {
	+ buf_offset = lb_num * lb_size;
	+ DPRINTF(WRITE, ("\tprocessing rel lb_num %d\n", lb_num));
	+
	+ /*
	+ * Mappings are not that important here. Just before we write
	+ * the lb_num we late-allocate them when needed and update the
	+ * mapping in the udf_node.
	+ */
	+
	+ /* XXX why not ignore the mapping altogether ? */
	+ DPRINTF(WRITE, ("\twrite lb_num "
	+ "%"PRIu64, mapping[lb_num]));
	+
	+ lblkno = from + lb_num;
	+ run_start = mapping[lb_num];
	+ run_length = 1;
	+ while (lb_num < num_lb-1) {
	+ if (mapping[lb_num+1] != mapping[lb_num]+1)
	+ if (mapping[lb_num+1] != mapping[lb_num])
	+ break;
	+ run_length++;
	+ lb_num++;
	+ }
	+ DPRINTF(WRITE, ("+ %d\n", run_length));
	+
	+ /* nest an iobuf on the master buffer for the extent */
	+ rbuflen = run_length * lb_size;
	+ rblk = run_start * (lb_size/DEV_BSIZE);
	+
	+ nestbuf = getiobuf(NULL, true);
	+ nestiobuf_setup(buf, nestbuf, buf_offset, rbuflen);
	+ /* nestbuf is B_ASYNC */
	+
	+ /* identify this nestbuf */
	+ nestbuf->b_lblkno = lblkno;
	+ KASSERT(nestbuf->b_vp == udf_node->vnode);
	+
	+ /* CD shedules on raw blkno */
	+ nestbuf->b_blkno = rblk;
	+ nestbuf->b_proc = NULL;
	+ nestbuf->b_rawblkno = rblk;
	+ nestbuf->b_udf_c_type = what;
	+
	+ /* increment our outstanding bufs counter */
	+ s = splbio();
	+ udf_node->outstanding_bufs++;
	+ splx(s);
	+
	+ udf_discstrat_queuebuf(ump, nestbuf);
	+ }
	+out:
	+ /* if we're synchronously writing, wait for the completion */
	+ if ((buf->b_flags & B_ASYNC) == 0)
	+ biowait(buf);
	+
	+ DPRINTF(WRITE, ("\tend of write_filebuf\n"));
	+ free(mapping, M_UDFTEMP);
	+ return;
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+
	+
	Index: sys/fs/udf2/udf_vfsops.c
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_vfsops.c
	@@ -0,0 +1,987 @@
	+/*-
	+ * Copyright (c) 2012 Oleksandr Dudinskyi
	+ * Copyright (c) 2012 Will DeVries
	+ * Copyright (c) 2006, 2008 Reinoud Zandijk
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ */
	+
	+#include <sys/param.h>
	+#include <sys/endian.h>
	+#include <sys/cdefs.h>
	+#include <sys/kernel.h>
	+#include <sys/malloc.h>
	+#include <sys/systm.h>
	+#include <sys/fcntl.h>
	+#include <sys/namei.h>
	+#include <sys/proc.h>
	+#include <sys/vnode.h>
	+#include <sys/mount.h>
	+#include <sys/conf.h>
	+#include <sys/module.h>
	+#include <sys/priv.h>
	+#include <sys/iconv.h>
	+#include <geom/geom.h>
	+#include <geom/geom_vfs.h>
	+
	+#include "ecma167-udf.h"
	+#include "udf.h"
	+#include "udf_subr.h"
	+#include "udf_mount.h"
	+
	+MALLOC_DEFINE(M_UDFTEMP, "UDF temp", "UDF allocation space");
	+uma_zone_t udf_zone_node = NULL;
	+
	+/* verbose levels of the udf filingsystem */
	+int udf_verbose = UDF_DEBUGGING;
	+
	+struct iconv_functions *udf2_iconv = NULL;
	+
	+/* internal finctions */
	+static int udf_mountfs(struct vnode , struct mount );
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* predefine vnode-op list descriptor */
	+
	+static vfs_init_t udf_init;
	+static vfs_mount_t udf_mount;
	+static vfs_root_t udf_root;
	+static vfs_statfs_t udf_statfs;
	+static vfs_uninit_t udf_uninit;
	+static vfs_unmount_t udf_unmount;
	+static vfs_fhtovp_t udf_fhtovp;
	+
	+static struct vfsops udf_vfsops = {
	+ .vfs_init = udf_init,
	+ .vfs_uninit = udf_uninit,
	+ .vfs_mount = udf_mount,
	+ .vfs_root = udf_root,
	+ .vfs_statfs = udf_statfs,
	+ .vfs_unmount = udf_unmount,
	+ .vfs_fhtovp = udf_fhtovp,
	+ .vfs_vget = udf_vget
	+};
	+VFS_SET(udf_vfsops, udf2, VFCF_READONLY);
	+
	+MODULE_VERSION(udf2, 1);
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* file system start here */
	+static int
	+udf_init(struct vfsconf *notused)
	+{
	+ /* init node pools */
	+ udf_zone_node = uma_zcreate("UDF Node Pool Zone",
	+ sizeof(struct udf_node), NULL, NULL, NULL, NULL, 0, 0);
	+
	+ if (udf_zone_node == NULL) {
	+ printf("Cannot create node pool zone.");
	+ return (ENOMEM);
	+ }
	+
	+ return (0);
	+}
	+
	+static int
	+udf_uninit(struct vfsconf *notused)
	+{
	+ /* remove pools */
	+ if (udf_zone_node != NULL) {
	+ uma_zdestroy(udf_zone_node);
	+ udf_zone_node = NULL;
	+ }
	+
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/* if the system nodes exist, release them */
	+static void
	+udf_release_system_nodes(struct mount *mp)
	+{
	+ struct udf_mount *ump = VFSTOUDF(mp);
	+ int error;
	+
	+ /* if we haven't even got an ump, dont bother */
	+ if (!ump)
	+ return;
	+
	+ /* VAT partition support */
	+ if (ump->vat_node)
	+ udf_dispose_node(ump->vat_node);
	+
	+ /* Metadata partition support */
	+ if (ump->metadata_node)
	+ udf_dispose_node(ump->metadata_node);
	+ if (ump->metadatamirror_node)
	+ udf_dispose_node(ump->metadatamirror_node);
	+ if (ump->metadatabitmap_node)
	+ udf_dispose_node(ump->metadatabitmap_node);
	+
	+ /* This flush should NOT write anything nor allow any node to remain */
	+ if ((error = vflush(ump->vfs_mountp, 0, 0, curthread)))
	+ panic("Failure to flush UDF system vnodes\n");
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+#define MPFREE(a, lst) \
	+ if ((a)) free((a), lst);
	+static void
	+free_udf_mountinfo(struct mount *mp)
	+{
	+ struct udf_mount *ump;
	+ int i;
	+
	+ if (!mp)
	+ return;
	+
	+ ump = VFSTOUDF(mp);
	+ if (ump) {
	+ /* clear our data */
	+ for (i = 0; i < UDF_ANCHORS; i++)
	+ MPFREE(ump->anchors[i], M_UDFTEMP);
	+ MPFREE(ump->primary_vol, M_UDFTEMP);
	+ MPFREE(ump->logical_vol, M_UDFTEMP);
	+ MPFREE(ump->unallocated, M_UDFTEMP);
	+ MPFREE(ump->implementation, M_UDFTEMP);
	+ MPFREE(ump->logvol_integrity, M_UDFTEMP);
	+ for (i = 0; i < UDF_PARTITIONS; i++) {
	+ MPFREE(ump->partitions[i], M_UDFTEMP);
	+ MPFREE(ump->part_unalloc_dscr[i], M_UDFTEMP);
	+ MPFREE(ump->part_freed_dscr[i], M_UDFTEMP);
	+ }
	+ MPFREE(ump->metadata_unalloc_dscr, M_UDFTEMP);
	+
	+ MPFREE(ump->fileset_desc, M_UDFTEMP);
	+ MPFREE(ump->sparing_table, M_UDFTEMP);
	+
	+#if 0
	+ MPFREE(ump->la_node_ad_cpy, M_UDFTEMP);
	+ MPFREE(ump->la_pmapping, M_UDFTEMP);
	+ MPFREE(ump->la_lmapping, M_UDFTEMP);
	+
	+ mutex_destroy(&ump->ihash_lock);
	+ mutex_destroy(&ump->get_node_lock);
	+ mutex_destroy(&ump->logvol_mutex);
	+ mutex_destroy(&ump->allocate_mutex);
	+ cv_destroy(&ump->dirtynodes_cv);
	+#endif
	+
	+ MPFREE(ump->vat_table, M_UDFTEMP);
	+
	+ free(ump, M_UDFTEMP);
	+ }
	+}
	+#undef MPFREE
	+
	+/* --------------------------------------------------------------------- */
	+
	+
	+static int
	+udf_mount(struct mount *mp)
	+{
	+ struct thread *td;
	+ struct vnode *devvp;
	+ struct nameidata nd;
	+ struct vfsoptlist *opts;
	+ int error, len;
	+ char *fspec;
	+
	+ td = curthread;
	+ opts = mp->mnt_optnew;
	+ DPRINTF(CALL, ("udf_mount called\n"));
	+
	+ /*
	+ * Unconditionally mount as read-only.
	+ */
	+ MNT_ILOCK(mp);
	+ mp->mnt_flag \|= MNT_RDONLY;
	+ MNT_IUNLOCK(mp);
	+
	+ /* No root filesystem support. Probably not a big deal, since the
	+ * bootloader doesn't understand UDF
	+ */
	+ if (mp->mnt_flag & MNT_ROOTFS)
	+ return (ENOTSUP);
	+
	+ fspec = NULL;
	+ error = vfs_getopt(opts, "from", (void **)&fspec, &len);
	+ if (!error && fspec[len - 1] != '\0')
	+ return (EINVAL);
	+
	+ /* handle request for updating mount parameters */
	+ /* TODO can't update my mountpoint yet */
	+ if (mp->mnt_flag & MNT_UPDATE)
	+ return (0);
	+
	+ /* Check that the mount device exists */
	+ if (fspec == NULL)
	+ return (EINVAL);
	+
	+ /* lookup name to get its vnode */
	+ NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, fspec, td);
	+ if ((error = namei(&nd)))
	+ return (error);
	+ NDFREE(&nd, NDF_ONLY_PNBUF);
	+ devvp = nd.ni_vp;
	+
	+ if (vn_isdisk(devvp, &error) == 0) {
	+ vput(devvp);
	+ return (error);
	+ }
	+
	+ /* Check the access rights on the mount device */
	+ error = VOP_ACCESS(devvp, VREAD, td->td_ucred, td);
	+ if (error)
	+ error = priv_check(td, PRIV_VFS_MOUNT_PERM);
	+ if (error) {
	+ vput(devvp);
	+ return (error);
	+ }
	+
	+
	+ /*
	+ * Open device and try to mount it!
	+ */
	+ if ((error = udf_mountfs(devvp, mp))) {
	+ vrele(devvp);
	+ return (error);
	+ }
	+
	+ /* successfully mounted */
	+ DPRINTF(VOLUMES, ("udf_mount() successfull\n"));
	+#if 0
	+ /* If we're not opened read-only, open its logical volume */
	+ if ((mp->mnt_flag & MNT_RDONLY) == 0) {
	+ if ((error = udf_open_logvol(VFSTOUDF(mp))) != 0) {
	+ printf( "mount_udf: can't open logical volume for "
	+ "writing, downgrading access to read-only\n");
	+ mp->mnt_flag \|= MNT_RDONLY;
	+ /* FIXME we can't return error now on open failure */
	+ return 0;
	+ }
	+ }
	+#endif
	+
	+ /* TODO: Add some iconv code here. */
	+
	+ vfs_mountedfrom(mp, fspec);
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+#ifdef DEBUG
	+static void
	+udf_unmount_sanity_check(struct mount *mp)
	+{
	+ struct vnode *vp;
	+
	+ printf("On unmount, i found the following nodes:\n");
	+ TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) {
	+ vprint("", vp);
	+ if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) {
	+ printf(" is locked\n");
	+ }
	+ if (vp->v_usecount > 1)
	+ printf(" more than one usecount %d\n", vp->v_usecount);
	+ }
	+}
	+#endif
	+
	+
	+int
	+udf_unmount(struct mount *mp, int mntflags)
	+{
	+ struct udf_mount *ump;
	+ int error, flags = 0;
	+
	+ DPRINTF(CALL, ("udf_unmount called\n"));
	+
	+ ump = VFSTOUDF(mp);
	+ if (!ump)
	+ panic("UDF unmount: empty ump\n");
	+
	+ flags = (mntflags & MNT_FORCE) ? FORCECLOSE : 0;
	+
	+ /* TODO remove these paranoid functions */
	+#ifdef DEBUG
	+ if (udf_verbose & UDF_DEBUG_LOCKING)
	+ udf_unmount_sanity_check(mp);
	+#endif
	+
	+ /*
	+ * By specifying SKIPSYSTEM we can skip vnodes marked with VV_SYSTEM.
	+ * This hardly documented feature allows us to exempt certain files
	+ * from being flushed.
	+ */
	+ if ((error = vflush(mp, 0, flags, curthread)))
	+ return (error);
	+
	+ /* update nodes and wait for completion of writeout of system nodes */
	+ //udf_sync(mp, FSYNC_WAIT, NOCRED);
	+
	+#ifdef DEBUG
	+ if (udf_verbose & UDF_DEBUG_LOCKING)
	+ udf_unmount_sanity_check(mp);
	+#endif
	+#if 0
	+ /* flush again, to check if we are still busy for something else */
	+ if ((error = vflush(ump->vfs_mountp, 0, flags, curthread)))
	+ return (error);
	+
	+ DPRINTF(VOLUMES, ("flush OK on unmount\n"));
	+
	+ /* close logical volume and close session if requested */
	+ if ((error = udf_close_logvol(ump, mntflags)) != 0)
	+ return (error);
	+#endif
	+
	+#ifdef DEBUG
	+ DPRINTF(VOLUMES, ("FINAL sanity check\n"));
	+ if (udf_verbose & UDF_DEBUG_LOCKING)
	+ udf_unmount_sanity_check(mp);
	+#endif
	+
	+ /* NOTE release system nodes should NOT write anything */
	+ udf_release_system_nodes(mp);
	+
	+#if 0
	+ /* finalise disc strategy */
	+ udf_discstrat_finish(ump);
	+
	+#endif
	+ /* synchronise device caches */
	+ (void) udf_synchronise_caches(ump);
	+
	+/* TODO: clean up iconv here */
	+ if (ump->iconv_d2l)
	+ udf2_iconv->close(ump->iconv_d2l);
	+
	+ DROP_GIANT();
	+ g_topology_lock();
	+ g_vfs_close(ump->geomcp);
	+ g_topology_unlock();
	+ PICKUP_GIANT();
	+ vrele(ump->devvp);
	+ dev_rel(ump->dev);
	+
	+ /* free our ump */
	+ free_udf_mountinfo(mp);
	+
	+ /* free ump struct references */
	+ mp->mnt_data = NULL;
	+ MNT_ILOCK(mp);
	+ mp->mnt_flag &= ~MNT_LOCAL;
	+ MNT_IUNLOCK(mp);
	+
	+ DPRINTF(VOLUMES, ("Fin unmount\n"));
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Helper function of udf_mount() that actually mounts the disc.
	+ */
	+
	+static int
	+udf_mountfs(struct vnode devvp, struct mount mp)
	+{
	+ struct udf_args *args = NULL;
	+ struct g_consumer *cp;
	+ struct cdev *dev;
	+ struct udf_mount *ump = NULL;
	+ struct vfsoptlist *opts;
	+ int num_anchors, error, len, *udf_flags;
	+ uint32_t bshift, logvol_integrity, sector_size; /lb_size,/
	+ char cs_disk, cs_local;
	+ void *optdata;
	+
	+#if 0
	+ /* flush out any old buffers remaining from a previous use. */
	+ if ((error = vinvalbuf(devvp, V_SAVE, l->l_cred, l, 0, 0)))
	+ return (error);
	+#endif
	+ opts = mp->mnt_optnew;
	+
	+ /* Open a consumer. */
	+ dev = devvp->v_rdev;
	+ dev_ref(dev);
	+ DROP_GIANT();
	+ g_topology_lock();
	+ error = g_vfs_open(devvp, &cp, "udf2", 0);
	+ g_topology_unlock();
	+ PICKUP_GIANT();
	+ VOP_UNLOCK(devvp, 0);
	+ if (error)
	+ goto fail;
	+
	+
	+ /* setup basic mount information */
	+ mp->mnt_data = NULL;
	+ mp->mnt_stat.f_fsid.val[0] = dev2udev(devvp->v_rdev);
	+ mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
	+ mp->mnt_stat.f_namemax = UDF_MAX_NAMELEN;
	+ if (devvp->v_rdev->si_iosize_max != 0)
	+ mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
	+ if (mp->mnt_iosize_max > MAXPHYS)
	+ mp->mnt_iosize_max = MAXPHYS;
	+ MNT_ILOCK(mp);
	+ mp->mnt_flag \|= MNT_LOCAL;
	+ mp->mnt_kern_flag \|= MNTK_LOOKUP_SHARED \| MNTK_EXTENDED_SHARED;
	+ MNT_IUNLOCK(mp);
	+
	+ /* allocate udf part of mount structure; malloc always succeeds */
	+ ump = malloc(sizeof(struct udf_mount), M_UDFTEMP, M_WAITOK \| M_ZERO);
	+
	+#if 0
	+ /* init locks */
	+ mutex_init(&ump->logvol_mutex, MUTEX_DEFAULT, IPL_NONE);
	+ mutex_init(&ump->ihash_lock, MUTEX_DEFAULT, IPL_NONE);
	+ mutex_init(&ump->get_node_lock, MUTEX_DEFAULT, IPL_NONE);
	+ mutex_init(&ump->allocate_mutex, MUTEX_DEFAULT, IPL_NONE);
	+ cv_init(&ump->dirtynodes_cv, "udfsync2");
	+
	+ /* init rbtree for nodes, ordered by their icb address (long_ad) */
	+ udf_init_nodes_tree(ump);
	+#endif
	+
	+ /* set up linkage */
	+ mp->mnt_data = ump;
	+ ump->vfs_mountp = mp;
	+ ump->devvp = devvp;
	+ ump->dev = dev;
	+ ump->geomcp = cp;
	+ ump->bo = &devvp->v_bufobj;
	+
	+ /* Load flags for later. Not sure what to use them for... */
	+ udf_flags = NULL;
	+ error = vfs_getopt(opts, "flags", (void **)&udf_flags, &len);
	+ if (error \|\| len != sizeof(int))
	+ return (EINVAL);
	+ ump->flags = *udf_flags;
	+
	+ optdata = NULL;
	+ error = vfs_getopt(opts, "udf_args", &optdata, &len);
	+ if (error \|\| len != sizeof(struct udf_args)) {
	+ error = EINVAL;
	+ goto fail;
	+ }
	+
	+ /* set up arguments and device */
	+ ump->mount_args = (struct udf_args )optdata;
	+
	+ if (ump->flags & UDFMNT_KICONV && udf2_iconv) {
	+ cs_disk = "UTF-16BE";
	+
	+ cs_local = NULL;
	+ error = vfs_getopt(opts, "cs_local", (void **)&cs_local, &len);
	+ if (error != 0 \|\| cs_local[len-1] != '\0') {
	+ error = EINVAL;
	+ goto fail;
	+ }
	+
	+ udf2_iconv->open(cs_local, cs_disk, &ump->iconv_d2l);
	+#if 0
	+ udf2_iconv->open(cs_disk, cs_local, &ump->iconv_l2d);
	+#endif
	+ }
	+
	+ if ((error = udf_update_discinfo(ump, cp->provider->sectorsize, cp->provider->mediasize))) {
	+ printf("UDF mount: error inspecting fs node\n");
	+ goto fail;
	+ }
	+
	+ /* inspect sector size */
	+ sector_size = ump->discinfo.sector_size;
	+ bshift = 1;
	+ while ((1 << bshift) < sector_size)
	+ bshift++;
	+ if ((1 << bshift) != sector_size) {
	+ printf("UDF mount: "
	+ "hit implementation fence on sector size\n");
	+ error = EIO;
	+ goto fail;
	+
	+ }
	+
	+ /* temporary check to overcome sectorsize >= 8192 bytes panic */
	+ if (sector_size >= 8192) {
	+ printf("UDF mount: "
	+ "hit implementation limit, sectorsize to big\n");
	+ error = EIO;
	+ goto fail;
	+
	+ }
	+
	+ /*
	+ * Inspect if we're asked to mount read-write on a non recordable or
	+ * closed sequential disc.
	+ */
	+ if ((mp->mnt_flag & MNT_RDONLY) == 0) {
	+ if ((ump->discinfo.mmc_cur & MMC_CAP_RECORDABLE) == 0) {
	+ printf("UDF mount: disc is not recordable\n");
	+ error = EROFS;
	+ goto fail;
	+ }
	+ if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
	+ if (ump->discinfo.disc_state == MMC_STATE_FULL) {
	+ printf("UDF mount: disc is not appendable\n");
	+ error = EROFS;
	+ goto fail;
	+ }
	+
	+ /*
	+ * TODO if the last session is closed check if there
	+ * is enough space to open/close new session
	+ */
	+ }
	+ /* double check if we're not mounting a pervious session RW */
	+
	+ if (args->sessionnr != 0) {
	+ printf("UDF mount: updating a previous session "
	+ "not yet allowed\n");
	+ error = EROFS;
	+ goto fail;
	+ }
	+
	+ }
	+
	+#if 0
	+ /* initialise bootstrap disc strategy */
	+ ump->strategy = &udf_strat_bootstrap;
	+ udf_discstrat_init(ump);
	+#endif
	+
	+ /* read all anchors to get volume descriptor sequence */
	+ num_anchors = udf_read_anchors(ump);
	+ if (num_anchors == 0) {
	+ printf("UDF mount: error reading anchors\n");
	+ error = EINVAL;
	+ goto fail;
	+ }
	+
	+ /*DPRINTF(VOLUMES, ("Read %d anchors on this disc, session %d\n",
	+ num_anchors, args->sessionnr));*/
	+
	+ /* read in volume descriptor sequence */
	+ if ((error = udf_read_vds_space(ump))) {
	+ printf("UDF mount: error reading volume space\n");
	+ goto fail;
	+ }
	+
	+#if 0
	+ /* close down bootstrap disc strategy */
	+ udf_discstrat_finish(ump);
	+#endif
	+
	+ /* check consistency and completeness */
	+ if ((error = udf_process_vds(ump))) {
	+ printf( "UDF mount: disc not properly formatted(bad VDS)\n");
	+ goto fail;
	+ }
	+
	+#if 0
	+ /* switch to new disc strategy */
	+ KASSERT(ump->strategy != &udf_strat_bootstrap,
	+ ("ump->strategy != &udf_strat_bootstrap"));
	+ udf_discstrat_init(ump);
	+
	+ /* initialise late allocation administration space */
	+ ump->la_lmapping = malloc(sizeof(uint64_t) * UDF_MAX_MAPPINGS,
	+ M_UDFTEMP, M_WAITOK);
	+ ump->la_pmapping = malloc(sizeof(uint64_t) * UDF_MAX_MAPPINGS,
	+ M_UDFTEMP, M_WAITOK);
	+
	+ /* setup node cleanup extents copy space */
	+ lb_size = le32toh(ump->logical_vol->lb_size);
	+ ump->la_node_ad_cpy = malloc(lb_size * UDF_MAX_ALLOC_EXTENTS,
	+ M_UDFTEMP, M_WAITOK);
	+ memset(ump->la_node_ad_cpy, 0, lb_size * UDF_MAX_ALLOC_EXTENTS);
	+#endif
	+
	+ /* setup rest of mount information */
	+ mp->mnt_data = ump;
	+
	+#if 0
	+ /* bshift is allways equal to disc sector size */
	+ mp->mnt_dev_bshift = bshift;
	+ mp->mnt_fs_bshift = bshift;
	+#endif
	+
	+ /* note that the mp info needs to be initialised for reading! */
	+ /* read vds support tables like VAT, sparable etc. */
	+ if ((error = udf_read_vds_tables(ump))) {
	+ printf( "UDF mount: error in format or damaged disc "
	+ "(VDS tables failing)\n");
	+ goto fail;
	+ }
	+
	+ /* check if volume integrity is closed otherwise its dirty */
	+ logvol_integrity = le32toh(ump->logvol_integrity->integrity_type);
	+ if (logvol_integrity != UDF_INTEGRITY_CLOSED) {
	+ printf("UDF mount: file system is not clean; ");
	+ printf("please fsck(8)\n");
	+ error = EPERM;
	+ goto fail;
	+ }
	+
	+ /* read root directory */
	+ if ((error = udf_read_rootdirs(ump))) {
	+ printf( "UDF mount: "
	+ "disc not properly formatted or damaged disc "
	+ "(rootdirs failing)\n");
	+ goto fail;
	+ }
	+
	+ /* do we have to set this? */
	+ /* devvp->v_specmountpoint = mp; */
	+
	+ /* success! */
	+ return (0);
	+
	+fail:
	+ if (cp != NULL) {
	+ DROP_GIANT();
	+ g_topology_lock();
	+ g_vfs_close(cp);
	+ g_topology_unlock();
	+ PICKUP_GIANT();
	+ }
	+ dev_rel(dev);
	+ if (ump != NULL) {
	+ /udf_discstrat_finish(VFSTOUDF(mp)); /
	+ free_udf_mountinfo(mp);
	+ }
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_root(struct mount mp, int flags, struct vnode *vpp)
	+{
	+ struct long_ad *dir_loc;
	+ struct udf_mount *ump = VFSTOUDF(mp);
	+ ino_t ino;
	+ int error;
	+
	+ DPRINTF(CALL, ("udf_root called\n"));
	+
	+ dir_loc = &ump->fileset_desc->rootdir_icb;
	+ ino = udf_get_node_id(dir_loc);
	+ error = udf_vget(mp, ino, flags, vpp);
	+
	+ if (!((*vpp)->v_vflag & VV_ROOT)) {
	+ printf("NOT A ROOT NODE?");
	+ return (EDOOFUS);
	+ }
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_statfs(struct mount mp, struct statfs sbp)
	+{
	+ struct udf_mount *ump = VFSTOUDF(mp);
	+ struct logvol_int_desc *lvid;
	+ struct udf_logvol_info *impl;
	+ uint64_t sizeblks, freeblks, files = 0;
	+ int num_part;
	+
	+ DPRINTF(CALL, ("udf_statvfs called\n"));
	+ /* mutex_enter(&ump->allocate_mutex); */
	+ udf_calc_freespace(ump, &sizeblks, &freeblks);
	+
	+ lvid = ump->logvol_integrity;
	+ num_part = le32toh(lvid->num_part);
	+ impl = (struct udf_logvol_info ) (lvid->tables + 2num_part);
	+ if (impl) {
	+ files = le32toh(impl->num_files);
	+ files += le32toh(impl->num_directories);
	+ }
	+/* mutex_exit(&ump->allocate_mutex); */
	+
	+ sbp->f_version = STATFS_VERSION; /* structure version number */
	+ /uint32_t f_type;/ /* type of filesystem */
	+ sbp->f_flags = mp->mnt_flag; /* copy of mount exported flags */
	+ sbp->f_bsize = ump->discinfo.sector_size; /* filesystem fragment size */
	+ sbp->f_iosize = ump->discinfo.sector_size; /* optimal transfer block size */
	+ sbp->f_blocks = sizeblks; /* total data blocks in filesystem */
	+ sbp->f_bfree = freeblks; /* free blocks in filesystem */
	+ sbp->f_bavail = 0; /* free blocks avail to non-superuser */
	+ sbp->f_files = files; /* total file nodes in filesystem */
	+ sbp->f_ffree = 0; /* free nodes avail to non-superuser */
	+ /uint64_t f_syncwrites;/ /* count of sync writes since mount */
	+ /uint64_t f_asyncwrites;/ /* count of async writes since mount */
	+ /uint64_t f_syncreads;/ /* count of sync reads since mount */
	+ /uint64_t f_asyncreads;/ /* count of async reads since mount */
	+ /uint64_t f_spare[10];/ /* unused spare */
	+ /uint32_t f_namemax;/ /* maximum filename length */
	+ /uid_t f_owner;/ /* user that mounted the filesystem */
	+ /fsid_t f_fsid;/ /* filesystem id */
	+ /char f_charspare[80];/ /* spare string space */
	+ /char f_fstypename[MFSNAMELEN];/ /* filesystem type name */
	+ /char f_mntfromname[MNAMELEN];/ /* mounted filesystem */
	+ /char f_mntonname[MNAMELEN];/ /* directory on which mounted */
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * TODO what about writing out free space maps, lvid etc? only on `waitfor'
	+ * i.e. explicit syncing by the user?
	+ */
	+#if 0
	+static int
	+udf_sync_writeout_system_files(struct udf_mount *ump, int clearflags)
	+{
	+ int error;
	+
	+ /* XXX lock for VAT en bitmaps? */
	+ /* metadata nodes are written synchronous */
	+ DPRINTF(CALL, ("udf_sync: syncing metadata\n"));
	+ if (ump->lvclose & UDF_WRITE_VAT)
	+ udf_writeout_vat(ump);
	+
	+ error = 0;
	+ if (ump->lvclose & UDF_WRITE_PART_BITMAPS) {
	+ /* writeout metadata spacetable if existing */
	+ error = udf_write_metadata_partition_spacetable(ump, MNT_WAIT);
	+ if (error)
	+ printf( "udf_writeout_system_files : "
	+ " writeout of metadata space bitmap failed\n");
	+
	+ /* writeout partition spacetables */
	+ error = udf_write_physical_partition_spacetables(ump, MNT_WAIT);
	+ if (error)
	+ printf( "udf_writeout_system_files : "
	+ "writeout of space tables failed\n");
	+ if (!error && clearflags)
	+ ump->lvclose &= ~UDF_WRITE_PART_BITMAPS;
	+ }
	+
	+ return (error);
	+}
	+
	+
	+int
	+udf_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
	+{
	+ struct udf_mount *ump = VFSTOUDF(mp);
	+
	+ DPRINTF(CALL, ("udf_sync called\n"));
	+ /* if called when mounted readonly, just ignore */
	+ if (mp->mnt_flag & MNT_RDONLY)
	+ return (0);
	+
	+ if (ump->syncing && !waitfor) {
	+ printf("UDF: skipping autosync\n");
	+ return (0);
	+ }
	+ /* get sync lock */
	+ ump->syncing = 1;
	+
	+ /* pre-sync */
	+ udf_do_sync(ump, cred, waitfor);
	+
	+ if (waitfor == MNT_WAIT)
	+ udf_sync_writeout_system_files(ump, true);
	+
	+ DPRINTF(CALL, ("end of udf_sync()\n"));
	+ ump->syncing = 0;
	+ return (0);
	+}
	+
	+#endif
	+/* This added only for temp use */
	+struct udf_node *
	+udf_alloc_node()
	+{
	+ return (uma_zalloc(udf_zone_node, M_WAITOK \| M_ZERO));
	+}
	+
	+void
	+udf_free_node(struct udf_node *unode)
	+{
	+ uma_zfree(udf_zone_node, unode);
	+}
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Get vnode for the file system type specific file id ino for the fs. Its
	+ * used for reference to files by unique ID and for NFSv3.
	+ * (optional) TODO lookup why some sources state NFSv3
	+
	+ * This done as in the current udf implementation. I really have no idea
	+ * if it is correct.
	+ */
	+int
	+udf_vget(struct mount mp, ino_t ino, int flags, struct vnode *vpp)
	+{
	+ struct vnode *nvp;
	+ struct udf_node *unode;
	+ struct udf_mount *ump;
	+ int error, udf_file_type;
	+
	+ DPRINTF(NOTIMPL, ("udf_vget called\n"));
	+ error = vfs_hash_get(mp, ino, flags, curthread, vpp, NULL, NULL);
	+ if (error \|\| *vpp != NULL)
	+ return (error);
	+
	+ /*
	+ * We must promote to an exclusive lock for vnode creation. This
	+ * can happen if lookup is passed LOCKSHARED.
	+ */
	+ if ((flags & LK_TYPE_MASK) == LK_SHARED) {
	+ flags &= ~LK_TYPE_MASK;
	+ flags \|= LK_EXCLUSIVE;
	+ }
	+
	+ ump = VFSTOUDF(mp);
	+ error = udf_getanode(mp, &nvp);
	+ if (error)
	+ return (error);
	+
	+ lockmgr(nvp->v_vnlock, LK_EXCLUSIVE, NULL);
	+ if ((error = insmntque(nvp, mp)) != 0)
	+ return (error);
	+
	+ /* TODO: Does this leak unode or vnodes? */
	+ error = vfs_hash_insert(nvp, ino, flags, curthread, vpp, NULL, NULL);
	+ if (error \|\| *vpp != NULL)
	+ return (error);
	+
	+
	+ /*
	+ * Load read and set up the unode structure.
	+ */
	+ error = udf_get_node(ump, ino, &unode);
	+ if (error) {
	+ vgone(nvp);
	+ vput(nvp);
	+ }
	+ nvp->v_data = unode;
	+ unode->vnode = nvp;
	+
	+ /* mark the root node as such */
	+ if (ump->fileset_desc &&
	+ ino == udf_get_node_id(&ump->fileset_desc->rootdir_icb))
	+ nvp->v_vflag \|= VV_ROOT;
	+
	+ /*
	+ * Translate UDF filetypes into vnode types.
	+ *
	+ * Systemfiles like the meta main and mirror files are not treated as
	+ * normal files, so we type them as having no type. UDF dictates that
	+ * they are not allowed to be visible.
	+ */
	+ if (unode->fe)
	+ udf_file_type = unode->fe->icbtag.file_type;
	+ else
	+ udf_file_type = unode->efe->icbtag.file_type;
	+
	+ switch (udf_file_type) {
	+ case UDF_ICB_FILETYPE_DIRECTORY :
	+ case UDF_ICB_FILETYPE_STREAMDIR :
	+ nvp->v_type = VDIR;
	+ break;
	+ case UDF_ICB_FILETYPE_BLOCKDEVICE :
	+ nvp->v_type = VBLK;
	+ break;
	+ case UDF_ICB_FILETYPE_CHARDEVICE :
	+ nvp->v_type = VCHR;
	+ break;
	+ case UDF_ICB_FILETYPE_SOCKET :
	+ nvp->v_type = VSOCK;
	+ break;
	+ case UDF_ICB_FILETYPE_FIFO :
	+ nvp->v_type = VFIFO;
	+ break;
	+ case UDF_ICB_FILETYPE_SYMLINK :
	+ nvp->v_type = VLNK;
	+ break;
	+ case UDF_ICB_FILETYPE_VAT :
	+ case UDF_ICB_FILETYPE_META_MAIN :
	+ case UDF_ICB_FILETYPE_META_MIRROR :
	+ nvp->v_type = VNON;
	+ break;
	+ case UDF_ICB_FILETYPE_RANDOMACCESS :
	+ case UDF_ICB_FILETYPE_REALTIME :
	+ nvp->v_type = VREG;
	+ break;
	+ default:
	+ nvp->v_type = VBAD;
	+ }
	+
	+ /* TODO specfs, fifofs etc etc. vnops setting */
	+
	+ /* don't forget to set vnode's v_size */
	+/* uvm_vnp_setsize(nvp, file_size); */
	+
	+ if (nvp->v_type != VFIFO)
	+ VN_LOCK_ASHARE(nvp);
	+
	+ *vpp = nvp;
	+
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Lookup vnode for file handle specified
	+ */
	+int
	+udf_fhtovp(struct mount mp, struct fid fhp, int flags,
	+ struct vnode **vpp)
	+{
	+ struct vnode *nvp;
	+ struct udf_fid ufid = (struct udf_fid)fhp;
	+ struct udf_node *udf_node;
	+ uint64_t filelen;
	+ int error;
	+
	+ if ((error = VFS_VGET(mp, ufid->ino, LK_EXCLUSIVE, &nvp)) != 0) {
	+ *vpp = NULLVP;
	+ return (error);
	+ }
	+
	+ udf_node = VTOI(nvp);
	+ if (udf_node->efe)
	+ filelen = le64toh(udf_node->efe->inf_len);
	+ else
	+ filelen = le64toh(udf_node->fe->inf_len);
	+
	+ *vpp = nvp;
	+ vnode_create_vobject(*vpp, filelen, curthread);
	+
	+ return (0);
	+}
	+
	Index: sys/fs/udf2/udf_vnops.c
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udf_vnops.c
	@@ -0,0 +1,2489 @@
	+/*-
	+ * Copyright (c) 2012 Oleksandr Dudinskyi
	+ * Copyright (c) 2012 Will DeVries
	+ * Copyright (c) 2006, 2008 Reinoud Zandijk
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ * Generic parts are derived from software contributed to The NetBSD Foundation
	+ * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
	+ * 2005 program.
	+ *
	+ */
	+
	+#include <sys/param.h>
	+#include <sys/cdefs.h>
	+#include <sys/endian.h>
	+#include <sys/systm.h>
	+#include <sys/namei.h>
	+#include <sys/buf.h>
	+#include <sys/mount.h>
	+#include <sys/vnode.h>
	+#include <sys/malloc.h>
	+#include <sys/dirent.h>
	+#include <sys/unistd.h>
	+#include <sys/bio.h>
	+
	+#include "ecma167-udf.h"
	+#include "udf.h"
	+#include "udf_subr.h"
	+
	+
	+static vop_access_t udf_access;
	+static vop_bmap_t udf_bmap;
	+static vop_cachedlookup_t udf_cachedlookup;
	+static vop_getattr_t udf_getattr;
	+static vop_ioctl_t udf_ioctl;
	+static vop_open_t udf_open;
	+static vop_pathconf_t udf_pathconf;
	+static vop_print_t udf_print;
	+static vop_read_t udf_read;
	+static vop_readdir_t udf_readdir;
	+static vop_readlink_t udf_readlink;
	+static vop_reclaim_t udf_reclaim;
	+static vop_setattr_t udf_setattr;
	+static vop_strategy_t udf_strategy;
	+static vop_vptofh_t udf_vptofh;
	+
	+static struct vop_vector udf_vnodeops = {
	+ .vop_default = &default_vnodeops,
	+ .vop_access = udf_access,
	+ .vop_getattr = udf_getattr,
	+ .vop_open = udf_open,
	+ .vop_ioctl = udf_ioctl,
	+ .vop_pathconf = udf_pathconf,
	+ .vop_print = udf_print,
	+ .vop_read = udf_read,
	+ .vop_readdir = udf_readdir,
	+ .vop_readlink = udf_readlink,
	+ .vop_setattr = udf_setattr,
	+ .vop_strategy = udf_strategy,
	+ .vop_bmap = udf_bmap,
	+ .vop_cachedlookup = udf_cachedlookup,
	+ .vop_reclaim = udf_reclaim,
	+ .vop_vptofh = udf_vptofh,
	+ .vop_lookup = vfs_cache_lookup,
	+};
	+
	+struct vop_vector udf_fifoops = {
	+ .vop_access = udf_access,
	+ .vop_getattr = udf_getattr,
	+ .vop_print = udf_print,
	+ .vop_setattr = udf_setattr,
	+ .vop_reclaim = udf_reclaim,
	+ .vop_vptofh = udf_vptofh,
	+ .vop_default = &fifo_specops,
	+};
	+
	+/* implementations of vnode functions; table follows at end */
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_getanode(struct mount mp, struct vnode *vpp)
	+{
	+ DPRINTF(CALL, ("udf_getanode called\n"));
	+
	+ return (getnewvnode("udf2", mp, &udf_vnodeops, vpp));
	+}
	+
	+
	+#if 0
	+int
	+udf_inactive(void *v)
	+{
	+ struct vop_inactive_args /* {
	+ struct vnode *a_vp;
	+ bool *a_recycle;
	+ } / ap = v;
	+ struct vnode *vp = ap->a_vp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ int refcnt;
	+
	+ DPRINTF(NODE, ("udf_inactive called for udf_node %p\n", VTOI(vp)));
	+
	+ if (udf_node == NULL) {
	+ DPRINTF(NODE, ("udf_inactive: inactive NULL UDF node\n"));
	+ VOP_UNLOCK(vp);
	+ return (0);
	+ }
	+
	+ /*
	+ * Optionally flush metadata to disc. If the file has not been
	+ * referenced anymore in a directory we ought to free up the resources
	+ * on disc if applicable.
	+ */
	+ if (udf_node->fe) {
	+ refcnt = le16toh(udf_node->fe->link_cnt);
	+ } else {
	+ assert(udf_node->efe);
	+ refcnt = le16toh(udf_node->efe->link_cnt);
	+ }
	+
	+ if ((refcnt == 0) && (vp->v_vflag & VV_SYSTEM)) {
	+ DPRINTF(VOLUMES, ("UDF_INACTIVE deleting VV_SYSTEM\n"));
	+ /* system nodes are not writen out on inactive, so flush */
	+ udf_node->i_flags = 0;
	+ }
	+
	+ *ap->a_recycle = false;
	+ if ((refcnt == 0) && ((vp->v_vflag & VV_SYSTEM) == 0)) {
	+ /* remove this file's allocation */
	+ DPRINTF(NODE, ("udf_inactive deleting unlinked file\n"));
	+ *ap->a_recycle = true;
	+ udf_delete_node(udf_node);
	+ VOP_UNLOCK(vp);
	+ vrecycle(vp, NULL, curlwp);
	+ return (0);
	+ }
	+
	+ /* write out its node */
	+ if (udf_node->i_flags & (IN_CHANGE \| IN_UPDATE \| IN_MODIFIED))
	+ udf_update(vp, NULL, NULL, NULL, 0);
	+ VOP_UNLOCK(vp);
	+
	+ return (0);
	+}
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	+
	+static int
	+udf_reclaim(struct vop_reclaim_args *ap)
	+{
	+ struct vnode *vp = ap->a_vp;
	+ struct udf_node *udf_node = VTOI(vp);
	+
	+ DPRINTF(NODE, ("udf_reclaim called for node %p\n", udf_node));
	+ /*
	+ * Destroy the vm object and flush associated pages.
	+ */
	+ vnode_destroy_vobject(vp);
	+
	+#if 0
	+ /* update note for closure */
	+ udf_update(vp, NULL, NULL, NULL, UPDATE_CLOSE);
	+
	+ /* async check to see if all node descriptors are written out */
	+ while ((volatile int) udf_node->outstanding_nodedscr > 0) {
	+ vprint("udf_reclaim(): waiting for writeout\n", vp);
	+ tsleep(&udf_node->outstanding_nodedscr, PRIBIO, "recl wait", hz/8);
	+ }
	+
	+ /* purge old data from namei */
	+ cache_purge(vp);
	+#endif
	+ /* dispose all node knowledge */
	+ if (udf_node == NULL) {
	+ DPRINTF(NODE, ("udf_reclaim(): null udfnode\n"));
	+ } else {
	+ vfs_hash_remove(vp);
	+ /* dispose all node knowledge */
	+ udf_dispose_node(udf_node);
	+ vp->v_data = NULL;
	+ }
	+
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+static int
	+udf_read(struct vop_read_args *ap)
	+{
	+ struct vnode *vp = ap->a_vp;
	+ struct uio *uio = ap->a_uio;
	+ struct buf *bp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ uint64_t file_size;
	+ int on, n, lbn;
	+ int error = 0;
	+
	+ DPRINTF(READ, ("udf_read called\n"));
	+
	+ /* can this happen? some filingsystems have this check */
	+ if (uio->uio_offset < 0)
	+ return (EINVAL);
	+ if (uio->uio_resid == 0)
	+ return (0);
	+
	+#ifdef INVARIANTS
	+ /* As in ffs_read() */
	+ if (vp->v_type != VDIR && vp->v_type != VREG)
	+ panic("udf_read: type %d", vp->v_type);
	+#endif
	+
	+ KASSERT(udf_node, ("udf_read: udf_node is null"));
	+ KASSERT(udf_node->fe \|\| udf_node->efe, ("udf_read: Extended File Entry or File Entry is null"));
	+
	+ /* get file/directory filesize */
	+ if (udf_node->fe)
	+ file_size = le64toh(udf_node->fe->inf_len);
	+ else
	+ KASSERT(udf_node->efe, ("Extended File Entry is null"));
	+ file_size = le64toh(udf_node->efe->inf_len);
	+
	+ /* read contents using buffercache */
	+ do {
	+ /* reached end? */
	+ if (file_size <= uio->uio_offset)
	+ break;
	+
	+ /* maximise length to file extremity */
	+ n = min(file_size - uio->uio_offset, uio->uio_resid);
	+
	+ lbn = uio->uio_offset / udf_node->ump->discinfo.sector_size;
	+ on = uio->uio_offset % udf_node->ump->discinfo.sector_size;
	+ n = min(udf_node->ump->discinfo.sector_size - on, uio->uio_resid);
	+ n = min(n, file_size - uio->uio_offset);
	+ error = bread(vp, lbn, udf_node->ump->discinfo.sector_size, NOCRED, &bp);
	+ n = min(n, udf_node->ump->discinfo.sector_size - bp->b_resid);
	+
	+ if (!error)
	+ error = uiomove(bp->b_data + on, n, uio);
	+
	+ brelse(bp);
	+ } while (error == 0 && uio->uio_resid > 0 && n != 0);
	+#if 0
	+ /* note access time unless not requested */
	+ if (!(vp->v_mount->mnt_flag & MNT_NOATIME)) {
	+ udf_node->i_flags \|= IN_ACCESS;
	+ if ((ioflag & IO_SYNC) == IO_SYNC)
	+ error = udf_update(vp, NULL, NULL, NULL, UPDATE_WAIT);
	+ }
	+#endif
	+
	+ return (error);
	+}
	+/* --------------------------------------------------------------------- */
	+#ifdef WRITE_SUPPORT
	+int
	+udf_write(struct vop_write_args *ap)
	+{
	+ struct vnode *vp = ap->a_vp;
	+ struct uio *uio = ap->a_uio;
	+ int ioflag = ap->a_ioflag;
	+ kauth_cred_t cred = ap->a_cred;
	+ int advice = IO_ADV_DECODE(ap->a_ioflag);
	+ struct uvm_object *uobj;
	+ struct udf_node *udf_node = VTOI(vp);
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ uint64_t file_size, old_size, old_offset;
	+ vsize_t len;
	+ int async = vp->v_mount->mnt_flag & MNT_ASYNC;
	+ int aflag = ioflag & IO_SYNC ? B_SYNC : 0;
	+ int error;
	+ int resid, extended;
	+
	+ /*
	+ * XXX writing to extended attributes not yet implemented. FreeBSD has
	+ * it in mind to forward the IO_EXT read call to the
	+ * VOP_READEXTATTR().
	+ */
	+
	+ DPRINTF(WRITE, ("udf_write called\n"));
	+
	+ /* can this happen? some filingsystems have this check */
	+ if (uio->uio_offset < 0)
	+ return (EINVAL);
	+ if (uio->uio_resid == 0)
	+ return (0);
	+
	+ /* protect against rogue programs writing raw directories or links */
	+ if ((ioflag & IO_ALTSEMANTICS) == 0) {
	+ if (vp->v_type == VDIR)
	+ return (EISDIR);
	+ /* all but regular files just give EINVAL for now */
	+ if (vp->v_type != VREG)
	+ return (EINVAL);
	+ }
	+
	+ assert(udf_node);
	+ assert(udf_node->fe \|\| udf_node->efe);
	+
	+ /* get file/directory filesize */
	+ if (udf_node->fe) {
	+ fe = udf_node->fe;
	+ file_size = le64toh(fe->inf_len);
	+ } else {
	+ assert(udf_node->efe);
	+ efe = udf_node->efe;
	+ file_size = le64toh(efe->inf_len);
	+ }
	+ old_size = file_size;
	+
	+ /* if explicitly asked to append, uio_offset can be wrong? */
	+ if (ioflag & IO_APPEND)
	+ uio->uio_offset = file_size;
	+
	+ extended = (uio->uio_offset + uio->uio_resid > file_size);
	+ if (extended) {
	+ DPRINTF(WRITE, ("extending file from %"PRIu64" to %"PRIu64"\n",
	+ file_size, uio->uio_offset + uio->uio_resid));
	+ error = udf_grow_node(udf_node, uio->uio_offset + uio->uio_resid);
	+ if (error)
	+ return (error);
	+ file_size = uio->uio_offset + uio->uio_resid;
	+ }
	+
	+ /* write contents using buffercache */
	+ uobj = &vp->v_uobj;
	+ resid = uio->uio_resid;
	+ error = 0;
	+
	+ uvm_vnp_setwritesize(vp, file_size);
	+ old_offset = uio->uio_offset;
	+ while (uio->uio_resid > 0) {
	+ /* maximise length to file extremity */
	+ len = MIN(file_size - uio->uio_offset, uio->uio_resid);
	+ if (len == 0)
	+ break;
	+
	+ genfs_node_wrlock(vp);
	+ error = GOP_ALLOC(vp, uio->uio_offset, len, aflag, cred);
	+ genfs_node_unlock(vp);
	+ if (error)
	+ break;
	+
	+ /* ubc, here we come, prepare to trap */
	+ error = ubc_uiomove(uobj, uio, len, advice,
	+ UBC_WRITE \| UBC_UNMAP_FLAG(vp));
	+ if (error)
	+ break;
	+
	+ /*
	+ * flush what we just wrote if necessary.
	+ * XXXUBC simplistic async flushing.
	+ *
	+ * Directories are excluded since its file data that we want
	+ * to purge.
	+ */
	+ if (!async && (vp->v_type != VDIR) &&
	+ (old_offset >> 16 != uio->uio_offset >> 16)) {
	+ mutex_enter(&vp->v_interlock);
	+ error = VOP_PUTPAGES(vp, (old_offset >> 16) << 16,
	+ (uio->uio_offset >> 16) << 16, PGO_CLEANIT);
	+ old_offset = uio->uio_offset;
	+ }
	+ }
	+ uvm_vnp_setsize(vp, file_size);
	+
	+ /* mark node changed and request update */
	+ udf_node->i_flags \|= IN_CHANGE \| IN_UPDATE;
	+
	+ /*
	+ * XXX TODO FFS has code here to reset setuid & setgid when we're not
	+ * the superuser as a precaution against tampering.
	+ */
	+
	+ /* if we wrote a thing, note write action on vnode */
	+ if (resid > uio->uio_resid)
	+ VN_KNOTE(vp, NOTE_WRITE \| (extended ? NOTE_EXTEND : 0));
	+
	+ if (error) {
	+ /* bring back file size to its former size */
	+ /* take notice of its errors? */
	+ (void) udf_chsize(vp, (u_quad_t) old_size, cred);
	+
	+ /* roll back uio */
	+ uio->uio_offset -= resid - uio->uio_resid;
	+ uio->uio_resid = resid;
	+ } else {
	+ /* if we write and we're synchronous, update node */
	+ if ((resid > uio->uio_resid) && ((ioflag & IO_SYNC) == IO_SYNC))
	+ error = udf_update(vp, NULL, NULL, NULL, UPDATE_WAIT);
	+ }
	+
	+ return (error);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+static int
	+udf_bmap(struct vop_bmap_args /* {
	+ struct vop_generic_args a_gen;
	+ struct vnode *a_vp;
	+ daddr_t a_bn;
	+ struct bufobj **a_bop;
	+ daddr_t *a_bnp;
	+ int *a_runp;
	+ int *a_runb;
	+ } / ap)
	+{
	+ struct vnode vp = ap->a_vp; / our node */
	+ struct udf_node *udf_node = VTOI(vp);
	+ uint64_t lsector;
	+ uint32_t maxblks;
	+ int error;
	+
	+ if (ap->a_bop != NULL)
	+ *ap->a_bop = &udf_node->ump->devvp->v_bufobj;
	+
	+ if (ap->a_bnp == NULL)
	+ return (0);
	+
	+ if (ap->a_runb)
	+ *ap->a_runb = 0;
	+
	+ /* get logical block and run */
	+ error = udf_bmap_translate(udf_node, ap->a_bn, &lsector, &maxblks);
	+ if (error)
	+ return (error);
	+
	+ /* Translate logical to phisascal sector number*/
	+ if (lsector == UDF_TRANS_INTERN)
	+ return (EOPNOTSUPP);
	+ else if (lsector == UDF_TRANS_ZERO)
	+ ap->a_bnp = -1; / zero the buffer */
	+ else
	+ ap->a_bnp = lsector (udf_node->ump->discinfo.sector_size/DEV_BSIZE);
	+
	+ /*
	+ * Determine maximum number of readahead blocks following the
	+ * requested block.
	+ */
	+ if (ap->a_runp) {
	+ if (maxblks <= 1)
	+ *ap->a_runp = 0;
	+ else if (maxblks - 1 >= MAXBSIZE)
	+ *ap->a_runp = MAXBSIZE - 1;
	+ else
	+ *ap->a_runp = maxblks - 1;
	+
	+ }
	+ if (ap->a_runb)
	+ *ap->a_runb = 0;
	+
	+ /* return success */
	+ return (0);
	+}
	+
	+static int
	+udf_strategy(struct vop_strategy_args /* {
	+ struct vnode *a_vp;
	+ struct buf *a_bp;
	+ } / ap)
	+{
	+ struct vnode *vp = ap->a_vp;
	+ struct buf *bp = ap->a_bp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ struct bufobj *bo = udf_node->ump->bo;
	+ uint64_t lsector;
	+ int error;
	+ uint32_t lb_size, from, sectors;
	+ uint32_t maxblks;
	+
	+ DPRINTF(STRATEGY, ("udf_strategy called\n"));
	+
	+ /* check if we ought to be here */
	+ if (vp->v_type == VBLK \|\| vp->v_type == VCHR)
	+ panic("udf_strategy: spec");
	+
	+ /* only filebuffers ought to be read/write by this, no descriptors */
	+ KASSERT(bp->b_blkno >= 0, ("udf_strategy: nonexistent physical block number"));
	+
	+ /* get sector size */
	+ lb_size = udf_node->ump->discinfo.sector_size;
	+
	+ /* calculate sector to start from */
	+ from = bp->b_blkno;
	+
	+ /* calculate length to fetch/store in sectors */
	+ sectors = bp->b_bcount / lb_size;
	+ KASSERT(bp->b_bcount > 0, ("udf_strategy: no valid bytes in buffer"));
	+
	+ /* NEVER assume later that this buffer is already translated */
	+ /* bp->b_lblkno = bp->b_blkno; */
	+
	+ /* check assertions: we OUGHT to always get multiples of this */
	+ KASSERT(sectors * lb_size == bp->b_bcount, ("udf_strategy: wrong length"
	+ "to fetch/store in sectors"));
	+ if (bp->b_blkno == bp->b_lblkno) {
	+ /* get logical block and run */
	+ error = udf_bmap_translate(udf_node, bp->b_lblkno, &lsector, &maxblks);
	+ if (error) {
	+ bp->b_error = error;
	+ bufdone(bp);
	+ return (error);
	+ }
	+ }
	+ if (bp->b_iocmd & BIO_READ) {
	+ DPRINTF(STRATEGY, ("\tread vp %p buf %p (blk no %ju)"
	+ ", sector %d for %d sectors\n",
	+ vp, bp, (uintmax_t)bp->b_blkno, from, sectors));
	+
	+ if (lsector == UDF_TRANS_ZERO) {
	+ /* copy sezo sector */
	+ memset(bp->b_data, 0, lb_size);
	+ if ((bp->b_flags & B_ASYNC) == 0)
	+ bufwait(bp);
	+ /* pre-check if its an internal */
	+ } else if (lsector == UDF_TRANS_INTERN) {
	+ error = udf_read_internal(udf_node, (uint8_t *) bp->b_data);
	+ if (error)
	+ bp->b_error = error;
	+ bufdone(bp);
	+ if ((bp->b_flags & B_ASYNC) == 0)
	+ bufwait(bp);
	+ } else {
	+ /* bmap gives sector numbers. bio works with device blocks */
	+ bp->b_blkno = lsector * (udf_node->ump->discinfo.sector_size/DEV_BSIZE);
	+ bp->b_iooffset = dbtob(bp->b_blkno);
	+ BO_STRATEGY(bo, bp);
	+ }
	+ } else {
	+ DPRINTF(STRATEGY, ("\twrite vp %p buf %p (blk no %ju)"
	+ ", sector %d for %d sectors\n",
	+ vp, bp, (uintmax_t)bp->b_blkno, from, sectors));
	+
	+ return (ENOTSUP);
	+ }
	+ return (bp->b_error);
	+}
	+
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_readdir(struct vop_readdir_args /* {
	+ struct vnode *a_vp;
	+ struct uio *a_uio;
	+ struct ucred *a_cred;
	+ int *a_eofflag;
	+ int *a_ncookies;
	+ u_long **a_cookies;
	+ } / ap)
	+{
	+ struct uio *uio;
	+ struct vnode *vp;
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ struct fileid_desc *fid;
	+ struct dirent *dirent;
	+ struct udf_mount *ump;
	+ struct udf_node *udf_node;
	+ uint64_t cookiesp, cookies, cookie;
	+ uint64_t file_size, diroffset, transoffset;
	+ int ncookies, acookies;
	+ int error;
	+ uint32_t lb_size;
	+ char *fid_name;
	+
	+ uio = ap->a_uio;
	+ vp = ap->a_vp;
	+ udf_node = VTOI(vp);
	+ ump = udf_node->ump;
	+
	+ DPRINTF(READDIR, ("udf_readdir called\n"));
	+
	+ /* This operation only makes sense on directory nodes. */
	+ if (vp->v_type != VDIR)
	+ return (ENOTDIR);
	+
	+ /* get directory filesize */
	+ if (udf_node->fe) {
	+ fe = udf_node->fe;
	+ file_size = le64toh(fe->inf_len);
	+ } else {
	+ efe = udf_node->efe;
	+ file_size = le64toh(efe->inf_len);
	+ }
	+
	+ dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK \| M_ZERO);
	+
	+ if (ap->a_ncookies != NULL) {
	+ /*
	+ * Guess how many entries are needed. If we run out, this
	+ * function will be called again and thing will pick up
	+ * were it left off.
	+ */
	+ ncookies = uio->uio_resid / 8;
	+ cookies = malloc(sizeof(u_long) * ncookies, M_TEMP,
	+ M_WAITOK \| M_ZERO);
	+ if (cookies == NULL)
	+ return (ENOMEM);
	+ cookiesp = cookies;
	+ } else {
	+ ncookies = 0;
	+ cookies = NULL;
	+ cookiesp = NULL;
	+ }
	+ acookies = 0;
	+
	+ /*
	+ * Add `.' pseudo entry if at offset zero since its not in the fid
	+ * stream
	+ */
	+ if (uio->uio_offset == 0) {
	+ DPRINTF(READDIR, ("\t'.' inserted\n"));
	+ memset(dirent, 0, sizeof(struct dirent));
	+ dirent->d_fileno = udf_get_node_id(&udf_node->loc);
	+ dirent->d_type = DT_DIR;
	+ dirent->d_name[0] = '.';
	+ dirent->d_name[1] = '\0';
	+ dirent->d_namlen = 1;
	+ dirent->d_reclen = GENERIC_DIRSIZ(dirent);
	+ if (cookiesp) {
	+ acookies++;
	+ *cookiesp++ = 1;
	+ }
	+ error = uiomove(dirent, GENERIC_DIRSIZ(dirent), uio);
	+ if (error)
	+ goto bail;
	+
	+ /* mark with magic value that we have done the dummy */
	+ uio->uio_offset = UDF_DIRCOOKIE_DOT;
	+ }
	+
	+ /* we are called just as long as we keep on pushing data in */
	+ error = 0;
	+ if (uio->uio_offset < file_size) {
	+ /* allocate temporary space for fid */
	+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
	+ fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
	+
	+ if (uio->uio_offset == UDF_DIRCOOKIE_DOT)
	+ uio->uio_offset = 0;
	+
	+ diroffset = uio->uio_offset;
	+ transoffset = diroffset;
	+ while (diroffset < file_size) {
	+ DPRINTF(READDIR, ("\tread in fid stream\n"));
	+ /* transfer a new fid/dirent */
	+ error = udf_read_fid_stream(vp, &diroffset, fid);
	+ DPRINTFIF(READDIR, error, ("read error in read fid "
	+ "stream : %d\n", error));
	+ if (error) {
	+ printf("Read error in read fid: %d\n", error);
	+ break;
	+ }
	+
	+ /*
	+ * create resulting dirent structure
	+ */
	+ memset(dirent, 0, sizeof(struct dirent));
	+ dirent->d_fileno = udf_get_node_id(&fid->icb); /* inode hash XXX */
	+
	+ /* Not worth trying to go for the filetypes now, too expensive */
	+ dirent->d_type = DT_UNKNOWN;
	+ if (fid->file_char & UDF_FILE_CHAR_DIR)
	+ dirent->d_type = DT_DIR;
	+
	+ /* '..' has no name, so provide one */
	+ if (fid->file_char & UDF_FILE_CHAR_PAR) {
	+ dirent->d_name[0] = '.';
	+ dirent->d_name[1] = '.';
	+ dirent->d_name[2] = '\0';
	+ dirent->d_namlen = 2;
	+ cookie = 2;
	+ }
	+ else {
	+ fid_name = (char *) fid->data +
	+ le16toh(fid->l_iu);
	+ udf_to_unix_name(ump, dirent->d_name, MAXNAMLEN,
	+ fid_name, fid->l_fi);
	+ dirent->d_namlen = strlen(dirent->d_name);
	+ cookie = transoffset;
	+ }
	+ dirent->d_reclen = GENERIC_DIRSIZ(dirent);
	+
	+ /*
	+ * If there isn't enough space in the uio to return a
	+ * whole dirent, break off read
	+ */
	+ if (uio->uio_resid < GENERIC_DIRSIZ(dirent))
	+ break;
	+
	+ /* remember the last entry we transferred */
	+ transoffset = diroffset;
	+
	+ /* skip deleted entries */
	+ if (fid->file_char & UDF_FILE_CHAR_DEL)
	+ continue;
	+
	+ /* skip not visible files */
	+ if (fid->file_char & UDF_FILE_CHAR_VIS)
	+ continue;
	+
	+ /* copy dirent to the caller */
	+ DPRINTF(READDIR, ("\tread dirent `%s', type %d\n",
	+ dirent->d_name, dirent->d_type));
	+ if (cookiesp) {
	+ if (acookies + 1 > ncookies)
	+ break;
	+ acookies++;
	+ *cookiesp++ = cookie;
	+ }
	+ error = uiomove(dirent, GENERIC_DIRSIZ(dirent), uio);
	+ if (error)
	+ break;
	+ }
	+
	+ /* pass on last transferred offset */
	+ /* We lied for '.', so tell more lies. */
	+ uio->uio_offset = transoffset;
	+ free(fid, M_UDFTEMP);
	+ }
	+
	+bail:
	+ /* tell the calling layer whether we need to be called again */
	+ if (ap->a_eofflag)
	+ *ap->a_eofflag = (uio->uio_offset >= file_size);
	+
	+ if (error < 0)
	+ error = 0;
	+
	+ if (ap->a_ncookies != NULL) {
	+ if (error) {
	+ free(cookies, M_UDFTEMP);
	+ } else {
	+ *ap->a_ncookies = acookies;
	+ ap->a_cookies = (u_long ) cookies;
	+ }
	+ }
	+
	+#ifdef DEBUG
	+ if (udf_verbose & UDF_DEBUG_READDIR) {
	+ printf("returning offset %d\n", (uint32_t) uio->uio_offset);
	+ if (ap->a_eofflag)
	+ printf("returning EOF ? %d\n", *ap->a_eofflag);
	+ if (error)
	+ printf("readdir returning error %d\n", error);
	+ }
	+#endif
	+
	+ free(dirent, M_UDFTEMP);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_cachedlookup(struct vop_cachedlookup_args *ap)
	+{
	+ struct vnode *dvp = ap->a_dvp;
	+ struct vnode **vpp = ap->a_vpp;
	+ struct vnode *tdp = NULL;
	+ struct componentname *cnp = ap->a_cnp;
	+ struct fileid_desc *fid;
	+ struct udf_node *dir_node;
	+ struct udf_mount *ump;
	+ uint64_t file_size, offset;
	+ ino_t id = 0;
	+ int nameiop, islastcn, mounted_ro, numpasses;
	+ int unix_len, ltype;
	+ int error = 0;
	+ char *fid_name;
	+ char *unix_name;
	+
	+ dir_node = VTOI(dvp);
	+ ump = dir_node->ump;
	+ *vpp = NULL;
	+
	+ DPRINTF(LOOKUP, ("udf_cachedlookup callen\n"));
	+
	+ /* simplify/clarification flags */
	+ nameiop = cnp->cn_nameiop;
	+ islastcn = cnp->cn_flags & ISLASTCN;
	+ mounted_ro = dvp->v_mount->mnt_flag & MNT_RDONLY;
	+
	+ /* check exec/dirread permissions first */
	+ error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, curthread);
	+ if (error)
	+ return (error);
	+
	+ DPRINTF(LOOKUP, ("\taccess ok\n"));
	+
	+ /*
	+ * If requesting a modify on the last path element on a read-only
	+ * filingsystem, reject lookup.
	+ */
	+ if (islastcn && mounted_ro && (nameiop == DELETE \|\| nameiop == RENAME))
	+ return (EROFS);
	+
	+ DPRINTF(LOOKUP, ("\tlooking up cnp->cn_nameptr '%s'\n", cnp->cn_nameptr));
	+
	+ /* look in the namei cache; return 0 on success!! */
	+#if 0
	+ error = cache_lookup(dvp, vpp, cnp);
	+ if (error >= 0)
	+ return error;
	+
	+ DPRINTF(LOOKUP, ("\tNOT found in cache\n"));
	+#endif
	+ /* get directory filesize */
	+ if (dir_node->fe)
	+ file_size = le64toh(dir_node->fe->inf_len);
	+ else
	+ file_size = le64toh(dir_node->efe->inf_len);
	+
	+ /*
	+ * If this is a LOOKUP and we've already partially searched through
	+ * the directory, pick up where we left off and flag that the
	+ * directory may need to be searched twice. For a full description,
	+ * see /sys/fs/cd9660/cd9660_lookup.c:cd9660_lookup()
	+ */
	+ if (nameiop != LOOKUP \|\| dir_node->diroff == 0 \|\| dir_node->diroff > file_size) {
	+ offset = 0;
	+ numpasses = 1;
	+ }
	+ else {
	+ offset = dir_node->diroff;
	+ numpasses = 2;
	+ nchstats.ncs_2passes++;
	+ }
	+
	+ fid = malloc(ump->discinfo.sector_size, M_UDFTEMP, M_WAITOK);
	+ unix_name = malloc(MAXNAMLEN, M_UDFTEMP, M_WAITOK);
	+lookuploop:
	+ while (offset < file_size) {
	+ error = udf_read_fid_stream(dvp, &offset, fid);
	+ if (error) {
	+ break;
	+ }
	+
	+ /* skip deleted entries */
	+ if (fid->file_char & UDF_FILE_CHAR_DEL)
	+ continue;
	+
	+ /* skip not visible files */
	+ if (fid->file_char & UDF_FILE_CHAR_VIS)
	+ continue;
	+
	+ if (fid->file_char & UDF_FILE_CHAR_PAR) {
	+ if (cnp->cn_flags & ISDOTDOT) {
	+ id = udf_get_node_id(&fid->icb);
	+ break;
	+ }
	+ }
	+ else {
	+ fid_name = (char *) fid->data + le16toh(fid->l_iu);
	+ udf_to_unix_name(ump, unix_name, MAXNAMLEN, fid_name,
	+ fid->l_fi);
	+ unix_len = strlen(unix_name);
	+
	+ if (unix_len == cnp->cn_namelen) {
	+ if (!strncmp(unix_name, cnp->cn_nameptr, cnp->cn_namelen)) {
	+ id = udf_get_node_id(&fid->icb);
	+ break;
	+ }
	+ }
	+ }
	+ }
	+
	+ if (error)
	+ goto exit;
	+
	+ /* Did we have a match? */
	+ if (id) {
	+ /*
	+ * Remember where this entry was if it's the final component.
	+ */
	+ if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == LOOKUP)
	+ dir_node->diroff = offset;
	+ if (numpasses == 2)
	+ nchstats.ncs_pass2++;
	+
	+ if (cnp->cn_flags & ISDOTDOT) {
	+ vn_vget_ino(dvp, id, cnp->cn_lkflags, &tdp);
	+ }
	+ else if (dir_node->hash_id == id) {
	+ VREF(dvp); /* we want ourself, ie "." */
	+ /*
	+ * When we lookup "." we still can be asked to lock it
	+ * differently.
	+ */
	+ ltype = cnp->cn_lkflags & LK_TYPE_MASK;
	+ if (ltype != VOP_ISLOCKED(dvp)) {
	+ if (ltype == LK_EXCLUSIVE)
	+ vn_lock(dvp, LK_UPGRADE \| LK_RETRY);
	+ else /* if (ltype == LK_SHARED) */
	+ vn_lock(dvp, LK_DOWNGRADE \| LK_RETRY);
	+ }
	+ tdp = dvp;
	+ }
	+ else {
	+ error = udf_vget(ump->vfs_mountp, id, cnp->cn_lkflags, &tdp);
	+ }
	+
	+ if (!error) {
	+ *vpp = tdp;
	+ /* Put this entry in the cache */
	+ if (cnp->cn_flags & MAKEENTRY)
	+ cache_enter(dvp, *vpp, cnp);
	+ }
	+ }
	+ else {
	+ /* Name wasn't found on this pass. Do another pass? */
	+ if (numpasses-- == 2) {
	+ offset = 0;
	+ goto lookuploop;
	+ }
	+
	+ /* Enter name into cache as non-existant */
	+ if (cnp->cn_flags & MAKEENTRY)
	+ cache_enter(dvp, *vpp, cnp);
	+
	+ if ((cnp->cn_flags & ISLASTCN) &&
	+ (cnp->cn_nameiop == CREATE \|\| cnp->cn_nameiop == RENAME))
	+ error = EROFS;
	+ else
	+ error = ENOENT;
	+ }
	+
	+exit:
	+ free(fid, M_UDFTEMP);
	+ free(unix_name, M_UDFTEMP);
	+
	+ DPRINTFIF(LOOKUP, error, ("udf_cachedlookup returning error %d\n", error));
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_getattr(struct vop_getattr_args *ap)
	+{
	+ struct vnode *vp = ap->a_vp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ struct file_entry *fe = udf_node->fe;
	+ struct extfile_entry *efe = udf_node->efe;
	+ struct filetimes_extattr_entry *ft_extattr;
	+ struct device_extattr_entry *devattr;
	+ struct vattr *vap = ap->a_vap;
	+ struct timestamp atime, mtime, attrtime, creatime;
	+ struct udf_mount *ump = udf_node->ump;
	+ uint64_t filesize, blkssize;
	+ uint32_t nlink, offset, a_l;
	+ uint8_t *filedata;
	+ uid_t uid;
	+ gid_t gid;
	+ int error;
	+
	+ DPRINTF(CALL, ("udf_getattr called\n"));
	+
	+ /* update times before we returning values */
	+#if 0
	+ udf_itimes(udf_node, NULL, NULL, NULL);
	+#endif
	+
	+ /* get descriptor information */
	+ if (fe) {
	+ nlink = le16toh(fe->link_cnt);
	+ uid = (uid_t)le32toh(fe->uid);
	+ gid = (gid_t)le32toh(fe->gid);
	+ filesize = le64toh(fe->inf_len);
	+ blkssize = le64toh(fe->logblks_rec);
	+ atime = &fe->atime;
	+ mtime = &fe->mtime;
	+ attrtime = &fe->attrtime;
	+ filedata = fe->data;
	+
	+ /* initial guess */
	+ creatime = mtime;
	+
	+ /* check our extended attribute if present */
	+ error = udf_extattr_search_intern(udf_node,
	+ UDF_FILETIMES_ATTR_NO, "", &offset, &a_l);
	+ if (!error) {
	+ ft_extattr = (struct filetimes_extattr_entry *)
	+ (filedata + offset);
	+ if (ft_extattr->existence & UDF_FILETIMES_FILE_CREATION)
	+ creatime = &ft_extattr->times[0];
	+ }
	+ } else {
	+ KASSERT(udf_node->efe, ("Extended File Entry is null"));
	+ nlink = le16toh(efe->link_cnt);
	+ uid = (uid_t)le32toh(efe->uid);
	+ gid = (gid_t)le32toh(efe->gid);
	+ filesize = le64toh(efe->inf_len); /* XXX or obj_size? */
	+ blkssize = le64toh(efe->logblks_rec);
	+ atime = &efe->atime;
	+ mtime = &efe->mtime;
	+ attrtime = &efe->attrtime;
	+ creatime = &efe->ctime;
	+ filedata = efe->data;
	+ }
	+
	+ /* do the uid/gid translation game */
	+ if (uid == (uid_t) -1)
	+ uid = ump->mount_args.anon_uid;
	+ if (gid == (gid_t) -1)
	+ gid = ump->mount_args.anon_gid;
	+
	+ /*
	+ * BUG-ALERT: UDF doesn't count '.' as an entry, so we'll have to add
	+ * 1 to the link count if its a directory we're requested attributes
	+ * of.
	+ */
	+ if (vp->v_type == VDIR) {
	+ nlink++;
	+
	+ /* directories should be at least a single block? */
	+ if (blkssize != 0)
	+ filesize = blkssize * ump->discinfo.sector_size;
	+ else
	+ filesize = ump->discinfo.sector_size;
	+ }
	+
	+ /* fill in struct vattr with values from the node */
	+ vattr_null(vap);
	+ vap->va_type = vp->v_type;
	+ vap->va_mode = udf_getaccessmode(udf_node);
	+ vap->va_nlink = nlink;
	+ vap->va_uid = uid;
	+ vap->va_gid = gid;
	+ vap->va_fsid = dev2udev(ump->dev); /* vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0]; */
	+ vap->va_fileid = udf_get_node_id(&udf_node->loc); /* inode hash XXX */
	+ vap->va_size = filesize;
	+ vap->va_blocksize = ump->discinfo.sector_size; /* wise? */
	+
	+ /* access times */
	+ udf_timestamp_to_timespec(ump, atime, &vap->va_atime);
	+ udf_timestamp_to_timespec(ump, mtime, &vap->va_mtime);
	+ udf_timestamp_to_timespec(ump, attrtime, &vap->va_ctime);
	+ udf_timestamp_to_timespec(ump, creatime, &vap->va_birthtime);
	+
	+ vap->va_gen = 1; /* no multiple generations yes (!?) */
	+ vap->va_flags = 0; /* no flags */
	+ vap->va_bytes = blkssize * ump->discinfo.sector_size;
	+ vap->va_filerev = 0; /* TODO file revision numbers?
	+ This was changed from a 1. */
	+ vap->va_vaflags = 0;
	+ /* TODO get vaflags from the extended attributes? */
	+
	+ if ((vap->va_type == VBLK) \|\| (vap->va_type == VCHR)) {
	+ error = udf_extattr_search_intern(udf_node,
	+ UDF_DEVICESPEC_ATTR_NO, "",
	+ &offset, &a_l);
	+ /* if error, deny access */
	+ if (error \|\| (filedata == NULL)) {
	+ vap->va_mode = 0; /* or v_type = VNON? */
	+ } else {
	+ devattr = (struct device_extattr_entry *)
	+ filedata + offset;
	+ vap->va_rdev = makedev(
	+ le32toh(devattr->major),
	+ le32toh(devattr->minor)
	+ );
	+ /* TODO we could check the implementator */
	+ }
	+ }
	+
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+#if 0
	+static int
	+udf_chown(struct vnode *vp, uid_t new_uid, gid_t new_gid,
	+ kauth_cred_t cred)
	+{
	+ struct udf_node *udf_node = VTOI(vp);
	+ uid_t uid;
	+ gid_t gid;
	+ int error;
	+
	+#ifdef notyet
	+ /* TODO get vaflags from the extended attributes? */
	+ /* Immutable or append-only files cannot be modified, either. */
	+ if (udf_node->flags & (IMMUTABLE \| APPEND))
	+ return (EPERM);
	+#endif
	+
	+ if (vp->v_mount->mnt_flag & MNT_RDONLY)
	+ return (EROFS);
	+
	+ /* retrieve old values */
	+ udf_getownership(udf_node, &uid, &gid);
	+
	+ /* only one could be specified */
	+ if (new_uid == VNOVAL)
	+ new_uid = uid;
	+ if (new_gid == VNOVAL)
	+ new_gid = gid;
	+
	+ /* check if we can fit it in an 32 bits */
	+ if ((uid_t) ((uint32_t) new_uid) != new_uid)
	+ return (EINVAL);
	+ if ((gid_t) ((uint32_t) new_gid) != new_gid)
	+ return (EINVAL);
	+
	+ /* check permissions */
	+ error = genfs_can_chown(vp, cred, uid, gid, new_uid, new_gid);
	+ if (error)
	+ return (error);
	+
	+ /* change the ownership */
	+ udf_setownership(udf_node, new_uid, new_gid);
	+
	+ /* mark node changed */
	+ udf_node->i_flags \|= IN_CHANGE;
	+
	+ return (0);
	+}
	+
	+
	+static int
	+udf_chmod(struct vnode *vp, mode_t mode, kauth_cred_t cred)
	+{
	+ struct udf_node *udf_node = VTOI(vp);
	+ uid_t uid;
	+ gid_t gid;
	+ int error;
	+
	+#ifdef notyet
	+ /* TODO get vaflags from the extended attributes? */
	+ /* Immutable or append-only files cannot be modified, either. */
	+ if (udf_node->flags & (IMMUTABLE \| APPEND))
	+ return (EPERM);
	+#endif
	+
	+ if (vp->v_mount->mnt_flag & MNT_RDONLY)
	+ return (EROFS);
	+
	+ /* retrieve uid/gid values */
	+ udf_getownership(udf_node, &uid, &gid);
	+
	+ /* check permissions */
	+ error = genfs_can_chmod(vp, cred, uid, gid, mode);
	+ if (error)
	+ return (error);
	+
	+ /* change mode */
	+ udf_setaccessmode(udf_node, mode);
	+
	+ /* mark node changed */
	+ udf_node->i_flags \|= IN_CHANGE;
	+
	+ return (0);
	+}
	+
	+
	+/* exported */
	+int
	+udf_chsize(struct vnode *vp, u_quad_t newsize, kauth_cred_t cred)
	+{
	+ struct udf_node *udf_node = VTOI(vp);
	+ int error, extended;
	+
	+ if (vp->v_mount->mnt_flag & MNT_RDONLY)
	+ return (EROFS);
	+
	+ /* Decide whether this is a valid operation based on the file type. */
	+ switch (vp->v_type) {
	+ case VDIR:
	+ return (EISDIR);
	+ case VREG:
	+ if (vp->v_mount->mnt_flag & MNT_RDONLY)
	+ return (EROFS);
	+ break;
	+ case VBLK:
	+ /* FALLTHROUGH */
	+ case VCHR:
	+ /* FALLTHROUGH */
	+ case VFIFO:
	+ /* Allow modifications of special files even if in the file
	+ * system is mounted read-only (we are not modifying the
	+ * files themselves, but the objects they represent). */
	+ return (0);
	+ default:
	+ /* Anything else is unsupported. */
	+ return (EOPNOTSUPP);
	+ }
	+
	+#if notyet
	+ /* TODO get vaflags from the extended attributes? */
	+ /* Immutable or append-only files cannot be modified, either. */
	+ if (node->flags & (IMMUTABLE \| APPEND))
	+ return (EPERM);
	+#endif
	+
	+ /* resize file to the requested size */
	+ error = udf_resize_node(udf_node, newsize, &extended);
	+
	+ if (error == 0) {
	+ /* mark change */
	+ udf_node->i_flags \|= IN_CHANGE \| IN_MODIFY;
	+ VN_KNOTE(vp, NOTE_ATTRIB \| (extended ? NOTE_EXTEND : 0));
	+ udf_update(vp, NULL, NULL, NULL, 0);
	+ }
	+
	+ return (error);
	+}
	+
	+
	+static int
	+udf_chflags(struct vnode *vp, mode_t mode, kauth_cred_t cred)
	+{
	+ if (vp->v_mount->mnt_flag & MNT_RDONLY)
	+ return (EROFS);
	+
	+ /* XXX we can't do this yet, but erroring out is enoying XXX */
	+
	+ return (0);
	+}
	+
	+
	+static int
	+udf_chtimes(struct vnode *vp,
	+ struct timespec atime, struct timespec mtime,
	+ struct timespec *birthtime, int setattrflags,
	+ kauth_cred_t cred)
	+{
	+ struct udf_node *udf_node = VTOI(vp);
	+ uid_t uid;
	+ gid_t gid;
	+ int error;
	+
	+#ifdef notyet
	+ /* TODO get vaflags from the extended attributes? */
	+ /* Immutable or append-only files cannot be modified, either. */
	+ if (udf_node->flags & (IMMUTABLE \| APPEND))
	+ return (EPERM);
	+#endif
	+
	+ if (vp->v_mount->mnt_flag & MNT_RDONLY)
	+ return (EROFS);
	+
	+ /* retrieve uid/gid values */
	+ udf_getownership(udf_node, &uid, &gid);
	+
	+ /* check permissions */
	+ error = genfs_can_chtimes(vp, setattrflags, uid, cred);
	+ if (error)
	+ return (error);
	+
	+ /* update node flags depending on what times are passed */
	+ if (atime->tv_sec != VNOVAL)
	+ if (!(vp->v_mount->mnt_flag & MNT_NOATIME))
	+ udf_node->i_flags \|= IN_ACCESS;
	+ if ((mtime->tv_sec != VNOVAL) \|\| (birthtime->tv_sec != VNOVAL))
	+ udf_node->i_flags \|= IN_CHANGE \| IN_UPDATE;
	+
	+ return (udf_update(vp, atime, mtime, birthtime, 0));
	+}
	+#endif
	+
	+static int
	+udf_setattr(struct vop_setattr_args *ap)
	+{
	+/* struct vnode vp = ap->a_vp; /
	+/* struct udf_node udf_node = VTOI(vp); /
	+/* struct udf_mount ump = udf_node->ump; /
	+/* kauth_cred_t cred = ap->a_cred; */
	+ struct vattr *vap = ap->a_vap;
	+ int error = 0;
	+
	+ DPRINTF(CALL, ("udf_setattr called\n"));
	+
	+ /* Abort if any unsettable attribute is given. */
	+ if (vap->va_type != VNON \|\|
	+ vap->va_nlink != VNOVAL \|\|
	+ vap->va_fsid != VNOVAL \|\|
	+ vap->va_fileid != VNOVAL \|\|
	+ vap->va_blocksize != VNOVAL \|\|
	+#ifdef notyet
	+ /* checks are debated */
	+ vap->va_ctime.tv_sec != VNOVAL \|\|
	+ vap->va_ctime.tv_nsec != VNOVAL \|\|
	+ vap->va_birthtime.tv_sec != VNOVAL \|\|
	+ vap->va_birthtime.tv_nsec != VNOVAL \|\|
	+#endif
	+ vap->va_gen != VNOVAL \|\|
	+ vap->va_rdev != VNOVAL \|\|
	+ vap->va_bytes != VNOVAL)
	+ error = EINVAL;
	+
	+ DPRINTF(ATTR, ("setattr changing:\n"));
	+ if (error == 0 && (vap->va_flags != VNOVAL)) {
	+ DPRINTF(ATTR, ("\tchflags\n"));
	+ return (EROFS);
	+/* error = udf_chflags(vp, vap->va_flags, cred); */
	+ }
	+
	+ if (error == 0 && (vap->va_size != VNOVAL)) {
	+ DPRINTF(ATTR, ("\tchsize\n"));
	+ if (vap->va_type == VDIR)
	+ return (EISDIR);
	+ if (vap->va_type == VLNK \|\| vap->va_type == VREG)
	+ return (EROFS);
	+/* error = udf_chsize(vp, vap->va_size, cred); */
	+ }
	+
	+ if (error == 0 && (vap->va_uid != VNOVAL \|\| vap->va_gid != VNOVAL)) {
	+ DPRINTF(ATTR, ("\tchown\n"));
	+ return (EROFS);
	+/* error = udf_chown(vp, vap->va_uid, vap->va_gid, cred); */
	+ }
	+
	+ if (error == 0 && (vap->va_mode != (mode_t)VNOVAL)) {
	+ DPRINTF(ATTR, ("\tchmod\n"));
	+ return (EROFS);
	+/* error = udf_chmod(vp, vap->va_mode, cred); */
	+ }
	+
	+ if (error == 0 &&
	+ ((vap->va_atime.tv_sec != VNOVAL &&
	+ vap->va_atime.tv_nsec != VNOVAL) \|\|
	+ (vap->va_mtime.tv_sec != VNOVAL &&
	+ vap->va_mtime.tv_nsec != VNOVAL))
	+ ) {
	+ DPRINTF(ATTR, ("\tchimes\n"));
	+ return (EROFS);
	+/* error = udf_chtimes(vp, &vap->va_atime, &vap->va_mtime,
	+ &vap->va_birthtime, vap->va_vaflags, cred); */
	+ }
	+/* VN_KNOTE(vp, NOTE_ATTRIB); */
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Return POSIX pathconf information for UDF file systems.
	+ */
	+static int
	+udf_pathconf(struct vop_pathconf_args *ap)
	+{
	+ uint32_t bits;
	+
	+ DPRINTF(CALL, ("udf_pathconf called\n"));
	+
	+ switch (ap->a_name) {
	+ case _PC_LINK_MAX:
	+ ap->a_retval = (1<<16)-1; / 16 bits */
	+ return (0);
	+ case _PC_NAME_MAX:
	+ *ap->a_retval = NAME_MAX;
	+ return (0);
	+ case _PC_PATH_MAX:
	+ *ap->a_retval = PATH_MAX;
	+ return (0);
	+ case _PC_PIPE_BUF:
	+ *ap->a_retval = PIPE_BUF;
	+ return (0);
	+ case _PC_CHOWN_RESTRICTED:
	+ *ap->a_retval = 1;
	+ return (0);
	+ case _PC_NO_TRUNC:
	+ *ap->a_retval = 1;
	+ return (0);
	+ case _PC_SYNC_IO:
	+ ap->a_retval = 0; / synchronised is off for performance */
	+ return (0);
	+ case _PC_FILESIZEBITS:
	+ /* 64 bit file offsets -> 2+floor(2log(2^64-1)) = 2 + 63 = 65 */
	+ bits = 64; /* XXX ought to deliver 65 */
	+
	+ *ap->a_retval = bits;
	+ return (0);
	+ }
	+
	+ return (EINVAL);
	+}
	+
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_open(struct vop_open_args *ap)
	+{
	+ struct udf_node *udf_node = VTOI(ap->a_vp);
	+ off_t file_size;
	+ /* int flags; */
	+
	+ DPRINTF(CALL, ("udf_open called\n"));
	+
	+ /*
	+ * Files marked append-only must be opened for appending.
	+ * TODO: get chflags(2) flags from extened attribute.
	+ */
	+ /* if ((flags & APPEND) && (ap->a_mode & (FWRITE \| O_APPEND)) == FWRITE)
	+ return (EPERM); */
	+
	+ if (udf_node->fe)
	+ file_size = le64toh(udf_node->fe->inf_len);
	+ else
	+ file_size = le64toh(udf_node->efe->inf_len);
	+
	+ vnode_create_vobject(ap->a_vp, file_size, ap->a_td);
	+
	+ return (0);
	+}
	+
	+
	+/* --------------------------------------------------------------------- */
	+#if 0
	+int
	+udf_close(void *v)
	+{
	+ struct vop_close_args /* {
	+ struct vnode *a_vp;
	+ int a_fflag;
	+ kauth_cred_t a_cred;
	+ struct proc *a_p;
	+ } / ap = v;
	+ struct vnode *vp = ap->a_vp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ int async = vp->v_mount->mnt_flag & MNT_ASYNC;
	+ int error;
	+
	+ DPRINTF(CALL, ("udf_close called\n"));
	+ udf_node = udf_node; /* shut up gcc */
	+
	+ if (!async && (vp->v_type != VDIR)) {
	+ mutex_enter(&vp->v_interlock);
	+ error = VOP_PUTPAGES(vp, 0, 0, PGO_CLEANIT);
	+ if (error)
	+ return (error);
	+ }
	+
	+ mutex_enter(&vp->v_interlock);
	+ if (vp->v_usecount > 1)
	+ udf_itimes(udf_node, NULL, NULL, NULL);
	+ mutex_exit(&vp->v_interlock);
	+
	+ return (0);
	+}
	+#endif
	+
	+/* --------------------------------------------------------------------- */
	+static int
	+udf_access(struct vop_access_args *ap)
	+{
	+ struct vnode *vp = ap->a_vp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ accmode_t accmode = ap->a_accmode;
	+ gid_t gid;
	+ mode_t mode;
	+ uid_t uid;
	+ /* int flags = 0; */
	+
	+ DPRINTF(CALL, ("udf_access called\n"));
	+
	+ /* check if we are allowed to write */
	+ switch (vp->v_type) {
	+ case VDIR:
	+ case VLNK:
	+ case VREG:
	+ /*
	+ * normal nodes: check if we're on a read-only mounted
	+ * filingsystem and bomb out if we're trying to write.
	+ */
	+ if ((accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY))
	+ return (EROFS);
	+ break;
	+ case VBLK:
	+ case VCHR:
	+ case VSOCK:
	+ case VFIFO:
	+ /*
	+ * special nodes: even on read-only mounted filingsystems
	+ * these are allowed to be written to if permissions allow.
	+ */
	+ break;
	+ default:
	+ /* no idea what this is */
	+ return (EINVAL);
	+ }
	+
	+ /* noone may write immutable files */
	+ /* TODO: get chflags(2) flags from extened attribute. */
	+#if 0
	+ if ((mode & VWRITE) && (flags & IMMUTABLE))
	+ return (EPERM);
	+#endif
	+
	+ mode = udf_getaccessmode(udf_node);
	+
	+ if (udf_node->fe) {
	+ uid = udf_node->fe->uid;
	+ gid = udf_node->fe->gid;
	+ }
	+ else {
	+ uid = udf_node->efe->uid;
	+ gid = udf_node->efe->gid;
	+ }
	+
	+ return (vaccess(vp->v_type, mode, uid, gid, accmode, ap->a_cred, NULL));
	+}
	+
	+/* --------------------------------------------------------------------- */
	+#ifdef WRITE_SUPPORT
	+int
	+udf_create(void *v)
	+{
	+ struct vop_create_args /* {
	+ struct vnode *a_dvp;
	+ struct vnode **a_vpp;
	+ struct componentname *a_cnp;
	+ struct vattr *a_vap;
	+ } / ap = v;
	+ struct vnode *dvp = ap->a_dvp;
	+ struct vnode **vpp = ap->a_vpp;
	+ struct vattr *vap = ap->a_vap;
	+ struct componentname *cnp = ap->a_cnp;
	+ int error;
	+
	+ DPRINTF(CALL, ("udf_create called\n"));
	+ error = udf_create_node(dvp, vpp, vap, cnp);
	+
	+ if (error \|\| !(cnp->cn_flags & SAVESTART))
	+ PNBUF_PUT(cnp->cn_pnbuf);
	+ vput(dvp);
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_mknod(void *v)
	+{
	+ struct vop_mknod_args /* {
	+ struct vnode *a_dvp;
	+ struct vnode **a_vpp;
	+ struct componentname *a_cnp;
	+ struct vattr *a_vap;
	+ } / ap = v;
	+ struct vnode *dvp = ap->a_dvp;
	+ struct vnode **vpp = ap->a_vpp;
	+ struct vattr *vap = ap->a_vap;
	+ struct componentname *cnp = ap->a_cnp;
	+ int error;
	+
	+ DPRINTF(CALL, ("udf_mknod called\n"));
	+ error = udf_create_node(dvp, vpp, vap, cnp);
	+
	+ if (error \|\| !(cnp->cn_flags & SAVESTART))
	+ PNBUF_PUT(cnp->cn_pnbuf);
	+ vput(dvp);
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_mkdir(void *v)
	+{
	+ struct vop_mkdir_args /* {
	+ struct vnode *a_dvp;
	+ struct vnode **a_vpp;
	+ struct componentname *a_cnp;
	+ struct vattr *a_vap;
	+ } / ap = v;
	+ struct vnode *dvp = ap->a_dvp;
	+ struct vnode **vpp = ap->a_vpp;
	+ struct vattr *vap = ap->a_vap;
	+ struct componentname *cnp = ap->a_cnp;
	+ int error;
	+
	+ DPRINTF(CALL, ("udf_mkdir called\n"));
	+ error = udf_create_node(dvp, vpp, vap, cnp);
	+
	+ if (error \|\| !(cnp->cn_flags & SAVESTART))
	+ PNBUF_PUT(cnp->cn_pnbuf);
	+ vput(dvp);
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_do_link(struct vnode dvp, struct vnode vp, struct componentname *cnp)
	+{
	+ struct udf_node udf_node, dir_node;
	+ struct vattr vap;
	+ int error;
	+
	+ DPRINTF(CALL, ("udf_link called\n"));
	+ error = 0;
	+
	+ /* some quick checks */
	+ if (vp->v_type == VDIR)
	+ return (EPERM); /* can't link a directory */
	+ if (dvp->v_mount != vp->v_mount)
	+ return (EXDEV); /* can't link across devices */
	+ if (dvp == vp)
	+ return (EPERM); /* can't be the same */
	+
	+ /* lock node */
	+ error = vn_lock(vp, LK_EXCLUSIVE);
	+ if (error)
	+ return (error);
	+
	+ /* get attributes */
	+ dir_node = VTOI(dvp);
	+ udf_node = VTOI(vp);
	+
	+ error = VOP_GETATTR(vp, &vap, FSCRED);
	+ if (error) {
	+ VOP_UNLOCK(vp);
	+ return (error);
	+ }
	+
	+ /* check link count overflow */
	+ if (vap.va_nlink >= (1<<16)-1) { /* uint16_t */
	+ VOP_UNLOCK(vp);
	+ return (EMLINK);
	+ }
	+
	+ error = udf_dir_attach(dir_node->ump, dir_node, udf_node, &vap, cnp);
	+ if (error)
	+ VOP_UNLOCK(vp);
	+ return (error);
	+}
	+
	+int
	+udf_link(void *v)
	+{
	+ struct vop_link_args /* {
	+ struct vnode *a_dvp;
	+ struct vnode *a_vp;
	+ struct componentname *a_cnp;
	+ } / ap = v;
	+ struct vnode *dvp = ap->a_dvp;
	+ struct vnode *vp = ap->a_vp;
	+ struct componentname *cnp = ap->a_cnp;
	+ int error;
	+
	+ error = udf_do_link(dvp, vp, cnp);
	+ if (error)
	+ VOP_ABORTOP(dvp, cnp);
	+
	+ VN_KNOTE(vp, NOTE_LINK);
	+ VN_KNOTE(dvp, NOTE_WRITE);
	+ vput(dvp);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+static int
	+udf_do_symlink(struct udf_node udf_node, char target)
	+{
	+ struct pathcomp pathcomp;
	+ uint8_t pathbuf, pathpos, *compnamepos;
	+ char *mntonname;
	+ int pathlen, len, compnamelen, mntonnamelen;
	+ int error;
	+
	+ /* process `target' to an UDF structure */
	+ pathbuf = malloc(UDF_SYMLINKBUFLEN, M_UDFTEMP, M_WAITOK);
	+ pathpos = pathbuf;
	+ pathlen = 0;
	+
	+ if (*target == '/') {
	+ /* symlink starts from the root */
	+ len = UDF_PATH_COMP_SIZE;
	+ memset(&pathcomp, 0, len);
	+ pathcomp.type = UDF_PATH_COMP_ROOT;
	+
	+ /* check if its mount-point relative! */
	+ mntonname = udf_node->ump->vfs_mountp->mnt_stat.f_mntonname;
	+ mntonnamelen = strlen(mntonname);
	+ if (strlen(target) >= mntonnamelen) {
	+ if (strncmp(target, mntonname, mntonnamelen) == 0) {
	+ pathcomp.type = UDF_PATH_COMP_MOUNTROOT;
	+ target += mntonnamelen;
	+ }
	+ } else {
	+ target++;
	+ }
	+
	+ memcpy(pathpos, &pathcomp, len);
	+ pathpos += len;
	+ pathlen += len;
	+ }
	+
	+ error = 0;
	+ while (*target) {
	+ /* ignore multiple '/' */
	+ while (*target == '/') {
	+ target++;
	+ }
	+ if (!*target)
	+ break;
	+
	+ /* extract component name */
	+ compnamelen = 0;
	+ compnamepos = target;
	+ while ((target) && (target != '/')) {
	+ target++;
	+ compnamelen++;
	+ }
	+
	+ /* just trunc if too long ?? (security issue) */
	+ if (compnamelen >= 127) {
	+ error = ENAMETOOLONG;
	+ break;
	+ }
	+
	+ /* convert unix name to UDF name */
	+ len = sizeof(struct pathcomp);
	+ memset(&pathcomp, 0, len);
	+ pathcomp.type = UDF_PATH_COMP_NAME;
	+ len = UDF_PATH_COMP_SIZE;
	+
	+ if ((compnamelen == 2) && (strncmp(compnamepos, "..", 2) == 0))
	+ pathcomp.type = UDF_PATH_COMP_PARENTDIR;
	+ if ((compnamelen == 1) && (*compnamepos == '.'))
	+ pathcomp.type = UDF_PATH_COMP_CURDIR;
	+
	+ if (pathcomp.type == UDF_PATH_COMP_NAME) {
	+ unix_to_udf_name(
	+ (char *) &pathcomp.ident, &pathcomp.l_ci,
	+ compnamepos, compnamelen,
	+ &udf_node->ump->logical_vol->desc_charset);
	+ len = UDF_PATH_COMP_SIZE + pathcomp.l_ci;
	+ }
	+
	+ if (pathlen + len >= UDF_SYMLINKBUFLEN) {
	+ error = ENAMETOOLONG;
	+ break;
	+ }
	+
	+ memcpy(pathpos, &pathcomp, len);
	+ pathpos += len;
	+ pathlen += len;
	+ }
	+
	+ if (error) {
	+ /* aparently too big */
	+ free(pathbuf, M_UDFTEMP);
	+ return (error);
	+ }
	+
	+ error = udf_grow_node(udf_node, pathlen);
	+ if (error) {
	+ /* failed to pregrow node */
	+ free(pathbuf, M_UDFTEMP);
	+ return (error);
	+ }
	+
	+ /* write out structure on the new file */
	+ error = vn_rdwr(UIO_WRITE, udf_node->vnode,
	+ pathbuf, pathlen, 0,
	+ UIO_SYSSPACE, IO_NODELOCKED \| IO_ALTSEMANTICS,
	+ FSCRED, NULL, NULL);
	+
	+ /* return status of symlink contents writeout */
	+ free(pathbuf, M_UDFTEMP);
	+ return (error);
	+}
	+
	+
	+int
	+udf_symlink(void *v)
	+{
	+ struct vop_symlink_args /* {
	+ struct vnode *a_dvp;
	+ struct vnode **a_vpp;
	+ struct componentname *a_cnp;
	+ struct vattr *a_vap;
	+ char *a_target;
	+ } / ap = v;
	+ struct vnode *dvp = ap->a_dvp;
	+ struct vnode **vpp = ap->a_vpp;
	+ struct vattr *vap = ap->a_vap;
	+ struct componentname *cnp = ap->a_cnp;
	+ struct udf_node *dir_node;
	+ struct udf_node *udf_node;
	+ int error;
	+
	+ error = udf_create_node(dvp, vpp, vap, cnp);
	+ KASSERT(((error == 0) && (vpp != NULL)) \|\| ((error && (vpp == NULL))));
	+ if (!error) {
	+ dir_node = VTOI(dvp);
	+ udf_node = VTOI(*vpp);
	+ KASSERT(udf_node);
	+ error = udf_do_symlink(udf_node, ap->a_target);
	+ if (error) {
	+ /* remove node */
	+ udf_shrink_node(udf_node, 0);
	+ udf_dir_detach(udf_node->ump, dir_node, udf_node, cnp);
	+ }
	+ }
	+ if (error \|\| !(cnp->cn_flags & SAVESTART))
	+ PNBUF_PUT(cnp->cn_pnbuf);
	+ vput(dvp);
	+ return (error);
	+}
	+#endif
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_readlink(struct vop_readlink_args *ap)
	+{
	+ struct vnode *vp = ap->a_vp;
	+ struct uio *uio = ap->a_uio;
	+ struct pathcomp pathcomp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ int pathlen, targetlen, namelen, mntonnamelen, len, l_ci, filelen;
	+ int first, error;
	+ char *mntonname;
	+ uint8_t pathbuf, targetbuf, *tmpname;
	+ uint8_t pathpos, targetpos;
	+
	+ DPRINTF(CALL, ("udf_readlink called\n"));
	+
	+ if (udf_node->efe)
	+ filelen = le64toh(udf_node->efe->inf_len);
	+ else
	+ filelen = le64toh(udf_node->fe->inf_len);
	+
	+ /* claim temporary buffers for translation */
	+ pathbuf = malloc(UDF_SYMLINKBUFLEN, M_UDFTEMP, M_WAITOK);
	+ targetbuf = malloc(PATH_MAX+1, M_UDFTEMP, M_WAITOK);
	+ tmpname = malloc(PATH_MAX+1, M_UDFTEMP, M_WAITOK);
	+ memset(pathbuf, 0, UDF_SYMLINKBUFLEN);
	+ memset(targetbuf, 0, PATH_MAX);
	+
	+
	+ /* read contents of file in our temporary buffer */
	+ error = vn_rdwr(UIO_READ, vp,
	+ pathbuf, filelen, 0,
	+ UIO_SYSSPACE, IO_NODELOCKED,
	+ FSCRED, NULL, NULL, curthread);
	+ if (error) {
	+ /* failed to read in symlink contents */
	+ free(pathbuf, M_UDFTEMP);
	+ free(targetbuf, M_UDFTEMP);
	+ free(tmpname, M_UDFTEMP);
	+ return (error);
	+ }
	+
	+ /* convert to a unix path */
	+ pathpos = pathbuf;
	+ pathlen = 0;
	+ targetpos = targetbuf;
	+ targetlen = PATH_MAX;
	+ mntonname = udf_node->ump->vfs_mountp->mnt_stat.f_mntonname;
	+ mntonnamelen = strlen(mntonname);
	+
	+ error = 0;
	+ first = 1;
	+ while (filelen - pathlen >= UDF_PATH_COMP_SIZE) {
	+ len = UDF_PATH_COMP_SIZE;
	+ memcpy(&pathcomp, pathpos, len);
	+ l_ci = pathcomp.l_ci;
	+ switch (pathcomp.type) {
	+ case UDF_PATH_COMP_ROOT :
	+ /* XXX should check for l_ci; bugcompatible now */
	+ if ((targetlen < 1) \|\| !first) {
	+ error = EINVAL;
	+ break;
	+ }
	+ *targetpos++ = '/'; targetlen--;
	+ break;
	+ case UDF_PATH_COMP_MOUNTROOT :
	+ /* XXX what should it be if l_ci > 0 ? [4/48.16.1.2] */
	+ if (l_ci \|\| (targetlen < mntonnamelen+1) \|\| !first) {
	+ error = EINVAL;
	+ break;
	+ }
	+ memcpy(targetpos, mntonname, mntonnamelen);
	+ targetpos += mntonnamelen; targetlen -= mntonnamelen;
	+ if (filelen-pathlen > UDF_PATH_COMP_SIZE+l_ci) {
	+ /* more follows, so must be directory */
	+ *targetpos++ = '/'; targetlen--;
	+ }
	+ break;
	+ case UDF_PATH_COMP_PARENTDIR :
	+ /* XXX should check for l_ci; bugcompatible now */
	+ if (targetlen < 3) {
	+ error = EINVAL;
	+ break;
	+ }
	+ *targetpos++ = '.'; targetlen--;
	+ *targetpos++ = '.'; targetlen--;
	+ *targetpos++ = '/'; targetlen--;
	+ break;
	+ case UDF_PATH_COMP_CURDIR :
	+ /* XXX should check for l_ci; bugcompatible now */
	+ if (targetlen < 2) {
	+ error = EINVAL;
	+ break;
	+ }
	+ *targetpos++ = '.'; targetlen--;
	+ *targetpos++ = '/'; targetlen--;
	+ break;
	+ case UDF_PATH_COMP_NAME :
	+ if (l_ci == 0) {
	+ error = EINVAL;
	+ break;
	+ }
	+ memset(tmpname, 0, PATH_MAX);
	+ memcpy(&pathcomp, pathpos, len + l_ci);
	+ udf_to_unix_name(udf_node->ump, tmpname, MAXPATHLEN,
	+ pathcomp.ident, l_ci);
	+ namelen = strlen(tmpname);
	+ if (targetlen < namelen + 1) {
	+ error = EINVAL;
	+ break;
	+ }
	+ memcpy(targetpos, tmpname, namelen);
	+ targetpos += namelen; targetlen -= namelen;
	+ if (filelen-pathlen > UDF_PATH_COMP_SIZE+l_ci) {
	+ /* more follows, so must be directory */
	+ *targetpos++ = '/'; targetlen--;
	+ }
	+ break;
	+ default :
	+ error = EINVAL;
	+ break;
	+ }
	+ first = 0;
	+ if (error)
	+ break;
	+ pathpos += UDF_PATH_COMP_SIZE + l_ci;
	+ pathlen += UDF_PATH_COMP_SIZE + l_ci;
	+
	+ }
	+ /* all processed? */
	+ if (filelen - pathlen > 0)
	+ error = EINVAL;
	+
	+ /* uiomove() to destination */
	+ if (!error)
	+ uiomove(targetbuf, PATH_MAX - targetlen, uio);
	+
	+ free(pathbuf, M_UDFTEMP);
	+ free(targetbuf, M_UDFTEMP);
	+ free(tmpname, M_UDFTEMP);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+/*
	+ * Check if source directory is in the path of the target directory. Target
	+ * is supplied locked, source is unlocked. The target is always vput before
	+ * returning. Modeled after UFS.
	+ *
	+ * If source is on the path from target to the root, return error.
	+ */
	+#ifdef WRITE_SUPPORT
	+static int
	+udf_on_rootpath(struct udf_node source, struct udf_node target)
	+{
	+ struct udf_mount *ump = target->ump;
	+ struct udf_node *res_node;
	+ struct long_ad icb_loc, *root_icb;
	+ const char *name;
	+ int namelen;
	+ int error, found;
	+
	+ name = "..";
	+ namelen = 2;
	+ error = 0;
	+ res_node = target;
	+
	+ root_icb = &ump->fileset_desc->rootdir_icb;
	+
	+ /* if nodes are equal, it is no use looking */
	+ if (udf_compare_icb(&source->loc, &target->loc) == 0) {
	+ error = EEXIST;
	+ goto out;
	+ }
	+
	+ /* nothing can exist before the root */
	+ if (udf_compare_icb(root_icb, &target->loc) == 0) {
	+ error = 0;
	+ goto out;
	+ }
	+
	+ for (;;) {
	+ DPRINTF(NODE, ("udf_on_rootpath : "
	+ "source vp %p, looking at vp %p\n",
	+ source->vnode, res_node->vnode));
	+
	+ /* sanity check */
	+ if (res_node->vnode->v_type != VDIR) {
	+ error = ENOTDIR;
	+ goto out;
	+ }
	+
	+ /* go down one level */
	+ error = udf_lookup_name_in_dir(res_node->vnode, name, namelen,
	+ &icb_loc, &found);
	+ DPRINTF(NODE, ("\tlookup of '..' resulted in error %d, "
	+ "found %d\n", error, found));
	+
	+ if (!found)
	+ error = ENOENT;
	+ if (error)
	+ goto out;
	+
	+ /* did we encounter source node? */
	+ if (udf_compare_icb(&icb_loc, &source->loc) == 0) {
	+ error = EINVAL;
	+ goto out;
	+ }
	+
	+ /* did we encounter the root node? */
	+ if (udf_compare_icb(&icb_loc, root_icb) == 0) {
	+ error = 0;
	+ goto out;
	+ }
	+
	+ /* push our intermediate node, we're done with it */
	+ /* DPRINTF(NODE, ("\tvput %p\n", target->vnode)); */
	+ vput(res_node->vnode);
	+
	+ DPRINTF(NODE, ("\tgetting the .. node\n"));
	+ error = udf_get_node(ump, &icb_loc, &res_node);
	+
	+ if (error) { /* argh, bail out */
	+ KASSERT(res_node == NULL);
	+ // res_node = NULL;
	+ goto out;
	+ }
	+ }
	+out:
	+ DPRINTF(NODE, ("\tresult: %svalid, error = %d\n", error?"in":"", error));
	+
	+ /* put our last node */
	+ if (res_node)
	+ vput(res_node->vnode);
	+
	+ return (error);
	+}
	+
	+/* note: i tried to follow the logics of the tmpfs rename code */
	+int
	+udf_rename(void *v)
	+{
	+ struct vop_rename_args /* {
	+ struct vnode *a_fdvp;
	+ struct vnode *a_fvp;
	+ struct componentname *a_fcnp;
	+ struct vnode *a_tdvp;
	+ struct vnode *a_tvp;
	+ struct componentname *a_tcnp;
	+ } / ap = v;
	+ struct vnode *tvp = ap->a_tvp;
	+ struct vnode *tdvp = ap->a_tdvp;
	+ struct vnode *fvp = ap->a_fvp;
	+ struct vnode *fdvp = ap->a_fdvp;
	+ struct componentname *tcnp = ap->a_tcnp;
	+ struct componentname *fcnp = ap->a_fcnp;
	+ struct udf_node fnode, fdnode, tnode, tdnode;
	+ struct vattr fvap, tvap;
	+ int error;
	+
	+ DPRINTF(CALL, ("udf_rename called\n"));
	+
	+ /* disallow cross-device renames */
	+ if (fvp->v_mount != tdvp->v_mount \|\|
	+ (tvp != NULL && fvp->v_mount != tvp->v_mount)) {
	+ error = EXDEV;
	+ goto out_unlocked;
	+ }
	+
	+ fnode = VTOI(fvp);
	+ fdnode = VTOI(fdvp);
	+ tnode = (tvp == NULL) ? NULL : VTOI(tvp);
	+ tdnode = VTOI(tdvp);
	+
	+ /* lock our source dir */
	+ if (fdnode != tdnode) {
	+ error = vn_lock(fdvp, LK_EXCLUSIVE \| LK_RETRY);
	+ if (error != 0)
	+ goto out_unlocked;
	+ }
	+
	+ /* get info about the node to be moved */
	+ error = VOP_GETATTR(fvp, &fvap, FSCRED);
	+ KASSERT(error == 0);
	+
	+ /* check when to delete the old already existing entry */
	+ if (tvp) {
	+ /* get info about the node to be moved to */
	+ error = VOP_GETATTR(fvp, &tvap, FSCRED);
	+ KASSERT(error == 0);
	+
	+ /* if both dirs, make sure the destination is empty */
	+ if (fvp->v_type == VDIR && tvp->v_type == VDIR) {
	+ if (tvap.va_nlink > 2) {
	+ error = ENOTEMPTY;
	+ goto out;
	+ }
	+ }
	+ /* if moving dir, make sure destination is dir too */
	+ if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
	+ error = ENOTDIR;
	+ goto out;
	+ }
	+ /* if we're moving a non-directory, make sure dest is no dir */
	+ if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
	+ error = EISDIR;
	+ goto out;
	+ }
	+ }
	+
	+ /* check if moving a directory to a new parent is allowed */
	+ if ((fdnode != tdnode) && (fvp->v_type == VDIR)) {
	+ /* release tvp since we might encounter it and lock up */
	+ if (tvp)
	+ vput(tvp);
	+
	+ /* vref tdvp since we lose its ref in udf_on_rootpath */
	+ vref(tdvp);
	+
	+ /* search if fnode is a component of tdnode's path to root */
	+ error = udf_on_rootpath(fnode, tdnode);
	+
	+ DPRINTF(NODE, ("Dir rename allowed ? %s\n", error ? "NO":"YES"));
	+
	+ if (error) {
	+ /* compensate for our vref earlier */
	+ vrele(tdvp);
	+ goto out;
	+ }
	+
	+ /* relock tdvp; its still here due to the vref earlier */
	+ vn_lock(tdvp, LK_EXCLUSIVE \| LK_RETRY);
	+
	+ /*
	+ * re-lookup tvp since the parent has been unlocked, so could
	+ * have changed/removed in the meantime.
	+ */
	+ tcnp->cn_flags &= ~SAVESTART;
	+ error = relookup(tdvp, &tvp, tcnp);
	+ if (error) {
	+ vput(tdvp);
	+ goto out;
	+ }
	+ tnode = (tvp == NULL) ? NULL : VTOI(tvp);
	+ }
	+
	+ /* remove existing entry if present */
	+ if (tvp)
	+ udf_dir_detach(tdnode->ump, tdnode, tnode, tcnp);
	+
	+ /* create new directory entry for the node */
	+ error = udf_dir_attach(tdnode->ump, tdnode, fnode, &fvap, tcnp);
	+ if (error)
	+ goto out;
	+
	+ /* unlink old directory entry for the node, if failing, unattach new */
	+ error = udf_dir_detach(tdnode->ump, fdnode, fnode, fcnp);
	+ if (error)
	+ udf_dir_detach(tdnode->ump, tdnode, fnode, tcnp);
	+ if (error)
	+ goto out;
	+
	+ /* update tnode's '..' if moving directory to new parent */
	+ if ((fdnode != tdnode) && (fvp->v_type == VDIR)) {
	+ /* update fnode's '..' entry */
	+ error = udf_dir_update_rootentry(fnode->ump, fnode, tdnode);
	+ if (error) {
	+ /* 'try' to recover from this situation */
	+ udf_dir_attach(tdnode->ump, fdnode, fnode, &fvap, fcnp);
	+ udf_dir_detach(tdnode->ump, tdnode, fnode, tcnp);
	+ }
	+ }
	+
	+out:
	+ if (fdnode != tdnode)
	+ VOP_UNLOCK(fdvp);
	+
	+out_unlocked:
	+ VOP_ABORTOP(tdvp, tcnp);
	+ if (tdvp == tvp)
	+ vrele(tdvp);
	+ else
	+ vput(tdvp);
	+ if (tvp)
	+ vput(tvp);
	+ VOP_ABORTOP(fdvp, fcnp);
	+
	+ /* release source nodes. */
	+ vrele(fdvp);
	+ vrele(fvp);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_remove(void *v)
	+{
	+ struct vop_remove_args /* {
	+ struct vnode *a_dvp;
	+ struct vnode *a_vp;
	+ struct componentname *a_cnp;
	+ } / ap = v;
	+ struct vnode *dvp = ap->a_dvp;
	+ struct vnode *vp = ap->a_vp;
	+ struct componentname *cnp = ap->a_cnp;
	+ struct udf_node *dir_node = VTOI(dvp);
	+ struct udf_node *udf_node = VTOI(vp);
	+ struct udf_mount *ump = dir_node->ump;
	+ int error;
	+
	+ DPRINTF(CALL, ("udf_remove called\n"));
	+ if (vp->v_type != VDIR) {
	+ error = udf_dir_detach(ump, dir_node, udf_node, cnp);
	+ DPRINTFIF(NODE, error, ("\tgot error removing file\n"));
	+ } else {
	+ DPRINTF(NODE, ("\tis a directory: perm. denied\n"));
	+ error = EPERM;
	+ }
	+
	+ if (error == 0) {
	+ VN_KNOTE(vp, NOTE_DELETE);
	+ VN_KNOTE(dvp, NOTE_WRITE);
	+ }
	+
	+ if (dvp == vp)
	+ vrele(vp);
	+ else
	+ vput(vp);
	+ vput(dvp);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_rmdir(void *v)
	+{
	+ struct vop_rmdir_args /* {
	+ struct vnode *a_dvp;
	+ struct vnode *a_vp;
	+ struct componentname *a_cnp;
	+ } / ap = v;
	+ struct vnode *vp = ap->a_vp;
	+ struct vnode *dvp = ap->a_dvp;
	+ struct componentname *cnp = ap->a_cnp;
	+ struct udf_node *dir_node = VTOI(dvp);
	+ struct udf_node *udf_node = VTOI(vp);
	+ struct udf_mount *ump = dir_node->ump;
	+ int refcnt, error;
	+
	+ DPRINTF(NOTIMPL, ("udf_rmdir called\n"));
	+
	+ /* don't allow '.' to be deleted */
	+ if (dir_node == udf_node) {
	+ vrele(dvp);
	+ vput(vp);
	+ return (EINVAL);
	+ }
	+
	+ /* check to see if the directory is empty */
	+ error = 0;
	+ if (dir_node->fe) {
	+ refcnt = le16toh(udf_node->fe->link_cnt);
	+ } else {
	+ refcnt = le16toh(udf_node->efe->link_cnt);
	+ }
	+ if (refcnt > 1) {
	+ /* NOT empty */
	+ vput(dvp);
	+ vput(vp);
	+ return (ENOTEMPTY);
	+ }
	+
	+ /* detach the node from the directory */
	+ error = udf_dir_detach(ump, dir_node, udf_node, cnp);
	+ if (error == 0) {
	+ cache_purge(vp);
	+// cache_purge(dvp); /* XXX from msdosfs, why? */
	+ VN_KNOTE(vp, NOTE_DELETE);
	+ }
	+ DPRINTFIF(NODE, error, ("\tgot error removing file\n"));
	+
	+ /* unput the nodes and exit */
	+ vput(dvp);
	+ vput(vp);
	+
	+ return (error);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_fsync(void *v)
	+{
	+ struct vop_fsync_args /* {
	+ struct vnode *a_vp;
	+ kauth_cred_t a_cred;
	+ int a_flags;
	+ off_t offlo;
	+ off_t offhi;
	+ struct proc *a_p;
	+ } / ap = v;
	+ struct vnode *vp = ap->a_vp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ int error, flags, wait;
	+
	+ DPRINTF(SYNC, ("udf_fsync called on %p : %s, %s\n",
	+ udf_node,
	+ (ap->a_flags & FSYNC_WAIT) ? "wait":"no wait",
	+ (ap->a_flags & FSYNC_DATAONLY) ? "data_only":"complete"));
	+
	+ /* flush data and wait for it when requested */
	+ wait = (ap->a_flags & FSYNC_WAIT) ? UPDATE_WAIT : 0;
	+ vflushbuf(vp, wait);
	+
	+ if (udf_node == NULL) {
	+ printf("udf_fsync() called on NULL udf_node!\n");
	+ return (0);
	+ }
	+ if (vp->v_tag != VT_UDF) {
	+ printf("udf_fsync() called on node not tagged as UDF node!\n");
	+ return (0);
	+ }
	+
	+ /* set our times */
	+ udf_itimes(udf_node, NULL, NULL, NULL);
	+
	+ /* if called when mounted readonly, never write back */
	+ if (vp->v_mount->mnt_flag & MNT_RDONLY)
	+ return (0);
	+
	+ /* if only data is requested, return */
	+ if (ap->a_flags & FSYNC_DATAONLY)
	+ return (0);
	+
	+ /* check if the node is dirty 'enough'*/
	+ flags = udf_node->i_flags & (IN_MODIFIED \| IN_ACCESSED);
	+ if (flags == 0)
	+ return (0);
	+
	+ /* if we don't have to wait, check for IO pending */
	+ if (!wait) {
	+ if (vp->v_numoutput > 0) {
	+ DPRINTF(SYNC, ("udf_fsync %p, rejecting on v_numoutput\n", udf_node));
	+ return (0);
	+ }
	+ if (udf_node->outstanding_bufs > 0) {
	+ DPRINTF(SYNC, ("udf_fsync %p, rejecting on outstanding_bufs\n", udf_node));
	+ return (0);
	+ }
	+ if (udf_node->outstanding_nodedscr > 0) {
	+ DPRINTF(SYNC, ("udf_fsync %p, rejecting on outstanding_nodedscr\n", udf_node));
	+ return (0);
	+ }
	+ }
	+
	+ /* wait until vp->v_numoutput reaches zero i.e. is finished */
	+ if (wait) {
	+ DPRINTF(SYNC, ("udf_fsync %p, waiting\n", udf_node));
	+ mutex_enter(&vp->v_interlock);
	+ while (vp->v_numoutput) {
	+ DPRINTF(SYNC, ("udf_fsync %p, v_numoutput %d\n", udf_node, vp->v_numoutput));
	+ cv_timedwait(&vp->v_cv, &vp->v_interlock, hz/8);
	+ }
	+ mutex_exit(&vp->v_interlock);
	+ DPRINTF(SYNC, ("udf_fsync %p, fin wait\n", udf_node));
	+ }
	+
	+ /* write out node and wait for it if requested */
	+ DPRINTF(SYNC, ("udf_fsync %p, writeout node\n", udf_node));
	+ error = udf_writeout_node(udf_node, wait);
	+ if (error)
	+ return (error);
	+
	+ /* TODO/XXX if ap->a_flags & FSYNC_CACHE, we ought to do a disc sync */
	+
	+ return (0);
	+}
	+
	+/* --------------------------------------------------------------------- */
	+
	+int
	+udf_advlock(void *v)
	+{
	+ struct vop_advlock_args /* {
	+ struct vnode *a_vp;
	+ void *a_id;
	+ int a_op;
	+ struct flock *a_fl;
	+ int a_flags;
	+ } / ap = v;
	+ struct vnode *vp = ap->a_vp;
	+ struct udf_node *udf_node = VTOI(vp);
	+ struct file_entry *fe;
	+ struct extfile_entry *efe;
	+ uint64_t file_size;
	+
	+ DPRINTF(LOCKING, ("udf_advlock called\n"));
	+
	+ /* get directory filesize */
	+ if (udf_node->fe) {
	+ fe = udf_node->fe;
	+ file_size = le64toh(fe->inf_len);
	+ } else {
	+ assert(udf_node->efe);
	+ efe = udf_node->efe;
	+ file_size = le64toh(efe->inf_len);
	+ }
	+
	+ return (lf_advlock(ap, &udf_node->lockf, file_size));
	+}
	+#endif
	+
	+/*
	+ * File specific ioctls.
	+ */
	+static int
	+udf_ioctl(struct vop_ioctl_args *ap)
	+{
	+ printf("%s called\n", __func__);
	+ return (ENOTTY);
	+}
	+
	+static int
	+udf_print(struct vop_print_args *ap)
	+{
	+ struct vnode *vp = ap->a_vp;
	+ struct udf_node *udf_node = VTOI(vp);
	+
	+ printf(" ino %u, on dev %s", (uint32_t)udf_node->hash_id,
	+ devtoname(udf_node->ump->dev));
	+ if (vp->v_type == VFIFO)
	+ fifo_printinfo(vp);
	+ printf("\n");
	+ return (0);
	+}
	+
	+static int
	+udf_vptofh(struct vop_vptofh_args *ap)
	+{
	+ struct udf_node *udf_node = VTOI(ap->a_vp);
	+ struct udf_fid ufid = (struct udf_fid )ap->a_fhp;
	+
	+ ufid->len = sizeof(struct udf_fid);
	+ ufid->ino = udf_node->hash_id;
	+
	+ return (0);
	+}
	+
	Index: sys/fs/udf2/udfio.h
	===================================================================
	--- /dev/null
	+++ sys/fs/udf2/udfio.h
	@@ -0,0 +1,198 @@
	+
	+/* Shared between kernel & process */
	+
	+#ifndef _SYS_UDFIO_H_
	+#define _SYS_UDFIO_H_
	+
	+#ifndef _KERNEL
	+#include <sys/types.h>
	+#endif
	+#include <sys/ioccom.h>
	+
	+struct udf_session_info {
	+ uint32_t session_num;
	+
	+ uint16_t sector_size;
	+ uint16_t num_sessions;
	+ uint32_t session_start_addr;
	+ uint32_t session_end_addr;
	+
	+ uint16_t num_tracks;
	+ uint8_t first_track;
	+ uint16_t session_first_track;
	+ uint16_t session_last_track;
	+};
	+#define UDFIOTEST _IOWR('c',300, struct udf_session_info)
	+
	+#if defined(_KERNEL) \|\| defined(_EXPOSE_MMC)
	+/* not exposed to userland yet until its completely mature */
	+/*
	+ * MMC device abstraction interface.
	+ *
	+ * It gathers information from GET_CONFIGURATION, READ_DISCINFO,
	+ * READ_TRACKINFO, READ_TOC2, READ_CD_CAPACITY and GET_CONFIGURATION
	+ * SCSI/ATAPI calls regardless if its a legacy CD-ROM/DVD-ROM device or a MMC
	+ * standard recordable device.
	+ */
	+struct mmc_discinfo {
	+ uint16_t mmc_profile;
	+ uint16_t mmc_class;
	+
	+ uint8_t disc_state;
	+ uint8_t last_session_state;
	+ uint8_t bg_format_state;
	+ uint8_t link_block_penalty; /* in sectors */
	+
	+ uint64_t mmc_cur; /* current MMC_CAPs */
	+ uint64_t mmc_cap; /* possible MMC_CAPs */
	+
	+ uint32_t disc_flags; /* misc flags */
	+
	+ uint32_t disc_id;
	+ uint64_t disc_barcode;
	+ uint8_t application_code; /* 8 bit really */
	+
	+ uint8_t unused1[3]; /* padding */
	+
	+ uint32_t last_possible_lba; /* last leadout start adr. */
	+ uint32_t sector_size;
	+
	+ uint16_t num_sessions;
	+ uint16_t num_tracks; /* derived */
	+
	+ uint16_t first_track;
	+ uint16_t first_track_last_session;
	+ uint16_t last_track_last_session;
	+
	+ uint16_t unused2; /* padding/misc info resv. */
	+
	+ uint16_t reserved1[4]; /* MMC-5 track resources */
	+ uint32_t reserved2[3]; /* MMC-5 POW resources */
	+
	+ uint32_t reserved3[8]; /* MMC-5+ */
	+};
	+#define FKIOCTL 0x80000000 /* kernel original ioctl */
	+#define MMCGETDISCINFO _IOR('c', 28, struct mmc_discinfo)
	+
	+#define MMC_CLASS_UNKN 0
	+#define MMC_CLASS_DISC 1
	+#define MMC_CLASS_CD 2
	+#define MMC_CLASS_DVD 3
	+#define MMC_CLASS_MO 4
	+#define MMC_CLASS_BD 5
	+#define MMC_CLASS_FILE 0xffff /* emulation mode */
	+
	+#define MMC_DFLAGS_BARCODEVALID (1 << 0) /* barcode is present and valid */
	+#define MMC_DFLAGS_DISCIDVALID (1 << 1) /* discid is present and valid */
	+#define MMC_DFLAGS_APPCODEVALID (1 << 2) /* application code valid */
	+#define MMC_DFLAGS_UNRESTRICTED (1 << 3) /* restricted, then set app. code */
	+
	+#define MMC_DFLAGS_FLAGBITS \
	+ "\10\1BARCODEVALID\2DISCIDVALID\3APPCODEVALID\4UNRESTRICTED"
	+
	+#define MMC_CAP_SEQUENTIAL (1 << 0) /* sequential writable only */
	+#define MMC_CAP_RECORDABLE (1 << 1) /* record-able; i.e. not static */
	+#define MMC_CAP_ERASABLE (1 << 2) /* drive can erase sectors */
	+#define MMC_CAP_BLANKABLE (1 << 3) /* media can be blanked */
	+#define MMC_CAP_FORMATTABLE (1 << 4) /* media can be formatted */
	+#define MMC_CAP_REWRITABLE (1 << 5) /* media can be rewritten */
	+#define MMC_CAP_MRW (1 << 6) /* Mount Rainier formatted */
	+#define MMC_CAP_PACKET (1 << 7) /* using packet recording */
	+#define MMC_CAP_STRICTOVERWRITE (1 << 8) /* only writes a packet at a time */
	+#define MMC_CAP_PSEUDOOVERWRITE (1 << 9) /* overwrite through replacement */
	+#define MMC_CAP_ZEROLINKBLK (1 << 10) /* zero link block length capable */
	+#define MMC_CAP_HW_DEFECTFREE (1 << 11) /* hardware defect management */
	+
	+#define MMC_CAP_FLAGBITS \
	+ "\10\1SEQUENTIAL\2RECORDABLE\3ERASABLE\4BLANKABLE\5FORMATTABLE" \
	+ "\6REWRITABLE\7MRW\10PACKET\11STRICTOVERWRITE\12PSEUDOOVERWRITE" \
	+ "\13ZEROLINKBLK\14HW_DEFECTFREE"
	+
	+#define MMC_STATE_EMPTY 0
	+#define MMC_STATE_INCOMPLETE 1
	+#define MMC_STATE_FULL 2
	+#define MMC_STATE_CLOSED 3
	+
	+#define MMC_BGFSTATE_UNFORM 0
	+#define MMC_BGFSTATE_STOPPED 1
	+#define MMC_BGFSTATE_RUNNING 2
	+#define MMC_BGFSTATE_COMPLETED 3
	+
	+
	+struct mmc_trackinfo {
	+ uint16_t tracknr; /* IN/OUT */
	+ uint16_t sessionnr;
	+
	+ uint8_t track_mode;
	+ uint8_t data_mode;
	+
	+ uint16_t flags;
	+
	+ uint32_t track_start;
	+ uint32_t next_writable;
	+ uint32_t free_blocks;
	+ uint32_t packet_size;
	+ uint32_t track_size;
	+ uint32_t last_recorded;
	+};
	+#define MMCGETTRACKINFO _IOWR('c', 29, struct mmc_trackinfo)
	+
	+#define MMC_TRACKINFO_COPY (1 << 0)
	+#define MMC_TRACKINFO_DAMAGED (1 << 1)
	+#define MMC_TRACKINFO_FIXED_PACKET (1 << 2)
	+#define MMC_TRACKINFO_INCREMENTAL (1 << 3)
	+#define MMC_TRACKINFO_BLANK (1 << 4)
	+#define MMC_TRACKINFO_RESERVED (1 << 5)
	+#define MMC_TRACKINFO_NWA_VALID (1 << 6)
	+#define MMC_TRACKINFO_LRA_VALID (1 << 7)
	+#define MMC_TRACKINFO_DATA (1 << 8)
	+#define MMC_TRACKINFO_AUDIO (1 << 9)
	+#define MMC_TRACKINFO_AUDIO_4CHAN (1 << 10)
	+#define MMC_TRACKINFO_PRE_EMPH (1 << 11)
	+
	+#define MMC_TRACKINFO_FLAGBITS \
	+ "\10\1COPY\2DAMAGED\3FIXEDPACKET\4INCREMENTAL\5BLANK" \
	+ "\6RESERVED\7NWA_VALID\10LRA_VALID\11DATA\12AUDIO" \
	+ "\13AUDIO_4CHAN\14PRE_EMPH"
	+
	+struct mmc_op {
	+ uint16_t operation; /* IN */
	+ uint16_t mmc_profile; /* IN */
	+
	+ /* parameters to operation */
	+ uint16_t tracknr; /* IN */
	+ uint16_t sessionnr; /* IN */
	+ uint32_t extent; /* IN */
	+
	+ uint32_t reserved[4];
	+};
	+#define MMCOP _IOWR('c', 30, struct mmc_op)
	+
	+#define MMC_OP_SYNCHRONISECACHE 1
	+#define MMC_OP_CLOSETRACK 2
	+#define MMC_OP_CLOSESESSION 3
	+#define MMC_OP_FINALISEDISC 4
	+#define MMC_OP_RESERVETRACK 5
	+#define MMC_OP_RESERVETRACK_NWA 6
	+#define MMC_OP_UNRESERVETRACK 7
	+#define MMC_OP_REPAIRTRACK 8
	+#define MMC_OP_UNCLOSELASTSESSION 9
	+#define MMC_OP_MAX 9
	+
	+struct mmc_writeparams {
	+ uint16_t tracknr; /* IN */
	+ uint16_t mmc_class; /* IN */
	+ uint32_t mmc_cur; /* IN */
	+ uint32_t blockingnr; /* IN */
	+
	+ /* when tracknr == 0 */
	+ uint8_t track_mode; /* IN; normally 5 */
	+ uint8_t data_mode; /* IN; normally 2 */
	+};
	+#define MMC_TRACKMODE_DEFAULT 5 /* data, incremental recording */
	+#define MMC_DATAMODE_DEFAULT 2 /* CDROM XA disc */
	+#define MMCSETUPWRITEPARAMS _IOW('c', 31, struct mmc_writeparams)
	+
	+#endif /* _KERNEL \|\| _EXPOSE_MMC */
	+
	+#endif /* !_SYS_UDFIO_H_ */
	Index: sys/modules/Makefile
	===================================================================
	--- sys/modules/Makefile
	+++ sys/modules/Makefile
	@@ -375,6 +375,8 @@
	ubsec \
	udf \
	udf_iconv \
	+ udf2 \
	+ udf2_iconv \
	ufs \
	uinput \
	unionfs \
	Index: sys/modules/udf2/Makefile
	===================================================================
	--- /dev/null
	+++ sys/modules/udf2/Makefile
	@@ -0,0 +1,13 @@
	+# $FreeBSD$
	+
	+.PATH: ${.CURDIR}/../../fs/udf2
	+
	+KMOD= udf2
	+
	+SRCS= udf_readwrite.c udf_subr.c udf_allocation.c \
	+ udf_osta.c udf_vfsops.c udf_vnops.c udf_filenames.c
	+# udf_strat_bootstrap.c udf_strat_direct.c udf_strat_rmw.c udf_strat_sequential.c
	+SRCS+= vnode_if.h
	+EXPORT_SYMS= udf_iconv
	+
	+.include <bsd.kmod.mk>
	Index: sys/modules/udf2_iconv/Makefile
	===================================================================
	--- /dev/null
	+++ sys/modules/udf2_iconv/Makefile
	@@ -0,0 +1,9 @@
	+# $FreeBSD$
	+
	+.PATH: ${.CURDIR}/../../fs/udf2
	+KMOD= udf2_iconv
	+SRCS= udf_iconv.c
	+
	+CFLAGS+= -I${.CURDIR}/../../
	+
	+.include <bsd.kmod.mk>

File Metadata

Mime Type: text/plain
Expires: Wed, Jun 24, 7:54 AM (6 h, 1 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 34277789
Default Alt Text: D9614.id25223.diff (476 KB)

D9614.id25223.diffNo OneTemporaryActions

D9614.id25223.diffView Options

File Metadata

Event Timeline

D9614.id25223.diff
No OneTemporary
Actions

D9614.id25223.diff
View Options