xref: /freebsd/sys/fs/udf/udf_vnops.c (revision 0c09ac0d576bbf7f93993229fbbf8d5662bbfa42)
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 		    &sector, &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, &sector, &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