151a7b740SScott Long /*- 251a7b740SScott Long * Copyright (c) 2001, 2002 Scott Long <scottl@freebsd.org> 351a7b740SScott Long * All rights reserved. 451a7b740SScott Long * 551a7b740SScott Long * Redistribution and use in source and binary forms, with or without 651a7b740SScott Long * modification, are permitted provided that the following conditions 751a7b740SScott Long * are met: 851a7b740SScott Long * 1. Redistributions of source code must retain the above copyright 951a7b740SScott Long * notice, this list of conditions and the following disclaimer. 1051a7b740SScott Long * 2. Redistributions in binary form must reproduce the above copyright 1151a7b740SScott Long * notice, this list of conditions and the following disclaimer in the 1251a7b740SScott Long * documentation and/or other materials provided with the distribution. 1351a7b740SScott Long * 1451a7b740SScott Long * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1551a7b740SScott Long * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1651a7b740SScott Long * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1751a7b740SScott Long * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 1851a7b740SScott Long * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1951a7b740SScott Long * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2051a7b740SScott Long * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2151a7b740SScott Long * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2251a7b740SScott Long * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2351a7b740SScott Long * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2451a7b740SScott Long * SUCH DAMAGE. 2551a7b740SScott Long * 2651a7b740SScott Long * $FreeBSD$ 2751a7b740SScott Long */ 2851a7b740SScott Long 2951a7b740SScott Long /* udf_vnops.c */ 3051a7b740SScott Long /* Take care of the vnode side of things */ 3151a7b740SScott Long 3251a7b740SScott Long #include <sys/param.h> 3351a7b740SScott Long #include <sys/systm.h> 3451a7b740SScott Long #include <sys/namei.h> 3551a7b740SScott Long #include <sys/kernel.h> 3651a7b740SScott Long #include <sys/malloc.h> 3751a7b740SScott Long #include <sys/stat.h> 3851a7b740SScott Long #include <sys/bio.h> 3951a7b740SScott Long #include <sys/buf.h> 4051a7b740SScott Long #include <sys/mount.h> 4151a7b740SScott Long #include <sys/vnode.h> 4251a7b740SScott Long #include <sys/dirent.h> 4351a7b740SScott Long #include <sys/queue.h> 4451a7b740SScott Long #include <sys/unistd.h> 4551a7b740SScott Long 4651a7b740SScott Long #include <vm/uma.h> 4751a7b740SScott Long 4851a7b740SScott Long #include <fs/udf/ecma167-udf.h> 4951a7b740SScott Long #include <fs/udf/osta.h> 5051a7b740SScott Long #include <fs/udf/udf.h> 5151a7b740SScott Long 5251a7b740SScott Long static int udf_access(struct vop_access_args *); 5351a7b740SScott Long static int udf_getattr(struct vop_getattr_args *); 5451a7b740SScott Long static int udf_ioctl(struct vop_ioctl_args *); 5551a7b740SScott Long static int udf_pathconf(struct vop_pathconf_args *); 5651a7b740SScott Long static int udf_read(struct vop_read_args *); 5751a7b740SScott Long static int udf_readdir(struct vop_readdir_args *); 5851a7b740SScott Long static int udf_readlink(struct vop_readlink_args *ap); 5951a7b740SScott Long static int udf_strategy(struct vop_strategy_args *); 6051a7b740SScott Long static int udf_print(struct vop_print_args *); 6151a7b740SScott Long static int udf_bmap(struct vop_bmap_args *); 6251a7b740SScott Long static int udf_lookup(struct vop_cachedlookup_args *); 6351a7b740SScott Long static int udf_reclaim(struct vop_reclaim_args *); 6451a7b740SScott Long static void udf_dumpblock(void *, int) __unused; 65c2d6947dSJeroen Ruigrok van der Werven static int udf_readatoffset(struct udf_node *, int *, int, struct buf **, uint8_t **); 6698b0c789SPoul-Henning Kamp static int udf_bmap_internal(struct udf_node *, uint32_t, daddr_t *, uint32_t *); 6751a7b740SScott Long 6851a7b740SScott Long vop_t **udf_vnodeop_p; 6951a7b740SScott Long static struct vnodeopv_entry_desc udf_vnodeop_entries[] = { 7051a7b740SScott Long { &vop_default_desc, (vop_t *) vop_defaultop }, 7151a7b740SScott Long { &vop_access_desc, (vop_t *) udf_access }, 7251a7b740SScott Long { &vop_bmap_desc, (vop_t *) udf_bmap }, 7351a7b740SScott Long { &vop_cachedlookup_desc, (vop_t *) udf_lookup }, 7451a7b740SScott Long { &vop_getattr_desc, (vop_t *) udf_getattr }, 7551a7b740SScott Long { &vop_ioctl_desc, (vop_t *) udf_ioctl }, 7651a7b740SScott Long { &vop_lookup_desc, (vop_t *) vfs_cache_lookup }, 7751a7b740SScott Long { &vop_pathconf_desc, (vop_t *) udf_pathconf }, 7851a7b740SScott Long { &vop_print_desc, (vop_t *) udf_print }, 7951a7b740SScott Long { &vop_read_desc, (vop_t *) udf_read }, 8051a7b740SScott Long { &vop_readdir_desc, (vop_t *) udf_readdir }, 8151a7b740SScott Long { &vop_readlink_desc, (vop_t *) udf_readlink }, 8251a7b740SScott Long { &vop_reclaim_desc, (vop_t *) udf_reclaim }, 8351a7b740SScott Long { &vop_strategy_desc, (vop_t *) udf_strategy }, 8451a7b740SScott Long { NULL, NULL } 8551a7b740SScott Long }; 8651a7b740SScott Long static struct vnodeopv_desc udf_vnodeop_opv_desc = 8751a7b740SScott Long { &udf_vnodeop_p, udf_vnodeop_entries }; 8851a7b740SScott Long VNODEOP_SET(udf_vnodeop_opv_desc); 8951a7b740SScott Long 9051a7b740SScott Long MALLOC_DEFINE(M_UDFFID, "UDF FID", "UDF FileId structure"); 911703656aSScott Long MALLOC_DEFINE(M_UDFDS, "UDF DS", "UDF Dirstream structure"); 9251a7b740SScott Long 934576293dSScott Long #define UDF_INVALID_BMAP -1 948db4c2f2SScott Long 9551a7b740SScott Long /* Look up a udf_node based on the ino_t passed in and return it's vnode */ 9651a7b740SScott Long int 9751a7b740SScott Long udf_hashlookup(struct udf_mnt *udfmp, ino_t id, int flags, struct vnode **vpp) 9851a7b740SScott Long { 9951a7b740SScott Long struct udf_node *node; 10051a7b740SScott Long int error; 10151a7b740SScott Long 10251a7b740SScott Long *vpp = NULL; 10351a7b740SScott Long 10451a7b740SScott Long loop: 10551a7b740SScott Long mtx_lock(&udfmp->hash_mtx); 10651a7b740SScott Long TAILQ_FOREACH(node, &udfmp->udf_tqh, tq) { 10751a7b740SScott Long if (node->hash_id == id) { 10851a7b740SScott Long VI_LOCK(node->i_vnode); 10951a7b740SScott Long mtx_unlock(&udfmp->hash_mtx); 11051a7b740SScott Long error = vget(node->i_vnode, flags | LK_INTERLOCK, 11151a7b740SScott Long curthread); 11251a7b740SScott Long if (error == ENOENT) 11351a7b740SScott Long goto loop; 11451a7b740SScott Long if (error) 11551a7b740SScott Long return (error); 11651a7b740SScott Long *vpp = node->i_vnode; 11751a7b740SScott Long return (0); 11851a7b740SScott Long } 11951a7b740SScott Long } 12051a7b740SScott Long 12151a7b740SScott Long mtx_unlock(&udfmp->hash_mtx); 12251a7b740SScott Long return (0); 12351a7b740SScott Long } 12451a7b740SScott Long 12551a7b740SScott Long int 12651a7b740SScott Long udf_hashins(struct udf_node *node) 12751a7b740SScott Long { 12851a7b740SScott Long struct udf_mnt *udfmp; 12951a7b740SScott Long 13051a7b740SScott Long udfmp = node->udfmp; 13151a7b740SScott Long 13251a7b740SScott Long mtx_lock(&udfmp->hash_mtx); 13351a7b740SScott Long TAILQ_INSERT_TAIL(&udfmp->udf_tqh, node, tq); 13451a7b740SScott Long mtx_unlock(&udfmp->hash_mtx); 135a5b65058SKirk McKusick vn_lock(node->i_vnode, LK_EXCLUSIVE | LK_RETRY, curthread); 13651a7b740SScott Long 13751a7b740SScott Long return (0); 13851a7b740SScott Long } 13951a7b740SScott Long 14051a7b740SScott Long int 14151a7b740SScott Long udf_hashrem(struct udf_node *node) 14251a7b740SScott Long { 14351a7b740SScott Long struct udf_mnt *udfmp; 14451a7b740SScott Long 14551a7b740SScott Long udfmp = node->udfmp; 14651a7b740SScott Long 14751a7b740SScott Long mtx_lock(&udfmp->hash_mtx); 14851a7b740SScott Long TAILQ_REMOVE(&udfmp->udf_tqh, node, tq); 14951a7b740SScott Long mtx_unlock(&udfmp->hash_mtx); 15051a7b740SScott Long 15151a7b740SScott Long return (0); 15251a7b740SScott Long } 15351a7b740SScott Long 15451a7b740SScott Long int 15551a7b740SScott Long udf_allocv(struct mount *mp, struct vnode **vpp, struct thread *td) 15651a7b740SScott Long { 15751a7b740SScott Long int error; 15851a7b740SScott Long struct vnode *vp; 15951a7b740SScott Long 16006be2aaaSNate Lawson error = getnewvnode("udf", mp, udf_vnodeop_p, &vp); 16151a7b740SScott Long if (error) { 16251a7b740SScott Long printf("udf_allocv: failed to allocate new vnode\n"); 16351a7b740SScott Long return (error); 16451a7b740SScott Long } 16551a7b740SScott Long 16651a7b740SScott Long vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 16751a7b740SScott Long *vpp = vp; 16851a7b740SScott Long return (0); 16951a7b740SScott Long } 17051a7b740SScott Long 17151a7b740SScott Long /* Convert file entry permission (5 bits per owner/group/user) to a mode_t */ 17251a7b740SScott Long static mode_t 17351a7b740SScott Long udf_permtomode(struct udf_node *node) 17451a7b740SScott Long { 175c2d6947dSJeroen Ruigrok van der Werven uint32_t perm; 176c2d6947dSJeroen Ruigrok van der Werven uint32_t flags; 17751a7b740SScott Long mode_t mode; 17851a7b740SScott Long 17951a7b740SScott Long perm = node->fentry->perm; 18051a7b740SScott Long flags = node->fentry->icbtag.flags; 18151a7b740SScott Long 18251a7b740SScott Long mode = perm & UDF_FENTRY_PERM_USER_MASK; 18351a7b740SScott Long mode |= ((perm & UDF_FENTRY_PERM_GRP_MASK) >> 2); 18451a7b740SScott Long mode |= ((perm & UDF_FENTRY_PERM_OWNER_MASK) >> 4); 18551a7b740SScott Long mode |= ((flags & UDF_ICB_TAG_FLAGS_STICKY) << 4); 18651a7b740SScott Long mode |= ((flags & UDF_ICB_TAG_FLAGS_SETGID) << 6); 18751a7b740SScott Long mode |= ((flags & UDF_ICB_TAG_FLAGS_SETUID) << 8); 18851a7b740SScott Long 18951a7b740SScott Long return (mode); 19051a7b740SScott Long } 19151a7b740SScott Long 19251a7b740SScott Long static int 19351a7b740SScott Long udf_access(struct vop_access_args *a) 19451a7b740SScott Long { 19551a7b740SScott Long struct vnode *vp; 19651a7b740SScott Long struct udf_node *node; 19751a7b740SScott Long mode_t a_mode, mode; 19851a7b740SScott Long 19951a7b740SScott Long vp = a->a_vp; 20051a7b740SScott Long node = VTON(vp); 20151a7b740SScott Long a_mode = a->a_mode; 20251a7b740SScott Long 20351a7b740SScott Long if (a_mode & VWRITE) { 20451a7b740SScott Long switch (vp->v_type) { 20551a7b740SScott Long case VDIR: 20651a7b740SScott Long case VLNK: 20751a7b740SScott Long case VREG: 20851a7b740SScott Long return (EROFS); 20951a7b740SScott Long /* NOT REACHED */ 21051a7b740SScott Long default: 21151a7b740SScott Long break; 21251a7b740SScott Long } 21351a7b740SScott Long } 21451a7b740SScott Long 21551a7b740SScott Long mode = udf_permtomode(node); 21651a7b740SScott Long 21751a7b740SScott Long return (vaccess(vp->v_type, mode, node->fentry->uid, node->fentry->gid, 21851a7b740SScott Long a_mode, a->a_cred, NULL)); 21951a7b740SScott Long } 22051a7b740SScott Long 22151a7b740SScott Long static int mon_lens[2][12] = { 22251a7b740SScott Long {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, 22351a7b740SScott Long {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} 22451a7b740SScott Long }; 22551a7b740SScott Long 22651a7b740SScott Long static int 22751a7b740SScott Long udf_isaleapyear(int year) 22851a7b740SScott Long { 22951a7b740SScott Long int i; 23051a7b740SScott Long 23151a7b740SScott Long i = (year % 4) ? 0 : 1; 23251a7b740SScott Long i &= (year % 100) ? 1 : 0; 23351a7b740SScott Long i |= (year % 400) ? 0 : 1; 23451a7b740SScott Long 23551a7b740SScott Long return i; 23651a7b740SScott Long } 23751a7b740SScott Long 23851a7b740SScott Long /* 23951a7b740SScott Long * XXX This is just a rough hack. Daylight savings isn't calculated and tv_nsec 24051a7b740SScott Long * is ignored. 24151a7b740SScott Long * Timezone calculation compliments of Julian Elischer <julian@elischer.org>. 24251a7b740SScott Long */ 24351a7b740SScott Long static void 24451a7b740SScott Long udf_timetotimespec(struct timestamp *time, struct timespec *t) 24551a7b740SScott Long { 24651a7b740SScott Long int i, lpyear, daysinyear; 24751a7b740SScott Long union { 248c2d6947dSJeroen Ruigrok van der Werven uint16_t u_tz_offset; 24951a7b740SScott Long int16_t s_tz_offset; 25051a7b740SScott Long } tz; 25151a7b740SScott Long 25251a7b740SScott Long t->tv_nsec = 0; 25351a7b740SScott Long 25451a7b740SScott Long /* DirectCD seems to like using bogus year values */ 25551a7b740SScott Long if (time->year < 1970) { 25651a7b740SScott Long t->tv_sec = 0; 25751a7b740SScott Long return; 25851a7b740SScott Long } 25951a7b740SScott Long 26051a7b740SScott Long /* Calculate the time and day */ 26151a7b740SScott Long t->tv_sec = time->second; 26251a7b740SScott Long t->tv_sec += time->minute * 60; 26351a7b740SScott Long t->tv_sec += time->hour * 3600; 26451a7b740SScott Long t->tv_sec += time->day * 3600 * 24; 26551a7b740SScott Long 26651a7b740SScott Long /* Calclulate the month */ 26751a7b740SScott Long lpyear = udf_isaleapyear(time->year); 26851a7b740SScott Long for (i = 1; i < time->month; i++) 26951a7b740SScott Long t->tv_sec += mon_lens[lpyear][i] * 3600 * 24; 27051a7b740SScott Long 27151a7b740SScott Long /* Speed up the calculation */ 27251a7b740SScott Long if (time->year > 1979) 27351a7b740SScott Long t->tv_sec += 315532800; 27451a7b740SScott Long if (time->year > 1989) 27551a7b740SScott Long t->tv_sec += 315619200; 27651a7b740SScott Long if (time->year > 1999) 27751a7b740SScott Long t->tv_sec += 315532800; 27851a7b740SScott Long for (i = 2000; i < time->year; i++) { 27951a7b740SScott Long daysinyear = udf_isaleapyear(i) + 365 ; 28051a7b740SScott Long t->tv_sec += daysinyear * 3600 * 24; 28151a7b740SScott Long } 28251a7b740SScott Long 28351a7b740SScott Long /* 28451a7b740SScott Long * Calculate the time zone. The timezone is 12 bit signed 2's 28551a7b740SScott Long * compliment, so we gotta do some extra magic to handle it right. 28651a7b740SScott Long */ 28751a7b740SScott Long tz.u_tz_offset = time->type_tz; 28851a7b740SScott Long tz.u_tz_offset &= 0x0fff; 28951a7b740SScott Long if (tz.u_tz_offset & 0x0800) 29051a7b740SScott Long tz.u_tz_offset |= 0xf000; /* extend the sign to 16 bits */ 29151a7b740SScott Long if ((time->type_tz & 0x1000) && (tz.s_tz_offset != -2047)) 29251a7b740SScott Long t->tv_sec -= tz.s_tz_offset * 60; 29351a7b740SScott Long 29451a7b740SScott Long return; 29551a7b740SScott Long } 29651a7b740SScott Long 29751a7b740SScott Long static int 29851a7b740SScott Long udf_getattr(struct vop_getattr_args *a) 29951a7b740SScott Long { 30051a7b740SScott Long struct vnode *vp; 30151a7b740SScott Long struct udf_node *node; 30251a7b740SScott Long struct vattr *vap; 30351a7b740SScott Long struct file_entry *fentry; 30451a7b740SScott Long struct timespec ts; 30551a7b740SScott Long 30651a7b740SScott Long ts.tv_sec = 0; 30751a7b740SScott Long 30851a7b740SScott Long vp = a->a_vp; 30951a7b740SScott Long vap = a->a_vap; 31051a7b740SScott Long node = VTON(vp); 31151a7b740SScott Long fentry = node->fentry; 31251a7b740SScott Long 31351a7b740SScott Long vap->va_fsid = dev2udev(node->i_dev); 31451a7b740SScott Long vap->va_fileid = node->hash_id; 31551a7b740SScott Long vap->va_mode = udf_permtomode(node); 31651a7b740SScott Long vap->va_nlink = fentry->link_cnt; 31751a7b740SScott Long /* 31851a7b740SScott Long * XXX The spec says that -1 is valid for uid/gid and indicates an 31951a7b740SScott Long * invalid uid/gid. How should this be represented? 32051a7b740SScott Long */ 32151a7b740SScott Long vap->va_uid = (fentry->uid == -1) ? 0 : fentry->uid; 32251a7b740SScott Long vap->va_gid = (fentry->gid == -1) ? 0 : fentry->gid; 32351a7b740SScott Long udf_timetotimespec(&fentry->atime, &vap->va_atime); 32451a7b740SScott Long udf_timetotimespec(&fentry->mtime, &vap->va_mtime); 32551a7b740SScott Long vap->va_ctime = vap->va_mtime; /* XXX Stored as an Extended Attribute */ 32651a7b740SScott Long vap->va_rdev = 0; /* XXX */ 32751a7b740SScott Long if (vp->v_type & VDIR) { 32851a7b740SScott Long /* 32951a7b740SScott Long * Directories that are recorded within their ICB will show 33051a7b740SScott Long * as having 0 blocks recorded. Since tradition dictates 33151a7b740SScott Long * that directories consume at least one logical block, 33251a7b740SScott Long * make it appear so. 33351a7b740SScott Long */ 33451a7b740SScott Long if (fentry->logblks_rec != 0) { 33551a7b740SScott Long vap->va_size = fentry->logblks_rec * node->udfmp->bsize; 33651a7b740SScott Long } else { 33751a7b740SScott Long vap->va_size = node->udfmp->bsize; 33851a7b740SScott Long } 33951a7b740SScott Long } else { 34051a7b740SScott Long vap->va_size = fentry->inf_len; 34151a7b740SScott Long } 34251a7b740SScott Long vap->va_flags = 0; 34351a7b740SScott Long vap->va_gen = 1; 34451a7b740SScott Long vap->va_blocksize = node->udfmp->bsize; 34551a7b740SScott Long vap->va_bytes = fentry->inf_len; 34651a7b740SScott Long vap->va_type = vp->v_type; 34751a7b740SScott Long vap->va_filerev = 0; /* XXX */ 34851a7b740SScott Long return (0); 34951a7b740SScott Long } 35051a7b740SScott Long 35151a7b740SScott Long /* 35251a7b740SScott Long * File specific ioctls. DeCSS candidate? 35351a7b740SScott Long */ 35451a7b740SScott Long static int 35551a7b740SScott Long udf_ioctl(struct vop_ioctl_args *a) 35651a7b740SScott Long { 35751a7b740SScott Long printf("%s called\n", __FUNCTION__); 3581d02d910SPoul-Henning Kamp return (ENOTTY); 35951a7b740SScott Long } 36051a7b740SScott Long 36151a7b740SScott Long /* 36251a7b740SScott Long * I'm not sure that this has much value in a read-only filesystem, but 36351a7b740SScott Long * cd9660 has it too. 36451a7b740SScott Long */ 36551a7b740SScott Long static int 36651a7b740SScott Long udf_pathconf(struct vop_pathconf_args *a) 36751a7b740SScott Long { 36851a7b740SScott Long 36951a7b740SScott Long switch (a->a_name) { 37051a7b740SScott Long case _PC_LINK_MAX: 37151a7b740SScott Long *a->a_retval = 65535; 37251a7b740SScott Long return (0); 37351a7b740SScott Long case _PC_NAME_MAX: 37451a7b740SScott Long *a->a_retval = NAME_MAX; 37551a7b740SScott Long return (0); 37651a7b740SScott Long case _PC_PATH_MAX: 37751a7b740SScott Long *a->a_retval = PATH_MAX; 37851a7b740SScott Long return (0); 37951a7b740SScott Long case _PC_NO_TRUNC: 38051a7b740SScott Long *a->a_retval = 1; 38151a7b740SScott Long return (0); 38251a7b740SScott Long default: 38351a7b740SScott Long return (EINVAL); 38451a7b740SScott Long } 38551a7b740SScott Long } 38651a7b740SScott Long 38751a7b740SScott Long static int 38851a7b740SScott Long udf_read(struct vop_read_args *a) 38951a7b740SScott Long { 39051a7b740SScott Long struct vnode *vp = a->a_vp; 39151a7b740SScott Long struct uio *uio = a->a_uio; 39251a7b740SScott Long struct udf_node *node = VTON(vp); 39351a7b740SScott Long struct buf *bp; 394c2d6947dSJeroen Ruigrok van der Werven uint8_t *data; 39551a7b740SScott Long int error = 0; 396d1def83bSScott Long int size, fsize, offset; 39751a7b740SScott Long 39851a7b740SScott Long if (uio->uio_offset < 0) 39951a7b740SScott Long return (EINVAL); 40051a7b740SScott Long 40151a7b740SScott Long fsize = node->fentry->inf_len; 402d1def83bSScott Long 40351a7b740SScott Long while (uio->uio_offset < fsize && uio->uio_resid > 0) { 40451a7b740SScott Long offset = uio->uio_offset; 405d1def83bSScott Long size = uio->uio_resid; 40651a7b740SScott Long error = udf_readatoffset(node, &size, offset, &bp, &data); 40751a7b740SScott Long if (error) 40851a7b740SScott Long return (error); 409d1def83bSScott Long error = uiomove((caddr_t)data, size, uio); 41051a7b740SScott Long if (bp != NULL) 41151a7b740SScott Long brelse(bp); 41251a7b740SScott Long if (error) 41351a7b740SScott Long break; 41451a7b740SScott Long }; 41551a7b740SScott Long 41651a7b740SScott Long return (error); 41751a7b740SScott Long } 41851a7b740SScott Long 41951a7b740SScott Long /* Convienience routine to dump a block in hex */ 42051a7b740SScott Long static void 42151a7b740SScott Long udf_dumpblock(void *data, int len) 42251a7b740SScott Long { 42351a7b740SScott Long int i, j; 42451a7b740SScott Long 42551a7b740SScott Long for (i = 0; i < len; i++) { 42651a7b740SScott Long printf("\noffset= %d: ", i); 42751a7b740SScott Long for (j = 0; j < 8; j++) { 42851a7b740SScott Long if (i + j == len) 42951a7b740SScott Long break; 430c2d6947dSJeroen Ruigrok van der Werven printf("0x%02x ", (uint8_t)((uint8_t*)(data))[i + j]); 43151a7b740SScott Long } 43251a7b740SScott Long i += j - 1; 43351a7b740SScott Long } 43451a7b740SScott Long printf("\n"); 43551a7b740SScott Long } 43651a7b740SScott Long 43751a7b740SScott Long /* 43851a7b740SScott Long * Call the OSTA routines to translate the name from a CS0 dstring to a 43951a7b740SScott Long * 16-bit Unicode String. Hooks need to be placed in here to translate from 44051a7b740SScott Long * Unicode to the encoding that the kernel/user expects. For now, compact 44151a7b740SScott Long * the encoding to 8 bits if possible. Return the length of the translated 44251a7b740SScott Long * string. 44351a7b740SScott Long * XXX This horribly pessimizes the 8bit case 44451a7b740SScott Long */ 44551a7b740SScott Long static int 44651a7b740SScott Long udf_transname(char *cs0string, char *destname, int len) 44751a7b740SScott Long { 44851a7b740SScott Long unicode_t *transname; 44951a7b740SScott Long int i, unilen = 0; 45051a7b740SScott Long 45151a7b740SScott Long /* allocate a buffer big enough to hold an 8->16 bit expansion */ 452a163d034SWarner Losh transname = uma_zalloc(udf_zone_trans, M_WAITOK); 45351a7b740SScott Long 45451a7b740SScott Long if ((unilen = udf_UncompressUnicode(len, cs0string, transname)) == -1) { 45551a7b740SScott Long printf("udf: Unicode translation failed\n"); 45651a7b740SScott Long uma_zfree(udf_zone_trans, transname); 45751a7b740SScott Long return 0; 45851a7b740SScott Long } 45951a7b740SScott Long 46051a7b740SScott Long /* At this point, the name is in 16-bit Unicode. Compact it down 46151a7b740SScott Long * to 8-bit 46251a7b740SScott Long */ 46351a7b740SScott Long for (i = 0; i < unilen ; i++) { 46451a7b740SScott Long if (transname[i] & 0xff00) { 46551a7b740SScott Long destname[i] = '.'; /* Fudge the 16bit chars */ 46651a7b740SScott Long } else { 46751a7b740SScott Long destname[i] = transname[i] & 0xff; 46851a7b740SScott Long } 46951a7b740SScott Long } 47051a7b740SScott Long 47151a7b740SScott Long destname[unilen] = 0; 47251a7b740SScott Long uma_zfree(udf_zone_trans, transname); 47351a7b740SScott Long 47451a7b740SScott Long return unilen; 47551a7b740SScott Long } 47651a7b740SScott Long 47751a7b740SScott Long /* 47851a7b740SScott Long * Compare a CS0 dstring with a name passed in from the VFS layer. Return 47951a7b740SScott Long * 0 on a successful match, nonzero therwise. Unicode work may need to be done 48051a7b740SScott Long * here also. 48151a7b740SScott Long */ 48251a7b740SScott Long static int 48351a7b740SScott Long udf_cmpname(char *cs0string, char *cmpname, int cs0len, int cmplen) 48451a7b740SScott Long { 48595ec5961SScott Long char *transname; 48695ec5961SScott Long int error = 0; 48751a7b740SScott Long 48895ec5961SScott Long /* This is overkill, but not worth creating a new zone */ 489a163d034SWarner Losh transname = uma_zalloc(udf_zone_trans, M_WAITOK); 49095ec5961SScott Long 49195ec5961SScott Long cs0len = udf_transname(cs0string, transname, cs0len); 49251a7b740SScott Long 49351a7b740SScott Long /* Easy check. If they aren't the same length, they aren't equal */ 49495ec5961SScott Long if ((cs0len == 0) || (cs0len != cmplen)) 49595ec5961SScott Long error = -1; 49695ec5961SScott Long else 49795ec5961SScott Long error = bcmp(transname, cmpname, cmplen); 49851a7b740SScott Long 49995ec5961SScott Long uma_zfree(udf_zone_trans, transname); 50095ec5961SScott Long return (error); 50151a7b740SScott Long } 50251a7b740SScott Long 50351a7b740SScott Long struct udf_uiodir { 50451a7b740SScott Long struct dirent *dirent; 50551a7b740SScott Long u_long *cookies; 50651a7b740SScott Long int ncookies; 50751a7b740SScott Long int acookies; 50851a7b740SScott Long int eofflag; 50951a7b740SScott Long }; 51051a7b740SScott Long 51151a7b740SScott Long static int 51251a7b740SScott Long udf_uiodir(struct udf_uiodir *uiodir, int de_size, struct uio *uio, long cookie) 51351a7b740SScott Long { 51451a7b740SScott Long if (uiodir->cookies != NULL) { 51551a7b740SScott Long if (++uiodir->acookies > uiodir->ncookies) { 51651a7b740SScott Long uiodir->eofflag = 0; 51751a7b740SScott Long return (-1); 51851a7b740SScott Long } 51951a7b740SScott Long *uiodir->cookies++ = cookie; 52051a7b740SScott Long } 52151a7b740SScott Long 52251a7b740SScott Long if (uio->uio_resid < de_size) { 52351a7b740SScott Long uiodir->eofflag = 0; 52451a7b740SScott Long return (-1); 52551a7b740SScott Long } 52651a7b740SScott Long 52751a7b740SScott Long return (uiomove((caddr_t)uiodir->dirent, de_size, uio)); 52851a7b740SScott Long } 52951a7b740SScott Long 5301703656aSScott Long static struct udf_dirstream * 5311703656aSScott Long udf_opendir(struct udf_node *node, int offset, int fsize, struct udf_mnt *udfmp) 5321703656aSScott Long { 5331703656aSScott Long struct udf_dirstream *ds; 5341703656aSScott Long 535a163d034SWarner Losh ds = uma_zalloc(udf_zone_ds, M_WAITOK | M_ZERO); 5361703656aSScott Long 5371703656aSScott Long ds->node = node; 5381703656aSScott Long ds->offset = offset; 5391703656aSScott Long ds->udfmp = udfmp; 5401703656aSScott Long ds->fsize = fsize; 5411703656aSScott Long 5421703656aSScott Long return (ds); 5431703656aSScott Long } 5441703656aSScott Long 5451703656aSScott Long static struct fileid_desc * 5461703656aSScott Long udf_getfid(struct udf_dirstream *ds) 5471703656aSScott Long { 5481703656aSScott Long struct fileid_desc *fid; 5491703656aSScott Long int error, frag_size = 0, total_fid_size; 5501703656aSScott Long 5511703656aSScott Long /* End of directory? */ 5521703656aSScott Long if (ds->offset + ds->off >= ds->fsize) { 5531703656aSScott Long ds->error = 0; 5541703656aSScott Long return (NULL); 5551703656aSScott Long } 5561703656aSScott Long 5571703656aSScott Long /* Grab the first extent of the directory */ 5581703656aSScott Long if (ds->off == 0) { 5591703656aSScott Long ds->size = 0; 5601703656aSScott Long error = udf_readatoffset(ds->node, &ds->size, ds->offset, 5611703656aSScott Long &ds->bp, &ds->data); 5621703656aSScott Long if (error) { 5631703656aSScott Long ds->error = error; 5641703656aSScott Long return (NULL); 5651703656aSScott Long } 5661703656aSScott Long } 5671703656aSScott Long 5684576293dSScott Long /* 5694576293dSScott Long * Clean up from a previous fragmented FID. 5704576293dSScott Long * XXX Is this the right place for this? 5714576293dSScott Long */ 5721703656aSScott Long if (ds->fid_fragment && ds->buf != NULL) { 5731703656aSScott Long ds->fid_fragment = 0; 5741703656aSScott Long FREE(ds->buf, M_UDFFID); 5751703656aSScott Long } 5761703656aSScott Long 5771703656aSScott Long fid = (struct fileid_desc*)&ds->data[ds->off]; 5781703656aSScott Long 5791703656aSScott Long /* 5801703656aSScott Long * Check to see if the fid is fragmented. The first test 5811703656aSScott Long * ensures that we don't wander off the end of the buffer 5821703656aSScott Long * looking for the l_iu and l_fi fields. 5831703656aSScott Long */ 5841703656aSScott Long if (ds->off + UDF_FID_SIZE > ds->size || 5851703656aSScott Long ds->off + fid->l_iu + fid->l_fi + UDF_FID_SIZE > ds->size) { 5861703656aSScott Long 5871703656aSScott Long /* Copy what we have of the fid into a buffer */ 5881703656aSScott Long frag_size = ds->size - ds->off; 5891703656aSScott Long if (frag_size >= ds->udfmp->bsize) { 5901703656aSScott Long printf("udf: invalid FID fragment\n"); 5911703656aSScott Long ds->error = EINVAL; 5921703656aSScott Long return (NULL); 5931703656aSScott Long } 5941703656aSScott Long 5951703656aSScott Long /* 5961703656aSScott Long * File ID descriptors can only be at most one 5971703656aSScott Long * logical sector in size. 5981703656aSScott Long */ 5991703656aSScott Long MALLOC(ds->buf, uint8_t*, ds->udfmp->bsize, M_UDFFID, 600a163d034SWarner Losh M_WAITOK | M_ZERO); 6011703656aSScott Long bcopy(fid, ds->buf, frag_size); 6021703656aSScott Long 6031703656aSScott Long /* Reduce all of the casting magic */ 6041703656aSScott Long fid = (struct fileid_desc*)ds->buf; 6051703656aSScott Long 6061703656aSScott Long if (ds->bp != NULL) 6071703656aSScott Long brelse(ds->bp); 6081703656aSScott Long 6091703656aSScott Long /* Fetch the next allocation */ 6101703656aSScott Long ds->offset += ds->size; 6111703656aSScott Long ds->size = 0; 6121703656aSScott Long error = udf_readatoffset(ds->node, &ds->size, ds->offset, 6131703656aSScott Long &ds->bp, &ds->data); 6141703656aSScott Long if (error) { 6151703656aSScott Long ds->error = error; 6161703656aSScott Long return (NULL); 6171703656aSScott Long } 6181703656aSScott Long 6191703656aSScott Long /* 6201703656aSScott Long * If the fragment was so small that we didn't get 6211703656aSScott Long * the l_iu and l_fi fields, copy those in. 6221703656aSScott Long */ 6231703656aSScott Long if (frag_size < UDF_FID_SIZE) 6241703656aSScott Long bcopy(ds->data, &ds->buf[frag_size], 6251703656aSScott Long UDF_FID_SIZE - frag_size); 6261703656aSScott Long 6271703656aSScott Long /* 6281703656aSScott Long * Now that we have enough of the fid to work with, 6291703656aSScott Long * copy in the rest of the fid from the new 6301703656aSScott Long * allocation. 6311703656aSScott Long */ 6321703656aSScott Long total_fid_size = UDF_FID_SIZE + fid->l_iu + fid->l_fi; 6331703656aSScott Long if (total_fid_size > ds->udfmp->bsize) { 6341703656aSScott Long printf("udf: invalid FID\n"); 6351703656aSScott Long ds->error = EIO; 6361703656aSScott Long return (NULL); 6371703656aSScott Long } 6381703656aSScott Long bcopy(ds->data, &ds->buf[frag_size], 6391703656aSScott Long total_fid_size - frag_size); 6401703656aSScott Long 6411703656aSScott Long ds->fid_fragment = 1; 6421703656aSScott Long } else { 6431703656aSScott Long total_fid_size = fid->l_iu + fid->l_fi + UDF_FID_SIZE; 6441703656aSScott Long } 6451703656aSScott Long 6461703656aSScott Long /* 6471703656aSScott Long * Update the offset. Align on a 4 byte boundary because the 6484576293dSScott Long * UDF spec says so. 6491703656aSScott Long */ 6501703656aSScott Long ds->this_off = ds->off; 6511703656aSScott Long if (!ds->fid_fragment) { 6521703656aSScott Long ds->off += (total_fid_size + 3) & ~0x03; 6531703656aSScott Long } else { 6541703656aSScott Long ds->off = (total_fid_size - frag_size + 3) & ~0x03; 6551703656aSScott Long } 6561703656aSScott Long 6571703656aSScott Long return (fid); 6581703656aSScott Long } 6591703656aSScott Long 6601703656aSScott Long static void 6611703656aSScott Long udf_closedir(struct udf_dirstream *ds) 6621703656aSScott Long { 6631703656aSScott Long 6641703656aSScott Long if (ds->bp != NULL) 6651703656aSScott Long brelse(ds->bp); 6661703656aSScott Long 6671703656aSScott Long if (ds->fid_fragment && ds->buf != NULL) 6681703656aSScott Long FREE(ds->buf, M_UDFFID); 6691703656aSScott Long 6701703656aSScott Long uma_zfree(udf_zone_ds, ds); 6711703656aSScott Long } 6721703656aSScott Long 67351a7b740SScott Long static int 67451a7b740SScott Long udf_readdir(struct vop_readdir_args *a) 67551a7b740SScott Long { 67651a7b740SScott Long struct vnode *vp; 67751a7b740SScott Long struct uio *uio; 67851a7b740SScott Long struct dirent dir; 67951a7b740SScott Long struct udf_node *node; 68051a7b740SScott Long struct fileid_desc *fid; 68151a7b740SScott Long struct udf_uiodir uiodir; 6821703656aSScott Long struct udf_dirstream *ds; 68351a7b740SScott Long u_long *cookies = NULL; 68451a7b740SScott Long int ncookies; 685c8eeea2fSScott Long int error = 0; 68651a7b740SScott Long 68751a7b740SScott Long vp = a->a_vp; 68851a7b740SScott Long uio = a->a_uio; 68951a7b740SScott Long node = VTON(vp); 69051a7b740SScott Long uiodir.eofflag = 1; 69151a7b740SScott Long 69251a7b740SScott Long if (a->a_ncookies != NULL) { 69351a7b740SScott Long /* 69451a7b740SScott Long * Guess how many entries are needed. If we run out, this 69551a7b740SScott Long * function will be called again and thing will pick up were 69651a7b740SScott Long * it left off. 69751a7b740SScott Long */ 69851a7b740SScott Long ncookies = uio->uio_resid / 8; 69951a7b740SScott Long MALLOC(cookies, u_long *, sizeof(u_long) * ncookies, 700a163d034SWarner Losh M_TEMP, M_WAITOK); 70151a7b740SScott Long if (cookies == NULL) 70251a7b740SScott Long return (ENOMEM); 70351a7b740SScott Long uiodir.ncookies = ncookies; 70451a7b740SScott Long uiodir.cookies = cookies; 70551a7b740SScott Long uiodir.acookies = 0; 70651a7b740SScott Long } else { 70751a7b740SScott Long uiodir.cookies = NULL; 70851a7b740SScott Long } 70951a7b740SScott Long 71051a7b740SScott Long /* 71151a7b740SScott Long * Iterate through the file id descriptors. Give the parent dir 7124576293dSScott Long * entry special attention. 71351a7b740SScott Long */ 7141703656aSScott Long ds = udf_opendir(node, uio->uio_offset, node->fentry->inf_len, 7151703656aSScott Long node->udfmp); 71651a7b740SScott Long 7171703656aSScott Long while ((fid = udf_getfid(ds)) != NULL) { 71851a7b740SScott Long 71951a7b740SScott Long /* XXX Should we return an error on a bad fid? */ 72051a7b740SScott Long if (udf_checktag(&fid->tag, TAGID_FID)) { 72151a7b740SScott Long printf("Invalid FID tag\n"); 7221703656aSScott Long udf_dumpblock(fid, UDF_FID_SIZE); 7231703656aSScott Long error = EIO; 72451a7b740SScott Long break; 72551a7b740SScott Long } 72651a7b740SScott Long 72751a7b740SScott Long /* Is this a deleted file? */ 7282bbe0d36SScott Long if (fid->file_char & UDF_FILE_CHAR_DEL) 7291703656aSScott Long continue; 73051a7b740SScott Long 7312bbe0d36SScott Long if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) { 73251a7b740SScott Long /* Do up the '.' and '..' entries. Dummy values are 73351a7b740SScott Long * used for the cookies since the offset here is 73451a7b740SScott Long * usually zero, and NFS doesn't like that value 73551a7b740SScott Long */ 736c8eeea2fSScott Long dir.d_fileno = node->hash_id; 737c8eeea2fSScott Long dir.d_type = DT_DIR; 738c8eeea2fSScott Long dir.d_name[0] = '.'; 739c8eeea2fSScott Long dir.d_namlen = 1; 740c8eeea2fSScott Long dir.d_reclen = GENERIC_DIRSIZ(&dir); 741c8eeea2fSScott Long uiodir.dirent = &dir; 742c8eeea2fSScott Long error = udf_uiodir(&uiodir, dir.d_reclen, uio, 1); 74351a7b740SScott Long if (error) 74451a7b740SScott Long break; 74551a7b740SScott Long 746c8eeea2fSScott Long dir.d_fileno = udf_getid(&fid->icb); 747c8eeea2fSScott Long dir.d_type = DT_DIR; 748c8eeea2fSScott Long dir.d_name[0] = '.'; 749c8eeea2fSScott Long dir.d_name[1] = '.'; 750c8eeea2fSScott Long dir.d_namlen = 2; 751c8eeea2fSScott Long dir.d_reclen = GENERIC_DIRSIZ(&dir); 752c8eeea2fSScott Long uiodir.dirent = &dir; 753c8eeea2fSScott Long error = udf_uiodir(&uiodir, dir.d_reclen, uio, 2); 75451a7b740SScott Long } else { 75551a7b740SScott Long dir.d_namlen = udf_transname(&fid->data[fid->l_iu], 75651a7b740SScott Long &dir.d_name[0], fid->l_fi); 75751a7b740SScott Long dir.d_fileno = udf_getid(&fid->icb); 7582bbe0d36SScott Long dir.d_type = (fid->file_char & UDF_FILE_CHAR_DIR) ? 7592bbe0d36SScott Long DT_DIR : DT_UNKNOWN; 76051a7b740SScott Long dir.d_reclen = GENERIC_DIRSIZ(&dir); 76151a7b740SScott Long uiodir.dirent = &dir; 7621703656aSScott Long error = udf_uiodir(&uiodir, dir.d_reclen, uio, 7631703656aSScott Long ds->this_off); 76451a7b740SScott Long } 76551a7b740SScott Long if (error) { 76651a7b740SScott Long printf("uiomove returned %d\n", error); 76751a7b740SScott Long break; 76851a7b740SScott Long } 76951a7b740SScott Long 77051a7b740SScott Long } 77151a7b740SScott Long 77251a7b740SScott Long /* tell the calling layer whether we need to be called again */ 77351a7b740SScott Long *a->a_eofflag = uiodir.eofflag; 7741703656aSScott Long uio->uio_offset = ds->offset + ds->off; 77551a7b740SScott Long 7761703656aSScott Long if (!error) 7771703656aSScott Long error = ds->error; 7781703656aSScott Long 7791703656aSScott Long udf_closedir(ds); 78051a7b740SScott Long 78151a7b740SScott Long if (a->a_ncookies != NULL) { 78251a7b740SScott Long if (error) 7831703656aSScott Long FREE(cookies, M_TEMP); 78451a7b740SScott Long else { 78551a7b740SScott Long *a->a_ncookies = uiodir.acookies; 78651a7b740SScott Long *a->a_cookies = cookies; 78751a7b740SScott Long } 78851a7b740SScott Long } 78951a7b740SScott Long 79051a7b740SScott Long return (error); 79151a7b740SScott Long } 79251a7b740SScott Long 79351a7b740SScott Long /* Are there any implementations out there that do soft-links? */ 79451a7b740SScott Long static int 79551a7b740SScott Long udf_readlink(struct vop_readlink_args *ap) 79651a7b740SScott Long { 79751a7b740SScott Long printf("%s called\n", __FUNCTION__); 79851a7b740SScott Long return (EOPNOTSUPP); 79951a7b740SScott Long } 80051a7b740SScott Long 80151a7b740SScott Long static int 80251a7b740SScott Long udf_strategy(struct vop_strategy_args *a) 80351a7b740SScott Long { 80451a7b740SScott Long struct buf *bp; 80551a7b740SScott Long struct vnode *vp; 80651a7b740SScott Long struct udf_node *node; 80751a7b740SScott Long int maxsize; 80851a7b740SScott Long 80951a7b740SScott Long bp = a->a_bp; 81051a7b740SScott Long vp = bp->b_vp; 81151a7b740SScott Long node = VTON(vp); 81251a7b740SScott Long 81351a7b740SScott Long /* cd9660 has this test reversed, but it seems more logical this way */ 81451a7b740SScott Long if (bp->b_blkno != bp->b_lblkno) { 81551a7b740SScott Long /* 81651a7b740SScott Long * Files that are embedded in the fentry don't translate well 81751a7b740SScott Long * to a block number. Reject. 81851a7b740SScott Long */ 81951a7b740SScott Long if (udf_bmap_internal(node, bp->b_lblkno * node->udfmp->bsize, 82051a7b740SScott Long &bp->b_lblkno, &maxsize)) { 82151a7b740SScott Long clrbuf(bp); 82251a7b740SScott Long bp->b_blkno = -1; 82351a7b740SScott Long } 82451a7b740SScott Long } 82551a7b740SScott Long if ((long)bp->b_blkno == -1) { 82651a7b740SScott Long bufdone(bp); 82751a7b740SScott Long return (0); 82851a7b740SScott Long } 82951a7b740SScott Long vp = node->i_devvp; 83051a7b740SScott Long bp->b_dev = vp->v_rdev; 831f5b11b6eSPoul-Henning Kamp VOP_SPECSTRATEGY(vp, bp); 83251a7b740SScott Long return (0); 83351a7b740SScott Long } 83451a7b740SScott Long 83551a7b740SScott Long static int 83651a7b740SScott Long udf_print(struct vop_print_args *a) 83751a7b740SScott Long { 83851a7b740SScott Long printf("%s called\n", __FUNCTION__); 83951a7b740SScott Long return (EOPNOTSUPP); 84051a7b740SScott Long } 84151a7b740SScott Long 84251a7b740SScott Long static int 84351a7b740SScott Long udf_bmap(struct vop_bmap_args *a) 84451a7b740SScott Long { 84551a7b740SScott Long struct udf_node *node; 846c2d6947dSJeroen Ruigrok van der Werven uint32_t max_size; 84798b0c789SPoul-Henning Kamp daddr_t lsector; 84851a7b740SScott Long int error; 84951a7b740SScott Long 85051a7b740SScott Long node = VTON(a->a_vp); 85151a7b740SScott Long 85251a7b740SScott Long if (a->a_vpp != NULL) 85351a7b740SScott Long *a->a_vpp = node->i_devvp; 85451a7b740SScott Long if (a->a_bnp == NULL) 85551a7b740SScott Long return (0); 85651a7b740SScott Long if (a->a_runb) 85751a7b740SScott Long *a->a_runb = 0; 85851a7b740SScott Long 859cd1b1a1dSScott Long error = udf_bmap_internal(node, a->a_bn * node->udfmp->bsize, &lsector, 86051a7b740SScott Long &max_size); 8618db4c2f2SScott Long if (error) 86251a7b740SScott Long return (error); 86351a7b740SScott Long 864cd1b1a1dSScott Long /* Translate logical to physical sector number */ 865cd1b1a1dSScott Long *a->a_bnp = lsector << (node->udfmp->bshift - DEV_BSHIFT); 866cd1b1a1dSScott Long 86751a7b740SScott Long /* Punt on read-ahead for now */ 86851a7b740SScott Long if (a->a_runp) 86951a7b740SScott Long *a->a_runp = 0; 87051a7b740SScott Long 87151a7b740SScott Long return (0); 87251a7b740SScott Long } 87351a7b740SScott Long 87451a7b740SScott Long /* 87551a7b740SScott Long * The all powerful VOP_LOOKUP(). 87651a7b740SScott Long */ 87751a7b740SScott Long static int 87851a7b740SScott Long udf_lookup(struct vop_cachedlookup_args *a) 87951a7b740SScott Long { 88051a7b740SScott Long struct vnode *dvp; 88151a7b740SScott Long struct vnode *tdp = NULL; 88251a7b740SScott Long struct vnode **vpp = a->a_vpp; 88351a7b740SScott Long struct udf_node *node; 88451a7b740SScott Long struct udf_mnt *udfmp; 88551a7b740SScott Long struct fileid_desc *fid = NULL; 8861703656aSScott Long struct udf_dirstream *ds; 88751a7b740SScott Long struct thread *td; 88851a7b740SScott Long u_long nameiop; 88951a7b740SScott Long u_long flags; 89051a7b740SScott Long char *nameptr; 89151a7b740SScott Long long namelen; 89251a7b740SScott Long ino_t id = 0; 8931703656aSScott Long int offset, error = 0; 8941703656aSScott Long int numdirpasses, fsize; 89551a7b740SScott Long 89651a7b740SScott Long dvp = a->a_dvp; 89751a7b740SScott Long node = VTON(dvp); 89851a7b740SScott Long udfmp = node->udfmp; 89951a7b740SScott Long nameiop = a->a_cnp->cn_nameiop; 90051a7b740SScott Long flags = a->a_cnp->cn_flags; 90151a7b740SScott Long nameptr = a->a_cnp->cn_nameptr; 90251a7b740SScott Long namelen = a->a_cnp->cn_namelen; 90351a7b740SScott Long fsize = node->fentry->inf_len; 90451a7b740SScott Long td = a->a_cnp->cn_thread; 90551a7b740SScott Long 90651a7b740SScott Long /* 90751a7b740SScott Long * If this is a LOOKUP and we've already partially searched through 90851a7b740SScott Long * the directory, pick up where we left off and flag that the 90951a7b740SScott Long * directory may need to be searched twice. For a full description, 91051a7b740SScott Long * see /sys/isofs/cd9660/cd9660_lookup.c:cd9660_lookup() 91151a7b740SScott Long */ 9121703656aSScott Long if (nameiop != LOOKUP || node->diroff == 0 || node->diroff > fsize) { 91351a7b740SScott Long offset = 0; 91451a7b740SScott Long numdirpasses = 1; 91551a7b740SScott Long } else { 91651a7b740SScott Long offset = node->diroff; 91751a7b740SScott Long numdirpasses = 2; 91851a7b740SScott Long nchstats.ncs_2passes++; 91951a7b740SScott Long } 92051a7b740SScott Long 92151a7b740SScott Long lookloop: 9221703656aSScott Long ds = udf_opendir(node, offset, fsize, udfmp); 92351a7b740SScott Long 9241703656aSScott Long while ((fid = udf_getfid(ds)) != NULL) { 92551a7b740SScott Long 92651a7b740SScott Long /* XXX Should we return an error on a bad fid? */ 9271703656aSScott Long if (udf_checktag(&fid->tag, TAGID_FID)) { 9281703656aSScott Long printf("udf_lookup: Invalid tag\n"); 9291703656aSScott Long error = EIO; 9301703656aSScott Long break; 9311703656aSScott Long } 932678d5effSScott Long 933678d5effSScott Long /* Is this a deleted file? */ 9342bbe0d36SScott Long if (fid->file_char & UDF_FILE_CHAR_DEL) 9351703656aSScott Long continue; 93651a7b740SScott Long 9372bbe0d36SScott Long if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) { 93851a7b740SScott Long if (flags & ISDOTDOT) { 93951a7b740SScott Long id = udf_getid(&fid->icb); 94051a7b740SScott Long break; 94151a7b740SScott Long } 94251a7b740SScott Long } else { 94351a7b740SScott Long if (!(udf_cmpname(&fid->data[fid->l_iu], 94451a7b740SScott Long nameptr, fid->l_fi, namelen))) { 94551a7b740SScott Long id = udf_getid(&fid->icb); 94651a7b740SScott Long break; 94751a7b740SScott Long } 94851a7b740SScott Long } 94951a7b740SScott Long } 9501703656aSScott Long 9511703656aSScott Long if (!error) 9521703656aSScott Long error = ds->error; 9531703656aSScott Long 9541703656aSScott Long /* XXX Bail out here? */ 9551703656aSScott Long if (error) { 9561703656aSScott Long udf_closedir(ds); 9571703656aSScott Long return (error); 95851a7b740SScott Long } 95951a7b740SScott Long 96051a7b740SScott Long /* Did we have a match? */ 96151a7b740SScott Long if (id) { 96251a7b740SScott Long error = udf_vget(udfmp->im_mountp, id, LK_EXCLUSIVE, &tdp); 9631703656aSScott Long if (!error) { 9641703656aSScott Long /* 9651703656aSScott Long * Remember where this entry was if it's the final 9661703656aSScott Long * component. 9671703656aSScott Long */ 96851a7b740SScott Long if ((flags & ISLASTCN) && nameiop == LOOKUP) 9691703656aSScott Long node->diroff = ds->offset + ds->off; 97051a7b740SScott Long if (numdirpasses == 2) 97151a7b740SScott Long nchstats.ncs_pass2++; 97251a7b740SScott Long if (!(flags & LOCKPARENT) || !(flags & ISLASTCN)) { 97351a7b740SScott Long a->a_cnp->cn_flags |= PDIRUNLOCK; 97451a7b740SScott Long VOP_UNLOCK(dvp, 0, td); 97551a7b740SScott Long } 97651a7b740SScott Long 97751a7b740SScott Long *vpp = tdp; 97851a7b740SScott Long 97951a7b740SScott Long /* Put this entry in the cache */ 98051a7b740SScott Long if (flags & MAKEENTRY) 98151a7b740SScott Long cache_enter(dvp, *vpp, a->a_cnp); 98251a7b740SScott Long } 9831703656aSScott Long } else { 98451a7b740SScott Long /* Name wasn't found on this pass. Do another pass? */ 98551a7b740SScott Long if (numdirpasses == 2) { 98651a7b740SScott Long numdirpasses--; 98751a7b740SScott Long offset = 0; 9881703656aSScott Long udf_closedir(ds); 98951a7b740SScott Long goto lookloop; 99051a7b740SScott Long } 99151a7b740SScott Long 99251a7b740SScott Long /* Enter name into cache as non-existant */ 99351a7b740SScott Long if (flags & MAKEENTRY) 99451a7b740SScott Long cache_enter(dvp, *vpp, a->a_cnp); 99551a7b740SScott Long 9961703656aSScott Long if ((flags & ISLASTCN) && 9971703656aSScott Long (nameiop == CREATE || nameiop == RENAME)) { 9981703656aSScott Long error = EROFS; 9991703656aSScott Long } else { 10001703656aSScott Long error = ENOENT; 10011703656aSScott Long } 10021703656aSScott Long } 100351a7b740SScott Long 10041703656aSScott Long udf_closedir(ds); 10051703656aSScott Long return (error); 100651a7b740SScott Long } 100751a7b740SScott Long 100851a7b740SScott Long static int 100951a7b740SScott Long udf_reclaim(struct vop_reclaim_args *a) 101051a7b740SScott Long { 101151a7b740SScott Long struct vnode *vp; 101251a7b740SScott Long struct udf_node *unode; 101351a7b740SScott Long 101451a7b740SScott Long vp = a->a_vp; 101551a7b740SScott Long unode = VTON(vp); 101651a7b740SScott Long 101751a7b740SScott Long cache_purge(vp); 101851a7b740SScott Long if (unode != NULL) { 101951a7b740SScott Long udf_hashrem(unode); 102051a7b740SScott Long if (unode->i_devvp) { 102151a7b740SScott Long vrele(unode->i_devvp); 102251a7b740SScott Long unode->i_devvp = 0; 102351a7b740SScott Long } 102451a7b740SScott Long 102551a7b740SScott Long if (unode->fentry != NULL) 102651a7b740SScott Long FREE(unode->fentry, M_UDFFENTRY); 102751a7b740SScott Long uma_zfree(udf_zone_node, unode); 102851a7b740SScott Long vp->v_data = NULL; 102951a7b740SScott Long } 103051a7b740SScott Long 103151a7b740SScott Long return (0); 103251a7b740SScott Long } 103351a7b740SScott Long 103451a7b740SScott Long /* 103551a7b740SScott Long * Read the block and then set the data pointer to correspond with the 103651a7b740SScott Long * offset passed in. Only read in at most 'size' bytes, and then set 'size' 103751a7b740SScott Long * to the number of bytes pointed to. If 'size' is zero, try to read in a 103851a7b740SScott Long * whole extent. 103951a7b740SScott Long * XXX 'size' is limited to the logical block size for now due to problems 104051a7b740SScott Long * with udf_read() 104151a7b740SScott Long */ 104251a7b740SScott Long static int 1043c2d6947dSJeroen Ruigrok van der Werven udf_readatoffset(struct udf_node *node, int *size, int offset, struct buf **bp, uint8_t **data) 104451a7b740SScott Long { 104551a7b740SScott Long struct udf_mnt *udfmp; 104651a7b740SScott Long struct file_entry *fentry = NULL; 104751a7b740SScott Long struct buf *bp1; 1048c2d6947dSJeroen Ruigrok van der Werven uint32_t max_size; 104998b0c789SPoul-Henning Kamp daddr_t sector; 105051a7b740SScott Long int error; 105151a7b740SScott Long 105251a7b740SScott Long udfmp = node->udfmp; 105351a7b740SScott Long 105451a7b740SScott Long error = udf_bmap_internal(node, offset, §or, &max_size); 10554576293dSScott Long if (error == UDF_INVALID_BMAP) { 105651a7b740SScott Long /* 105751a7b740SScott Long * This error means that the file *data* is stored in the 105851a7b740SScott Long * allocation descriptor field of the file entry. 105951a7b740SScott Long */ 106051a7b740SScott Long fentry = node->fentry; 106151a7b740SScott Long *data = &fentry->data[fentry->l_ea]; 106251a7b740SScott Long *size = fentry->l_ad; 106351a7b740SScott Long *bp = NULL; 106451a7b740SScott Long return (0); 106551a7b740SScott Long } else if (error != 0) { 106651a7b740SScott Long return (error); 106751a7b740SScott Long } 106851a7b740SScott Long 1069d1def83bSScott Long /* Adjust the size so that it is within range */ 107051a7b740SScott Long if (*size == 0 || *size > max_size) 107151a7b740SScott Long *size = max_size; 1072d1def83bSScott Long *size = min(*size, MAXBSIZE); 107351a7b740SScott Long 107451a7b740SScott Long if ((error = udf_readlblks(udfmp, sector, *size, bp))) { 107551a7b740SScott Long printf("udf_readlblks returned %d\n", error); 107651a7b740SScott Long return (error); 107751a7b740SScott Long } 107851a7b740SScott Long 107951a7b740SScott Long bp1 = *bp; 1080c2d6947dSJeroen Ruigrok van der Werven *data = (uint8_t *)&bp1->b_data[offset % udfmp->bsize]; 108151a7b740SScott Long return (0); 108251a7b740SScott Long } 108351a7b740SScott Long 108451a7b740SScott Long /* 108551a7b740SScott Long * Translate a file offset into a logical block and then into a physical 108651a7b740SScott Long * block. 108751a7b740SScott Long */ 108851a7b740SScott Long static int 108998b0c789SPoul-Henning Kamp udf_bmap_internal(struct udf_node *node, uint32_t offset, daddr_t *sector, uint32_t *max_size) 109051a7b740SScott Long { 109151a7b740SScott Long struct udf_mnt *udfmp; 109251a7b740SScott Long struct file_entry *fentry; 109351a7b740SScott Long void *icb; 109451a7b740SScott Long struct icb_tag *tag; 1095c2d6947dSJeroen Ruigrok van der Werven uint32_t icblen = 0; 109698b0c789SPoul-Henning Kamp daddr_t lsector; 109751a7b740SScott Long int ad_offset, ad_num = 0; 109851a7b740SScott Long int i, p_offset; 109951a7b740SScott Long 110051a7b740SScott Long udfmp = node->udfmp; 110151a7b740SScott Long fentry = node->fentry; 110251a7b740SScott Long tag = &fentry->icbtag; 110351a7b740SScott Long 110451a7b740SScott Long switch (tag->strat_type) { 110551a7b740SScott Long case 4: 110651a7b740SScott Long break; 110751a7b740SScott Long 110851a7b740SScott Long case 4096: 110951a7b740SScott Long printf("Cannot deal with strategy4096 yet!\n"); 111051a7b740SScott Long return (ENODEV); 111151a7b740SScott Long 111251a7b740SScott Long default: 111351a7b740SScott Long printf("Unknown strategy type %d\n", tag->strat_type); 111451a7b740SScott Long return (ENODEV); 111551a7b740SScott Long } 111651a7b740SScott Long 111751a7b740SScott Long switch (tag->flags & 0x7) { 111851a7b740SScott Long case 0: 111951a7b740SScott Long /* 112051a7b740SScott Long * The allocation descriptor field is filled with short_ad's. 112151a7b740SScott Long * If the offset is beyond the current extent, look for the 112251a7b740SScott Long * next extent. 112351a7b740SScott Long */ 112451a7b740SScott Long do { 112551a7b740SScott Long offset -= icblen; 112651a7b740SScott Long ad_offset = sizeof(struct short_ad) * ad_num; 112751a7b740SScott Long if (ad_offset > fentry->l_ad) { 112851a7b740SScott Long printf("File offset out of bounds\n"); 112951a7b740SScott Long return (EINVAL); 113051a7b740SScott Long } 113151a7b740SScott Long icb = GETICB(long_ad, fentry, fentry->l_ea + ad_offset); 113251a7b740SScott Long icblen = GETICBLEN(short_ad, icb); 113351a7b740SScott Long ad_num++; 113451a7b740SScott Long } while(offset >= icblen); 113551a7b740SScott Long 113651a7b740SScott Long lsector = (offset >> udfmp->bshift) + 113751a7b740SScott Long ((struct short_ad *)(icb))->pos; 113851a7b740SScott Long 113951a7b740SScott Long *max_size = GETICBLEN(short_ad, icb) - offset; 114051a7b740SScott Long 114151a7b740SScott Long break; 114251a7b740SScott Long case 1: 114351a7b740SScott Long /* 114451a7b740SScott Long * The allocation descriptor field is filled with long_ad's 114551a7b740SScott Long * If the offset is beyond the current extent, look for the 114651a7b740SScott Long * next extent. 114751a7b740SScott Long */ 114851a7b740SScott Long do { 114951a7b740SScott Long offset -= icblen; 115051a7b740SScott Long ad_offset = sizeof(struct long_ad) * ad_num; 115151a7b740SScott Long if (ad_offset > fentry->l_ad) { 115251a7b740SScott Long printf("File offset out of bounds\n"); 115351a7b740SScott Long return (EINVAL); 115451a7b740SScott Long } 115551a7b740SScott Long icb = GETICB(long_ad, fentry, fentry->l_ea + ad_offset); 115651a7b740SScott Long icblen = GETICBLEN(long_ad, icb); 115751a7b740SScott Long ad_num++; 115851a7b740SScott Long } while(offset >= icblen); 115951a7b740SScott Long 116051a7b740SScott Long lsector = (offset >> udfmp->bshift) + 116151a7b740SScott Long ((struct long_ad *)(icb))->loc.lb_num; 116251a7b740SScott Long 116351a7b740SScott Long *max_size = GETICBLEN(long_ad, icb) - offset; 116451a7b740SScott Long 116551a7b740SScott Long break; 116651a7b740SScott Long case 3: 116751a7b740SScott Long /* 116851a7b740SScott Long * This type means that the file *data* is stored in the 116951a7b740SScott Long * allocation descriptor field of the file entry. 117051a7b740SScott Long */ 117151a7b740SScott Long *max_size = 0; 11728db4c2f2SScott Long *sector = node->hash_id + udfmp->part_start; 117351a7b740SScott Long 11744576293dSScott Long return (UDF_INVALID_BMAP); 117551a7b740SScott Long case 2: 117651a7b740SScott Long /* DirectCD does not use extended_ad's */ 117751a7b740SScott Long default: 117851a7b740SScott Long printf("Unsupported allocation descriptor %d\n", 117951a7b740SScott Long tag->flags & 0x7); 118051a7b740SScott Long return (ENODEV); 118151a7b740SScott Long } 118251a7b740SScott Long 118351a7b740SScott Long *sector = lsector + udfmp->part_start; 118451a7b740SScott Long 118551a7b740SScott Long /* 118651a7b740SScott Long * Check the sparing table. Each entry represents the beginning of 118751a7b740SScott Long * a packet. 118851a7b740SScott Long */ 118951a7b740SScott Long if (udfmp->s_table != NULL) { 119051a7b740SScott Long for (i = 0; i< udfmp->s_table_entries; i++) { 119151a7b740SScott Long p_offset = lsector - udfmp->s_table->entries[i].org; 119251a7b740SScott Long if ((p_offset < udfmp->p_sectors) && (p_offset >= 0)) { 119351a7b740SScott Long *sector = udfmp->s_table->entries[i].map + 119451a7b740SScott Long p_offset; 119551a7b740SScott Long break; 119651a7b740SScott Long } 119751a7b740SScott Long } 119851a7b740SScott Long } 119951a7b740SScott Long 120051a7b740SScott Long return (0); 120151a7b740SScott Long } 1202