xref: /freebsd/sys/ufs/ffs/ffs_vnops.c (revision 9bd497b8354567454e075076d40c996e21bd6095)
1 /*-
2  * Copyright (c) 2002, 2003 Networks Associates Technology, Inc.
3  * All rights reserved.
4  *
5  * This software was developed for the FreeBSD Project by Marshall
6  * Kirk McKusick and Network Associates Laboratories, the Security
7  * Research Division of Network Associates, Inc. under DARPA/SPAWAR
8  * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
9  * research program
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * Copyright (c) 1982, 1986, 1989, 1993
33  *	The Regents of the University of California.  All rights reserved.
34  *
35  * Redistribution and use in source and binary forms, with or without
36  * modification, are permitted provided that the following conditions
37  * are met:
38  * 1. Redistributions of source code must retain the above copyright
39  *    notice, this list of conditions and the following disclaimer.
40  * 2. Redistributions in binary form must reproduce the above copyright
41  *    notice, this list of conditions and the following disclaimer in the
42  *    documentation and/or other materials provided with the distribution.
43  * 4. Neither the name of the University nor the names of its contributors
44  *    may be used to endorse or promote products derived from this software
45  *    without specific prior written permission.
46  *
47  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57  * SUCH DAMAGE.
58  *
59  *	from: @(#)ufs_readwrite.c	8.11 (Berkeley) 5/8/95
60  * from: $FreeBSD: .../ufs/ufs_readwrite.c,v 1.96 2002/08/12 09:22:11 phk ...
61  *	@(#)ffs_vnops.c	8.15 (Berkeley) 5/14/95
62  */
63 
64 #include <sys/cdefs.h>
65 __FBSDID("$FreeBSD$");
66 
67 #include <sys/param.h>
68 #include <sys/bio.h>
69 #include <sys/systm.h>
70 #include <sys/buf.h>
71 #include <sys/conf.h>
72 #include <sys/extattr.h>
73 #include <sys/kernel.h>
74 #include <sys/limits.h>
75 #include <sys/malloc.h>
76 #include <sys/mount.h>
77 #include <sys/priv.h>
78 #include <sys/proc.h>
79 #include <sys/resourcevar.h>
80 #include <sys/signalvar.h>
81 #include <sys/stat.h>
82 #include <sys/vmmeter.h>
83 #include <sys/vnode.h>
84 
85 #include <vm/vm.h>
86 #include <vm/vm_extern.h>
87 #include <vm/vm_object.h>
88 #include <vm/vm_page.h>
89 #include <vm/vm_pager.h>
90 #include <vm/vnode_pager.h>
91 
92 #include <ufs/ufs/extattr.h>
93 #include <ufs/ufs/quota.h>
94 #include <ufs/ufs/inode.h>
95 #include <ufs/ufs/ufs_extern.h>
96 #include <ufs/ufs/ufsmount.h>
97 
98 #include <ufs/ffs/fs.h>
99 #include <ufs/ffs/ffs_extern.h>
100 #include "opt_directio.h"
101 #include "opt_ffs.h"
102 
103 #ifdef DIRECTIO
104 extern int	ffs_rawread(struct vnode *vp, struct uio *uio, int *workdone);
105 #endif
106 static vop_fsync_t	ffs_fsync;
107 static vop_lock1_t	ffs_lock;
108 static vop_getpages_t	ffs_getpages;
109 static vop_read_t	ffs_read;
110 static vop_write_t	ffs_write;
111 static int	ffs_extread(struct vnode *vp, struct uio *uio, int ioflag);
112 static int	ffs_extwrite(struct vnode *vp, struct uio *uio, int ioflag,
113 		    struct ucred *cred);
114 static vop_strategy_t	ffsext_strategy;
115 static vop_closeextattr_t	ffs_closeextattr;
116 static vop_deleteextattr_t	ffs_deleteextattr;
117 static vop_getextattr_t	ffs_getextattr;
118 static vop_listextattr_t	ffs_listextattr;
119 static vop_openextattr_t	ffs_openextattr;
120 static vop_setextattr_t	ffs_setextattr;
121 static vop_vptofh_t	ffs_vptofh;
122 
123 
124 /* Global vfs data structures for ufs. */
125 struct vop_vector ffs_vnodeops1 = {
126 	.vop_default =		&ufs_vnodeops,
127 	.vop_fsync =		ffs_fsync,
128 	.vop_getpages =		ffs_getpages,
129 	.vop_lock1 =		ffs_lock,
130 	.vop_read =		ffs_read,
131 	.vop_reallocblks =	ffs_reallocblks,
132 	.vop_write =		ffs_write,
133 	.vop_vptofh =		ffs_vptofh,
134 };
135 
136 struct vop_vector ffs_fifoops1 = {
137 	.vop_default =		&ufs_fifoops,
138 	.vop_fsync =		ffs_fsync,
139 	.vop_reallocblks =	ffs_reallocblks, /* XXX: really ??? */
140 	.vop_vptofh =		ffs_vptofh,
141 };
142 
143 /* Global vfs data structures for ufs. */
144 struct vop_vector ffs_vnodeops2 = {
145 	.vop_default =		&ufs_vnodeops,
146 	.vop_fsync =		ffs_fsync,
147 	.vop_getpages =		ffs_getpages,
148 	.vop_lock1 =		ffs_lock,
149 	.vop_read =		ffs_read,
150 	.vop_reallocblks =	ffs_reallocblks,
151 	.vop_write =		ffs_write,
152 	.vop_closeextattr =	ffs_closeextattr,
153 	.vop_deleteextattr =	ffs_deleteextattr,
154 	.vop_getextattr =	ffs_getextattr,
155 	.vop_listextattr =	ffs_listextattr,
156 	.vop_openextattr =	ffs_openextattr,
157 	.vop_setextattr =	ffs_setextattr,
158 	.vop_vptofh =		ffs_vptofh,
159 };
160 
161 struct vop_vector ffs_fifoops2 = {
162 	.vop_default =		&ufs_fifoops,
163 	.vop_fsync =		ffs_fsync,
164 	.vop_lock1 =		ffs_lock,
165 	.vop_reallocblks =	ffs_reallocblks,
166 	.vop_strategy =		ffsext_strategy,
167 	.vop_closeextattr =	ffs_closeextattr,
168 	.vop_deleteextattr =	ffs_deleteextattr,
169 	.vop_getextattr =	ffs_getextattr,
170 	.vop_listextattr =	ffs_listextattr,
171 	.vop_openextattr =	ffs_openextattr,
172 	.vop_setextattr =	ffs_setextattr,
173 	.vop_vptofh =		ffs_vptofh,
174 };
175 
176 /*
177  * Synch an open file.
178  */
179 /* ARGSUSED */
180 static int
181 ffs_fsync(struct vop_fsync_args *ap)
182 {
183 	struct vnode *vp;
184 	struct bufobj *bo;
185 	int error;
186 
187 	vp = ap->a_vp;
188 	bo = &vp->v_bufobj;
189 retry:
190 	error = ffs_syncvnode(vp, ap->a_waitfor);
191 	if (error)
192 		return (error);
193 	if (ap->a_waitfor == MNT_WAIT &&
194 	    (vp->v_mount->mnt_flag & MNT_SOFTDEP)) {
195 		error = softdep_fsync(vp);
196 		if (error)
197 			return (error);
198 
199 		/*
200 		 * The softdep_fsync() function may drop vp lock,
201 		 * allowing for dirty buffers to reappear on the
202 		 * bo_dirty list. Recheck and resync as needed.
203 		 */
204 		BO_LOCK(bo);
205 		if (vp->v_type == VREG && (bo->bo_numoutput > 0 ||
206 		    bo->bo_dirty.bv_cnt > 0)) {
207 			BO_UNLOCK(bo);
208 			goto retry;
209 		}
210 		BO_UNLOCK(bo);
211 	}
212 	return (0);
213 }
214 
215 int
216 ffs_syncvnode(struct vnode *vp, int waitfor)
217 {
218 	struct inode *ip = VTOI(vp);
219 	struct bufobj *bo;
220 	struct buf *bp;
221 	struct buf *nbp;
222 	int s, error, wait, passes, skipmeta;
223 	ufs_lbn_t lbn;
224 
225 	wait = (waitfor == MNT_WAIT);
226 	lbn = lblkno(ip->i_fs, (ip->i_size + ip->i_fs->fs_bsize - 1));
227 	bo = &vp->v_bufobj;
228 
229 	/*
230 	 * Flush all dirty buffers associated with a vnode.
231 	 */
232 	passes = NIADDR + 1;
233 	skipmeta = 0;
234 	if (wait)
235 		skipmeta = 1;
236 	s = splbio();
237 	BO_LOCK(bo);
238 loop:
239 	TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs)
240 		bp->b_vflags &= ~BV_SCANNED;
241 	TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
242 		/*
243 		 * Reasons to skip this buffer: it has already been considered
244 		 * on this pass, this pass is the first time through on a
245 		 * synchronous flush request and the buffer being considered
246 		 * is metadata, the buffer has dependencies that will cause
247 		 * it to be redirtied and it has not already been deferred,
248 		 * or it is already being written.
249 		 */
250 		if ((bp->b_vflags & BV_SCANNED) != 0)
251 			continue;
252 		bp->b_vflags |= BV_SCANNED;
253 		if ((skipmeta == 1 && bp->b_lblkno < 0))
254 			continue;
255 		if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL))
256 			continue;
257 		BO_UNLOCK(bo);
258 		if (!wait && !LIST_EMPTY(&bp->b_dep) &&
259 		    (bp->b_flags & B_DEFERRED) == 0 &&
260 		    buf_countdeps(bp, 0)) {
261 			bp->b_flags |= B_DEFERRED;
262 			BUF_UNLOCK(bp);
263 			BO_LOCK(bo);
264 			continue;
265 		}
266 		if ((bp->b_flags & B_DELWRI) == 0)
267 			panic("ffs_fsync: not dirty");
268 		/*
269 		 * If this is a synchronous flush request, or it is not a
270 		 * file or device, start the write on this buffer immediately.
271 		 */
272 		if (wait || (vp->v_type != VREG && vp->v_type != VBLK)) {
273 
274 			/*
275 			 * On our final pass through, do all I/O synchronously
276 			 * so that we can find out if our flush is failing
277 			 * because of write errors.
278 			 */
279 			if (passes > 0 || !wait) {
280 				if ((bp->b_flags & B_CLUSTEROK) && !wait) {
281 					(void) vfs_bio_awrite(bp);
282 				} else {
283 					bremfree(bp);
284 					splx(s);
285 					(void) bawrite(bp);
286 					s = splbio();
287 				}
288 			} else {
289 				bremfree(bp);
290 				splx(s);
291 				if ((error = bwrite(bp)) != 0)
292 					return (error);
293 				s = splbio();
294 			}
295 		} else if ((vp->v_type == VREG) && (bp->b_lblkno >= lbn)) {
296 			/*
297 			 * If the buffer is for data that has been truncated
298 			 * off the file, then throw it away.
299 			 */
300 			bremfree(bp);
301 			bp->b_flags |= B_INVAL | B_NOCACHE;
302 			splx(s);
303 			brelse(bp);
304 			s = splbio();
305 		} else
306 			vfs_bio_awrite(bp);
307 
308 		/*
309 		 * Since we may have slept during the I/O, we need
310 		 * to start from a known point.
311 		 */
312 		BO_LOCK(bo);
313 		nbp = TAILQ_FIRST(&bo->bo_dirty.bv_hd);
314 	}
315 	/*
316 	 * If we were asked to do this synchronously, then go back for
317 	 * another pass, this time doing the metadata.
318 	 */
319 	if (skipmeta) {
320 		skipmeta = 0;
321 		goto loop;
322 	}
323 
324 	if (wait) {
325 		bufobj_wwait(bo, 3, 0);
326 		BO_UNLOCK(bo);
327 
328 		/*
329 		 * Ensure that any filesystem metatdata associated
330 		 * with the vnode has been written.
331 		 */
332 		splx(s);
333 		if ((error = softdep_sync_metadata(vp)) != 0)
334 			return (error);
335 		s = splbio();
336 
337 		BO_LOCK(bo);
338 		if (bo->bo_dirty.bv_cnt > 0) {
339 			/*
340 			 * Block devices associated with filesystems may
341 			 * have new I/O requests posted for them even if
342 			 * the vnode is locked, so no amount of trying will
343 			 * get them clean. Thus we give block devices a
344 			 * good effort, then just give up. For all other file
345 			 * types, go around and try again until it is clean.
346 			 */
347 			if (passes > 0) {
348 				passes -= 1;
349 				goto loop;
350 			}
351 #ifdef INVARIANTS
352 			if (!vn_isdisk(vp, NULL))
353 				vprint("ffs_fsync: dirty", vp);
354 #endif
355 		}
356 	}
357 	BO_UNLOCK(bo);
358 	splx(s);
359 	return (ffs_update(vp, wait));
360 }
361 
362 static int
363 ffs_lock(ap)
364 	struct vop_lock1_args /* {
365 		struct vnode *a_vp;
366 		int a_flags;
367 		struct thread *a_td;
368 		char *file;
369 		int line;
370 	} */ *ap;
371 {
372 #ifndef NO_FFS_SNAPSHOT
373 	struct vnode *vp;
374 	int flags;
375 	struct lock *lkp;
376 	int result;
377 
378 	switch (ap->a_flags & LK_TYPE_MASK) {
379 	case LK_SHARED:
380 	case LK_UPGRADE:
381 	case LK_EXCLUSIVE:
382 		vp = ap->a_vp;
383 		flags = ap->a_flags;
384 		for (;;) {
385 #ifdef DEBUG_VFS_LOCKS
386 			KASSERT(vp->v_holdcnt != 0,
387 			    ("ffs_lock %p: zero hold count", vp));
388 #endif
389 			lkp = vp->v_vnlock;
390 			result = _lockmgr_args(lkp, flags, VI_MTX(vp),
391 			    LK_WMESG_DEFAULT, LK_PRIO_DEFAULT, LK_TIMO_DEFAULT,
392 			    ap->a_file, ap->a_line);
393 			if (lkp == vp->v_vnlock || result != 0)
394 				break;
395 			/*
396 			 * Apparent success, except that the vnode
397 			 * mutated between snapshot file vnode and
398 			 * regular file vnode while this process
399 			 * slept.  The lock currently held is not the
400 			 * right lock.  Release it, and try to get the
401 			 * new lock.
402 			 */
403 			(void) _lockmgr_args(lkp, LK_RELEASE, NULL,
404 			    LK_WMESG_DEFAULT, LK_PRIO_DEFAULT, LK_TIMO_DEFAULT,
405 			    ap->a_file, ap->a_line);
406 			if ((flags & (LK_INTERLOCK | LK_NOWAIT)) ==
407 			    (LK_INTERLOCK | LK_NOWAIT))
408 				return (EBUSY);
409 			if ((flags & LK_TYPE_MASK) == LK_UPGRADE)
410 				flags = (flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE;
411 			flags &= ~LK_INTERLOCK;
412 		}
413 		break;
414 	default:
415 		result = VOP_LOCK1_APV(&ufs_vnodeops, ap);
416 	}
417 	return (result);
418 #else
419 	return (VOP_LOCK1_APV(&ufs_vnodeops, ap));
420 #endif
421 }
422 
423 /*
424  * Vnode op for reading.
425  */
426 /* ARGSUSED */
427 static int
428 ffs_read(ap)
429 	struct vop_read_args /* {
430 		struct vnode *a_vp;
431 		struct uio *a_uio;
432 		int a_ioflag;
433 		struct ucred *a_cred;
434 	} */ *ap;
435 {
436 	struct vnode *vp;
437 	struct inode *ip;
438 	struct uio *uio;
439 	struct fs *fs;
440 	struct buf *bp;
441 	ufs_lbn_t lbn, nextlbn;
442 	off_t bytesinfile;
443 	long size, xfersize, blkoffset;
444 	int error, orig_resid;
445 	int seqcount;
446 	int ioflag;
447 
448 	vp = ap->a_vp;
449 	uio = ap->a_uio;
450 	ioflag = ap->a_ioflag;
451 	if (ap->a_ioflag & IO_EXT)
452 #ifdef notyet
453 		return (ffs_extread(vp, uio, ioflag));
454 #else
455 		panic("ffs_read+IO_EXT");
456 #endif
457 #ifdef DIRECTIO
458 	if ((ioflag & IO_DIRECT) != 0) {
459 		int workdone;
460 
461 		error = ffs_rawread(vp, uio, &workdone);
462 		if (error != 0 || workdone != 0)
463 			return error;
464 	}
465 #endif
466 
467 	seqcount = ap->a_ioflag >> IO_SEQSHIFT;
468 	ip = VTOI(vp);
469 
470 #ifdef INVARIANTS
471 	if (uio->uio_rw != UIO_READ)
472 		panic("ffs_read: mode");
473 
474 	if (vp->v_type == VLNK) {
475 		if ((int)ip->i_size < vp->v_mount->mnt_maxsymlinklen)
476 			panic("ffs_read: short symlink");
477 	} else if (vp->v_type != VREG && vp->v_type != VDIR)
478 		panic("ffs_read: type %d",  vp->v_type);
479 #endif
480 	orig_resid = uio->uio_resid;
481 	KASSERT(orig_resid >= 0, ("ffs_read: uio->uio_resid < 0"));
482 	if (orig_resid == 0)
483 		return (0);
484 	KASSERT(uio->uio_offset >= 0, ("ffs_read: uio->uio_offset < 0"));
485 	fs = ip->i_fs;
486 	if (uio->uio_offset < ip->i_size &&
487 	    uio->uio_offset >= fs->fs_maxfilesize)
488 		return (EOVERFLOW);
489 
490 	for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
491 		if ((bytesinfile = ip->i_size - uio->uio_offset) <= 0)
492 			break;
493 		lbn = lblkno(fs, uio->uio_offset);
494 		nextlbn = lbn + 1;
495 
496 		/*
497 		 * size of buffer.  The buffer representing the
498 		 * end of the file is rounded up to the size of
499 		 * the block type ( fragment or full block,
500 		 * depending ).
501 		 */
502 		size = blksize(fs, ip, lbn);
503 		blkoffset = blkoff(fs, uio->uio_offset);
504 
505 		/*
506 		 * The amount we want to transfer in this iteration is
507 		 * one FS block less the amount of the data before
508 		 * our startpoint (duh!)
509 		 */
510 		xfersize = fs->fs_bsize - blkoffset;
511 
512 		/*
513 		 * But if we actually want less than the block,
514 		 * or the file doesn't have a whole block more of data,
515 		 * then use the lesser number.
516 		 */
517 		if (uio->uio_resid < xfersize)
518 			xfersize = uio->uio_resid;
519 		if (bytesinfile < xfersize)
520 			xfersize = bytesinfile;
521 
522 		if (lblktosize(fs, nextlbn) >= ip->i_size) {
523 			/*
524 			 * Don't do readahead if this is the end of the file.
525 			 */
526 			error = bread(vp, lbn, size, NOCRED, &bp);
527 		} else if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) {
528 			/*
529 			 * Otherwise if we are allowed to cluster,
530 			 * grab as much as we can.
531 			 *
532 			 * XXX  This may not be a win if we are not
533 			 * doing sequential access.
534 			 */
535 			error = cluster_read(vp, ip->i_size, lbn,
536 				size, NOCRED, blkoffset + uio->uio_resid, seqcount, &bp);
537 		} else if (seqcount > 1) {
538 			/*
539 			 * If we are NOT allowed to cluster, then
540 			 * if we appear to be acting sequentially,
541 			 * fire off a request for a readahead
542 			 * as well as a read. Note that the 4th and 5th
543 			 * arguments point to arrays of the size specified in
544 			 * the 6th argument.
545 			 */
546 			int nextsize = blksize(fs, ip, nextlbn);
547 			error = breadn(vp, lbn,
548 			    size, &nextlbn, &nextsize, 1, NOCRED, &bp);
549 		} else {
550 			/*
551 			 * Failing all of the above, just read what the
552 			 * user asked for. Interestingly, the same as
553 			 * the first option above.
554 			 */
555 			error = bread(vp, lbn, size, NOCRED, &bp);
556 		}
557 		if (error) {
558 			brelse(bp);
559 			bp = NULL;
560 			break;
561 		}
562 
563 		/*
564 		 * If IO_DIRECT then set B_DIRECT for the buffer.  This
565 		 * will cause us to attempt to release the buffer later on
566 		 * and will cause the buffer cache to attempt to free the
567 		 * underlying pages.
568 		 */
569 		if (ioflag & IO_DIRECT)
570 			bp->b_flags |= B_DIRECT;
571 
572 		/*
573 		 * We should only get non-zero b_resid when an I/O error
574 		 * has occurred, which should cause us to break above.
575 		 * However, if the short read did not cause an error,
576 		 * then we want to ensure that we do not uiomove bad
577 		 * or uninitialized data.
578 		 */
579 		size -= bp->b_resid;
580 		if (size < xfersize) {
581 			if (size == 0)
582 				break;
583 			xfersize = size;
584 		}
585 
586 		error = uiomove((char *)bp->b_data + blkoffset,
587 		    (int)xfersize, uio);
588 		if (error)
589 			break;
590 
591 		if ((ioflag & (IO_VMIO|IO_DIRECT)) &&
592 		   (LIST_EMPTY(&bp->b_dep))) {
593 			/*
594 			 * If there are no dependencies, and it's VMIO,
595 			 * then we don't need the buf, mark it available
596 			 * for freeing. The VM has the data.
597 			 */
598 			bp->b_flags |= B_RELBUF;
599 			brelse(bp);
600 		} else {
601 			/*
602 			 * Otherwise let whoever
603 			 * made the request take care of
604 			 * freeing it. We just queue
605 			 * it onto another list.
606 			 */
607 			bqrelse(bp);
608 		}
609 	}
610 
611 	/*
612 	 * This can only happen in the case of an error
613 	 * because the loop above resets bp to NULL on each iteration
614 	 * and on normal completion has not set a new value into it.
615 	 * so it must have come from a 'break' statement
616 	 */
617 	if (bp != NULL) {
618 		if ((ioflag & (IO_VMIO|IO_DIRECT)) &&
619 		   (LIST_EMPTY(&bp->b_dep))) {
620 			bp->b_flags |= B_RELBUF;
621 			brelse(bp);
622 		} else {
623 			bqrelse(bp);
624 		}
625 	}
626 
627 	if ((error == 0 || uio->uio_resid != orig_resid) &&
628 	    (vp->v_mount->mnt_flag & MNT_NOATIME) == 0 &&
629 	    (ip->i_flag & IN_ACCESS) == 0) {
630 		VI_LOCK(vp);
631 		ip->i_flag |= IN_ACCESS;
632 		VI_UNLOCK(vp);
633 	}
634 	return (error);
635 }
636 
637 /*
638  * Vnode op for writing.
639  */
640 static int
641 ffs_write(ap)
642 	struct vop_write_args /* {
643 		struct vnode *a_vp;
644 		struct uio *a_uio;
645 		int a_ioflag;
646 		struct ucred *a_cred;
647 	} */ *ap;
648 {
649 	struct vnode *vp;
650 	struct uio *uio;
651 	struct inode *ip;
652 	struct fs *fs;
653 	struct buf *bp;
654 	struct thread *td;
655 	ufs_lbn_t lbn;
656 	off_t osize;
657 	int seqcount;
658 	int blkoffset, error, flags, ioflag, resid, size, xfersize;
659 
660 	vp = ap->a_vp;
661 	uio = ap->a_uio;
662 	ioflag = ap->a_ioflag;
663 	if (ap->a_ioflag & IO_EXT)
664 #ifdef notyet
665 		return (ffs_extwrite(vp, uio, ioflag, ap->a_cred));
666 #else
667 		panic("ffs_write+IO_EXT");
668 #endif
669 
670 	seqcount = ap->a_ioflag >> IO_SEQSHIFT;
671 	ip = VTOI(vp);
672 
673 #ifdef INVARIANTS
674 	if (uio->uio_rw != UIO_WRITE)
675 		panic("ffs_write: mode");
676 #endif
677 
678 	switch (vp->v_type) {
679 	case VREG:
680 		if (ioflag & IO_APPEND)
681 			uio->uio_offset = ip->i_size;
682 		if ((ip->i_flags & APPEND) && uio->uio_offset != ip->i_size)
683 			return (EPERM);
684 		/* FALLTHROUGH */
685 	case VLNK:
686 		break;
687 	case VDIR:
688 		panic("ffs_write: dir write");
689 		break;
690 	default:
691 		panic("ffs_write: type %p %d (%d,%d)", vp, (int)vp->v_type,
692 			(int)uio->uio_offset,
693 			(int)uio->uio_resid
694 		);
695 	}
696 
697 	KASSERT(uio->uio_resid >= 0, ("ffs_write: uio->uio_resid < 0"));
698 	KASSERT(uio->uio_offset >= 0, ("ffs_write: uio->uio_offset < 0"));
699 	fs = ip->i_fs;
700 	if ((uoff_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize)
701 		return (EFBIG);
702 	/*
703 	 * Maybe this should be above the vnode op call, but so long as
704 	 * file servers have no limits, I don't think it matters.
705 	 */
706 	td = uio->uio_td;
707 	if (vp->v_type == VREG && td != NULL) {
708 		PROC_LOCK(td->td_proc);
709 		if (uio->uio_offset + uio->uio_resid >
710 		    lim_cur(td->td_proc, RLIMIT_FSIZE)) {
711 			psignal(td->td_proc, SIGXFSZ);
712 			PROC_UNLOCK(td->td_proc);
713 			return (EFBIG);
714 		}
715 		PROC_UNLOCK(td->td_proc);
716 	}
717 
718 	resid = uio->uio_resid;
719 	osize = ip->i_size;
720 	if (seqcount > BA_SEQMAX)
721 		flags = BA_SEQMAX << BA_SEQSHIFT;
722 	else
723 		flags = seqcount << BA_SEQSHIFT;
724 	if ((ioflag & IO_SYNC) && !DOINGASYNC(vp))
725 		flags |= IO_SYNC;
726 
727 	for (error = 0; uio->uio_resid > 0;) {
728 		lbn = lblkno(fs, uio->uio_offset);
729 		blkoffset = blkoff(fs, uio->uio_offset);
730 		xfersize = fs->fs_bsize - blkoffset;
731 		if (uio->uio_resid < xfersize)
732 			xfersize = uio->uio_resid;
733 		if (uio->uio_offset + xfersize > ip->i_size)
734 			vnode_pager_setsize(vp, uio->uio_offset + xfersize);
735 
736                 /*
737 		 * We must perform a read-before-write if the transfer size
738 		 * does not cover the entire buffer.
739                  */
740 		if (fs->fs_bsize > xfersize)
741 			flags |= BA_CLRBUF;
742 		else
743 			flags &= ~BA_CLRBUF;
744 /* XXX is uio->uio_offset the right thing here? */
745 		error = UFS_BALLOC(vp, uio->uio_offset, xfersize,
746 		    ap->a_cred, flags, &bp);
747 		if (error != 0) {
748 			vnode_pager_setsize(vp, ip->i_size);
749 			break;
750 		}
751 		/*
752 		 * If the buffer is not valid we have to clear out any
753 		 * garbage data from the pages instantiated for the buffer.
754 		 * If we do not, a failed uiomove() during a write can leave
755 		 * the prior contents of the pages exposed to a userland
756 		 * mmap().  XXX deal with uiomove() errors a better way.
757 		 */
758 		if ((bp->b_flags & B_CACHE) == 0 && fs->fs_bsize <= xfersize)
759 			vfs_bio_clrbuf(bp);
760 		if (ioflag & IO_DIRECT)
761 			bp->b_flags |= B_DIRECT;
762 		if ((ioflag & (IO_SYNC|IO_INVAL)) == (IO_SYNC|IO_INVAL))
763 			bp->b_flags |= B_NOCACHE;
764 
765 		if (uio->uio_offset + xfersize > ip->i_size) {
766 			ip->i_size = uio->uio_offset + xfersize;
767 			DIP_SET(ip, i_size, ip->i_size);
768 		}
769 
770 		size = blksize(fs, ip, lbn) - bp->b_resid;
771 		if (size < xfersize)
772 			xfersize = size;
773 
774 		error =
775 		    uiomove((char *)bp->b_data + blkoffset, (int)xfersize, uio);
776 		if ((ioflag & (IO_VMIO|IO_DIRECT)) &&
777 		   (LIST_EMPTY(&bp->b_dep))) {
778 			bp->b_flags |= B_RELBUF;
779 		}
780 
781 		/*
782 		 * If IO_SYNC each buffer is written synchronously.  Otherwise
783 		 * if we have a severe page deficiency write the buffer
784 		 * asynchronously.  Otherwise try to cluster, and if that
785 		 * doesn't do it then either do an async write (if O_DIRECT),
786 		 * or a delayed write (if not).
787 		 */
788 		if (ioflag & IO_SYNC) {
789 			(void)bwrite(bp);
790 		} else if (vm_page_count_severe() ||
791 			    buf_dirty_count_severe() ||
792 			    (ioflag & IO_ASYNC)) {
793 			bp->b_flags |= B_CLUSTEROK;
794 			bawrite(bp);
795 		} else if (xfersize + blkoffset == fs->fs_bsize) {
796 			if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERW) == 0) {
797 				bp->b_flags |= B_CLUSTEROK;
798 				cluster_write(vp, bp, ip->i_size, seqcount);
799 			} else {
800 				bawrite(bp);
801 			}
802 		} else if (ioflag & IO_DIRECT) {
803 			bp->b_flags |= B_CLUSTEROK;
804 			bawrite(bp);
805 		} else {
806 			bp->b_flags |= B_CLUSTEROK;
807 			bdwrite(bp);
808 		}
809 		if (error || xfersize == 0)
810 			break;
811 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
812 	}
813 	/*
814 	 * If we successfully wrote any data, and we are not the superuser
815 	 * we clear the setuid and setgid bits as a precaution against
816 	 * tampering.
817 	 */
818 	if ((ip->i_mode & (ISUID | ISGID)) && resid > uio->uio_resid &&
819 	    ap->a_cred) {
820 		if (priv_check_cred(ap->a_cred, PRIV_VFS_RETAINSUGID, 0)) {
821 			ip->i_mode &= ~(ISUID | ISGID);
822 			DIP_SET(ip, i_mode, ip->i_mode);
823 		}
824 	}
825 	if (error) {
826 		if (ioflag & IO_UNIT) {
827 			(void)ffs_truncate(vp, osize,
828 			    IO_NORMAL | (ioflag & IO_SYNC),
829 			    ap->a_cred, uio->uio_td);
830 			uio->uio_offset -= resid - uio->uio_resid;
831 			uio->uio_resid = resid;
832 		}
833 	} else if (resid > uio->uio_resid && (ioflag & IO_SYNC))
834 		error = ffs_update(vp, 1);
835 	return (error);
836 }
837 
838 /*
839  * get page routine
840  */
841 static int
842 ffs_getpages(ap)
843 	struct vop_getpages_args *ap;
844 {
845 	int i;
846 	vm_page_t mreq;
847 	int pcount;
848 
849 	pcount = round_page(ap->a_count) / PAGE_SIZE;
850 	mreq = ap->a_m[ap->a_reqpage];
851 
852 	/*
853 	 * if ANY DEV_BSIZE blocks are valid on a large filesystem block,
854 	 * then the entire page is valid.  Since the page may be mapped,
855 	 * user programs might reference data beyond the actual end of file
856 	 * occuring within the page.  We have to zero that data.
857 	 */
858 	VM_OBJECT_LOCK(mreq->object);
859 	if (mreq->valid) {
860 		if (mreq->valid != VM_PAGE_BITS_ALL)
861 			vm_page_zero_invalid(mreq, TRUE);
862 		vm_page_lock_queues();
863 		for (i = 0; i < pcount; i++) {
864 			if (i != ap->a_reqpage) {
865 				vm_page_free(ap->a_m[i]);
866 			}
867 		}
868 		vm_page_unlock_queues();
869 		VM_OBJECT_UNLOCK(mreq->object);
870 		return VM_PAGER_OK;
871 	}
872 	VM_OBJECT_UNLOCK(mreq->object);
873 
874 	return vnode_pager_generic_getpages(ap->a_vp, ap->a_m,
875 					    ap->a_count,
876 					    ap->a_reqpage);
877 }
878 
879 
880 /*
881  * Extended attribute area reading.
882  */
883 static int
884 ffs_extread(struct vnode *vp, struct uio *uio, int ioflag)
885 {
886 	struct inode *ip;
887 	struct ufs2_dinode *dp;
888 	struct fs *fs;
889 	struct buf *bp;
890 	ufs_lbn_t lbn, nextlbn;
891 	off_t bytesinfile;
892 	long size, xfersize, blkoffset;
893 	int error, orig_resid;
894 
895 	ip = VTOI(vp);
896 	fs = ip->i_fs;
897 	dp = ip->i_din2;
898 
899 #ifdef INVARIANTS
900 	if (uio->uio_rw != UIO_READ || fs->fs_magic != FS_UFS2_MAGIC)
901 		panic("ffs_extread: mode");
902 
903 #endif
904 	orig_resid = uio->uio_resid;
905 	KASSERT(orig_resid >= 0, ("ffs_extread: uio->uio_resid < 0"));
906 	if (orig_resid == 0)
907 		return (0);
908 	KASSERT(uio->uio_offset >= 0, ("ffs_extread: uio->uio_offset < 0"));
909 
910 	for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
911 		if ((bytesinfile = dp->di_extsize - uio->uio_offset) <= 0)
912 			break;
913 		lbn = lblkno(fs, uio->uio_offset);
914 		nextlbn = lbn + 1;
915 
916 		/*
917 		 * size of buffer.  The buffer representing the
918 		 * end of the file is rounded up to the size of
919 		 * the block type ( fragment or full block,
920 		 * depending ).
921 		 */
922 		size = sblksize(fs, dp->di_extsize, lbn);
923 		blkoffset = blkoff(fs, uio->uio_offset);
924 
925 		/*
926 		 * The amount we want to transfer in this iteration is
927 		 * one FS block less the amount of the data before
928 		 * our startpoint (duh!)
929 		 */
930 		xfersize = fs->fs_bsize - blkoffset;
931 
932 		/*
933 		 * But if we actually want less than the block,
934 		 * or the file doesn't have a whole block more of data,
935 		 * then use the lesser number.
936 		 */
937 		if (uio->uio_resid < xfersize)
938 			xfersize = uio->uio_resid;
939 		if (bytesinfile < xfersize)
940 			xfersize = bytesinfile;
941 
942 		if (lblktosize(fs, nextlbn) >= dp->di_extsize) {
943 			/*
944 			 * Don't do readahead if this is the end of the info.
945 			 */
946 			error = bread(vp, -1 - lbn, size, NOCRED, &bp);
947 		} else {
948 			/*
949 			 * If we have a second block, then
950 			 * fire off a request for a readahead
951 			 * as well as a read. Note that the 4th and 5th
952 			 * arguments point to arrays of the size specified in
953 			 * the 6th argument.
954 			 */
955 			int nextsize = sblksize(fs, dp->di_extsize, nextlbn);
956 
957 			nextlbn = -1 - nextlbn;
958 			error = breadn(vp, -1 - lbn,
959 			    size, &nextlbn, &nextsize, 1, NOCRED, &bp);
960 		}
961 		if (error) {
962 			brelse(bp);
963 			bp = NULL;
964 			break;
965 		}
966 
967 		/*
968 		 * If IO_DIRECT then set B_DIRECT for the buffer.  This
969 		 * will cause us to attempt to release the buffer later on
970 		 * and will cause the buffer cache to attempt to free the
971 		 * underlying pages.
972 		 */
973 		if (ioflag & IO_DIRECT)
974 			bp->b_flags |= B_DIRECT;
975 
976 		/*
977 		 * We should only get non-zero b_resid when an I/O error
978 		 * has occurred, which should cause us to break above.
979 		 * However, if the short read did not cause an error,
980 		 * then we want to ensure that we do not uiomove bad
981 		 * or uninitialized data.
982 		 */
983 		size -= bp->b_resid;
984 		if (size < xfersize) {
985 			if (size == 0)
986 				break;
987 			xfersize = size;
988 		}
989 
990 		error = uiomove((char *)bp->b_data + blkoffset,
991 					(int)xfersize, uio);
992 		if (error)
993 			break;
994 
995 		if ((ioflag & (IO_VMIO|IO_DIRECT)) &&
996 		   (LIST_EMPTY(&bp->b_dep))) {
997 			/*
998 			 * If there are no dependencies, and it's VMIO,
999 			 * then we don't need the buf, mark it available
1000 			 * for freeing. The VM has the data.
1001 			 */
1002 			bp->b_flags |= B_RELBUF;
1003 			brelse(bp);
1004 		} else {
1005 			/*
1006 			 * Otherwise let whoever
1007 			 * made the request take care of
1008 			 * freeing it. We just queue
1009 			 * it onto another list.
1010 			 */
1011 			bqrelse(bp);
1012 		}
1013 	}
1014 
1015 	/*
1016 	 * This can only happen in the case of an error
1017 	 * because the loop above resets bp to NULL on each iteration
1018 	 * and on normal completion has not set a new value into it.
1019 	 * so it must have come from a 'break' statement
1020 	 */
1021 	if (bp != NULL) {
1022 		if ((ioflag & (IO_VMIO|IO_DIRECT)) &&
1023 		   (LIST_EMPTY(&bp->b_dep))) {
1024 			bp->b_flags |= B_RELBUF;
1025 			brelse(bp);
1026 		} else {
1027 			bqrelse(bp);
1028 		}
1029 	}
1030 	return (error);
1031 }
1032 
1033 /*
1034  * Extended attribute area writing.
1035  */
1036 static int
1037 ffs_extwrite(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *ucred)
1038 {
1039 	struct inode *ip;
1040 	struct ufs2_dinode *dp;
1041 	struct fs *fs;
1042 	struct buf *bp;
1043 	ufs_lbn_t lbn;
1044 	off_t osize;
1045 	int blkoffset, error, flags, resid, size, xfersize;
1046 
1047 	ip = VTOI(vp);
1048 	fs = ip->i_fs;
1049 	dp = ip->i_din2;
1050 
1051 	KASSERT(!(ip->i_flag & IN_SPACECOUNTED), ("inode %u: inode is dead",
1052 	    ip->i_number));
1053 
1054 #ifdef INVARIANTS
1055 	if (uio->uio_rw != UIO_WRITE || fs->fs_magic != FS_UFS2_MAGIC)
1056 		panic("ffs_extwrite: mode");
1057 #endif
1058 
1059 	if (ioflag & IO_APPEND)
1060 		uio->uio_offset = dp->di_extsize;
1061 	KASSERT(uio->uio_offset >= 0, ("ffs_extwrite: uio->uio_offset < 0"));
1062 	KASSERT(uio->uio_resid >= 0, ("ffs_extwrite: uio->uio_resid < 0"));
1063 	if ((uoff_t)uio->uio_offset + uio->uio_resid > NXADDR * fs->fs_bsize)
1064 		return (EFBIG);
1065 
1066 	resid = uio->uio_resid;
1067 	osize = dp->di_extsize;
1068 	flags = IO_EXT;
1069 	if ((ioflag & IO_SYNC) && !DOINGASYNC(vp))
1070 		flags |= IO_SYNC;
1071 
1072 	for (error = 0; uio->uio_resid > 0;) {
1073 		lbn = lblkno(fs, uio->uio_offset);
1074 		blkoffset = blkoff(fs, uio->uio_offset);
1075 		xfersize = fs->fs_bsize - blkoffset;
1076 		if (uio->uio_resid < xfersize)
1077 			xfersize = uio->uio_resid;
1078 
1079 		/*
1080 		 * We must perform a read-before-write if the transfer size
1081 		 * does not cover the entire buffer.
1082                  */
1083 		if (fs->fs_bsize > xfersize)
1084 			flags |= BA_CLRBUF;
1085 		else
1086 			flags &= ~BA_CLRBUF;
1087 		error = UFS_BALLOC(vp, uio->uio_offset, xfersize,
1088 		    ucred, flags, &bp);
1089 		if (error != 0)
1090 			break;
1091 		/*
1092 		 * If the buffer is not valid we have to clear out any
1093 		 * garbage data from the pages instantiated for the buffer.
1094 		 * If we do not, a failed uiomove() during a write can leave
1095 		 * the prior contents of the pages exposed to a userland
1096 		 * mmap().  XXX deal with uiomove() errors a better way.
1097 		 */
1098 		if ((bp->b_flags & B_CACHE) == 0 && fs->fs_bsize <= xfersize)
1099 			vfs_bio_clrbuf(bp);
1100 		if (ioflag & IO_DIRECT)
1101 			bp->b_flags |= B_DIRECT;
1102 
1103 		if (uio->uio_offset + xfersize > dp->di_extsize)
1104 			dp->di_extsize = uio->uio_offset + xfersize;
1105 
1106 		size = sblksize(fs, dp->di_extsize, lbn) - bp->b_resid;
1107 		if (size < xfersize)
1108 			xfersize = size;
1109 
1110 		error =
1111 		    uiomove((char *)bp->b_data + blkoffset, (int)xfersize, uio);
1112 		if ((ioflag & (IO_VMIO|IO_DIRECT)) &&
1113 		   (LIST_EMPTY(&bp->b_dep))) {
1114 			bp->b_flags |= B_RELBUF;
1115 		}
1116 
1117 		/*
1118 		 * If IO_SYNC each buffer is written synchronously.  Otherwise
1119 		 * if we have a severe page deficiency write the buffer
1120 		 * asynchronously.  Otherwise try to cluster, and if that
1121 		 * doesn't do it then either do an async write (if O_DIRECT),
1122 		 * or a delayed write (if not).
1123 		 */
1124 		if (ioflag & IO_SYNC) {
1125 			(void)bwrite(bp);
1126 		} else if (vm_page_count_severe() ||
1127 			    buf_dirty_count_severe() ||
1128 			    xfersize + blkoffset == fs->fs_bsize ||
1129 			    (ioflag & (IO_ASYNC | IO_DIRECT)))
1130 			bawrite(bp);
1131 		else
1132 			bdwrite(bp);
1133 		if (error || xfersize == 0)
1134 			break;
1135 		ip->i_flag |= IN_CHANGE;
1136 	}
1137 	/*
1138 	 * If we successfully wrote any data, and we are not the superuser
1139 	 * we clear the setuid and setgid bits as a precaution against
1140 	 * tampering.
1141 	 */
1142 	if ((ip->i_mode & (ISUID | ISGID)) && resid > uio->uio_resid && ucred) {
1143 		if (priv_check_cred(ucred, PRIV_VFS_RETAINSUGID, 0)) {
1144 			ip->i_mode &= ~(ISUID | ISGID);
1145 			dp->di_mode = ip->i_mode;
1146 		}
1147 	}
1148 	if (error) {
1149 		if (ioflag & IO_UNIT) {
1150 			(void)ffs_truncate(vp, osize,
1151 			    IO_EXT | (ioflag&IO_SYNC), ucred, uio->uio_td);
1152 			uio->uio_offset -= resid - uio->uio_resid;
1153 			uio->uio_resid = resid;
1154 		}
1155 	} else if (resid > uio->uio_resid && (ioflag & IO_SYNC))
1156 		error = ffs_update(vp, 1);
1157 	return (error);
1158 }
1159 
1160 
1161 /*
1162  * Vnode operating to retrieve a named extended attribute.
1163  *
1164  * Locate a particular EA (nspace:name) in the area (ptr:length), and return
1165  * the length of the EA, and possibly the pointer to the entry and to the data.
1166  */
1167 static int
1168 ffs_findextattr(u_char *ptr, u_int length, int nspace, const char *name, u_char **eap, u_char **eac)
1169 {
1170 	u_char *p, *pe, *pn, *p0;
1171 	int eapad1, eapad2, ealength, ealen, nlen;
1172 	uint32_t ul;
1173 
1174 	pe = ptr + length;
1175 	nlen = strlen(name);
1176 
1177 	for (p = ptr; p < pe; p = pn) {
1178 		p0 = p;
1179 		bcopy(p, &ul, sizeof(ul));
1180 		pn = p + ul;
1181 		/* make sure this entry is complete */
1182 		if (pn > pe)
1183 			break;
1184 		p += sizeof(uint32_t);
1185 		if (*p != nspace)
1186 			continue;
1187 		p++;
1188 		eapad2 = *p++;
1189 		if (*p != nlen)
1190 			continue;
1191 		p++;
1192 		if (bcmp(p, name, nlen))
1193 			continue;
1194 		ealength = sizeof(uint32_t) + 3 + nlen;
1195 		eapad1 = 8 - (ealength % 8);
1196 		if (eapad1 == 8)
1197 			eapad1 = 0;
1198 		ealength += eapad1;
1199 		ealen = ul - ealength - eapad2;
1200 		p += nlen + eapad1;
1201 		if (eap != NULL)
1202 			*eap = p0;
1203 		if (eac != NULL)
1204 			*eac = p;
1205 		return (ealen);
1206 	}
1207 	return(-1);
1208 }
1209 
1210 static int
1211 ffs_rdextattr(u_char **p, struct vnode *vp, struct thread *td, int extra)
1212 {
1213 	struct inode *ip;
1214 	struct ufs2_dinode *dp;
1215 	struct fs *fs;
1216 	struct uio luio;
1217 	struct iovec liovec;
1218 	int easize, error;
1219 	u_char *eae;
1220 
1221 	ip = VTOI(vp);
1222 	fs = ip->i_fs;
1223 	dp = ip->i_din2;
1224 	easize = dp->di_extsize;
1225 	if ((uoff_t)easize + extra > NXADDR * fs->fs_bsize)
1226 		return (EFBIG);
1227 
1228 	eae = malloc(easize + extra, M_TEMP, M_WAITOK);
1229 
1230 	liovec.iov_base = eae;
1231 	liovec.iov_len = easize;
1232 	luio.uio_iov = &liovec;
1233 	luio.uio_iovcnt = 1;
1234 	luio.uio_offset = 0;
1235 	luio.uio_resid = easize;
1236 	luio.uio_segflg = UIO_SYSSPACE;
1237 	luio.uio_rw = UIO_READ;
1238 	luio.uio_td = td;
1239 
1240 	error = ffs_extread(vp, &luio, IO_EXT | IO_SYNC);
1241 	if (error) {
1242 		free(eae, M_TEMP);
1243 		return(error);
1244 	}
1245 	*p = eae;
1246 	return (0);
1247 }
1248 
1249 static void
1250 ffs_lock_ea(struct vnode *vp)
1251 {
1252 	struct inode *ip;
1253 
1254 	ip = VTOI(vp);
1255 	VI_LOCK(vp);
1256 	while (ip->i_flag & IN_EA_LOCKED) {
1257 		ip->i_flag |= IN_EA_LOCKWAIT;
1258 		msleep(&ip->i_ea_refs, &vp->v_interlock, PINOD + 2, "ufs_ea",
1259 		    0);
1260 	}
1261 	ip->i_flag |= IN_EA_LOCKED;
1262 	VI_UNLOCK(vp);
1263 }
1264 
1265 static void
1266 ffs_unlock_ea(struct vnode *vp)
1267 {
1268 	struct inode *ip;
1269 
1270 	ip = VTOI(vp);
1271 	VI_LOCK(vp);
1272 	if (ip->i_flag & IN_EA_LOCKWAIT)
1273 		wakeup(&ip->i_ea_refs);
1274 	ip->i_flag &= ~(IN_EA_LOCKED | IN_EA_LOCKWAIT);
1275 	VI_UNLOCK(vp);
1276 }
1277 
1278 static int
1279 ffs_open_ea(struct vnode *vp, struct ucred *cred, struct thread *td)
1280 {
1281 	struct inode *ip;
1282 	struct ufs2_dinode *dp;
1283 	int error;
1284 
1285 	ip = VTOI(vp);
1286 
1287 	ffs_lock_ea(vp);
1288 	if (ip->i_ea_area != NULL) {
1289 		ip->i_ea_refs++;
1290 		ffs_unlock_ea(vp);
1291 		return (0);
1292 	}
1293 	dp = ip->i_din2;
1294 	error = ffs_rdextattr(&ip->i_ea_area, vp, td, 0);
1295 	if (error) {
1296 		ffs_unlock_ea(vp);
1297 		return (error);
1298 	}
1299 	ip->i_ea_len = dp->di_extsize;
1300 	ip->i_ea_error = 0;
1301 	ip->i_ea_refs++;
1302 	ffs_unlock_ea(vp);
1303 	return (0);
1304 }
1305 
1306 /*
1307  * Vnode extattr transaction commit/abort
1308  */
1309 static int
1310 ffs_close_ea(struct vnode *vp, int commit, struct ucred *cred, struct thread *td)
1311 {
1312 	struct inode *ip;
1313 	struct uio luio;
1314 	struct iovec liovec;
1315 	int error;
1316 	struct ufs2_dinode *dp;
1317 
1318 	ip = VTOI(vp);
1319 
1320 	ffs_lock_ea(vp);
1321 	if (ip->i_ea_area == NULL) {
1322 		ffs_unlock_ea(vp);
1323 		return (EINVAL);
1324 	}
1325 	dp = ip->i_din2;
1326 	error = ip->i_ea_error;
1327 	if (commit && error == 0) {
1328 		ASSERT_VOP_ELOCKED(vp, "ffs_close_ea commit");
1329 		if (cred == NOCRED)
1330 			cred =  vp->v_mount->mnt_cred;
1331 		liovec.iov_base = ip->i_ea_area;
1332 		liovec.iov_len = ip->i_ea_len;
1333 		luio.uio_iov = &liovec;
1334 		luio.uio_iovcnt = 1;
1335 		luio.uio_offset = 0;
1336 		luio.uio_resid = ip->i_ea_len;
1337 		luio.uio_segflg = UIO_SYSSPACE;
1338 		luio.uio_rw = UIO_WRITE;
1339 		luio.uio_td = td;
1340 		/* XXX: I'm not happy about truncating to zero size */
1341 		if (ip->i_ea_len < dp->di_extsize)
1342 			error = ffs_truncate(vp, 0, IO_EXT, cred, td);
1343 		error = ffs_extwrite(vp, &luio, IO_EXT | IO_SYNC, cred);
1344 	}
1345 	if (--ip->i_ea_refs == 0) {
1346 		free(ip->i_ea_area, M_TEMP);
1347 		ip->i_ea_area = NULL;
1348 		ip->i_ea_len = 0;
1349 		ip->i_ea_error = 0;
1350 	}
1351 	ffs_unlock_ea(vp);
1352 	return (error);
1353 }
1354 
1355 /*
1356  * Vnode extattr strategy routine for fifos.
1357  *
1358  * We need to check for a read or write of the external attributes.
1359  * Otherwise we just fall through and do the usual thing.
1360  */
1361 static int
1362 ffsext_strategy(struct vop_strategy_args *ap)
1363 /*
1364 struct vop_strategy_args {
1365 	struct vnodeop_desc *a_desc;
1366 	struct vnode *a_vp;
1367 	struct buf *a_bp;
1368 };
1369 */
1370 {
1371 	struct vnode *vp;
1372 	daddr_t lbn;
1373 
1374 	vp = ap->a_vp;
1375 	lbn = ap->a_bp->b_lblkno;
1376 	if (VTOI(vp)->i_fs->fs_magic == FS_UFS2_MAGIC &&
1377 	    lbn < 0 && lbn >= -NXADDR)
1378 		return (VOP_STRATEGY_APV(&ufs_vnodeops, ap));
1379 	if (vp->v_type == VFIFO)
1380 		return (VOP_STRATEGY_APV(&ufs_fifoops, ap));
1381 	panic("spec nodes went here");
1382 }
1383 
1384 /*
1385  * Vnode extattr transaction commit/abort
1386  */
1387 static int
1388 ffs_openextattr(struct vop_openextattr_args *ap)
1389 /*
1390 struct vop_openextattr_args {
1391 	struct vnodeop_desc *a_desc;
1392 	struct vnode *a_vp;
1393 	IN struct ucred *a_cred;
1394 	IN struct thread *a_td;
1395 };
1396 */
1397 {
1398 	struct inode *ip;
1399 	struct fs *fs;
1400 
1401 	ip = VTOI(ap->a_vp);
1402 	fs = ip->i_fs;
1403 
1404 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1405 		return (EOPNOTSUPP);
1406 
1407 	return (ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td));
1408 }
1409 
1410 
1411 /*
1412  * Vnode extattr transaction commit/abort
1413  */
1414 static int
1415 ffs_closeextattr(struct vop_closeextattr_args *ap)
1416 /*
1417 struct vop_closeextattr_args {
1418 	struct vnodeop_desc *a_desc;
1419 	struct vnode *a_vp;
1420 	int a_commit;
1421 	IN struct ucred *a_cred;
1422 	IN struct thread *a_td;
1423 };
1424 */
1425 {
1426 	struct inode *ip;
1427 	struct fs *fs;
1428 
1429 	ip = VTOI(ap->a_vp);
1430 	fs = ip->i_fs;
1431 
1432 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1433 		return (EOPNOTSUPP);
1434 
1435 	if (ap->a_commit && (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY))
1436 		return (EROFS);
1437 
1438 	return (ffs_close_ea(ap->a_vp, ap->a_commit, ap->a_cred, ap->a_td));
1439 }
1440 
1441 /*
1442  * Vnode operation to remove a named attribute.
1443  */
1444 static int
1445 ffs_deleteextattr(struct vop_deleteextattr_args *ap)
1446 /*
1447 vop_deleteextattr {
1448 	IN struct vnode *a_vp;
1449 	IN int a_attrnamespace;
1450 	IN const char *a_name;
1451 	IN struct ucred *a_cred;
1452 	IN struct thread *a_td;
1453 };
1454 */
1455 {
1456 	struct inode *ip;
1457 	struct fs *fs;
1458 	uint32_t ealength, ul;
1459 	int ealen, olen, eapad1, eapad2, error, i, easize;
1460 	u_char *eae, *p;
1461 
1462 	ip = VTOI(ap->a_vp);
1463 	fs = ip->i_fs;
1464 
1465 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1466 		return (EOPNOTSUPP);
1467 
1468 	if (strlen(ap->a_name) == 0)
1469 		return (EINVAL);
1470 
1471 	if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
1472 		return (EROFS);
1473 
1474 	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1475 	    ap->a_cred, ap->a_td, VWRITE);
1476 	if (error) {
1477 
1478 		/*
1479 		 * ffs_lock_ea is not needed there, because the vnode
1480 		 * must be exclusively locked.
1481 		 */
1482 		if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1483 			ip->i_ea_error = error;
1484 		return (error);
1485 	}
1486 
1487 	error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1488 	if (error)
1489 		return (error);
1490 
1491 	ealength = eapad1 = ealen = eapad2 = 0;
1492 
1493 	eae = malloc(ip->i_ea_len, M_TEMP, M_WAITOK);
1494 	bcopy(ip->i_ea_area, eae, ip->i_ea_len);
1495 	easize = ip->i_ea_len;
1496 
1497 	olen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name,
1498 	    &p, NULL);
1499 	if (olen == -1) {
1500 		/* delete but nonexistent */
1501 		free(eae, M_TEMP);
1502 		ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1503 		return(ENOATTR);
1504 	}
1505 	bcopy(p, &ul, sizeof ul);
1506 	i = p - eae + ul;
1507 	if (ul != ealength) {
1508 		bcopy(p + ul, p + ealength, easize - i);
1509 		easize += (ealength - ul);
1510 	}
1511 	if (easize > NXADDR * fs->fs_bsize) {
1512 		free(eae, M_TEMP);
1513 		ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1514 		if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1515 			ip->i_ea_error = ENOSPC;
1516 		return(ENOSPC);
1517 	}
1518 	p = ip->i_ea_area;
1519 	ip->i_ea_area = eae;
1520 	ip->i_ea_len = easize;
1521 	free(p, M_TEMP);
1522 	error = ffs_close_ea(ap->a_vp, 1, ap->a_cred, ap->a_td);
1523 	return(error);
1524 }
1525 
1526 /*
1527  * Vnode operation to retrieve a named extended attribute.
1528  */
1529 static int
1530 ffs_getextattr(struct vop_getextattr_args *ap)
1531 /*
1532 vop_getextattr {
1533 	IN struct vnode *a_vp;
1534 	IN int a_attrnamespace;
1535 	IN const char *a_name;
1536 	INOUT struct uio *a_uio;
1537 	OUT size_t *a_size;
1538 	IN struct ucred *a_cred;
1539 	IN struct thread *a_td;
1540 };
1541 */
1542 {
1543 	struct inode *ip;
1544 	struct fs *fs;
1545 	u_char *eae, *p;
1546 	unsigned easize;
1547 	int error, ealen;
1548 
1549 	ip = VTOI(ap->a_vp);
1550 	fs = ip->i_fs;
1551 
1552 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1553 		return (EOPNOTSUPP);
1554 
1555 	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1556 	    ap->a_cred, ap->a_td, VREAD);
1557 	if (error)
1558 		return (error);
1559 
1560 	error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1561 	if (error)
1562 		return (error);
1563 
1564 	eae = ip->i_ea_area;
1565 	easize = ip->i_ea_len;
1566 
1567 	ealen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name,
1568 	    NULL, &p);
1569 	if (ealen >= 0) {
1570 		error = 0;
1571 		if (ap->a_size != NULL)
1572 			*ap->a_size = ealen;
1573 		else if (ap->a_uio != NULL)
1574 			error = uiomove(p, ealen, ap->a_uio);
1575 	} else
1576 		error = ENOATTR;
1577 
1578 	ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1579 	return(error);
1580 }
1581 
1582 /*
1583  * Vnode operation to retrieve extended attributes on a vnode.
1584  */
1585 static int
1586 ffs_listextattr(struct vop_listextattr_args *ap)
1587 /*
1588 vop_listextattr {
1589 	IN struct vnode *a_vp;
1590 	IN int a_attrnamespace;
1591 	INOUT struct uio *a_uio;
1592 	OUT size_t *a_size;
1593 	IN struct ucred *a_cred;
1594 	IN struct thread *a_td;
1595 };
1596 */
1597 {
1598 	struct inode *ip;
1599 	struct fs *fs;
1600 	u_char *eae, *p, *pe, *pn;
1601 	unsigned easize;
1602 	uint32_t ul;
1603 	int error, ealen;
1604 
1605 	ip = VTOI(ap->a_vp);
1606 	fs = ip->i_fs;
1607 
1608 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1609 		return (EOPNOTSUPP);
1610 
1611 	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1612 	    ap->a_cred, ap->a_td, VREAD);
1613 	if (error)
1614 		return (error);
1615 
1616 	error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1617 	if (error)
1618 		return (error);
1619 	eae = ip->i_ea_area;
1620 	easize = ip->i_ea_len;
1621 
1622 	error = 0;
1623 	if (ap->a_size != NULL)
1624 		*ap->a_size = 0;
1625 	pe = eae + easize;
1626 	for(p = eae; error == 0 && p < pe; p = pn) {
1627 		bcopy(p, &ul, sizeof(ul));
1628 		pn = p + ul;
1629 		if (pn > pe)
1630 			break;
1631 		p += sizeof(ul);
1632 		if (*p++ != ap->a_attrnamespace)
1633 			continue;
1634 		p++;	/* pad2 */
1635 		ealen = *p;
1636 		if (ap->a_size != NULL) {
1637 			*ap->a_size += ealen + 1;
1638 		} else if (ap->a_uio != NULL) {
1639 			error = uiomove(p, ealen + 1, ap->a_uio);
1640 		}
1641 	}
1642 	ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1643 	return(error);
1644 }
1645 
1646 /*
1647  * Vnode operation to set a named attribute.
1648  */
1649 static int
1650 ffs_setextattr(struct vop_setextattr_args *ap)
1651 /*
1652 vop_setextattr {
1653 	IN struct vnode *a_vp;
1654 	IN int a_attrnamespace;
1655 	IN const char *a_name;
1656 	INOUT struct uio *a_uio;
1657 	IN struct ucred *a_cred;
1658 	IN struct thread *a_td;
1659 };
1660 */
1661 {
1662 	struct inode *ip;
1663 	struct fs *fs;
1664 	uint32_t ealength, ul;
1665 	int ealen, olen, eapad1, eapad2, error, i, easize;
1666 	u_char *eae, *p;
1667 
1668 	ip = VTOI(ap->a_vp);
1669 	fs = ip->i_fs;
1670 
1671 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1672 		return (EOPNOTSUPP);
1673 
1674 	if (strlen(ap->a_name) == 0)
1675 		return (EINVAL);
1676 
1677 	/* XXX Now unsupported API to delete EAs using NULL uio. */
1678 	if (ap->a_uio == NULL)
1679 		return (EOPNOTSUPP);
1680 
1681 	if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
1682 		return (EROFS);
1683 
1684 	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1685 	    ap->a_cred, ap->a_td, VWRITE);
1686 	if (error) {
1687 
1688 		/*
1689 		 * ffs_lock_ea is not needed there, because the vnode
1690 		 * must be exclusively locked.
1691 		 */
1692 		if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1693 			ip->i_ea_error = error;
1694 		return (error);
1695 	}
1696 
1697 	error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1698 	if (error)
1699 		return (error);
1700 
1701 	ealen = ap->a_uio->uio_resid;
1702 	ealength = sizeof(uint32_t) + 3 + strlen(ap->a_name);
1703 	eapad1 = 8 - (ealength % 8);
1704 	if (eapad1 == 8)
1705 		eapad1 = 0;
1706 	eapad2 = 8 - (ealen % 8);
1707 	if (eapad2 == 8)
1708 		eapad2 = 0;
1709 	ealength += eapad1 + ealen + eapad2;
1710 
1711 	eae = malloc(ip->i_ea_len + ealength, M_TEMP, M_WAITOK);
1712 	bcopy(ip->i_ea_area, eae, ip->i_ea_len);
1713 	easize = ip->i_ea_len;
1714 
1715 	olen = ffs_findextattr(eae, easize,
1716 	    ap->a_attrnamespace, ap->a_name, &p, NULL);
1717         if (olen == -1) {
1718 		/* new, append at end */
1719 		p = eae + easize;
1720 		easize += ealength;
1721 	} else {
1722 		bcopy(p, &ul, sizeof ul);
1723 		i = p - eae + ul;
1724 		if (ul != ealength) {
1725 			bcopy(p + ul, p + ealength, easize - i);
1726 			easize += (ealength - ul);
1727 		}
1728 	}
1729 	if (easize > NXADDR * fs->fs_bsize) {
1730 		free(eae, M_TEMP);
1731 		ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1732 		if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1733 			ip->i_ea_error = ENOSPC;
1734 		return(ENOSPC);
1735 	}
1736 	bcopy(&ealength, p, sizeof(ealength));
1737 	p += sizeof(ealength);
1738 	*p++ = ap->a_attrnamespace;
1739 	*p++ = eapad2;
1740 	*p++ = strlen(ap->a_name);
1741 	strcpy(p, ap->a_name);
1742 	p += strlen(ap->a_name);
1743 	bzero(p, eapad1);
1744 	p += eapad1;
1745 	error = uiomove(p, ealen, ap->a_uio);
1746 	if (error) {
1747 		free(eae, M_TEMP);
1748 		ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1749 		if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1750 			ip->i_ea_error = error;
1751 		return(error);
1752 	}
1753 	p += ealen;
1754 	bzero(p, eapad2);
1755 
1756 	p = ip->i_ea_area;
1757 	ip->i_ea_area = eae;
1758 	ip->i_ea_len = easize;
1759 	free(p, M_TEMP);
1760 	error = ffs_close_ea(ap->a_vp, 1, ap->a_cred, ap->a_td);
1761 	return(error);
1762 }
1763 
1764 /*
1765  * Vnode pointer to File handle
1766  */
1767 static int
1768 ffs_vptofh(struct vop_vptofh_args *ap)
1769 /*
1770 vop_vptofh {
1771 	IN struct vnode *a_vp;
1772 	IN struct fid *a_fhp;
1773 };
1774 */
1775 {
1776 	struct inode *ip;
1777 	struct ufid *ufhp;
1778 
1779 	ip = VTOI(ap->a_vp);
1780 	ufhp = (struct ufid *)ap->a_fhp;
1781 	ufhp->ufid_len = sizeof(struct ufid);
1782 	ufhp->ufid_ino = ip->i_number;
1783 	ufhp->ufid_gen = ip->i_gen;
1784 	return (0);
1785 }
1786