Home | History | Annotate | Line # | Download | only in sysvbfs
sysvbfs_vnops.c revision 1.62
      1 /*	$NetBSD: sysvbfs_vnops.c,v 1.62 2017/04/26 03:02:48 riastradh Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2004 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by UCHIYAMA Yasushi.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 __KERNEL_RCSID(0, "$NetBSD: sysvbfs_vnops.c,v 1.62 2017/04/26 03:02:48 riastradh Exp $");
     34 
     35 #include <sys/param.h>
     36 #include <sys/kernel.h>
     37 #include <sys/resource.h>
     38 #include <sys/vnode.h>
     39 #include <sys/namei.h>
     40 #include <sys/dirent.h>
     41 #include <sys/malloc.h>
     42 #include <sys/lockf.h>
     43 #include <sys/unistd.h>
     44 #include <sys/fcntl.h>
     45 #include <sys/kauth.h>
     46 #include <sys/buf.h>
     47 
     48 #include <miscfs/genfs/genfs.h>
     49 
     50 #include <fs/sysvbfs/sysvbfs.h>
     51 #include <fs/sysvbfs/bfs.h>
     52 
     53 #ifdef SYSVBFS_VNOPS_DEBUG
     54 #define	DPRINTF(fmt, args...)	printf(fmt, ##args)
     55 #else
     56 #define	DPRINTF(arg...)		((void)0)
     57 #endif
     58 #define	ROUND_SECTOR(x)		(((x) + 511) & ~511)
     59 
     60 MALLOC_JUSTDEFINE(M_SYSVBFS_VNODE, "sysvbfs vnode", "sysvbfs vnode structures");
     61 MALLOC_DECLARE(M_BFS);
     62 
     63 static void sysvbfs_file_setsize(struct vnode *, size_t);
     64 
     65 int
     66 sysvbfs_lookup(void *arg)
     67 {
     68 	struct vop_lookup_v2_args /* {
     69 		struct vnode *a_dvp;
     70 		struct vnode **a_vpp;
     71 		struct componentname *a_cnp;
     72 	} */ *a = arg;
     73 	struct vnode *v = a->a_dvp;
     74 	struct sysvbfs_node *bnode = v->v_data;
     75 	struct bfs *bfs = bnode->bmp->bfs;	/* my filesystem */
     76 	struct vnode *vpp = NULL;
     77 	struct bfs_dirent *dirent = NULL;
     78 	struct componentname *cnp = a->a_cnp;
     79 	int nameiop = cnp->cn_nameiop;
     80 	const char *name = cnp->cn_nameptr;
     81 	int namelen = cnp->cn_namelen;
     82 	int error;
     83 
     84 	DPRINTF("%s: %s op=%d %d\n", __func__, name, nameiop,
     85 	    cnp->cn_flags);
     86 
     87 	*a->a_vpp = NULL;
     88 
     89 	KASSERT((cnp->cn_flags & ISDOTDOT) == 0);
     90 
     91 	if ((error = VOP_ACCESS(a->a_dvp, VEXEC, cnp->cn_cred)) != 0) {
     92 		return error;	/* directory permission. */
     93 	}
     94 
     95 	/* Deny last component write operation on a read-only mount */
     96 	if ((cnp->cn_flags & ISLASTCN) && (v->v_mount->mnt_flag & MNT_RDONLY) &&
     97 	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
     98 		return EROFS;
     99 
    100 	if (namelen == 1 && name[0] == '.') {	/* "." */
    101 		vref(v);
    102 		*a->a_vpp = v;
    103 	} else {				/* Regular file */
    104 		if (!bfs_dirent_lookup_by_name(bfs, cnp->cn_nameptr,
    105 		    &dirent)) {
    106 			if (nameiop != CREATE && nameiop != RENAME) {
    107 				DPRINTF("%s: no such a file. (1)\n",
    108 				    __func__);
    109 				return ENOENT;
    110 			}
    111 			if ((error = VOP_ACCESS(v, VWRITE, cnp->cn_cred)) != 0)
    112 				return error;
    113 			return EJUSTRETURN;
    114 		}
    115 
    116 		/* Allocate v-node */
    117 		if ((error = sysvbfs_vget(v->v_mount, dirent->inode, &vpp)) != 0) {
    118 			DPRINTF("%s: can't get vnode.\n", __func__);
    119 			return error;
    120 		}
    121 		VOP_UNLOCK(vpp);
    122 		*a->a_vpp = vpp;
    123 	}
    124 
    125 	return 0;
    126 }
    127 
    128 int
    129 sysvbfs_create(void *arg)
    130 {
    131 	struct vop_create_v3_args /* {
    132 		struct vnode *a_dvp;
    133 		struct vnode **a_vpp;
    134 		struct componentname *a_cnp;
    135 		struct vattr *a_vap;
    136 	} */ *a = arg;
    137 	struct sysvbfs_node *bnode = a->a_dvp->v_data;
    138 	struct sysvbfs_mount *bmp = bnode->bmp;
    139 	struct bfs *bfs = bmp->bfs;
    140 	struct mount *mp = bmp->mountp;
    141 	struct bfs_dirent *dirent;
    142 	struct bfs_fileattr attr;
    143 	struct vattr *va = a->a_vap;
    144 	kauth_cred_t cr = a->a_cnp->cn_cred;
    145 	int err = 0;
    146 
    147 	DPRINTF("%s: %s\n", __func__, a->a_cnp->cn_nameptr);
    148 	KDASSERT(a->a_vap->va_type == VREG);
    149 	attr.uid = kauth_cred_geteuid(cr);
    150 	attr.gid = kauth_cred_getegid(cr);
    151 	attr.mode = va->va_mode;
    152 
    153 	if ((err = bfs_file_create(bfs, a->a_cnp->cn_nameptr, 0, 0, &attr))
    154 	    != 0) {
    155 		DPRINTF("%s: bfs_file_create failed.\n", __func__);
    156 		return err;
    157 	}
    158 
    159 	if (!bfs_dirent_lookup_by_name(bfs, a->a_cnp->cn_nameptr, &dirent))
    160 		panic("no dirent for created file.");
    161 
    162 	if ((err = sysvbfs_vget(mp, dirent->inode, a->a_vpp)) != 0) {
    163 		DPRINTF("%s: sysvbfs_vget failed.\n", __func__);
    164 		return err;
    165 	}
    166 	bnode = (*a->a_vpp)->v_data;
    167 	bnode->update_ctime = true;
    168 	bnode->update_mtime = true;
    169 	bnode->update_atime = true;
    170 	VOP_UNLOCK(*a->a_vpp);
    171 
    172 	return err;
    173 }
    174 
    175 int
    176 sysvbfs_open(void *arg)
    177 {
    178 	struct vop_open_args /* {
    179 		struct vnode *a_vp;
    180 		int  a_mode;
    181 		kauth_cred_t a_cred;
    182 	} */ *a = arg;
    183 	struct vnode *v = a->a_vp;
    184 	struct sysvbfs_node *bnode = v->v_data;
    185 	struct bfs_inode *inode = bnode->inode;
    186 
    187 	DPRINTF("%s:\n", __func__);
    188 	KDASSERT(v->v_type == VREG || v->v_type == VDIR);
    189 
    190 	bnode->update_atime = true;
    191 	if ((a->a_mode & FWRITE) && !(a->a_mode & O_APPEND)) {
    192 		bnode->size = 0;
    193 	} else {
    194 		bnode->size = bfs_file_size(inode);
    195 	}
    196 	bnode->data_block = inode->start_sector;
    197 
    198 	return 0;
    199 }
    200 
    201 int
    202 sysvbfs_close(void *arg)
    203 {
    204 	struct vop_close_args /* {
    205 		struct vnodeop_desc *a_desc;
    206 		struct vnode *a_vp;
    207 		int  a_fflag;
    208 		kauth_cred_t a_cred;
    209 	} */ *a = arg;
    210 	struct vnode *v = a->a_vp;
    211 	struct sysvbfs_node *bnode = v->v_data;
    212 	struct bfs_fileattr attr;
    213 
    214 	DPRINTF("%s:\n", __func__);
    215 
    216 	if (v->v_mount->mnt_flag & MNT_RDONLY)
    217 		goto out;
    218 
    219 	uvm_vnp_setsize(v, bnode->size);
    220 
    221 	memset(&attr, 0xff, sizeof attr);	/* Set VNOVAL all */
    222 	if (bnode->update_atime)
    223 		attr.atime = time_second;
    224 	if (bnode->update_ctime)
    225 		attr.ctime = time_second;
    226 	if (bnode->update_mtime)
    227 		attr.mtime = time_second;
    228 	bfs_inode_set_attr(bnode->bmp->bfs, bnode->inode, &attr);
    229 
    230 	VOP_FSYNC(a->a_vp, a->a_cred, FSYNC_WAIT, 0, 0);
    231 
    232  out:
    233 	return 0;
    234 }
    235 
    236 static int
    237 sysvbfs_check_possible(struct vnode *vp, struct sysvbfs_node *bnode,
    238     mode_t mode)
    239 {
    240 
    241 	if ((mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY))
    242 		return EROFS;
    243 
    244 	return 0;
    245 }
    246 
    247 static int
    248 sysvbfs_check_permitted(struct vnode *vp, struct sysvbfs_node *bnode,
    249     mode_t mode, kauth_cred_t cred)
    250 {
    251 	struct bfs_fileattr *attr = &bnode->inode->attr;
    252 
    253 	return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(mode,
    254 	    vp->v_type, attr->mode), vp, NULL, genfs_can_access(vp->v_type,
    255 	    attr->mode, attr->uid, attr->gid, mode, cred));
    256 }
    257 
    258 int
    259 sysvbfs_access(void *arg)
    260 {
    261 	struct vop_access_args /* {
    262 		struct vnode	*a_vp;
    263 		int		a_mode;
    264 		kauth_cred_t	a_cred;
    265 	} */ *ap = arg;
    266 	struct vnode *vp = ap->a_vp;
    267 	struct sysvbfs_node *bnode = vp->v_data;
    268 	int error;
    269 
    270 	DPRINTF("%s:\n", __func__);
    271 
    272 	error = sysvbfs_check_possible(vp, bnode, ap->a_mode);
    273 	if (error)
    274 		return error;
    275 
    276 	error = sysvbfs_check_permitted(vp, bnode, ap->a_mode, ap->a_cred);
    277 
    278 	return error;
    279 }
    280 
    281 int
    282 sysvbfs_getattr(void *v)
    283 {
    284 	struct vop_getattr_args /* {
    285 		struct vnode *a_vp;
    286 		struct vattr *a_vap;
    287 		kauth_cred_t a_cred;
    288 	} */ *ap = v;
    289 	struct vnode *vp = ap->a_vp;
    290 	struct sysvbfs_node *bnode = vp->v_data;
    291 	struct bfs_inode *inode = bnode->inode;
    292 	struct bfs_fileattr *attr = &inode->attr;
    293 	struct sysvbfs_mount *bmp = bnode->bmp;
    294 	struct vattr *vap = ap->a_vap;
    295 
    296 	DPRINTF("%s:\n", __func__);
    297 
    298 	vap->va_type = vp->v_type;
    299 	vap->va_mode = attr->mode;
    300 	vap->va_nlink = attr->nlink;
    301 	vap->va_uid = attr->uid;
    302 	vap->va_gid = attr->gid;
    303 	vap->va_fsid = bmp->devvp->v_rdev;
    304 	vap->va_fileid = inode->number;
    305 	vap->va_size = bfs_file_size(inode);
    306 	vap->va_blocksize = BFS_BSIZE;
    307 	vap->va_atime.tv_sec = attr->atime;
    308 	vap->va_mtime.tv_sec = attr->mtime;
    309 	vap->va_ctime.tv_sec = attr->ctime;
    310 	vap->va_birthtime.tv_sec = 0;
    311 	vap->va_gen = 1;
    312 	vap->va_flags = 0;
    313 	vap->va_rdev = 0;	/* No device file */
    314 	vap->va_bytes = vap->va_size;
    315 	vap->va_filerev = 0;
    316 	vap->va_vaflags = 0;
    317 
    318 	return 0;
    319 }
    320 
    321 int
    322 sysvbfs_setattr(void *arg)
    323 {
    324 	struct vop_setattr_args /* {
    325 		struct vnode *a_vp;
    326 		struct vattr *a_vap;
    327 		kauth_cred_t a_cred;
    328 		struct proc *p;
    329 	} */ *ap = arg;
    330 	struct vnode *vp = ap->a_vp;
    331 	struct vattr *vap = ap->a_vap;
    332 	struct sysvbfs_node *bnode = vp->v_data;
    333 	struct bfs_inode *inode = bnode->inode;
    334 	struct bfs_fileattr *attr = &inode->attr;
    335 	struct bfs *bfs = bnode->bmp->bfs;
    336 	kauth_cred_t cred = ap->a_cred;
    337 	int error;
    338 
    339 	DPRINTF("%s:\n", __func__);
    340 	if (vp->v_mount->mnt_flag & MNT_RDONLY)
    341 		return EROFS;
    342 
    343 	if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
    344 	    (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
    345 	    (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
    346 	    ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL))
    347 		return EINVAL;
    348 
    349 	if (vap->va_flags != VNOVAL)
    350 		return EOPNOTSUPP;
    351 
    352 	if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
    353 		uid_t uid =
    354 		    (vap->va_uid != (uid_t)VNOVAL) ? vap->va_uid : attr->uid;
    355 		gid_t gid =
    356 		    (vap->va_gid != (gid_t)VNOVAL) ? vap->va_gid : attr->gid;
    357 		error = kauth_authorize_vnode(cred,
    358 		    KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL,
    359 		    genfs_can_chown(cred, attr->uid, attr->gid, uid, gid));
    360 		if (error)
    361 			return error;
    362 		attr->uid = uid;
    363 		attr->gid = gid;
    364 	}
    365 
    366 	if (vap->va_size != VNOVAL)
    367 		switch (vp->v_type) {
    368 		case VDIR:
    369 			return EISDIR;
    370 		case VCHR:
    371 		case VBLK:
    372 		case VFIFO:
    373 			break;
    374 		case VREG:
    375 			if (vp->v_mount->mnt_flag & MNT_RDONLY)
    376 				return EROFS;
    377 			sysvbfs_file_setsize(vp, vap->va_size);
    378 			break;
    379 		default:
    380 			return EOPNOTSUPP;
    381 		}
    382 
    383 	if (vap->va_mode != (mode_t)VNOVAL) {
    384 		mode_t mode = vap->va_mode;
    385 		error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY,
    386 		    vp, NULL, genfs_can_chmod(vp->v_type, cred, attr->uid,
    387 		    attr->gid, mode));
    388 		if (error)
    389 			return error;
    390 		attr->mode = mode;
    391 	}
    392 
    393 	if ((vap->va_atime.tv_sec != VNOVAL) ||
    394 	    (vap->va_mtime.tv_sec != VNOVAL) ||
    395 	    (vap->va_ctime.tv_sec != VNOVAL)) {
    396 		error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp,
    397 		    NULL, genfs_can_chtimes(vp, vap->va_vaflags, attr->uid,
    398 		    cred));
    399 		if (error)
    400 			return error;
    401 
    402 		if (vap->va_atime.tv_sec != VNOVAL)
    403 			attr->atime = vap->va_atime.tv_sec;
    404 		if (vap->va_mtime.tv_sec != VNOVAL)
    405 			attr->mtime = vap->va_mtime.tv_sec;
    406 		if (vap->va_ctime.tv_sec != VNOVAL)
    407 			attr->ctime = vap->va_ctime.tv_sec;
    408 	}
    409 
    410 	bfs_inode_set_attr(bfs, inode, attr);
    411 
    412 	return 0;
    413 }
    414 
    415 int
    416 sysvbfs_read(void *arg)
    417 {
    418 	struct vop_read_args /* {
    419 		struct vnode *a_vp;
    420 		struct uio *a_uio;
    421 		int a_ioflag;
    422 		kauth_cred_t a_cred;
    423 	} */ *a = arg;
    424 	struct vnode *v = a->a_vp;
    425 	struct uio *uio = a->a_uio;
    426 	struct sysvbfs_node *bnode = v->v_data;
    427 	struct bfs_inode *inode = bnode->inode;
    428 	vsize_t sz, filesz = bfs_file_size(inode);
    429 	int err, uerr;
    430 	const int advice = IO_ADV_DECODE(a->a_ioflag);
    431 
    432 	DPRINTF("%s: type=%d\n", __func__, v->v_type);
    433 	switch (v->v_type) {
    434 	case VREG:
    435 		break;
    436 	case VDIR:
    437 		return EISDIR;
    438 	default:
    439 		return EINVAL;
    440 	}
    441 
    442 	err = 0;
    443 	while (uio->uio_resid > 0) {
    444 		if ((sz = MIN(filesz - uio->uio_offset, uio->uio_resid)) == 0)
    445 			break;
    446 
    447 		err = ubc_uiomove(&v->v_uobj, uio, sz, advice,
    448 		    UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(v));
    449 		if (err)
    450 			break;
    451 		DPRINTF("%s: read %ldbyte\n", __func__, sz);
    452 	}
    453 
    454 	uerr = sysvbfs_update(v, NULL, NULL, UPDATE_WAIT);
    455 	if (err == 0)
    456 		err = uerr;
    457 
    458 	return err;
    459 }
    460 
    461 int
    462 sysvbfs_write(void *arg)
    463 {
    464 	struct vop_write_args /* {
    465 		struct vnode *a_vp;
    466 		struct uio *a_uio;
    467 		int  a_ioflag;
    468 		kauth_cred_t a_cred;
    469 	} */ *a = arg;
    470 	struct vnode *v = a->a_vp;
    471 	struct uio *uio = a->a_uio;
    472 	int advice = IO_ADV_DECODE(a->a_ioflag);
    473 	struct sysvbfs_node *bnode = v->v_data;
    474 	bool extended = false;
    475 	vsize_t sz;
    476 	int err = 0;
    477 
    478 	if (a->a_vp->v_type != VREG)
    479 		return EISDIR;
    480 
    481 	if (a->a_ioflag & IO_APPEND)
    482 		uio->uio_offset = bnode->size;
    483 
    484 	if (uio->uio_resid == 0)
    485 		return 0;
    486 
    487 	if (bnode->size < uio->uio_offset + uio->uio_resid) {
    488 		sysvbfs_file_setsize(v, uio->uio_offset + uio->uio_resid);
    489 		extended = true;
    490 	}
    491 
    492 	while (uio->uio_resid > 0) {
    493 		sz = uio->uio_resid;
    494 		err = ubc_uiomove(&v->v_uobj, uio, sz, advice,
    495 		    UBC_WRITE | UBC_UNMAP_FLAG(v));
    496 		if (err)
    497 			break;
    498 		DPRINTF("%s: write %ldbyte\n", __func__, sz);
    499 	}
    500 	if (err)
    501 		sysvbfs_file_setsize(v, bnode->size - uio->uio_resid);
    502 
    503 	VN_KNOTE(v, NOTE_WRITE | (extended ? NOTE_EXTEND : 0));
    504 
    505 	return err;
    506 }
    507 
    508 int
    509 sysvbfs_remove(void *arg)
    510 {
    511 	struct vop_remove_v2_args /* {
    512 		struct vnodeop_desc *a_desc;
    513 		struct vnode * a_dvp;
    514 		struct vnode * a_vp;
    515 		struct componentname * a_cnp;
    516 	} */ *ap = arg;
    517 	struct vnode *vp = ap->a_vp;
    518 	struct vnode *dvp = ap->a_dvp;
    519 	struct sysvbfs_node *bnode = vp->v_data;
    520 	struct sysvbfs_mount *bmp = bnode->bmp;
    521 	struct bfs *bfs = bmp->bfs;
    522 	int err;
    523 
    524 	DPRINTF("%s: delete %s\n", __func__, ap->a_cnp->cn_nameptr);
    525 
    526 	if (vp->v_type == VDIR) {
    527 		vrele(vp);
    528 		return EPERM;
    529 	}
    530 
    531 	if ((err = bfs_file_delete(bfs, ap->a_cnp->cn_nameptr, true)) != 0)
    532 		DPRINTF("%s: bfs_file_delete failed.\n", __func__);
    533 
    534 	VN_KNOTE(ap->a_vp, NOTE_DELETE);
    535 	VN_KNOTE(ap->a_dvp, NOTE_WRITE);
    536 	if (dvp == vp)
    537 		vrele(vp);
    538 	else
    539 		vput(vp);
    540 
    541 	if (err == 0) {
    542 		bnode->removed = 1;
    543 	}
    544 
    545 	return err;
    546 }
    547 
    548 int
    549 sysvbfs_rename(void *arg)
    550 {
    551 	struct vop_rename_args /* {
    552 		struct vnode *a_fdvp;	from parent-directory v-node
    553 		struct vnode *a_fvp;	from file v-node
    554 		struct componentname *a_fcnp;
    555 		struct vnode *a_tdvp;	to parent-directory
    556 		struct vnode *a_tvp;	to file v-node
    557 		struct componentname *a_tcnp;
    558 	} */ *ap = arg;
    559 	struct vnode *fvp = ap->a_fvp;
    560 	struct vnode *fdvp = ap->a_fdvp;
    561 	struct vnode *tvp = ap->a_tvp;
    562 	struct vnode *tdvp = ap->a_tdvp;
    563 	struct sysvbfs_node *bnode = fvp->v_data;
    564 	struct bfs *bfs = bnode->bmp->bfs;
    565 	const char *from_name = ap->a_fcnp->cn_nameptr;
    566 	const char *to_name = ap->a_tcnp->cn_nameptr;
    567 	int error;
    568 
    569 	DPRINTF("%s: %s->%s\n", __func__, from_name, to_name);
    570 	if ((fvp->v_mount != tdvp->v_mount) ||
    571 	    (tvp && (fvp->v_mount != tvp->v_mount))) {
    572 		error = EXDEV;
    573 		printf("cross-device link\n");
    574 		goto out;
    575 	}
    576 
    577 	KDASSERT(fvp->v_type == VREG);
    578 	KDASSERT(tvp == NULL ? true : tvp->v_type == VREG);
    579 	KASSERT(tdvp == fdvp);
    580 
    581 	/*
    582 	 * Make sure the source hasn't been removed between lookup
    583 	 * and target directory lock.
    584 	 */
    585 	if (bnode->removed) {
    586 		error = ENOENT;
    587 		goto out;
    588 	}
    589 
    590 	/*
    591 	 * Remove the target if it exists.
    592 	 */
    593 	if (tvp != NULL) {
    594 		error = bfs_file_delete(bfs, to_name, true);
    595 		if (error)
    596 			goto out;
    597 	}
    598 	error = bfs_file_rename(bfs, from_name, to_name);
    599  out:
    600 	/* tdvp == tvp probably can't happen with this fs, but safety first */
    601 	if (tdvp == tvp)
    602 		vrele(tdvp);
    603 	else
    604 		vput(tdvp);
    605 	if (tvp)
    606 		vput(tvp);
    607 
    608 	vrele(fdvp);
    609 	vrele(fvp);
    610 
    611 	return 0;
    612 }
    613 
    614 int
    615 sysvbfs_readdir(void *v)
    616 {
    617 	struct vop_readdir_args /* {
    618 		struct vnode *a_vp;
    619 		struct uio *a_uio;
    620 		kauth_cred_t a_cred;
    621 		int *a_eofflag;
    622 		off_t **a_cookies;
    623 		int *a_ncookies;
    624 	} */ *ap = v;
    625 	struct uio *uio = ap->a_uio;
    626 	struct vnode *vp = ap->a_vp;
    627 	struct sysvbfs_node *bnode = vp->v_data;
    628 	struct bfs *bfs = bnode->bmp->bfs;
    629 	struct dirent *dp;
    630 	struct bfs_dirent *file;
    631 	int i, n, error;
    632 
    633 	DPRINTF("%s: offset=%" PRId64 " residue=%zu\n", __func__,
    634 	    uio->uio_offset, uio->uio_resid);
    635 
    636 	KDASSERT(vp->v_type == VDIR);
    637 	KDASSERT(uio->uio_offset >= 0);
    638 
    639 	dp = malloc(sizeof(struct dirent), M_BFS, M_WAITOK | M_ZERO);
    640 
    641 	i = uio->uio_offset / sizeof(struct dirent);
    642 	n = uio->uio_resid / sizeof(struct dirent);
    643 	if ((i + n) > bfs->n_dirent)
    644 		n = bfs->n_dirent - i;
    645 
    646 	DPRINTF("%s 1: %d %d %d\n", __func__, i, n, bfs->n_dirent);
    647 	for (file = &bfs->dirent[i]; n > 0; file++, i++) {
    648 		if (i == bfs->max_dirent) {
    649 			DPRINTF("%s: file system inconsistent.\n",
    650 			    __func__);
    651 			break;
    652 		}
    653 		if (file->inode == 0)
    654 			continue;
    655 
    656 		/* ok, we have a live one here */
    657 		n--;
    658 		memset(dp, 0, sizeof(struct dirent));
    659 		dp->d_fileno = file->inode;
    660 		dp->d_type = file->inode == BFS_ROOT_INODE ? DT_DIR : DT_REG;
    661 		dp->d_namlen = strlen(file->name);
    662 		strncpy(dp->d_name, file->name, BFS_FILENAME_MAXLEN);
    663 		dp->d_reclen = sizeof(struct dirent);
    664 		if ((error = uiomove(dp, dp->d_reclen, uio)) != 0) {
    665 			DPRINTF("%s: uiomove failed.\n", __func__);
    666 			free(dp, M_BFS);
    667 			return error;
    668 		}
    669 	}
    670 	DPRINTF("%s 2: %d %d %d\n", __func__, i, n, bfs->n_dirent);
    671 	*ap->a_eofflag = (i == bfs->n_dirent);
    672 
    673 	free(dp, M_BFS);
    674 	return 0;
    675 }
    676 
    677 int
    678 sysvbfs_inactive(void *arg)
    679 {
    680 	struct vop_inactive_v2_args /* {
    681 		struct vnode *a_vp;
    682 		bool *a_recycle;
    683 	} */ *a = arg;
    684 	struct vnode *v = a->a_vp;
    685 	struct sysvbfs_node *bnode = v->v_data;
    686 
    687 	DPRINTF("%s:\n", __func__);
    688 	if (bnode->removed)
    689 		*a->a_recycle = true;
    690 	else
    691 		*a->a_recycle = false;
    692 
    693 	return 0;
    694 }
    695 
    696 int
    697 sysvbfs_reclaim(void *v)
    698 {
    699 	extern struct pool sysvbfs_node_pool;
    700 	struct vop_reclaim_args /* {
    701 		struct vnode *a_vp;
    702 	} */ *ap = v;
    703 	struct vnode *vp = ap->a_vp;
    704 	struct sysvbfs_node *bnode = vp->v_data;
    705 	struct bfs *bfs = bnode->bmp->bfs;
    706 
    707 	DPRINTF("%s:\n", __func__);
    708 
    709 	if (bnode->removed) {
    710 		if (bfs_inode_delete(bfs, bnode->inode->number) != 0)
    711 			DPRINTF("%s: delete inode failed\n", __func__);
    712 	}
    713 	genfs_node_destroy(vp);
    714 	pool_put(&sysvbfs_node_pool, bnode);
    715 	vp->v_data = NULL;
    716 
    717 	return 0;
    718 }
    719 
    720 int
    721 sysvbfs_bmap(void *arg)
    722 {
    723 	struct vop_bmap_args /* {
    724 		struct vnode *a_vp;
    725 		daddr_t  a_bn;
    726 		struct vnode **a_vpp;
    727 		daddr_t *a_bnp;
    728 		int *a_runp;
    729 	} */ *a = arg;
    730 	struct vnode *v = a->a_vp;
    731 	struct sysvbfs_node *bnode = v->v_data;
    732 	struct sysvbfs_mount *bmp = bnode->bmp;
    733 	struct bfs_inode *inode = bnode->inode;
    734 	daddr_t blk;
    735 
    736 	DPRINTF("%s:\n", __func__);
    737 	/* BFS algorithm is contiguous allocation */
    738 	blk = inode->start_sector + a->a_bn;
    739 
    740 	if (blk * BFS_BSIZE > bmp->bfs->data_end)
    741 		return ENOSPC;
    742 
    743 	*a->a_vpp = bmp->devvp;
    744 	*a->a_runp = 0;
    745 	DPRINTF("%s: %d + %" PRId64 "\n", __func__, inode->start_sector,
    746 	    a->a_bn);
    747 
    748 	*a->a_bnp = blk;
    749 
    750 
    751 	return 0;
    752 }
    753 
    754 int
    755 sysvbfs_strategy(void *arg)
    756 {
    757 	struct vop_strategy_args /* {
    758 		struct vnode *a_vp;
    759 		struct buf *a_bp;
    760 	} */ *a = arg;
    761 	struct buf *b = a->a_bp;
    762 	struct vnode *v = a->a_vp;
    763 	struct sysvbfs_node *bnode = v->v_data;
    764 	struct sysvbfs_mount *bmp = bnode->bmp;
    765 	int error;
    766 
    767 	DPRINTF("%s:\n", __func__);
    768 	KDASSERT(v->v_type == VREG);
    769 	if (b->b_blkno == b->b_lblkno) {
    770 		error = VOP_BMAP(v, b->b_lblkno, NULL, &b->b_blkno, NULL);
    771 		if (error) {
    772 			b->b_error = error;
    773 			biodone(b);
    774 			return error;
    775 		}
    776 		if ((long)b->b_blkno == -1)
    777 			clrbuf(b);
    778 	}
    779 	if ((long)b->b_blkno == -1) {
    780 		biodone(b);
    781 		return 0;
    782 	}
    783 
    784 	return VOP_STRATEGY(bmp->devvp, b);
    785 }
    786 
    787 int
    788 sysvbfs_print(void *v)
    789 {
    790 	struct vop_print_args /* {
    791 		struct vnode *a_vp;
    792 	} */ *ap = v;
    793 	struct sysvbfs_node *bnode = ap->a_vp->v_data;
    794 
    795 	DPRINTF("%s:\n", __func__);
    796 	bfs_dump(bnode->bmp->bfs);
    797 
    798 	return 0;
    799 }
    800 
    801 int
    802 sysvbfs_advlock(void *v)
    803 {
    804 	struct vop_advlock_args /* {
    805 		struct vnode *a_vp;
    806 		void *a_id;
    807 		int a_op;
    808 		struct flock *a_fl;
    809 		int a_flags;
    810 	} */ *ap = v;
    811 	struct sysvbfs_node *bnode = ap->a_vp->v_data;
    812 
    813 	DPRINTF("%s: op=%d\n", __func__, ap->a_op);
    814 
    815 	return lf_advlock(ap, &bnode->lockf, bfs_file_size(bnode->inode));
    816 }
    817 
    818 int
    819 sysvbfs_pathconf(void *v)
    820 {
    821 	struct vop_pathconf_args /* {
    822 		struct vnode *a_vp;
    823 		int a_name;
    824 		register_t *a_retval;
    825 	} */ *ap = v;
    826 	int err = 0;
    827 
    828 	DPRINTF("%s:\n", __func__);
    829 
    830 	switch (ap->a_name) {
    831 	case _PC_LINK_MAX:
    832 		*ap->a_retval = 1;
    833 		break;
    834 	case _PC_NAME_MAX:
    835 		*ap->a_retval = BFS_FILENAME_MAXLEN;
    836 		break;
    837 	case _PC_PATH_MAX:
    838 		*ap->a_retval = BFS_FILENAME_MAXLEN;
    839 		break;
    840 	case _PC_CHOWN_RESTRICTED:
    841 		*ap->a_retval = 1;
    842 		break;
    843 	case _PC_NO_TRUNC:
    844 		*ap->a_retval = 0;
    845 		break;
    846 	case _PC_SYNC_IO:
    847 		*ap->a_retval = 1;
    848 		break;
    849 	case _PC_FILESIZEBITS:
    850 		*ap->a_retval = 32;
    851 		break;
    852 	default:
    853 		err = EINVAL;
    854 		break;
    855 	}
    856 
    857 	return err;
    858 }
    859 
    860 int
    861 sysvbfs_fsync(void *v)
    862 {
    863 	struct vop_fsync_args /* {
    864 		struct vnode *a_vp;
    865 		kauth_cred_t a_cred;
    866 		int a_flags;
    867 		off_t offlo;
    868 		off_t offhi;
    869 	} */ *ap = v;
    870 	struct vnode *vp = ap->a_vp;
    871 	int error, wait;
    872 
    873 	if (ap->a_flags & FSYNC_CACHE) {
    874 		return EOPNOTSUPP;
    875 	}
    876 
    877 	wait = (ap->a_flags & FSYNC_WAIT) != 0;
    878 	error = vflushbuf(vp, ap->a_flags);
    879 	if (error == 0 && (ap->a_flags & FSYNC_DATAONLY) == 0)
    880 		error = sysvbfs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0);
    881 
    882 	return error;
    883 }
    884 
    885 int
    886 sysvbfs_update(struct vnode *vp, const struct timespec *acc,
    887     const struct timespec *mod, int flags)
    888 {
    889 	struct sysvbfs_node *bnode = vp->v_data;
    890 	struct bfs_fileattr attr;
    891 
    892 	if (vp->v_mount->mnt_flag & MNT_RDONLY)
    893 		return 0;
    894 
    895 	DPRINTF("%s:\n", __func__);
    896 	memset(&attr, 0xff, sizeof attr);	/* Set VNOVAL all */
    897 	if (bnode->update_atime) {
    898 		attr.atime = acc ? acc->tv_sec : time_second;
    899 		bnode->update_atime = false;
    900 	}
    901 	if (bnode->update_ctime) {
    902 		attr.ctime = time_second;
    903 		bnode->update_ctime = false;
    904 	}
    905 	if (bnode->update_mtime) {
    906 		attr.mtime = mod ? mod->tv_sec : time_second;
    907 		bnode->update_mtime = false;
    908 	}
    909 	bfs_inode_set_attr(bnode->bmp->bfs, bnode->inode, &attr);
    910 
    911 	return 0;
    912 }
    913 
    914 static void
    915 sysvbfs_file_setsize(struct vnode *v, size_t size)
    916 {
    917 	struct sysvbfs_node *bnode = v->v_data;
    918 	struct bfs_inode *inode = bnode->inode;
    919 
    920 	bnode->size = size;
    921 	uvm_vnp_setsize(v, bnode->size);
    922 	inode->end_sector = bnode->data_block +
    923 	    (ROUND_SECTOR(bnode->size) >> DEV_BSHIFT) - 1;
    924 	inode->eof_offset_byte = bnode->data_block * DEV_BSIZE +
    925 	    bnode->size - 1;
    926 	bnode->update_mtime = true;
    927 }
    928