Home | History | Annotate | Line # | Download | only in efs
efs_vnops.c revision 1.16 
      1 /*	$NetBSD: efs_vnops.c,v 1.16 2008/11/26 20:17:33 pooka Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2006 Stephen M. Rumble <rumble (at) ephemeral.org>
      5  *
      6  * Permission to use, copy, modify, and distribute this software for any
      7  * purpose with or without fee is hereby granted, provided that the above
      8  * copyright notice and this permission notice appear in all copies.
      9  *
     10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
     11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
     13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
     14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
     15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
     16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
     17  */
     18 
     19 #include <sys/cdefs.h>
     20 __KERNEL_RCSID(0, "$NetBSD: efs_vnops.c,v 1.16 2008/11/26 20:17:33 pooka Exp $");
     21 
     22 #include <sys/param.h>
     23 #include <sys/systm.h>
     24 #include <sys/proc.h>
     25 #include <sys/kernel.h>
     26 #include <sys/vnode.h>
     27 #include <sys/mount.h>
     28 #include <sys/malloc.h>
     29 #include <sys/namei.h>
     30 #include <sys/dirent.h>
     31 #include <sys/lockf.h>
     32 #include <sys/unistd.h>
     33 #include <sys/buf.h>
     34 
     35 #include <miscfs/genfs/genfs.h>
     36 #include <miscfs/genfs/genfs_node.h>
     37 
     38 #include <fs/efs/efs.h>
     39 #include <fs/efs/efs_sb.h>
     40 #include <fs/efs/efs_dir.h>
     41 #include <fs/efs/efs_genfs.h>
     42 #include <fs/efs/efs_mount.h>
     43 #include <fs/efs/efs_extent.h>
     44 #include <fs/efs/efs_dinode.h>
     45 #include <fs/efs/efs_inode.h>
     46 #include <fs/efs/efs_subr.h>
     47 #include <fs/efs/efs_ihash.h>
     48 
     49 MALLOC_DECLARE(M_EFSTMP);
     50 
     51 /*
     52  * Lookup a pathname component in the given directory.
     53  *
     54  * Returns 0 on success.
     55  */
     56 static int
     57 efs_lookup(void *v)
     58 {
     59 	struct vop_lookup_args /* {
     60 		struct vnode *a_dvp;
     61 		struct vnode **a_vpp;
     62 		struct componentname *a_cnp;
     63 	} */ *ap = v;
     64 	struct componentname *cnp = ap->a_cnp;
     65 	struct vnode *vp;
     66 	ino_t ino;
     67 	int err, nameiop = cnp->cn_nameiop;
     68 
     69 	/* ensure that the directory can be accessed first */
     70         err = VOP_ACCESS(ap->a_dvp, VEXEC, cnp->cn_cred);
     71 	if (err)
     72 		return (err);
     73 
     74 	err = cache_lookup(ap->a_dvp, ap->a_vpp, cnp);
     75 	if (err != -1)
     76 		return (err);
     77 
     78 	/*
     79 	 * Handle the three lookup types: '.', '..', and everything else.
     80 	 */
     81 	if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
     82 		vref(ap->a_dvp);
     83 		*ap->a_vpp = ap->a_dvp;
     84 	} else if (cnp->cn_flags & ISDOTDOT) {
     85 		err = efs_inode_lookup(VFSTOEFS(ap->a_dvp->v_mount),
     86 		    EFS_VTOI(ap->a_dvp), ap->a_cnp, &ino);
     87 		if (err)
     88 			return (err);
     89 
     90 		VOP_UNLOCK(ap->a_dvp, 0);	/* preserve lock order */
     91 
     92 		err = VFS_VGET(ap->a_dvp->v_mount, ino, &vp);
     93 		if (err) {
     94 			vn_lock(ap->a_dvp, LK_EXCLUSIVE | LK_RETRY);
     95 			return (err);
     96 		}
     97 		vn_lock(ap->a_dvp, LK_EXCLUSIVE | LK_RETRY);
     98 		*ap->a_vpp = vp;
     99 	} else {
    100 		err = efs_inode_lookup(VFSTOEFS(ap->a_dvp->v_mount),
    101 		    EFS_VTOI(ap->a_dvp), ap->a_cnp, &ino);
    102 		if (err) {
    103 			if (err == ENOENT && (cnp->cn_flags & MAKEENTRY) &&
    104 			    nameiop != CREATE)
    105 				cache_enter(ap->a_dvp, NULL, cnp);
    106 			if (err == ENOENT && (nameiop == CREATE ||
    107 			    nameiop == RENAME)) {
    108 				err = VOP_ACCESS(ap->a_dvp, VWRITE,
    109 				    cnp->cn_cred);
    110 				if (err)
    111 					return (err);
    112 				cnp->cn_flags |= SAVENAME;
    113 				return (EJUSTRETURN);
    114 			}
    115 			return (err);
    116 		}
    117 		err = VFS_VGET(ap->a_dvp->v_mount, ino, &vp);
    118 		if (err)
    119 			return (err);
    120 		*ap->a_vpp = vp;
    121 	}
    122 
    123 	if (cnp->cn_flags & MAKEENTRY)
    124 		cache_enter(ap->a_dvp, *ap->a_vpp, cnp);
    125 
    126 	return (0);
    127 }
    128 
    129 /*
    130  * Determine the accessiblity of a file based on the permissions allowed by the
    131  * specified credentials.
    132  *
    133  * Returns 0 on success.
    134  */
    135 static int
    136 efs_access(void *v)
    137 {
    138 	struct vop_access_args /* {
    139 		const struct vnodeop_desc *a_desc;
    140 		struct vnode *a_vp;
    141 		int a_mode;
    142 		struct ucred *a_cred;
    143 	} */ *ap = v;
    144 	struct vnode *vp = ap->a_vp;
    145 	struct efs_inode *eip = EFS_VTOI(vp);
    146 
    147 	if ((ap->a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY))
    148 		return (EROFS);
    149 
    150 	return (vaccess(vp->v_type, eip->ei_mode, eip->ei_uid, eip->ei_gid,
    151 	    ap->a_mode, ap->a_cred));
    152 }
    153 
    154 /*
    155  * Get specific vnode attributes on a file. See vattr(9).
    156  *
    157  * Returns 0 on success.
    158  */
    159 static int
    160 efs_getattr(void *v)
    161 {
    162 	struct vop_getattr_args /* {
    163 		const struct vnodeop_desc *a_desc;
    164 		struct vnode *a_vp;
    165 		struct vattr *a_vap;
    166 		struct ucred *a_cred;
    167 	} */ *ap = v;
    168 
    169 	struct vattr *vap = ap->a_vap;
    170 	struct efs_inode *eip = EFS_VTOI(ap->a_vp);
    171 
    172 	vattr_null(ap->a_vap);
    173 	vap->va_type		= ap->a_vp->v_type;
    174 	vap->va_mode		= eip->ei_mode;
    175 	vap->va_nlink		= eip->ei_nlink;
    176 	vap->va_uid		= eip->ei_uid;
    177 	vap->va_gid		= eip->ei_gid;
    178 	vap->va_fsid 		= ap->a_vp->v_mount->mnt_stat.f_fsid;
    179 	vap->va_fileid 		= eip->ei_number;
    180 	vap->va_size 		= eip->ei_size;
    181 
    182 	if (ap->a_vp->v_type == VBLK)
    183 		vap->va_blocksize = BLKDEV_IOSIZE;
    184 	else if (ap->a_vp->v_type == VCHR)
    185 		vap->va_blocksize = MAXBSIZE;
    186 	else
    187 		vap->va_blocksize = EFS_BB_SIZE;
    188 
    189 	vap->va_atime.tv_sec	= eip->ei_atime;
    190 	vap->va_mtime.tv_sec	= eip->ei_mtime;
    191 	vap->va_ctime.tv_sec	= eip->ei_ctime;
    192 /*	vap->va_birthtime 	= */
    193 	vap->va_gen		= eip->ei_gen;
    194 	vap->va_flags		= ap->a_vp->v_vflag |
    195 	    ap->a_vp->v_iflag | ap->a_vp->v_uflag;
    196 
    197 	if (ap->a_vp->v_type == VBLK || ap->a_vp->v_type == VCHR) {
    198 		uint32_t dmaj, dmin;
    199 
    200 		if (be16toh(eip->ei_di.di_odev) != EFS_DINODE_ODEV_INVALID) {
    201 			dmaj = EFS_DINODE_ODEV_MAJ(be16toh(eip->ei_di.di_odev));
    202 			dmin = EFS_DINODE_ODEV_MIN(be16toh(eip->ei_di.di_odev));
    203 		} else {
    204 			dmaj = EFS_DINODE_NDEV_MAJ(be32toh(eip->ei_di.di_ndev));
    205 			dmin = EFS_DINODE_NDEV_MIN(be32toh(eip->ei_di.di_ndev));
    206 		}
    207 
    208 		vap->va_rdev = makedev(dmaj, dmin);
    209 	}
    210 
    211 	vap->va_bytes		= eip->ei_size;
    212 /*	vap->va_filerev		= */
    213 /*	vap->va_vaflags		= */
    214 
    215 	return (0);
    216 }
    217 
    218 /*
    219  * Read a file.
    220  *
    221  * Returns 0 on success.
    222  */
    223 static int
    224 efs_read(void *v)
    225 {
    226 	struct vop_read_args /* {
    227 		const struct vnodeop_desc *a_desc;
    228 		struct vnode *a_vp;
    229 		struct uio *a_uio;
    230 		int a_ioflag;
    231 		struct ucred *a_cred;
    232 	} */ *ap = v;
    233 	struct efs_extent ex;
    234 	struct efs_extent_iterator exi;
    235 	struct uio *uio = ap->a_uio;
    236 	struct efs_inode *eip = EFS_VTOI(ap->a_vp);
    237 	off_t start;
    238 	vsize_t len;
    239 	int err, ret;
    240 	const int advice = IO_ADV_DECODE(ap->a_ioflag);
    241 
    242 	if (ap->a_vp->v_type == VDIR)
    243 		return (EISDIR);
    244 
    245 	if (ap->a_vp->v_type != VREG)
    246 		return (EINVAL);
    247 
    248 	efs_extent_iterator_init(&exi, eip, uio->uio_offset);
    249 	ret = efs_extent_iterator_next(&exi, &ex);
    250 	while (ret == 0) {
    251 		if (uio->uio_offset < 0 || uio->uio_offset >= eip->ei_size ||
    252 		    uio->uio_resid == 0)
    253 			break;
    254 
    255 		start = ex.ex_offset * EFS_BB_SIZE;
    256 		len   = ex.ex_length * EFS_BB_SIZE;
    257 
    258 		if (!(uio->uio_offset >= start &&
    259 		      uio->uio_offset < (start + len))) {
    260 			ret = efs_extent_iterator_next(&exi, &ex);
    261 			continue;
    262 		}
    263 
    264 		start = uio->uio_offset - start;
    265 
    266 		len = MIN(len - start, uio->uio_resid);
    267 		len = MIN(len, eip->ei_size - uio->uio_offset);
    268 
    269 		err = ubc_uiomove(&ap->a_vp->v_uobj, uio, len, advice,
    270 		    UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(ap->a_vp));
    271 		if (err) {
    272 			EFS_DPRINTF(("efs_read: uiomove error %d\n",
    273 			    err));
    274 			return (err);
    275 		}
    276 	}
    277 
    278 	return ((ret == -1) ? 0 : ret);
    279 }
    280 
    281 static int
    282 efs_readdir(void *v)
    283 {
    284 	struct vop_readdir_args /* {
    285 		const struct vnodeop_desc *a_desc;
    286 		struct vnode *a_vp;
    287 		struct uio *a_uio;
    288 		struct ucred *a_cred;
    289 		int *a_eofflag;
    290 		off_t **a_cookies;
    291 		int *a_ncookies;
    292 	} */ *ap = v;
    293 	struct dirent *dp;
    294 	struct efs_dinode edi;
    295 	struct efs_extent ex;
    296 	struct efs_extent_iterator exi;
    297 	struct buf *bp;
    298 	struct efs_dirent *de;
    299 	struct efs_dirblk *db;
    300 	struct uio *uio = ap->a_uio;
    301 	struct efs_inode *ei = EFS_VTOI(ap->a_vp);
    302 	off_t *cookies = NULL;
    303 	off_t offset;
    304 	int i, j, err, ret, s, slot, ncookies, maxcookies = 0;
    305 
    306 	if (ap->a_vp->v_type != VDIR)
    307 		return (ENOTDIR);
    308 
    309 	if (ap->a_eofflag != NULL)
    310 		*ap->a_eofflag = false;
    311 
    312 	if (ap->a_ncookies != NULL) {
    313 		ncookies = 0;
    314 		maxcookies =
    315 		    uio->uio_resid / _DIRENT_MINSIZE((struct dirent *)0);
    316 		cookies = malloc(maxcookies * sizeof(off_t), M_TEMP, M_WAITOK);
    317  	}
    318 
    319 	dp = malloc(sizeof(struct dirent), M_EFSTMP, M_WAITOK | M_ZERO);
    320 
    321 	offset = 0;
    322 	efs_extent_iterator_init(&exi, ei, 0);
    323 	while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) {
    324 		for (i = 0; i < ex.ex_length; i++) {
    325 			err = efs_bread(VFSTOEFS(ap->a_vp->v_mount),
    326 			    ex.ex_bn + i, NULL, &bp);
    327 			if (err) {
    328 				brelse(bp, 0);
    329 				goto exit_err;
    330 			}
    331 
    332 			db = (struct efs_dirblk *)bp->b_data;
    333 
    334 			if (be16toh(db->db_magic) != EFS_DIRBLK_MAGIC) {
    335 				printf("efs_readdir: bad dirblk\n");
    336 				brelse(bp, 0);
    337 				continue;
    338 			}
    339 
    340 			for (j = 0; j < db->db_slots; j++) {
    341 				slot = EFS_DIRENT_OFF_EXPND(db->db_space[j]);
    342 				if (slot == EFS_DIRBLK_SLOT_FREE)
    343 					continue;
    344 
    345 				if (!EFS_DIRENT_OFF_VALID(slot)) {
    346 					printf("efs_readdir: bad dirent\n");
    347 					continue;
    348 				}
    349 
    350 				de = EFS_DIRBLK_TO_DIRENT(db, slot);
    351 				s = _DIRENT_RECLEN(dp, de->de_namelen);
    352 
    353 				if (offset < uio->uio_offset) {
    354 					offset += s;
    355 					continue;
    356 				}
    357 
    358 				/* XXX - shouldn't happen, right? */
    359 				if (offset > uio->uio_offset ||
    360 				    s > uio->uio_resid) {
    361 					brelse(bp, 0);
    362 					goto exit_ok;
    363 				}
    364 
    365 				/* de_namelen is uint8_t, d.d_name is 512b */
    366 				KASSERT(sizeof(dp->d_name)-de->de_namelen > 0);
    367 				dp->d_fileno = be32toh(de->de_inumber);
    368 				dp->d_reclen = s;
    369 				dp->d_namlen = de->de_namelen;
    370 				memcpy(dp->d_name, de->de_name,
    371 				    de->de_namelen);
    372 				dp->d_name[de->de_namelen] = '\0';
    373 
    374 				/* look up inode to get type */
    375 				err = efs_read_inode(
    376 				    VFSTOEFS(ap->a_vp->v_mount),
    377 				    dp->d_fileno, NULL, &edi);
    378 				if (err) {
    379 					brelse(bp, 0);
    380 					goto exit_err;
    381 				}
    382 
    383 				switch (be16toh(edi.di_mode) & EFS_IFMT) {
    384 				case EFS_IFIFO:
    385 					dp->d_type = DT_FIFO;
    386 					break;
    387 				case EFS_IFCHR:
    388 					dp->d_type = DT_CHR;
    389 					break;
    390 				case EFS_IFDIR:
    391 					dp->d_type = DT_DIR;
    392 					break;
    393 				case EFS_IFBLK:
    394 					dp->d_type = DT_BLK;
    395 					break;
    396 				case EFS_IFREG:
    397 					dp->d_type = DT_REG;
    398 					break;
    399 				case EFS_IFLNK:
    400 					dp->d_type = DT_LNK;
    401 					break;
    402 				case EFS_IFSOCK:
    403 					dp->d_type = DT_SOCK;
    404 					break;
    405 				default:
    406 					dp->d_type = DT_UNKNOWN;
    407 					break;
    408 				}
    409 
    410 				err = uiomove(dp, s, uio);
    411 				if (err) {
    412 					brelse(bp, 0);
    413 					goto exit_err;
    414 				}
    415 
    416 				offset += s;
    417 
    418 				if (cookies != NULL && maxcookies != 0) {
    419 					cookies[ncookies++] = offset;
    420 					if (ncookies == maxcookies) {
    421 						brelse(bp, 0);
    422 						goto exit_ok;
    423 					}
    424 				}
    425 			}
    426 
    427 			brelse(bp, 0);
    428 		}
    429 	}
    430 
    431 	if (ret != -1) {
    432 		err = ret;
    433 		goto exit_err;
    434 	}
    435 
    436 	if (ap->a_eofflag != NULL)
    437 		*ap->a_eofflag = true;
    438 
    439  exit_ok:
    440 	if (cookies != NULL) {
    441 		*ap->a_cookies = cookies;
    442 		*ap->a_ncookies = ncookies;
    443 	}
    444 
    445 	uio->uio_offset = offset;
    446 
    447 	free(dp, M_EFSTMP);
    448 
    449 	return (0);
    450 
    451  exit_err:
    452 	if (cookies != NULL)
    453 		free(cookies, M_TEMP);
    454 
    455 	free(dp, M_EFSTMP);
    456 
    457 	return (err);
    458 }
    459 
    460 static int
    461 efs_readlink(void *v)
    462 {
    463 	struct vop_readlink_args /* {
    464 		const struct vnodeop_desc *a_desc;
    465 		struct vnode *a_vp;
    466 		struct uio *a_uio;
    467 		struct ucred *a_cred;
    468 	} */ *ap = v;
    469 	struct uio *uio = ap->a_uio;
    470 	struct efs_inode *eip = EFS_VTOI(ap->a_vp);
    471 	char *buf;
    472 	size_t len;
    473 	int err, i;
    474 
    475 	if ((eip->ei_mode & EFS_IFMT) != EFS_IFLNK)
    476 		return (EINVAL);
    477 
    478 	if (uio->uio_resid < 1)
    479 		return (EINVAL);
    480 
    481 	buf = malloc(eip->ei_size + 1, M_EFSTMP, M_ZERO | M_WAITOK);
    482 
    483 	/* symlinks are either inlined in the inode, or in extents */
    484 	if (eip->ei_numextents == 0) {
    485 		if (eip->ei_size > sizeof(eip->ei_di.di_symlink)) {
    486 			EFS_DPRINTF(("efs_readlink: too big for inline\n"));
    487 			free(buf, M_EFSTMP);
    488 			return (EBADF);
    489 		}
    490 
    491 		memcpy(buf, eip->ei_di.di_symlink, eip->ei_size);
    492 		len = MIN(uio->uio_resid, eip->ei_size + 1);
    493 	} else {
    494 		struct efs_extent_iterator exi;
    495 		struct efs_extent ex;
    496 		struct buf *bp;
    497 		int resid, off, ret;
    498 
    499 		off = 0;
    500 		resid = eip->ei_size;
    501 
    502 		efs_extent_iterator_init(&exi, eip, 0);
    503 		while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) {
    504 			for (i = 0; i < ex.ex_length; i++) {
    505 				err = efs_bread(VFSTOEFS(ap->a_vp->v_mount),
    506 				    ex.ex_bn + i, NULL, &bp);
    507 				if (err) {
    508 					brelse(bp, 0);
    509 					free(buf, M_EFSTMP);
    510 					return (err);
    511 				}
    512 
    513 				len = MIN(resid, bp->b_bcount);
    514 				memcpy(buf + off, bp->b_data, len);
    515 				brelse(bp, 0);
    516 
    517 				off += len;
    518 				resid -= len;
    519 
    520 				if (resid == 0)
    521 					break;
    522 			}
    523 
    524 			if (resid == 0)
    525 				break;
    526 		}
    527 
    528 		if (ret != 0 && ret != -1) {
    529 			free(buf, M_EFSTMP);
    530 			return (ret);
    531 		}
    532 
    533 		len = off + 1;
    534 	}
    535 
    536 	KASSERT(len >= 1 && len <= (eip->ei_size + 1));
    537 	buf[len - 1] = '\0';
    538 	err = uiomove(buf, len, uio);
    539 	free(buf, M_EFSTMP);
    540 
    541 	return (err);
    542 }
    543 
    544 /*
    545  * Release an inactive vnode. The vnode _must_ be unlocked on return.
    546  * It is either nolonger being used by the kernel, or an unmount is being
    547  * forced.
    548  *
    549  * Returns 0 on success.
    550  */
    551 static int
    552 efs_inactive(void *v)
    553 {
    554 	struct vop_inactive_args /* {
    555 		const struct vnodeop_desc *a_desc;
    556 		struct vnode *a_vp;
    557 		bool *a_recycle
    558 	} */ *ap = v;
    559 	struct efs_inode *eip = EFS_VTOI(ap->a_vp);
    560 
    561 	*ap->a_recycle = (eip->ei_mode == 0);
    562 	VOP_UNLOCK(ap->a_vp, 0);
    563 
    564 	return (0);
    565 }
    566 
    567 static int
    568 efs_reclaim(void *v)
    569 {
    570 	struct vop_reclaim_args /* {
    571 		const struct vnodeop_desc *a_desc;
    572 		struct vnode *a_vp;
    573 	} */ *ap = v;
    574 	struct vnode *vp = ap->a_vp;
    575 
    576 	efs_ihashrem(EFS_VTOI(vp));
    577 	cache_purge(vp);
    578 	genfs_node_destroy(vp);
    579 	pool_put(&efs_inode_pool, vp->v_data);
    580 	vp->v_data = NULL;
    581 
    582 	return (0);
    583 }
    584 
    585 static int
    586 efs_bmap(void *v)
    587 {
    588 	struct vop_bmap_args /* {
    589 		const struct vnodeop_desc *a_desc;
    590 		struct vnode *a_vp;
    591 		daddr_t a_bn;
    592 		struct vnode **a_vpp;
    593 		daddr_t *a_bnp;
    594 		int *a_runp;
    595 	} */ *ap = v;
    596 	struct efs_extent ex;
    597 	struct efs_extent_iterator exi;
    598 	struct vnode *vp = ap->a_vp;
    599 	struct efs_inode *eip = EFS_VTOI(vp);
    600 	bool found;
    601 	int ret;
    602 
    603 	if (ap->a_vpp != NULL)
    604 		*ap->a_vpp = VFSTOEFS(vp->v_mount)->em_devvp;
    605 
    606 	found = false;
    607 	efs_extent_iterator_init(&exi, eip, ap->a_bn * EFS_BB_SIZE);
    608 	while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) {
    609 		if (ap->a_bn >= ex.ex_offset &&
    610 		    ap->a_bn < (ex.ex_offset + ex.ex_length)) {
    611 			found = true;
    612 			break;
    613 		}
    614 	}
    615 
    616 	KASSERT(!found || (found && ret == 0));
    617 
    618 	if (!found) {
    619 		EFS_DPRINTF(("efs_bmap: ap->a_bn not in extents\n"));
    620 		return ((ret == -1) ? EIO : ret);
    621 	}
    622 
    623 	if (ex.ex_magic != EFS_EXTENT_MAGIC) {
    624 		EFS_DPRINTF(("efs_bmap: exn.ex_magic != EFS_EXTENT_MAGIC\n"));
    625 		return (EIO);
    626 	}
    627 
    628 	if (ap->a_bn < ex.ex_offset) {
    629 		EFS_DPRINTF(("efs_bmap: ap->a_bn < exn.ex_offset\n"));
    630 		return (EIO);
    631 	}
    632 
    633 	KASSERT(ap->a_bn >= ex.ex_offset);
    634 	KASSERT(ex.ex_length > ap->a_bn - ex.ex_offset);
    635 
    636 	*ap->a_bnp = ex.ex_bn + (ap->a_bn - ex.ex_offset);
    637 	if (ap->a_runp != NULL)
    638 		*ap->a_runp = ex.ex_length - (ap->a_bn - ex.ex_offset) - 1;
    639 
    640 	return (0);
    641 }
    642 
    643 static int
    644 efs_strategy(void *v)
    645 {
    646 	struct vop_strategy_args /* {
    647 		const struct vnodeop_desc *a_desc;
    648 		struct vnode *a_vp;
    649 		struct buf *a_bp;
    650 	} */ *ap = v;
    651 	struct vnode *vp = ap->a_vp;
    652 	struct buf *bp = ap->a_bp;
    653 	int error;
    654 
    655 	if (vp == NULL) {
    656 		bp->b_error = EIO;
    657 		biodone(bp);
    658 		return (EIO);
    659 	}
    660 
    661 	if (bp->b_blkno == bp->b_lblkno) {
    662 		error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL);
    663 		if (error) {
    664 			bp->b_error = error;
    665 			biodone(bp);
    666 			return (error);
    667 		}
    668 		if ((long)bp->b_blkno == -1)
    669 			clrbuf(bp);
    670 	}
    671 
    672 	if ((long)bp->b_blkno == -1) {
    673 		biodone(bp);
    674 		return (0);
    675 	}
    676 
    677 	return (VOP_STRATEGY(VFSTOEFS(vp->v_mount)->em_devvp, bp));
    678 }
    679 
    680 static int
    681 efs_print(void *v)
    682 {
    683 	struct vop_print_args /* {
    684 		const struct vnodeop_desc *a_desc;
    685 		struct vnode *a_vp;
    686 	} */ *ap = v;
    687 	struct efs_inode *eip = EFS_VTOI(ap->a_vp);
    688 
    689 	printf(	"efs_inode (ino %lu):\n"
    690 		"    ei_mode:         %07o\n"
    691 		"    ei_nlink:        %d\n"
    692 		"    ei_uid:          %d\n"
    693 		"    ei_gid:          %d\n"
    694 		"    ei_size:         %d\n"
    695 		"    ei_atime:        %d\n"
    696 		"    ei_mtime:        %d\n"
    697 		"    ei_ctime:        %d\n"
    698 		"    ei_gen:          %d\n"
    699 		"    ei_numextents:   %d\n"
    700 		"    ei_version:      %d\n",
    701 		(unsigned long)eip->ei_number,
    702 		(unsigned int)eip->ei_mode,
    703 		eip->ei_nlink,
    704 		eip->ei_uid,
    705 		eip->ei_gid,
    706 		eip->ei_size,
    707 		(int32_t)eip->ei_atime,
    708 		(int32_t)eip->ei_mtime,
    709 		(int32_t)eip->ei_ctime,
    710 		eip->ei_gen,
    711 		eip->ei_numextents,
    712 		eip->ei_version);
    713 
    714 	return (0);
    715 }
    716 
    717 static int
    718 efs_pathconf(void *v)
    719 {
    720 	struct vop_pathconf_args /* {
    721 		const struct vnodeop_desc *a_desc;
    722 		struct vnode *a_vp;
    723 		int a_name;
    724 		register_t *a_retval;
    725 	} */ *ap = v;
    726 
    727 	/* IRIX 4 values */
    728 	switch (ap->a_name) {
    729 	case _PC_LINK_MAX:
    730 		*ap->a_retval = 30000;
    731 		break;
    732 	case _PC_NAME_MAX:
    733 		*ap->a_retval = 255;
    734 		break;
    735 	case _PC_PATH_MAX:
    736 		*ap->a_retval = 1024;
    737 		break;
    738 	case _PC_NO_TRUNC:
    739 		*ap->a_retval = 1;
    740 		break;
    741 	case _PC_CHOWN_RESTRICTED:
    742 		*ap->a_retval = 1;
    743 		break;
    744 	case _PC_SYNC_IO:
    745 		*ap->a_retval = 1;
    746 		break;
    747 	case _PC_FILESIZEBITS:
    748 		*ap->a_retval = 32;
    749 		break;
    750 	default:
    751 		return (EINVAL);
    752 	}
    753 
    754 	return (0);
    755 }
    756 
    757 static int
    758 efs_advlock(void *v)
    759 {
    760 	struct vop_advlock_args /* {
    761 		const struct vnodeop_desc *a_desc;
    762 		struct vnode *a_vp;
    763 		void *a_id;
    764 		int a_op;
    765 		struct flock *a_fl;
    766 		int a_flags;
    767 	} */ *ap = v;
    768 	struct efs_inode *eip = EFS_VTOI(ap->a_vp);
    769 
    770 	return (lf_advlock(ap, &eip->ei_lockf, eip->ei_size));
    771 }
    772 
    773 /* Global vfs data structures for efs */
    774 int (**efs_vnodeop_p)(void *);
    775 const struct vnodeopv_entry_desc efs_vnodeop_entries[] = {
    776 	{ &vop_default_desc,	vn_default_error},	/* error handler */
    777 	{ &vop_lookup_desc,	efs_lookup	},	/* lookup */
    778 	{ &vop_create_desc,	genfs_eopnotsupp},	/* create */
    779 	{ &vop_mknod_desc,	genfs_eopnotsupp},	/* mknod */
    780 	{ &vop_open_desc,	genfs_nullop	},	/* open */
    781 	{ &vop_close_desc,	genfs_nullop	},	/* close */
    782 	{ &vop_access_desc,	efs_access	},	/* access */
    783 	{ &vop_getattr_desc,	efs_getattr	},	/* getattr */
    784 	{ &vop_setattr_desc,	genfs_eopnotsupp},	/* setattr */
    785 	{ &vop_read_desc,	efs_read	},	/* read */
    786 	{ &vop_write_desc,	genfs_eopnotsupp},	/* write */
    787 	{ &vop_ioctl_desc,	genfs_enoioctl	},	/* ioctl */
    788 	{ &vop_fcntl_desc,	genfs_fcntl	},	/* fcntl */
    789 	{ &vop_poll_desc,	genfs_poll	},	/* poll */
    790 	{ &vop_kqfilter_desc,	genfs_kqfilter	},	/* kqfilter */
    791 	{ &vop_revoke_desc,	genfs_revoke	},	/* revoke */
    792 	{ &vop_mmap_desc,	genfs_mmap	},	/* mmap */
    793 	{ &vop_fsync_desc,	genfs_eopnotsupp},	/* fsync */
    794 	{ &vop_seek_desc,	genfs_seek	},	/* seek */
    795 	{ &vop_remove_desc,	genfs_eopnotsupp},	/* remove */
    796 	{ &vop_link_desc,	genfs_eopnotsupp},	/* link */
    797 	{ &vop_rename_desc,	genfs_eopnotsupp},	/* rename */
    798 	{ &vop_mkdir_desc,	genfs_eopnotsupp},	/* mkdir */
    799 	{ &vop_rmdir_desc,	genfs_eopnotsupp},	/* rmdir */
    800 	{ &vop_symlink_desc,	genfs_eopnotsupp},	/* symlink */
    801 	{ &vop_readdir_desc,	efs_readdir	},	/* readdir */
    802 	{ &vop_readlink_desc,	efs_readlink	},	/* readlink */
    803 	{ &vop_abortop_desc,	genfs_abortop	},	/* abortop */
    804 	{ &vop_inactive_desc,	efs_inactive	},	/* inactive */
    805 	{ &vop_reclaim_desc,	efs_reclaim	},	/* reclaim */
    806 	{ &vop_lock_desc,	genfs_lock,	},	/* lock */
    807 	{ &vop_unlock_desc,	genfs_unlock,	},	/* unlock */
    808 	{ &vop_islocked_desc,	genfs_islocked,	},	/* islocked */
    809 	{ &vop_bmap_desc,	efs_bmap	},	/* bmap */
    810 	{ &vop_print_desc,	efs_print	},	/* print */
    811 	{ &vop_pathconf_desc,	efs_pathconf	},	/* pathconf */
    812 	{ &vop_advlock_desc,	efs_advlock	},	/* advlock */
    813 							/* blkatoff */
    814 							/* valloc */
    815 							/* balloc */
    816 							/* vfree */
    817 							/* truncate */
    818 							/* whiteout */
    819 	{ &vop_getpages_desc,	genfs_getpages	},	/* getpages */
    820 	{ &vop_putpages_desc,	genfs_putpages	},	/* putpages */
    821 	{ &vop_bwrite_desc,	vn_bwrite	},	/* bwrite */
    822 	{ &vop_strategy_desc,	efs_strategy	},	/* strategy */
    823 	{ NULL, NULL }
    824 };
    825 const struct vnodeopv_desc efs_vnodeop_opv_desc = {
    826 	&efs_vnodeop_p,
    827 	efs_vnodeop_entries
    828 };
    829