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> 394e94fafcSPoul-Henning Kamp #include <sys/conf.h> 4051a7b740SScott Long #include <sys/buf.h> 416565282cSScott Long #include <sys/iconv.h> 4251a7b740SScott Long #include <sys/mount.h> 4351a7b740SScott Long #include <sys/vnode.h> 4451a7b740SScott Long #include <sys/dirent.h> 4551a7b740SScott Long #include <sys/queue.h> 4651a7b740SScott Long #include <sys/unistd.h> 4789ec2c3cSScott Long #include <sys/endian.h> 4851a7b740SScott Long 4951a7b740SScott Long #include <vm/uma.h> 5051a7b740SScott Long 5151a7b740SScott Long #include <fs/udf/ecma167-udf.h> 5251a7b740SScott Long #include <fs/udf/osta.h> 5351a7b740SScott Long #include <fs/udf/udf.h> 546565282cSScott Long #include <fs/udf/udf_mount.h> 556565282cSScott Long 566565282cSScott Long extern struct iconv_functions *udf_iconv; 5751a7b740SScott Long 586fde64c7SPoul-Henning Kamp static vop_access_t udf_access; 596fde64c7SPoul-Henning Kamp static vop_getattr_t udf_getattr; 6035e06624SPav Lucistnik static vop_open_t udf_open; 616fde64c7SPoul-Henning Kamp static vop_ioctl_t udf_ioctl; 626fde64c7SPoul-Henning Kamp static vop_pathconf_t udf_pathconf; 636fde64c7SPoul-Henning Kamp static vop_read_t udf_read; 646fde64c7SPoul-Henning Kamp static vop_readdir_t udf_readdir; 656fde64c7SPoul-Henning Kamp static vop_readlink_t udf_readlink; 666fde64c7SPoul-Henning Kamp static vop_strategy_t udf_strategy; 676fde64c7SPoul-Henning Kamp static vop_bmap_t udf_bmap; 686fde64c7SPoul-Henning Kamp static vop_cachedlookup_t udf_lookup; 696fde64c7SPoul-Henning Kamp static vop_reclaim_t udf_reclaim; 709d32fde8SScott Long static int udf_readatoffset(struct udf_node *node, int *size, off_t offset, 719d32fde8SScott Long struct buf **bp, uint8_t **data); 729d32fde8SScott Long static int udf_bmap_internal(struct udf_node *node, off_t offset, 739d32fde8SScott Long daddr_t *sector, uint32_t *max_size); 7451a7b740SScott Long 75aec0fb7bSPoul-Henning Kamp static struct vop_vector udf_vnodeops = { 76aec0fb7bSPoul-Henning Kamp .vop_default = &default_vnodeops, 7783c64397SPoul-Henning Kamp 78aec0fb7bSPoul-Henning Kamp .vop_access = udf_access, 79aec0fb7bSPoul-Henning Kamp .vop_bmap = udf_bmap, 80aec0fb7bSPoul-Henning Kamp .vop_cachedlookup = udf_lookup, 81aec0fb7bSPoul-Henning Kamp .vop_getattr = udf_getattr, 82aec0fb7bSPoul-Henning Kamp .vop_ioctl = udf_ioctl, 83aec0fb7bSPoul-Henning Kamp .vop_lookup = vfs_cache_lookup, 8435e06624SPav Lucistnik .vop_open = udf_open, 85aec0fb7bSPoul-Henning Kamp .vop_pathconf = udf_pathconf, 86aec0fb7bSPoul-Henning Kamp .vop_read = udf_read, 87aec0fb7bSPoul-Henning Kamp .vop_readdir = udf_readdir, 88aec0fb7bSPoul-Henning Kamp .vop_readlink = udf_readlink, 89aec0fb7bSPoul-Henning Kamp .vop_reclaim = udf_reclaim, 90aec0fb7bSPoul-Henning Kamp .vop_strategy = udf_strategy, 9151a7b740SScott Long }; 9251a7b740SScott Long 935bb84bc8SRobert Watson MALLOC_DEFINE(M_UDFFID, "udf_fid", "UDF FileId structure"); 945bb84bc8SRobert Watson MALLOC_DEFINE(M_UDFDS, "udf_ds", "UDF Dirstream structure"); 9551a7b740SScott Long 964576293dSScott Long #define UDF_INVALID_BMAP -1 978db4c2f2SScott Long 9851a7b740SScott Long int 9951a7b740SScott Long udf_allocv(struct mount *mp, struct vnode **vpp, struct thread *td) 10051a7b740SScott Long { 10151a7b740SScott Long int error; 10251a7b740SScott Long struct vnode *vp; 10351a7b740SScott Long 104aec0fb7bSPoul-Henning Kamp error = getnewvnode("udf", mp, &udf_vnodeops, &vp); 10551a7b740SScott Long if (error) { 10651a7b740SScott Long printf("udf_allocv: failed to allocate new vnode\n"); 10751a7b740SScott Long return (error); 10851a7b740SScott Long } 10951a7b740SScott Long 11051a7b740SScott Long *vpp = vp; 11151a7b740SScott Long return (0); 11251a7b740SScott Long } 11351a7b740SScott Long 11451a7b740SScott Long /* Convert file entry permission (5 bits per owner/group/user) to a mode_t */ 11551a7b740SScott Long static mode_t 11651a7b740SScott Long udf_permtomode(struct udf_node *node) 11751a7b740SScott Long { 118c2d6947dSJeroen Ruigrok van der Werven uint32_t perm; 119bf1c3dddSScott Long uint16_t flags; 12051a7b740SScott Long mode_t mode; 12151a7b740SScott Long 122bf1c3dddSScott Long perm = le32toh(node->fentry->perm); 123bf1c3dddSScott Long flags = le16toh(node->fentry->icbtag.flags); 12451a7b740SScott Long 12551a7b740SScott Long mode = perm & UDF_FENTRY_PERM_USER_MASK; 12651a7b740SScott Long mode |= ((perm & UDF_FENTRY_PERM_GRP_MASK) >> 2); 12751a7b740SScott Long mode |= ((perm & UDF_FENTRY_PERM_OWNER_MASK) >> 4); 12851a7b740SScott Long mode |= ((flags & UDF_ICB_TAG_FLAGS_STICKY) << 4); 12951a7b740SScott Long mode |= ((flags & UDF_ICB_TAG_FLAGS_SETGID) << 6); 13051a7b740SScott Long mode |= ((flags & UDF_ICB_TAG_FLAGS_SETUID) << 8); 13151a7b740SScott Long 13251a7b740SScott Long return (mode); 13351a7b740SScott Long } 13451a7b740SScott Long 13551a7b740SScott Long static int 13651a7b740SScott Long udf_access(struct vop_access_args *a) 13751a7b740SScott Long { 13851a7b740SScott Long struct vnode *vp; 13951a7b740SScott Long struct udf_node *node; 14051a7b740SScott Long mode_t a_mode, mode; 14151a7b740SScott Long 14251a7b740SScott Long vp = a->a_vp; 14351a7b740SScott Long node = VTON(vp); 14451a7b740SScott Long a_mode = a->a_mode; 14551a7b740SScott Long 14651a7b740SScott Long if (a_mode & VWRITE) { 14751a7b740SScott Long switch (vp->v_type) { 14851a7b740SScott Long case VDIR: 14951a7b740SScott Long case VLNK: 15051a7b740SScott Long case VREG: 15151a7b740SScott Long return (EROFS); 15251a7b740SScott Long /* NOT REACHED */ 15351a7b740SScott Long default: 15451a7b740SScott Long break; 15551a7b740SScott Long } 15651a7b740SScott Long } 15751a7b740SScott Long 15851a7b740SScott Long mode = udf_permtomode(node); 15951a7b740SScott Long 16051a7b740SScott Long return (vaccess(vp->v_type, mode, node->fentry->uid, node->fentry->gid, 16151a7b740SScott Long a_mode, a->a_cred, NULL)); 16251a7b740SScott Long } 16351a7b740SScott Long 16435e06624SPav Lucistnik static int 16535e06624SPav Lucistnik udf_open(struct vop_open_args *ap) { 16635e06624SPav Lucistnik struct udf_node *np = VTON(ap->a_vp); 16735e06624SPav Lucistnik off_t fsize; 16835e06624SPav Lucistnik 16935e06624SPav Lucistnik fsize = le64toh(np->fentry->inf_len); 17035e06624SPav Lucistnik vnode_create_vobject(ap->a_vp, fsize, ap->a_td); 17135e06624SPav Lucistnik return 0; 17235e06624SPav Lucistnik } 17335e06624SPav Lucistnik 17451a7b740SScott Long static int mon_lens[2][12] = { 17551a7b740SScott Long {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, 17651a7b740SScott Long {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} 17751a7b740SScott Long }; 17851a7b740SScott Long 17951a7b740SScott Long static int 18051a7b740SScott Long udf_isaleapyear(int year) 18151a7b740SScott Long { 18251a7b740SScott Long int i; 18351a7b740SScott Long 18451a7b740SScott Long i = (year % 4) ? 0 : 1; 18551a7b740SScott Long i &= (year % 100) ? 1 : 0; 18651a7b740SScott Long i |= (year % 400) ? 0 : 1; 18751a7b740SScott Long 18851a7b740SScott Long return i; 18951a7b740SScott Long } 19051a7b740SScott Long 19151a7b740SScott Long /* 19251a7b740SScott Long * XXX This is just a rough hack. Daylight savings isn't calculated and tv_nsec 19351a7b740SScott Long * is ignored. 19451a7b740SScott Long * Timezone calculation compliments of Julian Elischer <julian@elischer.org>. 19551a7b740SScott Long */ 19651a7b740SScott Long static void 19751a7b740SScott Long udf_timetotimespec(struct timestamp *time, struct timespec *t) 19851a7b740SScott Long { 199bf1c3dddSScott Long int i, lpyear, daysinyear, year; 20051a7b740SScott Long union { 201c2d6947dSJeroen Ruigrok van der Werven uint16_t u_tz_offset; 20251a7b740SScott Long int16_t s_tz_offset; 20351a7b740SScott Long } tz; 20451a7b740SScott Long 20551a7b740SScott Long t->tv_nsec = 0; 20651a7b740SScott Long 20751a7b740SScott Long /* DirectCD seems to like using bogus year values */ 208bf1c3dddSScott Long year = le16toh(time->year); 209bf1c3dddSScott Long if (year < 1970) { 21051a7b740SScott Long t->tv_sec = 0; 21151a7b740SScott Long return; 21251a7b740SScott Long } 21351a7b740SScott Long 21451a7b740SScott Long /* Calculate the time and day */ 21551a7b740SScott Long t->tv_sec = time->second; 21651a7b740SScott Long t->tv_sec += time->minute * 60; 21751a7b740SScott Long t->tv_sec += time->hour * 3600; 21851a7b740SScott Long t->tv_sec += time->day * 3600 * 24; 21951a7b740SScott Long 220befb7f33SChristian Brueffer /* Calculate the month */ 221bf1c3dddSScott Long lpyear = udf_isaleapyear(year); 22251a7b740SScott Long for (i = 1; i < time->month; i++) 22351a7b740SScott Long t->tv_sec += mon_lens[lpyear][i] * 3600 * 24; 22451a7b740SScott Long 22551a7b740SScott Long /* Speed up the calculation */ 226bf1c3dddSScott Long if (year > 1979) 22751a7b740SScott Long t->tv_sec += 315532800; 228bf1c3dddSScott Long if (year > 1989) 22951a7b740SScott Long t->tv_sec += 315619200; 230bf1c3dddSScott Long if (year > 1999) 23151a7b740SScott Long t->tv_sec += 315532800; 232bf1c3dddSScott Long for (i = 2000; i < year; i++) { 23351a7b740SScott Long daysinyear = udf_isaleapyear(i) + 365 ; 23451a7b740SScott Long t->tv_sec += daysinyear * 3600 * 24; 23551a7b740SScott Long } 23651a7b740SScott Long 23751a7b740SScott Long /* 23851a7b740SScott Long * Calculate the time zone. The timezone is 12 bit signed 2's 239befb7f33SChristian Brueffer * complement, so we gotta do some extra magic to handle it right. 24051a7b740SScott Long */ 241bf1c3dddSScott Long tz.u_tz_offset = le16toh(time->type_tz); 24251a7b740SScott Long tz.u_tz_offset &= 0x0fff; 24351a7b740SScott Long if (tz.u_tz_offset & 0x0800) 24451a7b740SScott Long tz.u_tz_offset |= 0xf000; /* extend the sign to 16 bits */ 24551a7b740SScott Long if ((time->type_tz & 0x1000) && (tz.s_tz_offset != -2047)) 24651a7b740SScott Long t->tv_sec -= tz.s_tz_offset * 60; 24751a7b740SScott Long 24851a7b740SScott Long return; 24951a7b740SScott Long } 25051a7b740SScott Long 25151a7b740SScott Long static int 25251a7b740SScott Long udf_getattr(struct vop_getattr_args *a) 25351a7b740SScott Long { 25451a7b740SScott Long struct vnode *vp; 25551a7b740SScott Long struct udf_node *node; 25651a7b740SScott Long struct vattr *vap; 25751a7b740SScott Long struct file_entry *fentry; 25851a7b740SScott Long struct timespec ts; 25951a7b740SScott Long 26051a7b740SScott Long ts.tv_sec = 0; 26151a7b740SScott Long 26251a7b740SScott Long vp = a->a_vp; 26351a7b740SScott Long vap = a->a_vap; 26451a7b740SScott Long node = VTON(vp); 26551a7b740SScott Long fentry = node->fentry; 26651a7b740SScott Long 267c049546eSPoul-Henning Kamp vap->va_fsid = dev2udev(node->udfmp->im_dev); 26851a7b740SScott Long vap->va_fileid = node->hash_id; 26951a7b740SScott Long vap->va_mode = udf_permtomode(node); 270bf1c3dddSScott Long vap->va_nlink = le16toh(fentry->link_cnt); 27151a7b740SScott Long /* 27251a7b740SScott Long * XXX The spec says that -1 is valid for uid/gid and indicates an 27351a7b740SScott Long * invalid uid/gid. How should this be represented? 27451a7b740SScott Long */ 275bf1c3dddSScott Long vap->va_uid = (le32toh(fentry->uid) == -1) ? 0 : le32toh(fentry->uid); 276bf1c3dddSScott Long vap->va_gid = (le32toh(fentry->gid) == -1) ? 0 : le32toh(fentry->gid); 27751a7b740SScott Long udf_timetotimespec(&fentry->atime, &vap->va_atime); 27851a7b740SScott Long udf_timetotimespec(&fentry->mtime, &vap->va_mtime); 27951a7b740SScott Long vap->va_ctime = vap->va_mtime; /* XXX Stored as an Extended Attribute */ 28051a7b740SScott Long vap->va_rdev = 0; /* XXX */ 28151a7b740SScott Long if (vp->v_type & VDIR) { 28251a7b740SScott Long /* 28351a7b740SScott Long * Directories that are recorded within their ICB will show 28451a7b740SScott Long * as having 0 blocks recorded. Since tradition dictates 28551a7b740SScott Long * that directories consume at least one logical block, 28651a7b740SScott Long * make it appear so. 28751a7b740SScott Long */ 28851a7b740SScott Long if (fentry->logblks_rec != 0) { 289bf1c3dddSScott Long vap->va_size = 290bf1c3dddSScott Long le64toh(fentry->logblks_rec) * node->udfmp->bsize; 29151a7b740SScott Long } else { 29251a7b740SScott Long vap->va_size = node->udfmp->bsize; 29351a7b740SScott Long } 29451a7b740SScott Long } else { 295bf1c3dddSScott Long vap->va_size = le64toh(fentry->inf_len); 29651a7b740SScott Long } 29751a7b740SScott Long vap->va_flags = 0; 29851a7b740SScott Long vap->va_gen = 1; 29951a7b740SScott Long vap->va_blocksize = node->udfmp->bsize; 300bf1c3dddSScott Long vap->va_bytes = le64toh(fentry->inf_len); 30151a7b740SScott Long vap->va_type = vp->v_type; 30251a7b740SScott Long vap->va_filerev = 0; /* XXX */ 30351a7b740SScott Long return (0); 30451a7b740SScott Long } 30551a7b740SScott Long 30651a7b740SScott Long /* 307bf1c3dddSScott Long * File specific ioctls. 30851a7b740SScott Long */ 30951a7b740SScott Long static int 31051a7b740SScott Long udf_ioctl(struct vop_ioctl_args *a) 31151a7b740SScott Long { 312c80a90c5SScott Long printf("%s called\n", __func__); 3131d02d910SPoul-Henning Kamp return (ENOTTY); 31451a7b740SScott Long } 31551a7b740SScott Long 31651a7b740SScott Long /* 31751a7b740SScott Long * I'm not sure that this has much value in a read-only filesystem, but 31851a7b740SScott Long * cd9660 has it too. 31951a7b740SScott Long */ 32051a7b740SScott Long static int 32151a7b740SScott Long udf_pathconf(struct vop_pathconf_args *a) 32251a7b740SScott Long { 32351a7b740SScott Long 32451a7b740SScott Long switch (a->a_name) { 32551a7b740SScott Long case _PC_LINK_MAX: 32651a7b740SScott Long *a->a_retval = 65535; 32751a7b740SScott Long return (0); 32851a7b740SScott Long case _PC_NAME_MAX: 32951a7b740SScott Long *a->a_retval = NAME_MAX; 33051a7b740SScott Long return (0); 33151a7b740SScott Long case _PC_PATH_MAX: 33251a7b740SScott Long *a->a_retval = PATH_MAX; 33351a7b740SScott Long return (0); 33451a7b740SScott Long case _PC_NO_TRUNC: 33551a7b740SScott Long *a->a_retval = 1; 33651a7b740SScott Long return (0); 33751a7b740SScott Long default: 33851a7b740SScott Long return (EINVAL); 33951a7b740SScott Long } 34051a7b740SScott Long } 34151a7b740SScott Long 3420c09ac0dSPav Lucistnik #define lblkno(udfmp, loc) ((loc) >> (udfmp)->bshift) 3430c09ac0dSPav Lucistnik #define blkoff(udfmp, loc) ((loc) & (udfmp)->bmask) 3440c09ac0dSPav Lucistnik #define lblktosize(imp, blk) ((blk) << (udfmp)->bshift) 34551a7b740SScott Long 3460c09ac0dSPav Lucistnik static int 3470c09ac0dSPav Lucistnik udf_read(struct vop_read_args *ap) 3480c09ac0dSPav Lucistnik { 3490c09ac0dSPav Lucistnik struct vnode *vp = ap->a_vp; 3500c09ac0dSPav Lucistnik struct uio *uio = ap->a_uio; 3510c09ac0dSPav Lucistnik struct udf_node *node = VTON(vp); 3520c09ac0dSPav Lucistnik struct udf_mnt *udfmp; 3530c09ac0dSPav Lucistnik struct buf *bp; 3540c09ac0dSPav Lucistnik daddr_t lbn, rablock; 3550c09ac0dSPav Lucistnik off_t diff, fsize; 3560c09ac0dSPav Lucistnik int error = 0; 3570c09ac0dSPav Lucistnik long size, n, on; 3580c09ac0dSPav Lucistnik 3590c09ac0dSPav Lucistnik if (uio->uio_resid == 0) 3600c09ac0dSPav Lucistnik return (0); 36151a7b740SScott Long if (uio->uio_offset < 0) 36251a7b740SScott Long return (EINVAL); 363bf1c3dddSScott Long fsize = le64toh(node->fentry->inf_len); 3640c09ac0dSPav Lucistnik udfmp = node->udfmp; 3650c09ac0dSPav Lucistnik do { 3660c09ac0dSPav Lucistnik lbn = lblkno(udfmp, uio->uio_offset); 3670c09ac0dSPav Lucistnik on = blkoff(udfmp, uio->uio_offset); 3680c09ac0dSPav Lucistnik n = min((u_int)(udfmp->bsize - on), 3690c09ac0dSPav Lucistnik uio->uio_resid); 3700c09ac0dSPav Lucistnik diff = fsize - uio->uio_offset; 3710c09ac0dSPav Lucistnik if (diff <= 0) 3720c09ac0dSPav Lucistnik return (0); 3730c09ac0dSPav Lucistnik if (diff < n) 3740c09ac0dSPav Lucistnik n = diff; 3750c09ac0dSPav Lucistnik size = udfmp->bsize; 3760c09ac0dSPav Lucistnik rablock = lbn + 1; 3770c09ac0dSPav Lucistnik if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) { 3780c09ac0dSPav Lucistnik if (lblktosize(udfmp, rablock) < fsize) { 3790c09ac0dSPav Lucistnik error = cluster_read(vp, fsize, lbn, size, NOCRED, 3800c09ac0dSPav Lucistnik uio->uio_resid, (ap->a_ioflag >> 16), &bp); 3810c09ac0dSPav Lucistnik } else { 3820c09ac0dSPav Lucistnik error = bread(vp, lbn, size, NOCRED, &bp); 3830c09ac0dSPav Lucistnik } 3840c09ac0dSPav Lucistnik } else { 3850c09ac0dSPav Lucistnik error = bread(vp, lbn, size, NOCRED, &bp); 3860c09ac0dSPav Lucistnik } 3870c09ac0dSPav Lucistnik n = min(n, size - bp->b_resid); 3880c09ac0dSPav Lucistnik if (error) { 38951a7b740SScott Long brelse(bp); 3900c09ac0dSPav Lucistnik return (error); 3910c09ac0dSPav Lucistnik } 39251a7b740SScott Long 3930c09ac0dSPav Lucistnik error = uiomove(bp->b_data + on, (int)n, uio); 3940c09ac0dSPav Lucistnik brelse(bp); 3950c09ac0dSPav Lucistnik } while (error == 0 && uio->uio_resid > 0 && n != 0); 39651a7b740SScott Long return (error); 39751a7b740SScott Long } 39851a7b740SScott Long 39951a7b740SScott Long /* 40051a7b740SScott Long * Call the OSTA routines to translate the name from a CS0 dstring to a 40151a7b740SScott Long * 16-bit Unicode String. Hooks need to be placed in here to translate from 4026565282cSScott Long * Unicode to the encoding that the kernel/user expects. Return the length 4036565282cSScott Long * of the translated string. 40451a7b740SScott Long */ 40551a7b740SScott Long static int 4066565282cSScott Long udf_transname(char *cs0string, char *destname, int len, struct udf_mnt *udfmp) 40751a7b740SScott Long { 40851a7b740SScott Long unicode_t *transname; 4096565282cSScott Long char *unibuf, *unip; 410181fc3c6SR. Imura int i, destlen; 411181fc3c6SR. Imura ssize_t unilen = 0; 4126565282cSScott Long size_t destleft = MAXNAMLEN; 41351a7b740SScott Long 4146565282cSScott Long /* Convert 16-bit Unicode to destname */ 4156565282cSScott Long if (udfmp->im_flags & UDFMNT_KICONV && udf_iconv) { 4166565282cSScott Long /* allocate a buffer big enough to hold an 8->16 bit expansion */ 4176565282cSScott Long unibuf = uma_zalloc(udf_zone_trans, M_WAITOK); 4186565282cSScott Long unip = unibuf; 419181fc3c6SR. Imura if ((unilen = (ssize_t)udf_UncompressUnicodeByte(len, cs0string, unibuf)) == -1) { 4206565282cSScott Long printf("udf: Unicode translation failed\n"); 4216565282cSScott Long uma_zfree(udf_zone_trans, unibuf); 4226565282cSScott Long return 0; 4236565282cSScott Long } 4246565282cSScott Long 4256565282cSScott Long while (unilen > 0 && destleft > 0) { 4266565282cSScott Long udf_iconv->conv(udfmp->im_d2l, (const char **)&unibuf, 4276565282cSScott Long (size_t *)&unilen, (char **)&destname, &destleft); 4286565282cSScott Long /* Unconverted character found */ 4296565282cSScott Long if (unilen > 0 && destleft > 0) { 4306565282cSScott Long *destname++ = '?'; 4316565282cSScott Long destleft--; 4326565282cSScott Long unibuf += 2; 4336565282cSScott Long unilen -= 2; 4346565282cSScott Long } 4356565282cSScott Long } 4366565282cSScott Long uma_zfree(udf_zone_trans, unip); 4376565282cSScott Long *destname = '\0'; 4386565282cSScott Long destlen = MAXNAMLEN - (int)destleft; 4396565282cSScott Long } else { 44051a7b740SScott Long /* allocate a buffer big enough to hold an 8->16 bit expansion */ 441a163d034SWarner Losh transname = uma_zalloc(udf_zone_trans, M_WAITOK); 44251a7b740SScott Long 443181fc3c6SR. Imura if ((unilen = (ssize_t)udf_UncompressUnicode(len, cs0string, transname)) == -1) { 44451a7b740SScott Long printf("udf: Unicode translation failed\n"); 44551a7b740SScott Long uma_zfree(udf_zone_trans, transname); 44651a7b740SScott Long return 0; 44751a7b740SScott Long } 44851a7b740SScott Long 44951a7b740SScott Long for (i = 0; i < unilen ; i++) { 45051a7b740SScott Long if (transname[i] & 0xff00) { 45151a7b740SScott Long destname[i] = '.'; /* Fudge the 16bit chars */ 45251a7b740SScott Long } else { 45351a7b740SScott Long destname[i] = transname[i] & 0xff; 45451a7b740SScott Long } 45551a7b740SScott Long } 45651a7b740SScott Long uma_zfree(udf_zone_trans, transname); 4576565282cSScott Long destname[unilen] = 0; 458181fc3c6SR. Imura destlen = (int)unilen; 4596565282cSScott Long } 46051a7b740SScott Long 4616565282cSScott Long return (destlen); 46251a7b740SScott Long } 46351a7b740SScott Long 46451a7b740SScott Long /* 46551a7b740SScott Long * Compare a CS0 dstring with a name passed in from the VFS layer. Return 466befb7f33SChristian Brueffer * 0 on a successful match, nonzero otherwise. Unicode work may need to be done 46751a7b740SScott Long * here also. 46851a7b740SScott Long */ 46951a7b740SScott Long static int 4706565282cSScott Long udf_cmpname(char *cs0string, char *cmpname, int cs0len, int cmplen, struct udf_mnt *udfmp) 47151a7b740SScott Long { 47295ec5961SScott Long char *transname; 47395ec5961SScott Long int error = 0; 47451a7b740SScott Long 47595ec5961SScott Long /* This is overkill, but not worth creating a new zone */ 476a163d034SWarner Losh transname = uma_zalloc(udf_zone_trans, M_WAITOK); 47795ec5961SScott Long 4786565282cSScott Long cs0len = udf_transname(cs0string, transname, cs0len, udfmp); 47951a7b740SScott Long 48051a7b740SScott Long /* Easy check. If they aren't the same length, they aren't equal */ 48195ec5961SScott Long if ((cs0len == 0) || (cs0len != cmplen)) 48295ec5961SScott Long error = -1; 48395ec5961SScott Long else 48495ec5961SScott Long error = bcmp(transname, cmpname, cmplen); 48551a7b740SScott Long 48695ec5961SScott Long uma_zfree(udf_zone_trans, transname); 48795ec5961SScott Long return (error); 48851a7b740SScott Long } 48951a7b740SScott Long 49051a7b740SScott Long struct udf_uiodir { 49151a7b740SScott Long struct dirent *dirent; 49251a7b740SScott Long u_long *cookies; 49351a7b740SScott Long int ncookies; 49451a7b740SScott Long int acookies; 49551a7b740SScott Long int eofflag; 49651a7b740SScott Long }; 49751a7b740SScott Long 49851a7b740SScott Long static int 49951a7b740SScott Long udf_uiodir(struct udf_uiodir *uiodir, int de_size, struct uio *uio, long cookie) 50051a7b740SScott Long { 50151a7b740SScott Long if (uiodir->cookies != NULL) { 50251a7b740SScott Long if (++uiodir->acookies > uiodir->ncookies) { 50351a7b740SScott Long uiodir->eofflag = 0; 50451a7b740SScott Long return (-1); 50551a7b740SScott Long } 50651a7b740SScott Long *uiodir->cookies++ = cookie; 50751a7b740SScott Long } 50851a7b740SScott Long 50951a7b740SScott Long if (uio->uio_resid < de_size) { 51051a7b740SScott Long uiodir->eofflag = 0; 51151a7b740SScott Long return (-1); 51251a7b740SScott Long } 51351a7b740SScott Long 514c9524588SDag-Erling Smørgrav return (uiomove(uiodir->dirent, de_size, uio)); 51551a7b740SScott Long } 51651a7b740SScott Long 5171703656aSScott Long static struct udf_dirstream * 5181703656aSScott Long udf_opendir(struct udf_node *node, int offset, int fsize, struct udf_mnt *udfmp) 5191703656aSScott Long { 5201703656aSScott Long struct udf_dirstream *ds; 5211703656aSScott Long 522a163d034SWarner Losh ds = uma_zalloc(udf_zone_ds, M_WAITOK | M_ZERO); 5231703656aSScott Long 5241703656aSScott Long ds->node = node; 5251703656aSScott Long ds->offset = offset; 5261703656aSScott Long ds->udfmp = udfmp; 5271703656aSScott Long ds->fsize = fsize; 5281703656aSScott Long 5291703656aSScott Long return (ds); 5301703656aSScott Long } 5311703656aSScott Long 5321703656aSScott Long static struct fileid_desc * 5331703656aSScott Long udf_getfid(struct udf_dirstream *ds) 5341703656aSScott Long { 5351703656aSScott Long struct fileid_desc *fid; 5361703656aSScott Long int error, frag_size = 0, total_fid_size; 5371703656aSScott Long 5381703656aSScott Long /* End of directory? */ 5391703656aSScott Long if (ds->offset + ds->off >= ds->fsize) { 5401703656aSScott Long ds->error = 0; 5411703656aSScott Long return (NULL); 5421703656aSScott Long } 5431703656aSScott Long 5441703656aSScott Long /* Grab the first extent of the directory */ 5451703656aSScott Long if (ds->off == 0) { 5461703656aSScott Long ds->size = 0; 5471703656aSScott Long error = udf_readatoffset(ds->node, &ds->size, ds->offset, 5481703656aSScott Long &ds->bp, &ds->data); 5491703656aSScott Long if (error) { 5501703656aSScott Long ds->error = error; 551744bb56dSScott Long if (ds->bp != NULL) 552744bb56dSScott Long brelse(ds->bp); 5531703656aSScott Long return (NULL); 5541703656aSScott Long } 5551703656aSScott Long } 5561703656aSScott Long 5574576293dSScott Long /* 5584576293dSScott Long * Clean up from a previous fragmented FID. 5594576293dSScott Long * XXX Is this the right place for this? 5604576293dSScott Long */ 5611703656aSScott Long if (ds->fid_fragment && ds->buf != NULL) { 5621703656aSScott Long ds->fid_fragment = 0; 5631703656aSScott Long FREE(ds->buf, M_UDFFID); 5641703656aSScott Long } 5651703656aSScott Long 5661703656aSScott Long fid = (struct fileid_desc*)&ds->data[ds->off]; 5671703656aSScott Long 5681703656aSScott Long /* 5691703656aSScott Long * Check to see if the fid is fragmented. The first test 5701703656aSScott Long * ensures that we don't wander off the end of the buffer 5711703656aSScott Long * looking for the l_iu and l_fi fields. 5721703656aSScott Long */ 5731703656aSScott Long if (ds->off + UDF_FID_SIZE > ds->size || 574bf1c3dddSScott Long ds->off + le16toh(fid->l_iu) + fid->l_fi + UDF_FID_SIZE > ds->size){ 5751703656aSScott Long 5761703656aSScott Long /* Copy what we have of the fid into a buffer */ 5771703656aSScott Long frag_size = ds->size - ds->off; 5781703656aSScott Long if (frag_size >= ds->udfmp->bsize) { 5791703656aSScott Long printf("udf: invalid FID fragment\n"); 5801703656aSScott Long ds->error = EINVAL; 5811703656aSScott Long return (NULL); 5821703656aSScott Long } 5831703656aSScott Long 5841703656aSScott Long /* 5851703656aSScott Long * File ID descriptors can only be at most one 5861703656aSScott Long * logical sector in size. 5871703656aSScott Long */ 5881703656aSScott Long MALLOC(ds->buf, uint8_t*, ds->udfmp->bsize, M_UDFFID, 589a163d034SWarner Losh M_WAITOK | M_ZERO); 5901703656aSScott Long bcopy(fid, ds->buf, frag_size); 5911703656aSScott Long 5921703656aSScott Long /* Reduce all of the casting magic */ 5931703656aSScott Long fid = (struct fileid_desc*)ds->buf; 5941703656aSScott Long 5951703656aSScott Long if (ds->bp != NULL) 5961703656aSScott Long brelse(ds->bp); 5971703656aSScott Long 5981703656aSScott Long /* Fetch the next allocation */ 5991703656aSScott Long ds->offset += ds->size; 6001703656aSScott Long ds->size = 0; 6011703656aSScott Long error = udf_readatoffset(ds->node, &ds->size, ds->offset, 6021703656aSScott Long &ds->bp, &ds->data); 6031703656aSScott Long if (error) { 6041703656aSScott Long ds->error = error; 6051703656aSScott Long return (NULL); 6061703656aSScott Long } 6071703656aSScott Long 6081703656aSScott Long /* 6091703656aSScott Long * If the fragment was so small that we didn't get 6101703656aSScott Long * the l_iu and l_fi fields, copy those in. 6111703656aSScott Long */ 6121703656aSScott Long if (frag_size < UDF_FID_SIZE) 6131703656aSScott Long bcopy(ds->data, &ds->buf[frag_size], 6141703656aSScott Long UDF_FID_SIZE - frag_size); 6151703656aSScott Long 6161703656aSScott Long /* 6171703656aSScott Long * Now that we have enough of the fid to work with, 6181703656aSScott Long * copy in the rest of the fid from the new 6191703656aSScott Long * allocation. 6201703656aSScott Long */ 621bf1c3dddSScott Long total_fid_size = UDF_FID_SIZE + le16toh(fid->l_iu) + fid->l_fi; 6221703656aSScott Long if (total_fid_size > ds->udfmp->bsize) { 6231703656aSScott Long printf("udf: invalid FID\n"); 6241703656aSScott Long ds->error = EIO; 6251703656aSScott Long return (NULL); 6261703656aSScott Long } 6271703656aSScott Long bcopy(ds->data, &ds->buf[frag_size], 6281703656aSScott Long total_fid_size - frag_size); 6291703656aSScott Long 6301703656aSScott Long ds->fid_fragment = 1; 6311703656aSScott Long } else { 632bf1c3dddSScott Long total_fid_size = le16toh(fid->l_iu) + fid->l_fi + UDF_FID_SIZE; 6331703656aSScott Long } 6341703656aSScott Long 6351703656aSScott Long /* 6361703656aSScott Long * Update the offset. Align on a 4 byte boundary because the 6374576293dSScott Long * UDF spec says so. 6381703656aSScott Long */ 6391703656aSScott Long ds->this_off = ds->off; 6401703656aSScott Long if (!ds->fid_fragment) { 6411703656aSScott Long ds->off += (total_fid_size + 3) & ~0x03; 6421703656aSScott Long } else { 6431703656aSScott Long ds->off = (total_fid_size - frag_size + 3) & ~0x03; 6441703656aSScott Long } 6451703656aSScott Long 6461703656aSScott Long return (fid); 6471703656aSScott Long } 6481703656aSScott Long 6491703656aSScott Long static void 6501703656aSScott Long udf_closedir(struct udf_dirstream *ds) 6511703656aSScott Long { 6521703656aSScott Long 6531703656aSScott Long if (ds->bp != NULL) 6541703656aSScott Long brelse(ds->bp); 6551703656aSScott Long 6561703656aSScott Long if (ds->fid_fragment && ds->buf != NULL) 6571703656aSScott Long FREE(ds->buf, M_UDFFID); 6581703656aSScott Long 6591703656aSScott Long uma_zfree(udf_zone_ds, ds); 6601703656aSScott Long } 6611703656aSScott Long 66251a7b740SScott Long static int 66351a7b740SScott Long udf_readdir(struct vop_readdir_args *a) 66451a7b740SScott Long { 66551a7b740SScott Long struct vnode *vp; 66651a7b740SScott Long struct uio *uio; 66751a7b740SScott Long struct dirent dir; 66851a7b740SScott Long struct udf_node *node; 6696565282cSScott Long struct udf_mnt *udfmp; 67051a7b740SScott Long struct fileid_desc *fid; 67151a7b740SScott Long struct udf_uiodir uiodir; 6721703656aSScott Long struct udf_dirstream *ds; 67351a7b740SScott Long u_long *cookies = NULL; 67451a7b740SScott Long int ncookies; 675c8eeea2fSScott Long int error = 0; 67651a7b740SScott Long 67751a7b740SScott Long vp = a->a_vp; 67851a7b740SScott Long uio = a->a_uio; 67951a7b740SScott Long node = VTON(vp); 6806565282cSScott Long udfmp = node->udfmp; 68151a7b740SScott Long uiodir.eofflag = 1; 68251a7b740SScott Long 68351a7b740SScott Long if (a->a_ncookies != NULL) { 68451a7b740SScott Long /* 68551a7b740SScott Long * Guess how many entries are needed. If we run out, this 68651a7b740SScott Long * function will be called again and thing will pick up were 68751a7b740SScott Long * it left off. 68851a7b740SScott Long */ 68951a7b740SScott Long ncookies = uio->uio_resid / 8; 69051a7b740SScott Long MALLOC(cookies, u_long *, sizeof(u_long) * ncookies, 691a163d034SWarner Losh M_TEMP, M_WAITOK); 69251a7b740SScott Long if (cookies == NULL) 69351a7b740SScott Long return (ENOMEM); 69451a7b740SScott Long uiodir.ncookies = ncookies; 69551a7b740SScott Long uiodir.cookies = cookies; 69651a7b740SScott Long uiodir.acookies = 0; 69751a7b740SScott Long } else { 69851a7b740SScott Long uiodir.cookies = NULL; 69951a7b740SScott Long } 70051a7b740SScott Long 70151a7b740SScott Long /* 70251a7b740SScott Long * Iterate through the file id descriptors. Give the parent dir 7034576293dSScott Long * entry special attention. 70451a7b740SScott Long */ 705bf1c3dddSScott Long ds = udf_opendir(node, uio->uio_offset, le64toh(node->fentry->inf_len), 7061703656aSScott Long node->udfmp); 70751a7b740SScott Long 7081703656aSScott Long while ((fid = udf_getfid(ds)) != NULL) { 70951a7b740SScott Long 71051a7b740SScott Long /* XXX Should we return an error on a bad fid? */ 71151a7b740SScott Long if (udf_checktag(&fid->tag, TAGID_FID)) { 71251a7b740SScott Long printf("Invalid FID tag\n"); 71377411499SScott Long hexdump(fid, UDF_FID_SIZE, NULL, 0); 7141703656aSScott Long error = EIO; 71551a7b740SScott Long break; 71651a7b740SScott Long } 71751a7b740SScott Long 71851a7b740SScott Long /* Is this a deleted file? */ 7192bbe0d36SScott Long if (fid->file_char & UDF_FILE_CHAR_DEL) 7201703656aSScott Long continue; 72151a7b740SScott Long 7222bbe0d36SScott Long if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) { 72351a7b740SScott Long /* Do up the '.' and '..' entries. Dummy values are 72451a7b740SScott Long * used for the cookies since the offset here is 72551a7b740SScott Long * usually zero, and NFS doesn't like that value 72651a7b740SScott Long */ 727c8eeea2fSScott Long dir.d_fileno = node->hash_id; 728c8eeea2fSScott Long dir.d_type = DT_DIR; 729c8eeea2fSScott Long dir.d_name[0] = '.'; 730444acc16SScott Long dir.d_name[1] = '\0'; 731c8eeea2fSScott Long dir.d_namlen = 1; 732c8eeea2fSScott Long dir.d_reclen = GENERIC_DIRSIZ(&dir); 733c8eeea2fSScott Long uiodir.dirent = &dir; 734c8eeea2fSScott Long error = udf_uiodir(&uiodir, dir.d_reclen, uio, 1); 73551a7b740SScott Long if (error) 73651a7b740SScott Long break; 73751a7b740SScott Long 738c8eeea2fSScott Long dir.d_fileno = udf_getid(&fid->icb); 739c8eeea2fSScott Long dir.d_type = DT_DIR; 740c8eeea2fSScott Long dir.d_name[0] = '.'; 741c8eeea2fSScott Long dir.d_name[1] = '.'; 742444acc16SScott Long dir.d_name[2] = '\0'; 743c8eeea2fSScott Long dir.d_namlen = 2; 744c8eeea2fSScott Long dir.d_reclen = GENERIC_DIRSIZ(&dir); 745c8eeea2fSScott Long uiodir.dirent = &dir; 746c8eeea2fSScott Long error = udf_uiodir(&uiodir, dir.d_reclen, uio, 2); 74751a7b740SScott Long } else { 74851a7b740SScott Long dir.d_namlen = udf_transname(&fid->data[fid->l_iu], 7496565282cSScott Long &dir.d_name[0], fid->l_fi, udfmp); 75051a7b740SScott Long dir.d_fileno = udf_getid(&fid->icb); 7512bbe0d36SScott Long dir.d_type = (fid->file_char & UDF_FILE_CHAR_DIR) ? 7522bbe0d36SScott Long DT_DIR : DT_UNKNOWN; 75351a7b740SScott Long dir.d_reclen = GENERIC_DIRSIZ(&dir); 75451a7b740SScott Long uiodir.dirent = &dir; 7551703656aSScott Long error = udf_uiodir(&uiodir, dir.d_reclen, uio, 7561703656aSScott Long ds->this_off); 75751a7b740SScott Long } 75851a7b740SScott Long if (error) { 75951a7b740SScott Long printf("uiomove returned %d\n", error); 76051a7b740SScott Long break; 76151a7b740SScott Long } 76251a7b740SScott Long 76351a7b740SScott Long } 76451a7b740SScott Long 76551a7b740SScott Long /* tell the calling layer whether we need to be called again */ 76651a7b740SScott Long *a->a_eofflag = uiodir.eofflag; 7671703656aSScott Long uio->uio_offset = ds->offset + ds->off; 76851a7b740SScott Long 7691703656aSScott Long if (!error) 7701703656aSScott Long error = ds->error; 7711703656aSScott Long 7721703656aSScott Long udf_closedir(ds); 77351a7b740SScott Long 77451a7b740SScott Long if (a->a_ncookies != NULL) { 77551a7b740SScott Long if (error) 7761703656aSScott Long FREE(cookies, M_TEMP); 77751a7b740SScott Long else { 77851a7b740SScott Long *a->a_ncookies = uiodir.acookies; 77951a7b740SScott Long *a->a_cookies = cookies; 78051a7b740SScott Long } 78151a7b740SScott Long } 78251a7b740SScott Long 78351a7b740SScott Long return (error); 78451a7b740SScott Long } 78551a7b740SScott Long 78651a7b740SScott Long /* Are there any implementations out there that do soft-links? */ 78751a7b740SScott Long static int 78851a7b740SScott Long udf_readlink(struct vop_readlink_args *ap) 78951a7b740SScott Long { 790c80a90c5SScott Long printf("%s called\n", __func__); 79151a7b740SScott Long return (EOPNOTSUPP); 79251a7b740SScott Long } 79351a7b740SScott Long 79451a7b740SScott Long static int 79551a7b740SScott Long udf_strategy(struct vop_strategy_args *a) 79651a7b740SScott Long { 79751a7b740SScott Long struct buf *bp; 79851a7b740SScott Long struct vnode *vp; 79951a7b740SScott Long struct udf_node *node; 80051a7b740SScott Long int maxsize; 8010c09ac0dSPav Lucistnik daddr_t sector; 802429c018aSPoul-Henning Kamp struct bufobj *bo; 8030c09ac0dSPav Lucistnik int multiplier; 80451a7b740SScott Long 80551a7b740SScott Long bp = a->a_bp; 806d83b7498SPoul-Henning Kamp vp = a->a_vp; 80751a7b740SScott Long node = VTON(vp); 80851a7b740SScott Long 8090c09ac0dSPav Lucistnik if (bp->b_blkno == bp->b_lblkno) { 81051a7b740SScott Long /* 81151a7b740SScott Long * Files that are embedded in the fentry don't translate well 81251a7b740SScott Long * to a block number. Reject. 81351a7b740SScott Long */ 81451a7b740SScott Long if (udf_bmap_internal(node, bp->b_lblkno * node->udfmp->bsize, 8150c09ac0dSPav Lucistnik §or, &maxsize)) { 81651a7b740SScott Long clrbuf(bp); 81751a7b740SScott Long bp->b_blkno = -1; 81851a7b740SScott Long } 8190c09ac0dSPav Lucistnik 8200c09ac0dSPav Lucistnik /* bmap gives sector numbers, bio works with device blocks */ 8210c09ac0dSPav Lucistnik multiplier = node->udfmp->bsize / DEV_BSIZE; 8220c09ac0dSPav Lucistnik bp->b_blkno = sector * multiplier; 8230c09ac0dSPav Lucistnik 82451a7b740SScott Long } 82551a7b740SScott Long if ((long)bp->b_blkno == -1) { 82651a7b740SScott Long bufdone(bp); 82751a7b740SScott Long return (0); 82851a7b740SScott Long } 829429c018aSPoul-Henning Kamp bo = node->udfmp->im_bo; 8302c18019fSPoul-Henning Kamp bp->b_iooffset = dbtob(bp->b_blkno); 8310391e5a1SPoul-Henning Kamp BO_STRATEGY(bo, bp); 83251a7b740SScott Long return (0); 83351a7b740SScott Long } 83451a7b740SScott Long 83551a7b740SScott Long static int 83651a7b740SScott Long udf_bmap(struct vop_bmap_args *a) 83751a7b740SScott Long { 83851a7b740SScott Long struct udf_node *node; 839c2d6947dSJeroen Ruigrok van der Werven uint32_t max_size; 84098b0c789SPoul-Henning Kamp daddr_t lsector; 84151a7b740SScott Long int error; 84251a7b740SScott Long 84351a7b740SScott Long node = VTON(a->a_vp); 84451a7b740SScott Long 8459c83534dSPoul-Henning Kamp if (a->a_bop != NULL) 846e0251bbbSPoul-Henning Kamp *a->a_bop = &node->udfmp->im_devvp->v_bufobj; 84751a7b740SScott Long if (a->a_bnp == NULL) 84851a7b740SScott Long return (0); 84951a7b740SScott Long if (a->a_runb) 85051a7b740SScott Long *a->a_runb = 0; 85151a7b740SScott Long 852cd1b1a1dSScott Long error = udf_bmap_internal(node, a->a_bn * node->udfmp->bsize, &lsector, 85351a7b740SScott Long &max_size); 8548db4c2f2SScott Long if (error) 85551a7b740SScott Long return (error); 85651a7b740SScott Long 857cd1b1a1dSScott Long /* Translate logical to physical sector number */ 858cd1b1a1dSScott Long *a->a_bnp = lsector << (node->udfmp->bshift - DEV_BSHIFT); 859cd1b1a1dSScott Long 86051a7b740SScott Long /* Punt on read-ahead for now */ 86151a7b740SScott Long if (a->a_runp) 86251a7b740SScott Long *a->a_runp = 0; 86351a7b740SScott Long 86451a7b740SScott Long return (0); 86551a7b740SScott Long } 86651a7b740SScott Long 86751a7b740SScott Long /* 86851a7b740SScott Long * The all powerful VOP_LOOKUP(). 86951a7b740SScott Long */ 87051a7b740SScott Long static int 87151a7b740SScott Long udf_lookup(struct vop_cachedlookup_args *a) 87251a7b740SScott Long { 87351a7b740SScott Long struct vnode *dvp; 87451a7b740SScott Long struct vnode *tdp = NULL; 87551a7b740SScott Long struct vnode **vpp = a->a_vpp; 87651a7b740SScott Long struct udf_node *node; 87751a7b740SScott Long struct udf_mnt *udfmp; 87851a7b740SScott Long struct fileid_desc *fid = NULL; 8791703656aSScott Long struct udf_dirstream *ds; 88051a7b740SScott Long struct thread *td; 88151a7b740SScott Long u_long nameiop; 88251a7b740SScott Long u_long flags; 88351a7b740SScott Long char *nameptr; 88451a7b740SScott Long long namelen; 88551a7b740SScott Long ino_t id = 0; 8861703656aSScott Long int offset, error = 0; 8871703656aSScott Long int numdirpasses, fsize; 88851a7b740SScott Long 88951a7b740SScott Long dvp = a->a_dvp; 89051a7b740SScott Long node = VTON(dvp); 89151a7b740SScott Long udfmp = node->udfmp; 89251a7b740SScott Long nameiop = a->a_cnp->cn_nameiop; 89351a7b740SScott Long flags = a->a_cnp->cn_flags; 89451a7b740SScott Long nameptr = a->a_cnp->cn_nameptr; 89551a7b740SScott Long namelen = a->a_cnp->cn_namelen; 896bf1c3dddSScott Long fsize = le64toh(node->fentry->inf_len); 89751a7b740SScott Long td = a->a_cnp->cn_thread; 89851a7b740SScott Long 89951a7b740SScott Long /* 90051a7b740SScott Long * If this is a LOOKUP and we've already partially searched through 90151a7b740SScott Long * the directory, pick up where we left off and flag that the 90251a7b740SScott Long * directory may need to be searched twice. For a full description, 90351a7b740SScott Long * see /sys/isofs/cd9660/cd9660_lookup.c:cd9660_lookup() 90451a7b740SScott Long */ 9051703656aSScott Long if (nameiop != LOOKUP || node->diroff == 0 || node->diroff > fsize) { 90651a7b740SScott Long offset = 0; 90751a7b740SScott Long numdirpasses = 1; 90851a7b740SScott Long } else { 90951a7b740SScott Long offset = node->diroff; 91051a7b740SScott Long numdirpasses = 2; 91151a7b740SScott Long nchstats.ncs_2passes++; 91251a7b740SScott Long } 91351a7b740SScott Long 91451a7b740SScott Long lookloop: 9151703656aSScott Long ds = udf_opendir(node, offset, fsize, udfmp); 91651a7b740SScott Long 9171703656aSScott Long while ((fid = udf_getfid(ds)) != NULL) { 91851a7b740SScott Long 91951a7b740SScott Long /* XXX Should we return an error on a bad fid? */ 9201703656aSScott Long if (udf_checktag(&fid->tag, TAGID_FID)) { 9211703656aSScott Long printf("udf_lookup: Invalid tag\n"); 9221703656aSScott Long error = EIO; 9231703656aSScott Long break; 9241703656aSScott Long } 925678d5effSScott Long 926678d5effSScott Long /* Is this a deleted file? */ 9272bbe0d36SScott Long if (fid->file_char & UDF_FILE_CHAR_DEL) 9281703656aSScott Long continue; 92951a7b740SScott Long 9302bbe0d36SScott Long if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) { 93151a7b740SScott Long if (flags & ISDOTDOT) { 93251a7b740SScott Long id = udf_getid(&fid->icb); 93351a7b740SScott Long break; 93451a7b740SScott Long } 93551a7b740SScott Long } else { 93651a7b740SScott Long if (!(udf_cmpname(&fid->data[fid->l_iu], 9376565282cSScott Long nameptr, fid->l_fi, namelen, udfmp))) { 93851a7b740SScott Long id = udf_getid(&fid->icb); 93951a7b740SScott Long break; 94051a7b740SScott Long } 94151a7b740SScott Long } 94251a7b740SScott Long } 9431703656aSScott Long 9441703656aSScott Long if (!error) 9451703656aSScott Long error = ds->error; 9461703656aSScott Long 9471703656aSScott Long /* XXX Bail out here? */ 9481703656aSScott Long if (error) { 9491703656aSScott Long udf_closedir(ds); 9501703656aSScott Long return (error); 95151a7b740SScott Long } 95251a7b740SScott Long 95351a7b740SScott Long /* Did we have a match? */ 95451a7b740SScott Long if (id) { 95527ad03cbSJeff Roberson if (flags & ISDOTDOT) 95627ad03cbSJeff Roberson VOP_UNLOCK(dvp, 0, a->a_cnp->cn_thread); 95751a7b740SScott Long error = udf_vget(udfmp->im_mountp, id, LK_EXCLUSIVE, &tdp); 958045f25a2SSeigo Tanimura if (flags & ISDOTDOT) 9594585e3acSJeff Roberson vn_lock(dvp, LK_EXCLUSIVE|LK_RETRY, a->a_cnp->cn_thread); 9601703656aSScott Long if (!error) { 9611703656aSScott Long /* 9621703656aSScott Long * Remember where this entry was if it's the final 9631703656aSScott Long * component. 9641703656aSScott Long */ 96551a7b740SScott Long if ((flags & ISLASTCN) && nameiop == LOOKUP) 9661703656aSScott Long node->diroff = ds->offset + ds->off; 96751a7b740SScott Long if (numdirpasses == 2) 96851a7b740SScott Long nchstats.ncs_pass2++; 96951a7b740SScott Long *vpp = tdp; 97051a7b740SScott Long /* Put this entry in the cache */ 97151a7b740SScott Long if (flags & MAKEENTRY) 97251a7b740SScott Long cache_enter(dvp, *vpp, a->a_cnp); 9734585e3acSJeff Roberson } 9741703656aSScott Long } else { 97551a7b740SScott Long /* Name wasn't found on this pass. Do another pass? */ 97651a7b740SScott Long if (numdirpasses == 2) { 97751a7b740SScott Long numdirpasses--; 97851a7b740SScott Long offset = 0; 9791703656aSScott Long udf_closedir(ds); 98051a7b740SScott Long goto lookloop; 98151a7b740SScott Long } 98251a7b740SScott Long 98351a7b740SScott Long /* Enter name into cache as non-existant */ 98451a7b740SScott Long if (flags & MAKEENTRY) 98551a7b740SScott Long cache_enter(dvp, *vpp, a->a_cnp); 98651a7b740SScott Long 9871703656aSScott Long if ((flags & ISLASTCN) && 9881703656aSScott Long (nameiop == CREATE || nameiop == RENAME)) { 9891703656aSScott Long error = EROFS; 9901703656aSScott Long } else { 9911703656aSScott Long error = ENOENT; 9921703656aSScott Long } 9931703656aSScott Long } 99451a7b740SScott Long 9951703656aSScott Long udf_closedir(ds); 9961703656aSScott Long return (error); 99751a7b740SScott Long } 99851a7b740SScott Long 99951a7b740SScott Long static int 100051a7b740SScott Long udf_reclaim(struct vop_reclaim_args *a) 100151a7b740SScott Long { 100251a7b740SScott Long struct vnode *vp; 100351a7b740SScott Long struct udf_node *unode; 100451a7b740SScott Long 100551a7b740SScott Long vp = a->a_vp; 100651a7b740SScott Long unode = VTON(vp); 100751a7b740SScott Long 100892e73f57SAlfred Perlstein /* 100992e73f57SAlfred Perlstein * Destroy the vm object and flush associated pages. 101092e73f57SAlfred Perlstein */ 101192e73f57SAlfred Perlstein vnode_destroy_vobject(vp); 101292e73f57SAlfred Perlstein 101351a7b740SScott Long if (unode != NULL) { 10144e94fafcSPoul-Henning Kamp vfs_hash_remove(vp); 101551a7b740SScott Long 101651a7b740SScott Long if (unode->fentry != NULL) 101751a7b740SScott Long FREE(unode->fentry, M_UDFFENTRY); 101851a7b740SScott Long uma_zfree(udf_zone_node, unode); 101951a7b740SScott Long vp->v_data = NULL; 102051a7b740SScott Long } 102151a7b740SScott Long 102251a7b740SScott Long return (0); 102351a7b740SScott Long } 102451a7b740SScott Long 102551a7b740SScott Long /* 102651a7b740SScott Long * Read the block and then set the data pointer to correspond with the 102751a7b740SScott Long * offset passed in. Only read in at most 'size' bytes, and then set 'size' 102851a7b740SScott Long * to the number of bytes pointed to. If 'size' is zero, try to read in a 102951a7b740SScott Long * whole extent. 1030744bb56dSScott Long * 1031744bb56dSScott Long * Note that *bp may be assigned error or not. 1032744bb56dSScott Long * 103351a7b740SScott Long */ 103451a7b740SScott Long static int 10359d32fde8SScott Long udf_readatoffset(struct udf_node *node, int *size, off_t offset, 10369d32fde8SScott Long struct buf **bp, uint8_t **data) 103751a7b740SScott Long { 103851a7b740SScott Long struct udf_mnt *udfmp; 103951a7b740SScott Long struct file_entry *fentry = NULL; 104051a7b740SScott Long struct buf *bp1; 1041c2d6947dSJeroen Ruigrok van der Werven uint32_t max_size; 104298b0c789SPoul-Henning Kamp daddr_t sector; 104351a7b740SScott Long int error; 104451a7b740SScott Long 104551a7b740SScott Long udfmp = node->udfmp; 104651a7b740SScott Long 1047744bb56dSScott Long *bp = NULL; 104851a7b740SScott Long error = udf_bmap_internal(node, offset, §or, &max_size); 10494576293dSScott Long if (error == UDF_INVALID_BMAP) { 105051a7b740SScott Long /* 105151a7b740SScott Long * This error means that the file *data* is stored in the 105251a7b740SScott Long * allocation descriptor field of the file entry. 105351a7b740SScott Long */ 105451a7b740SScott Long fentry = node->fentry; 1055bf1c3dddSScott Long *data = &fentry->data[le32toh(fentry->l_ea)]; 1056bf1c3dddSScott Long *size = le32toh(fentry->l_ad); 105751a7b740SScott Long return (0); 105851a7b740SScott Long } else if (error != 0) { 105951a7b740SScott Long return (error); 106051a7b740SScott Long } 106151a7b740SScott Long 1062d1def83bSScott Long /* Adjust the size so that it is within range */ 106351a7b740SScott Long if (*size == 0 || *size > max_size) 106451a7b740SScott Long *size = max_size; 1065d1def83bSScott Long *size = min(*size, MAXBSIZE); 106651a7b740SScott Long 106751a7b740SScott Long if ((error = udf_readlblks(udfmp, sector, *size, bp))) { 10681830bca1SScott Long printf("warning: udf_readlblks returned error %d\n", error); 1069744bb56dSScott Long /* note: *bp may be non-NULL */ 107051a7b740SScott Long return (error); 107151a7b740SScott Long } 107251a7b740SScott Long 107351a7b740SScott Long bp1 = *bp; 1074c2d6947dSJeroen Ruigrok van der Werven *data = (uint8_t *)&bp1->b_data[offset % udfmp->bsize]; 107551a7b740SScott Long return (0); 107651a7b740SScott Long } 107751a7b740SScott Long 107851a7b740SScott Long /* 107951a7b740SScott Long * Translate a file offset into a logical block and then into a physical 108051a7b740SScott Long * block. 108151a7b740SScott Long */ 108251a7b740SScott Long static int 10839d32fde8SScott Long udf_bmap_internal(struct udf_node *node, off_t offset, daddr_t *sector, 10849d32fde8SScott Long uint32_t *max_size) 108551a7b740SScott Long { 108651a7b740SScott Long struct udf_mnt *udfmp; 108751a7b740SScott Long struct file_entry *fentry; 108851a7b740SScott Long void *icb; 108951a7b740SScott Long struct icb_tag *tag; 1090c2d6947dSJeroen Ruigrok van der Werven uint32_t icblen = 0; 109198b0c789SPoul-Henning Kamp daddr_t lsector; 109251a7b740SScott Long int ad_offset, ad_num = 0; 109351a7b740SScott Long int i, p_offset; 109451a7b740SScott Long 109551a7b740SScott Long udfmp = node->udfmp; 109651a7b740SScott Long fentry = node->fentry; 109751a7b740SScott Long tag = &fentry->icbtag; 109851a7b740SScott Long 1099bf1c3dddSScott Long switch (le16toh(tag->strat_type)) { 110051a7b740SScott Long case 4: 110151a7b740SScott Long break; 110251a7b740SScott Long 110351a7b740SScott Long case 4096: 110451a7b740SScott Long printf("Cannot deal with strategy4096 yet!\n"); 110551a7b740SScott Long return (ENODEV); 110651a7b740SScott Long 110751a7b740SScott Long default: 110851a7b740SScott Long printf("Unknown strategy type %d\n", tag->strat_type); 110951a7b740SScott Long return (ENODEV); 111051a7b740SScott Long } 111151a7b740SScott Long 1112bf1c3dddSScott Long switch (le16toh(tag->flags) & 0x7) { 111351a7b740SScott Long case 0: 111451a7b740SScott Long /* 111551a7b740SScott Long * The allocation descriptor field is filled with short_ad's. 111651a7b740SScott Long * If the offset is beyond the current extent, look for the 111751a7b740SScott Long * next extent. 111851a7b740SScott Long */ 111951a7b740SScott Long do { 112051a7b740SScott Long offset -= icblen; 112151a7b740SScott Long ad_offset = sizeof(struct short_ad) * ad_num; 1122bf1c3dddSScott Long if (ad_offset > le32toh(fentry->l_ad)) { 112351a7b740SScott Long printf("File offset out of bounds\n"); 112451a7b740SScott Long return (EINVAL); 112551a7b740SScott Long } 1126a4d629e3SScott Long icb = GETICB(short_ad, fentry, 1127bf1c3dddSScott Long le32toh(fentry->l_ea) + ad_offset); 112851a7b740SScott Long icblen = GETICBLEN(short_ad, icb); 112951a7b740SScott Long ad_num++; 113051a7b740SScott Long } while(offset >= icblen); 113151a7b740SScott Long 113251a7b740SScott Long lsector = (offset >> udfmp->bshift) + 1133937a2387SWill Andrews le32toh(((struct short_ad *)(icb))->pos); 113451a7b740SScott Long 11351830bca1SScott Long *max_size = GETICBLEN(short_ad, icb); 113651a7b740SScott Long 113751a7b740SScott Long break; 113851a7b740SScott Long case 1: 113951a7b740SScott Long /* 114051a7b740SScott Long * The allocation descriptor field is filled with long_ad's 114151a7b740SScott Long * If the offset is beyond the current extent, look for the 114251a7b740SScott Long * next extent. 114351a7b740SScott Long */ 114451a7b740SScott Long do { 114551a7b740SScott Long offset -= icblen; 114651a7b740SScott Long ad_offset = sizeof(struct long_ad) * ad_num; 1147bf1c3dddSScott Long if (ad_offset > le32toh(fentry->l_ad)) { 114851a7b740SScott Long printf("File offset out of bounds\n"); 114951a7b740SScott Long return (EINVAL); 115051a7b740SScott Long } 1151bf1c3dddSScott Long icb = GETICB(long_ad, fentry, 1152bf1c3dddSScott Long le32toh(fentry->l_ea) + ad_offset); 115351a7b740SScott Long icblen = GETICBLEN(long_ad, icb); 115451a7b740SScott Long ad_num++; 115551a7b740SScott Long } while(offset >= icblen); 115651a7b740SScott Long 115751a7b740SScott Long lsector = (offset >> udfmp->bshift) + 1158bf1c3dddSScott Long le32toh(((struct long_ad *)(icb))->loc.lb_num); 115951a7b740SScott Long 11601830bca1SScott Long *max_size = GETICBLEN(long_ad, icb); 116151a7b740SScott Long 116251a7b740SScott Long break; 116351a7b740SScott Long case 3: 116451a7b740SScott Long /* 116551a7b740SScott Long * This type means that the file *data* is stored in the 116651a7b740SScott Long * allocation descriptor field of the file entry. 116751a7b740SScott Long */ 116851a7b740SScott Long *max_size = 0; 11698db4c2f2SScott Long *sector = node->hash_id + udfmp->part_start; 117051a7b740SScott Long 11714576293dSScott Long return (UDF_INVALID_BMAP); 117251a7b740SScott Long case 2: 117351a7b740SScott Long /* DirectCD does not use extended_ad's */ 117451a7b740SScott Long default: 117551a7b740SScott Long printf("Unsupported allocation descriptor %d\n", 117651a7b740SScott Long tag->flags & 0x7); 117751a7b740SScott Long return (ENODEV); 117851a7b740SScott Long } 117951a7b740SScott Long 118051a7b740SScott Long *sector = lsector + udfmp->part_start; 118151a7b740SScott Long 118251a7b740SScott Long /* 118351a7b740SScott Long * Check the sparing table. Each entry represents the beginning of 118451a7b740SScott Long * a packet. 118551a7b740SScott Long */ 118651a7b740SScott Long if (udfmp->s_table != NULL) { 118751a7b740SScott Long for (i = 0; i< udfmp->s_table_entries; i++) { 1188bf1c3dddSScott Long p_offset = 1189bf1c3dddSScott Long lsector - le32toh(udfmp->s_table->entries[i].org); 119051a7b740SScott Long if ((p_offset < udfmp->p_sectors) && (p_offset >= 0)) { 1191bf1c3dddSScott Long *sector = 1192bf1c3dddSScott Long le32toh(udfmp->s_table->entries[i].map) + 119351a7b740SScott Long p_offset; 119451a7b740SScott Long break; 119551a7b740SScott Long } 119651a7b740SScott Long } 119751a7b740SScott Long } 119851a7b740SScott Long 119951a7b740SScott Long return (0); 120051a7b740SScott Long } 1201