xref: /freebsd/sys/ufs/ffs/ffs_snapshot.c (revision 13464e4a44fc58490a03bb8bfc7e3c972e9c30b2)
1 /*-
2  * Copyright 2000 Marshall Kirk McKusick. All Rights Reserved.
3  *
4  * Further information about snapshots can be obtained from:
5  *
6  *	Marshall Kirk McKusick		http://www.mckusick.com/softdep/
7  *	1614 Oxford Street		mckusick@mckusick.com
8  *	Berkeley, CA 94709-1608		+1-510-843-9542
9  *	USA
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  *
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  *
21  * THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND ANY
22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24  * DISCLAIMED.  IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE FOR
25  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *	@(#)ffs_snapshot.c	8.11 (McKusick) 7/23/00
34  */
35 
36 #include <sys/cdefs.h>
37 __FBSDID("$FreeBSD$");
38 
39 #include "opt_quota.h"
40 
41 #include <sys/param.h>
42 #include <sys/kernel.h>
43 #include <sys/systm.h>
44 #include <sys/conf.h>
45 #include <sys/bio.h>
46 #include <sys/buf.h>
47 #include <sys/fcntl.h>
48 #include <sys/proc.h>
49 #include <sys/namei.h>
50 #include <sys/sched.h>
51 #include <sys/stat.h>
52 #include <sys/malloc.h>
53 #include <sys/mount.h>
54 #include <sys/resource.h>
55 #include <sys/resourcevar.h>
56 #include <sys/rwlock.h>
57 #include <sys/vnode.h>
58 
59 #include <geom/geom.h>
60 
61 #include <ufs/ufs/extattr.h>
62 #include <ufs/ufs/quota.h>
63 #include <ufs/ufs/ufsmount.h>
64 #include <ufs/ufs/inode.h>
65 #include <ufs/ufs/ufs_extern.h>
66 
67 #include <ufs/ffs/fs.h>
68 #include <ufs/ffs/ffs_extern.h>
69 
70 #define KERNCRED thread0.td_ucred
71 #define DEBUG 1
72 
73 #include "opt_ffs.h"
74 
75 #ifdef NO_FFS_SNAPSHOT
76 int
77 ffs_snapshot(mp, snapfile)
78 	struct mount *mp;
79 	char *snapfile;
80 {
81 	return (EINVAL);
82 }
83 
84 int
85 ffs_snapblkfree(fs, devvp, bno, size, inum, vtype, wkhd)
86 	struct fs *fs;
87 	struct vnode *devvp;
88 	ufs2_daddr_t bno;
89 	long size;
90 	ino_t inum;
91 	enum vtype vtype;
92 	struct workhead *wkhd;
93 {
94 	return (EINVAL);
95 }
96 
97 void
98 ffs_snapremove(vp)
99 	struct vnode *vp;
100 {
101 }
102 
103 void
104 ffs_snapshot_mount(mp)
105 	struct mount *mp;
106 {
107 }
108 
109 void
110 ffs_snapshot_unmount(mp)
111 	struct mount *mp;
112 {
113 }
114 
115 void
116 ffs_snapgone(ip)
117 	struct inode *ip;
118 {
119 }
120 
121 int
122 ffs_copyonwrite(devvp, bp)
123 	struct vnode *devvp;
124 	struct buf *bp;
125 {
126 	return (EINVAL);
127 }
128 
129 void
130 ffs_sync_snap(mp, waitfor)
131 	struct mount *mp;
132 	int waitfor;
133 {
134 }
135 
136 #else
137 FEATURE(ffs_snapshot, "FFS snapshot support");
138 
139 LIST_HEAD(, snapdata) snapfree;
140 static struct mtx snapfree_lock;
141 MTX_SYSINIT(ffs_snapfree, &snapfree_lock, "snapdata free list", MTX_DEF);
142 
143 static int cgaccount(int, struct vnode *, struct buf *, int);
144 static int expunge_ufs1(struct vnode *, struct inode *, struct fs *,
145     int (*)(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *, struct fs *,
146     ufs_lbn_t, int), int, int);
147 static int indiracct_ufs1(struct vnode *, struct vnode *, int,
148     ufs1_daddr_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, struct fs *,
149     int (*)(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *, struct fs *,
150     ufs_lbn_t, int), int);
151 static int fullacct_ufs1(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *,
152     struct fs *, ufs_lbn_t, int);
153 static int snapacct_ufs1(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *,
154     struct fs *, ufs_lbn_t, int);
155 static int mapacct_ufs1(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *,
156     struct fs *, ufs_lbn_t, int);
157 static int expunge_ufs2(struct vnode *, struct inode *, struct fs *,
158     int (*)(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *, struct fs *,
159     ufs_lbn_t, int), int, int);
160 static int indiracct_ufs2(struct vnode *, struct vnode *, int,
161     ufs2_daddr_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, ufs_lbn_t, struct fs *,
162     int (*)(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *, struct fs *,
163     ufs_lbn_t, int), int);
164 static int fullacct_ufs2(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *,
165     struct fs *, ufs_lbn_t, int);
166 static int snapacct_ufs2(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *,
167     struct fs *, ufs_lbn_t, int);
168 static int mapacct_ufs2(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *,
169     struct fs *, ufs_lbn_t, int);
170 static int readblock(struct vnode *vp, struct buf *, ufs2_daddr_t);
171 static void try_free_snapdata(struct vnode *devvp);
172 static struct snapdata *ffs_snapdata_acquire(struct vnode *devvp);
173 static int ffs_bp_snapblk(struct vnode *, struct buf *);
174 
175 /*
176  * To ensure the consistency of snapshots across crashes, we must
177  * synchronously write out copied blocks before allowing the
178  * originals to be modified. Because of the rather severe speed
179  * penalty that this imposes, the code normally only ensures
180  * persistence for the filesystem metadata contained within a
181  * snapshot. Setting the following flag allows this crash
182  * persistence to be enabled for file contents.
183  */
184 int dopersistence = 0;
185 
186 #ifdef DEBUG
187 #include <sys/sysctl.h>
188 SYSCTL_INT(_debug, OID_AUTO, dopersistence, CTLFLAG_RW, &dopersistence, 0, "");
189 static int snapdebug = 0;
190 SYSCTL_INT(_debug, OID_AUTO, snapdebug, CTLFLAG_RW, &snapdebug, 0, "");
191 int collectsnapstats = 0;
192 SYSCTL_INT(_debug, OID_AUTO, collectsnapstats, CTLFLAG_RW, &collectsnapstats,
193 	0, "");
194 #endif /* DEBUG */
195 
196 /*
197  * Create a snapshot file and initialize it for the filesystem.
198  */
199 int
200 ffs_snapshot(mp, snapfile)
201 	struct mount *mp;
202 	char *snapfile;
203 {
204 	ufs2_daddr_t numblks, blkno, *blkp, *snapblklist;
205 	int error, cg, snaploc;
206 	int i, size, len, loc;
207 	ufs2_daddr_t blockno;
208 	uint64_t flag;
209 	struct timespec starttime = {0, 0}, endtime;
210 	char saved_nice = 0;
211 	long redo = 0, snaplistsize = 0;
212 	int32_t *lp;
213 	void *space;
214 	struct fs *copy_fs = NULL, *fs;
215 	struct thread *td = curthread;
216 	struct inode *ip, *xp;
217 	struct buf *bp, *nbp, *ibp;
218 	struct nameidata nd;
219 	struct mount *wrtmp;
220 	struct vattr vat;
221 	struct vnode *vp, *xvp, *mvp, *devvp;
222 	struct uio auio;
223 	struct iovec aiov;
224 	struct snapdata *sn;
225 	struct ufsmount *ump;
226 
227 	ump = VFSTOUFS(mp);
228 	fs = ump->um_fs;
229 	sn = NULL;
230 	/*
231 	 * At the moment, journaled soft updates cannot support
232 	 * taking snapshots.
233 	 */
234 	if (MOUNTEDSUJ(mp)) {
235 		vfs_mount_error(mp, "%s: Snapshots are not yet supported when "
236 		    "running with journaled soft updates", fs->fs_fsmnt);
237 		return (EOPNOTSUPP);
238 	}
239 	MNT_ILOCK(mp);
240 	flag = mp->mnt_flag;
241 	MNT_IUNLOCK(mp);
242 	/*
243 	 * Need to serialize access to snapshot code per filesystem.
244 	 */
245 	/*
246 	 * Assign a snapshot slot in the superblock.
247 	 */
248 	UFS_LOCK(ump);
249 	for (snaploc = 0; snaploc < FSMAXSNAP; snaploc++)
250 		if (fs->fs_snapinum[snaploc] == 0)
251 			break;
252 	UFS_UNLOCK(ump);
253 	if (snaploc == FSMAXSNAP)
254 		return (ENOSPC);
255 	/*
256 	 * Create the snapshot file.
257 	 */
258 restart:
259 	NDINIT(&nd, CREATE, LOCKPARENT | LOCKLEAF | NOCACHE, UIO_SYSSPACE,
260 	    snapfile, td);
261 	if ((error = namei(&nd)) != 0)
262 		return (error);
263 	if (nd.ni_vp != NULL) {
264 		vput(nd.ni_vp);
265 		error = EEXIST;
266 	}
267 	if (nd.ni_dvp->v_mount != mp)
268 		error = EXDEV;
269 	if (error) {
270 		NDFREE(&nd, NDF_ONLY_PNBUF);
271 		if (nd.ni_dvp == nd.ni_vp)
272 			vrele(nd.ni_dvp);
273 		else
274 			vput(nd.ni_dvp);
275 		return (error);
276 	}
277 	VATTR_NULL(&vat);
278 	vat.va_type = VREG;
279 	vat.va_mode = S_IRUSR;
280 	vat.va_vaflags |= VA_EXCLUSIVE;
281 	if (VOP_GETWRITEMOUNT(nd.ni_dvp, &wrtmp))
282 		wrtmp = NULL;
283 	if (wrtmp != mp)
284 		panic("ffs_snapshot: mount mismatch");
285 	vfs_rel(wrtmp);
286 	if (vn_start_write(NULL, &wrtmp, V_NOWAIT) != 0) {
287 		NDFREE(&nd, NDF_ONLY_PNBUF);
288 		vput(nd.ni_dvp);
289 		if ((error = vn_start_write(NULL, &wrtmp,
290 		    V_XSLEEP | PCATCH)) != 0)
291 			return (error);
292 		goto restart;
293 	}
294 	error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vat);
295 	VOP_UNLOCK(nd.ni_dvp, 0);
296 	if (error) {
297 		NDFREE(&nd, NDF_ONLY_PNBUF);
298 		vn_finished_write(wrtmp);
299 		vrele(nd.ni_dvp);
300 		return (error);
301 	}
302 	vp = nd.ni_vp;
303 	vp->v_vflag |= VV_SYSTEM;
304 	ip = VTOI(vp);
305 	devvp = ITODEVVP(ip);
306 	/*
307 	 * Allocate and copy the last block contents so as to be able
308 	 * to set size to that of the filesystem.
309 	 */
310 	numblks = howmany(fs->fs_size, fs->fs_frag);
311 	error = UFS_BALLOC(vp, lblktosize(fs, (off_t)(numblks - 1)),
312 	    fs->fs_bsize, KERNCRED, BA_CLRBUF, &bp);
313 	if (error)
314 		goto out;
315 	ip->i_size = lblktosize(fs, (off_t)numblks);
316 	DIP_SET(ip, i_size, ip->i_size);
317 	ip->i_flag |= IN_CHANGE | IN_UPDATE;
318 	error = readblock(vp, bp, numblks - 1);
319 	bawrite(bp);
320 	if (error != 0)
321 		goto out;
322 	/*
323 	 * Preallocate critical data structures so that we can copy
324 	 * them in without further allocation after we suspend all
325 	 * operations on the filesystem. We would like to just release
326 	 * the allocated buffers without writing them since they will
327 	 * be filled in below once we are ready to go, but this upsets
328 	 * the soft update code, so we go ahead and write the new buffers.
329 	 *
330 	 * Allocate all indirect blocks and mark all of them as not
331 	 * needing to be copied.
332 	 */
333 	for (blkno = UFS_NDADDR; blkno < numblks; blkno += NINDIR(fs)) {
334 		error = UFS_BALLOC(vp, lblktosize(fs, (off_t)blkno),
335 		    fs->fs_bsize, td->td_ucred, BA_METAONLY, &ibp);
336 		if (error)
337 			goto out;
338 		bawrite(ibp);
339 	}
340 	/*
341 	 * Allocate copies for the superblock and its summary information.
342 	 */
343 	error = UFS_BALLOC(vp, fs->fs_sblockloc, fs->fs_sbsize, KERNCRED,
344 	    0, &nbp);
345 	if (error)
346 		goto out;
347 	bawrite(nbp);
348 	blkno = fragstoblks(fs, fs->fs_csaddr);
349 	len = howmany(fs->fs_cssize, fs->fs_bsize);
350 	for (loc = 0; loc < len; loc++) {
351 		error = UFS_BALLOC(vp, lblktosize(fs, (off_t)(blkno + loc)),
352 		    fs->fs_bsize, KERNCRED, 0, &nbp);
353 		if (error)
354 			goto out;
355 		bawrite(nbp);
356 	}
357 	/*
358 	 * Allocate all cylinder group blocks.
359 	 */
360 	for (cg = 0; cg < fs->fs_ncg; cg++) {
361 		error = UFS_BALLOC(vp, lfragtosize(fs, cgtod(fs, cg)),
362 		    fs->fs_bsize, KERNCRED, 0, &nbp);
363 		if (error)
364 			goto out;
365 		bawrite(nbp);
366 		if (cg % 10 == 0)
367 			ffs_syncvnode(vp, MNT_WAIT, 0);
368 	}
369 	/*
370 	 * Copy all the cylinder group maps. Although the
371 	 * filesystem is still active, we hope that only a few
372 	 * cylinder groups will change between now and when we
373 	 * suspend operations. Thus, we will be able to quickly
374 	 * touch up the few cylinder groups that changed during
375 	 * the suspension period.
376 	 */
377 	len = howmany(fs->fs_ncg, NBBY);
378 	space = malloc(len, M_DEVBUF, M_WAITOK|M_ZERO);
379 	UFS_LOCK(ump);
380 	fs->fs_active = space;
381 	UFS_UNLOCK(ump);
382 	for (cg = 0; cg < fs->fs_ncg; cg++) {
383 		error = UFS_BALLOC(vp, lfragtosize(fs, cgtod(fs, cg)),
384 		    fs->fs_bsize, KERNCRED, 0, &nbp);
385 		if (error)
386 			goto out;
387 		error = cgaccount(cg, vp, nbp, 1);
388 		bawrite(nbp);
389 		if (cg % 10 == 0)
390 			ffs_syncvnode(vp, MNT_WAIT, 0);
391 		if (error)
392 			goto out;
393 	}
394 	/*
395 	 * Change inode to snapshot type file.
396 	 */
397 	ip->i_flags |= SF_SNAPSHOT;
398 	DIP_SET(ip, i_flags, ip->i_flags);
399 	ip->i_flag |= IN_CHANGE | IN_UPDATE;
400 	/*
401 	 * Ensure that the snapshot is completely on disk.
402 	 * Since we have marked it as a snapshot it is safe to
403 	 * unlock it as no process will be allowed to write to it.
404 	 */
405 	if ((error = ffs_syncvnode(vp, MNT_WAIT, 0)) != 0)
406 		goto out;
407 	VOP_UNLOCK(vp, 0);
408 	/*
409 	 * All allocations are done, so we can now snapshot the system.
410 	 *
411 	 * Recind nice scheduling while running with the filesystem suspended.
412 	 */
413 	if (td->td_proc->p_nice > 0) {
414 		struct proc *p;
415 
416 		p = td->td_proc;
417 		PROC_LOCK(p);
418 		saved_nice = p->p_nice;
419 		sched_nice(p, 0);
420 		PROC_UNLOCK(p);
421 	}
422 	/*
423 	 * Suspend operation on filesystem.
424 	 */
425 	for (;;) {
426 		vn_finished_write(wrtmp);
427 		if ((error = vfs_write_suspend(vp->v_mount, 0)) != 0) {
428 			vn_start_write(NULL, &wrtmp, V_WAIT);
429 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
430 			goto out;
431 		}
432 		if (mp->mnt_kern_flag & MNTK_SUSPENDED)
433 			break;
434 		vn_start_write(NULL, &wrtmp, V_WAIT);
435 	}
436 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
437 	if (ip->i_effnlink == 0) {
438 		error = ENOENT;		/* Snapshot file unlinked */
439 		goto out1;
440 	}
441 	if (collectsnapstats)
442 		nanotime(&starttime);
443 
444 	/* The last block might have changed.  Copy it again to be sure. */
445 	error = UFS_BALLOC(vp, lblktosize(fs, (off_t)(numblks - 1)),
446 	    fs->fs_bsize, KERNCRED, BA_CLRBUF, &bp);
447 	if (error != 0)
448 		goto out1;
449 	error = readblock(vp, bp, numblks - 1);
450 	bp->b_flags |= B_VALIDSUSPWRT;
451 	bawrite(bp);
452 	if (error != 0)
453 		goto out1;
454 	/*
455 	 * First, copy all the cylinder group maps that have changed.
456 	 */
457 	for (cg = 0; cg < fs->fs_ncg; cg++) {
458 		if ((ACTIVECGNUM(fs, cg) & ACTIVECGOFF(cg)) != 0)
459 			continue;
460 		redo++;
461 		error = UFS_BALLOC(vp, lfragtosize(fs, cgtod(fs, cg)),
462 		    fs->fs_bsize, KERNCRED, 0, &nbp);
463 		if (error)
464 			goto out1;
465 		error = cgaccount(cg, vp, nbp, 2);
466 		bawrite(nbp);
467 		if (error)
468 			goto out1;
469 	}
470 	/*
471 	 * Grab a copy of the superblock and its summary information.
472 	 * We delay writing it until the suspension is released below.
473 	 */
474 	copy_fs = malloc((u_long)fs->fs_bsize, M_UFSMNT, M_WAITOK);
475 	bcopy(fs, copy_fs, fs->fs_sbsize);
476 	if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0)
477 		copy_fs->fs_clean = 1;
478 	size = fs->fs_bsize < SBLOCKSIZE ? fs->fs_bsize : SBLOCKSIZE;
479 	if (fs->fs_sbsize < size)
480 		bzero(&((char *)copy_fs)[fs->fs_sbsize],
481 		    size - fs->fs_sbsize);
482 	size = blkroundup(fs, fs->fs_cssize);
483 	if (fs->fs_contigsumsize > 0)
484 		size += fs->fs_ncg * sizeof(int32_t);
485 	space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
486 	copy_fs->fs_csp = space;
487 	bcopy(fs->fs_csp, copy_fs->fs_csp, fs->fs_cssize);
488 	space = (char *)space + fs->fs_cssize;
489 	loc = howmany(fs->fs_cssize, fs->fs_fsize);
490 	i = fs->fs_frag - loc % fs->fs_frag;
491 	len = (i == fs->fs_frag) ? 0 : i * fs->fs_fsize;
492 	if (len > 0) {
493 		if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + loc),
494 		    len, KERNCRED, &bp)) != 0) {
495 			brelse(bp);
496 			free(copy_fs->fs_csp, M_UFSMNT);
497 			free(copy_fs, M_UFSMNT);
498 			copy_fs = NULL;
499 			goto out1;
500 		}
501 		bcopy(bp->b_data, space, (u_int)len);
502 		space = (char *)space + len;
503 		bp->b_flags |= B_INVAL | B_NOCACHE;
504 		brelse(bp);
505 	}
506 	if (fs->fs_contigsumsize > 0) {
507 		copy_fs->fs_maxcluster = lp = space;
508 		for (i = 0; i < fs->fs_ncg; i++)
509 			*lp++ = fs->fs_contigsumsize;
510 	}
511 	/*
512 	 * We must check for active files that have been unlinked
513 	 * (e.g., with a zero link count). We have to expunge all
514 	 * trace of these files from the snapshot so that they are
515 	 * not reclaimed prematurely by fsck or unnecessarily dumped.
516 	 * We turn off the MNTK_SUSPENDED flag to avoid a panic from
517 	 * spec_strategy about writing on a suspended filesystem.
518 	 * Note that we skip unlinked snapshot files as they will
519 	 * be handled separately below.
520 	 *
521 	 * We also calculate the needed size for the snapshot list.
522 	 */
523 	snaplistsize = fs->fs_ncg + howmany(fs->fs_cssize, fs->fs_bsize) +
524 	    FSMAXSNAP + 1 /* superblock */ + 1 /* last block */ + 1 /* size */;
525 	MNT_ILOCK(mp);
526 	mp->mnt_kern_flag &= ~MNTK_SUSPENDED;
527 	MNT_IUNLOCK(mp);
528 loop:
529 	MNT_VNODE_FOREACH_ALL(xvp, mp, mvp) {
530 		if ((xvp->v_usecount == 0 &&
531 		     (xvp->v_iflag & (VI_OWEINACT | VI_DOINGINACT)) == 0) ||
532 		    xvp->v_type == VNON ||
533 		    IS_SNAPSHOT(VTOI(xvp))) {
534 			VI_UNLOCK(xvp);
535 			continue;
536 		}
537 		/*
538 		 * We can skip parent directory vnode because it must have
539 		 * this snapshot file in it.
540 		 */
541 		if (xvp == nd.ni_dvp) {
542 			VI_UNLOCK(xvp);
543 			continue;
544 		}
545 		vholdl(xvp);
546 		if (vn_lock(xvp, LK_EXCLUSIVE | LK_INTERLOCK) != 0) {
547 			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
548 			vdrop(xvp);
549 			goto loop;
550 		}
551 		VI_LOCK(xvp);
552 		if (xvp->v_usecount == 0 &&
553 		    (xvp->v_iflag & (VI_OWEINACT | VI_DOINGINACT)) == 0) {
554 			VI_UNLOCK(xvp);
555 			VOP_UNLOCK(xvp, 0);
556 			vdrop(xvp);
557 			continue;
558 		}
559 		VI_UNLOCK(xvp);
560 		if (snapdebug)
561 			vn_printf(xvp, "ffs_snapshot: busy vnode ");
562 		if (VOP_GETATTR(xvp, &vat, td->td_ucred) == 0 &&
563 		    vat.va_nlink > 0) {
564 			VOP_UNLOCK(xvp, 0);
565 			vdrop(xvp);
566 			continue;
567 		}
568 		xp = VTOI(xvp);
569 		if (ffs_checkfreefile(copy_fs, vp, xp->i_number)) {
570 			VOP_UNLOCK(xvp, 0);
571 			vdrop(xvp);
572 			continue;
573 		}
574 		/*
575 		 * If there is a fragment, clear it here.
576 		 */
577 		blkno = 0;
578 		loc = howmany(xp->i_size, fs->fs_bsize) - 1;
579 		if (loc < UFS_NDADDR) {
580 			len = fragroundup(fs, blkoff(fs, xp->i_size));
581 			if (len != 0 && len < fs->fs_bsize) {
582 				ffs_blkfree(ump, copy_fs, vp,
583 				    DIP(xp, i_db[loc]), len, xp->i_number,
584 				    xvp->v_type, NULL);
585 				blkno = DIP(xp, i_db[loc]);
586 				DIP_SET(xp, i_db[loc], 0);
587 			}
588 		}
589 		snaplistsize += 1;
590 		if (I_IS_UFS1(xp))
591 			error = expunge_ufs1(vp, xp, copy_fs, fullacct_ufs1,
592 			    BLK_NOCOPY, 1);
593 		else
594 			error = expunge_ufs2(vp, xp, copy_fs, fullacct_ufs2,
595 			    BLK_NOCOPY, 1);
596 		if (blkno)
597 			DIP_SET(xp, i_db[loc], blkno);
598 		if (!error)
599 			error = ffs_freefile(ump, copy_fs, vp, xp->i_number,
600 			    xp->i_mode, NULL);
601 		VOP_UNLOCK(xvp, 0);
602 		vdrop(xvp);
603 		if (error) {
604 			free(copy_fs->fs_csp, M_UFSMNT);
605 			free(copy_fs, M_UFSMNT);
606 			copy_fs = NULL;
607 			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
608 			goto out1;
609 		}
610 	}
611 	/*
612 	 * Erase the journal file from the snapshot.
613 	 */
614 	if (fs->fs_flags & FS_SUJ) {
615 		error = softdep_journal_lookup(mp, &xvp);
616 		if (error) {
617 			free(copy_fs->fs_csp, M_UFSMNT);
618 			free(copy_fs, M_UFSMNT);
619 			copy_fs = NULL;
620 			goto out1;
621 		}
622 		xp = VTOI(xvp);
623 		if (I_IS_UFS1(xp))
624 			error = expunge_ufs1(vp, xp, copy_fs, fullacct_ufs1,
625 			    BLK_NOCOPY, 0);
626 		else
627 			error = expunge_ufs2(vp, xp, copy_fs, fullacct_ufs2,
628 			    BLK_NOCOPY, 0);
629 		vput(xvp);
630 	}
631 	/*
632 	 * Acquire a lock on the snapdata structure, creating it if necessary.
633 	 */
634 	sn = ffs_snapdata_acquire(devvp);
635 	/*
636 	 * Change vnode to use shared snapshot lock instead of the original
637 	 * private lock.
638 	 */
639 	vp->v_vnlock = &sn->sn_lock;
640 	lockmgr(&vp->v_lock, LK_RELEASE, NULL);
641 	xp = TAILQ_FIRST(&sn->sn_head);
642 	/*
643 	 * If this is the first snapshot on this filesystem, then we need
644 	 * to allocate the space for the list of preallocated snapshot blocks.
645 	 * This list will be refined below, but this preliminary one will
646 	 * keep us out of deadlock until the full one is ready.
647 	 */
648 	if (xp == NULL) {
649 		snapblklist = malloc(snaplistsize * sizeof(daddr_t),
650 		    M_UFSMNT, M_WAITOK);
651 		blkp = &snapblklist[1];
652 		*blkp++ = lblkno(fs, fs->fs_sblockloc);
653 		blkno = fragstoblks(fs, fs->fs_csaddr);
654 		for (cg = 0; cg < fs->fs_ncg; cg++) {
655 			if (fragstoblks(fs, cgtod(fs, cg) > blkno))
656 				break;
657 			*blkp++ = fragstoblks(fs, cgtod(fs, cg));
658 		}
659 		len = howmany(fs->fs_cssize, fs->fs_bsize);
660 		for (loc = 0; loc < len; loc++)
661 			*blkp++ = blkno + loc;
662 		for (; cg < fs->fs_ncg; cg++)
663 			*blkp++ = fragstoblks(fs, cgtod(fs, cg));
664 		snapblklist[0] = blkp - snapblklist;
665 		VI_LOCK(devvp);
666 		if (sn->sn_blklist != NULL)
667 			panic("ffs_snapshot: non-empty list");
668 		sn->sn_blklist = snapblklist;
669 		sn->sn_listsize = blkp - snapblklist;
670 		VI_UNLOCK(devvp);
671 	}
672 	/*
673 	 * Record snapshot inode. Since this is the newest snapshot,
674 	 * it must be placed at the end of the list.
675 	 */
676 	VI_LOCK(devvp);
677 	fs->fs_snapinum[snaploc] = ip->i_number;
678 	if (ip->i_nextsnap.tqe_prev != 0)
679 		panic("ffs_snapshot: %ju already on list",
680 		    (uintmax_t)ip->i_number);
681 	TAILQ_INSERT_TAIL(&sn->sn_head, ip, i_nextsnap);
682 	devvp->v_vflag |= VV_COPYONWRITE;
683 	VI_UNLOCK(devvp);
684 	ASSERT_VOP_LOCKED(vp, "ffs_snapshot vp");
685 out1:
686 	KASSERT((sn != NULL && copy_fs != NULL && error == 0) ||
687 		(sn == NULL && copy_fs == NULL && error != 0),
688 		("email phk@ and mckusick@"));
689 	/*
690 	 * Resume operation on filesystem.
691 	 */
692 	vfs_write_resume(vp->v_mount, VR_START_WRITE | VR_NO_SUSPCLR);
693 	if (collectsnapstats && starttime.tv_sec > 0) {
694 		nanotime(&endtime);
695 		timespecsub(&endtime, &starttime);
696 		printf("%s: suspended %ld.%03ld sec, redo %ld of %d\n",
697 		    vp->v_mount->mnt_stat.f_mntonname, (long)endtime.tv_sec,
698 		    endtime.tv_nsec / 1000000, redo, fs->fs_ncg);
699 	}
700 	if (copy_fs == NULL)
701 		goto out;
702 	/*
703 	 * Copy allocation information from all the snapshots in
704 	 * this snapshot and then expunge them from its view.
705 	 */
706 	TAILQ_FOREACH(xp, &sn->sn_head, i_nextsnap) {
707 		if (xp == ip)
708 			break;
709 		if (I_IS_UFS1(xp))
710 			error = expunge_ufs1(vp, xp, fs, snapacct_ufs1,
711 			    BLK_SNAP, 0);
712 		else
713 			error = expunge_ufs2(vp, xp, fs, snapacct_ufs2,
714 			    BLK_SNAP, 0);
715 		if (error == 0 && xp->i_effnlink == 0) {
716 			error = ffs_freefile(ump,
717 					     copy_fs,
718 					     vp,
719 					     xp->i_number,
720 					     xp->i_mode, NULL);
721 		}
722 		if (error) {
723 			fs->fs_snapinum[snaploc] = 0;
724 			goto done;
725 		}
726 	}
727 	/*
728 	 * Allocate space for the full list of preallocated snapshot blocks.
729 	 */
730 	snapblklist = malloc(snaplistsize * sizeof(daddr_t),
731 	    M_UFSMNT, M_WAITOK);
732 	ip->i_snapblklist = &snapblklist[1];
733 	/*
734 	 * Expunge the blocks used by the snapshots from the set of
735 	 * blocks marked as used in the snapshot bitmaps. Also, collect
736 	 * the list of allocated blocks in i_snapblklist.
737 	 */
738 	if (I_IS_UFS1(ip))
739 		error = expunge_ufs1(vp, ip, copy_fs, mapacct_ufs1,
740 		    BLK_SNAP, 0);
741 	else
742 		error = expunge_ufs2(vp, ip, copy_fs, mapacct_ufs2,
743 		    BLK_SNAP, 0);
744 	if (error) {
745 		fs->fs_snapinum[snaploc] = 0;
746 		free(snapblklist, M_UFSMNT);
747 		goto done;
748 	}
749 	if (snaplistsize < ip->i_snapblklist - snapblklist)
750 		panic("ffs_snapshot: list too small");
751 	snaplistsize = ip->i_snapblklist - snapblklist;
752 	snapblklist[0] = snaplistsize;
753 	ip->i_snapblklist = 0;
754 	/*
755 	 * Write out the list of allocated blocks to the end of the snapshot.
756 	 */
757 	auio.uio_iov = &aiov;
758 	auio.uio_iovcnt = 1;
759 	aiov.iov_base = (void *)snapblklist;
760 	aiov.iov_len = snaplistsize * sizeof(daddr_t);
761 	auio.uio_resid = aiov.iov_len;
762 	auio.uio_offset = ip->i_size;
763 	auio.uio_segflg = UIO_SYSSPACE;
764 	auio.uio_rw = UIO_WRITE;
765 	auio.uio_td = td;
766 	if ((error = VOP_WRITE(vp, &auio, IO_UNIT, td->td_ucred)) != 0) {
767 		fs->fs_snapinum[snaploc] = 0;
768 		free(snapblklist, M_UFSMNT);
769 		goto done;
770 	}
771 	/*
772 	 * Write the superblock and its summary information
773 	 * to the snapshot.
774 	 */
775 	blkno = fragstoblks(fs, fs->fs_csaddr);
776 	len = howmany(fs->fs_cssize, fs->fs_bsize);
777 	space = copy_fs->fs_csp;
778 	for (loc = 0; loc < len; loc++) {
779 		error = bread(vp, blkno + loc, fs->fs_bsize, KERNCRED, &nbp);
780 		if (error) {
781 			brelse(nbp);
782 			fs->fs_snapinum[snaploc] = 0;
783 			free(snapblklist, M_UFSMNT);
784 			goto done;
785 		}
786 		bcopy(space, nbp->b_data, fs->fs_bsize);
787 		space = (char *)space + fs->fs_bsize;
788 		bawrite(nbp);
789 	}
790 	error = bread(vp, lblkno(fs, fs->fs_sblockloc), fs->fs_bsize,
791 	    KERNCRED, &nbp);
792 	if (error) {
793 		brelse(nbp);
794 	} else {
795 		loc = blkoff(fs, fs->fs_sblockloc);
796 		bcopy((char *)copy_fs, &nbp->b_data[loc], (u_int)fs->fs_sbsize);
797 		bawrite(nbp);
798 	}
799 	/*
800 	 * As this is the newest list, it is the most inclusive, so
801 	 * should replace the previous list.
802 	 */
803 	VI_LOCK(devvp);
804 	space = sn->sn_blklist;
805 	sn->sn_blklist = snapblklist;
806 	sn->sn_listsize = snaplistsize;
807 	VI_UNLOCK(devvp);
808 	if (space != NULL)
809 		free(space, M_UFSMNT);
810 	/*
811 	 * Preallocate all the direct blocks in the snapshot inode so
812 	 * that we never have to write the inode itself to commit an
813 	 * update to the contents of the snapshot. Note that once
814 	 * created, the size of the snapshot will never change, so
815 	 * there will never be a need to write the inode except to
816 	 * update the non-integrity-critical time fields and
817 	 * allocated-block count.
818 	 */
819 	for (blockno = 0; blockno < UFS_NDADDR; blockno++) {
820 		if (DIP(ip, i_db[blockno]) != 0)
821 			continue;
822 		error = UFS_BALLOC(vp, lblktosize(fs, blockno),
823 		    fs->fs_bsize, KERNCRED, BA_CLRBUF, &bp);
824 		if (error)
825 			break;
826 		error = readblock(vp, bp, blockno);
827 		bawrite(bp);
828 		if (error != 0)
829 			break;
830 	}
831 done:
832 	free(copy_fs->fs_csp, M_UFSMNT);
833 	free(copy_fs, M_UFSMNT);
834 	copy_fs = NULL;
835 out:
836 	NDFREE(&nd, NDF_ONLY_PNBUF);
837 	if (saved_nice > 0) {
838 		struct proc *p;
839 
840 		p = td->td_proc;
841 		PROC_LOCK(p);
842 		sched_nice(td->td_proc, saved_nice);
843 		PROC_UNLOCK(td->td_proc);
844 	}
845 	UFS_LOCK(ump);
846 	if (fs->fs_active != 0) {
847 		free(fs->fs_active, M_DEVBUF);
848 		fs->fs_active = 0;
849 	}
850 	UFS_UNLOCK(ump);
851 	MNT_ILOCK(mp);
852 	mp->mnt_flag = (mp->mnt_flag & MNT_QUOTA) | (flag & ~MNT_QUOTA);
853 	MNT_IUNLOCK(mp);
854 	if (error)
855 		(void) ffs_truncate(vp, (off_t)0, 0, NOCRED);
856 	(void) ffs_syncvnode(vp, MNT_WAIT, 0);
857 	if (error)
858 		vput(vp);
859 	else
860 		VOP_UNLOCK(vp, 0);
861 	vrele(nd.ni_dvp);
862 	vn_finished_write(wrtmp);
863 	process_deferred_inactive(mp);
864 	return (error);
865 }
866 
867 /*
868  * Copy a cylinder group map. All the unallocated blocks are marked
869  * BLK_NOCOPY so that the snapshot knows that it need not copy them
870  * if they are later written. If passno is one, then this is a first
871  * pass, so only setting needs to be done. If passno is 2, then this
872  * is a revision to a previous pass which must be undone as the
873  * replacement pass is done.
874  */
875 static int
876 cgaccount(cg, vp, nbp, passno)
877 	int cg;
878 	struct vnode *vp;
879 	struct buf *nbp;
880 	int passno;
881 {
882 	struct buf *bp, *ibp;
883 	struct inode *ip;
884 	struct cg *cgp;
885 	struct fs *fs;
886 	ufs2_daddr_t base, numblks;
887 	int error, len, loc, indiroff;
888 
889 	ip = VTOI(vp);
890 	fs = ITOFS(ip);
891 	if ((error = ffs_getcg(fs, ITODEVVP(ip), cg, &bp, &cgp)) != 0)
892 		return (error);
893 	UFS_LOCK(ITOUMP(ip));
894 	ACTIVESET(fs, cg);
895 	/*
896 	 * Recomputation of summary information might not have been performed
897 	 * at mount time.  Sync up summary information for current cylinder
898 	 * group while data is in memory to ensure that result of background
899 	 * fsck is slightly more consistent.
900 	 */
901 	fs->fs_cs(fs, cg) = cgp->cg_cs;
902 	UFS_UNLOCK(ITOUMP(ip));
903 	bcopy(bp->b_data, nbp->b_data, fs->fs_cgsize);
904 	if (fs->fs_cgsize < fs->fs_bsize)
905 		bzero(&nbp->b_data[fs->fs_cgsize],
906 		    fs->fs_bsize - fs->fs_cgsize);
907 	cgp = (struct cg *)nbp->b_data;
908 	bqrelse(bp);
909 	if (passno == 2)
910 		nbp->b_flags |= B_VALIDSUSPWRT;
911 	numblks = howmany(fs->fs_size, fs->fs_frag);
912 	len = howmany(fs->fs_fpg, fs->fs_frag);
913 	base = cgbase(fs, cg) / fs->fs_frag;
914 	if (base + len >= numblks)
915 		len = numblks - base - 1;
916 	loc = 0;
917 	if (base < UFS_NDADDR) {
918 		for ( ; loc < UFS_NDADDR; loc++) {
919 			if (ffs_isblock(fs, cg_blksfree(cgp), loc))
920 				DIP_SET(ip, i_db[loc], BLK_NOCOPY);
921 			else if (passno == 2 && DIP(ip, i_db[loc])== BLK_NOCOPY)
922 				DIP_SET(ip, i_db[loc], 0);
923 			else if (passno == 1 && DIP(ip, i_db[loc])== BLK_NOCOPY)
924 				panic("ffs_snapshot: lost direct block");
925 		}
926 	}
927 	error = UFS_BALLOC(vp, lblktosize(fs, (off_t)(base + loc)),
928 	    fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
929 	if (error) {
930 		return (error);
931 	}
932 	indiroff = (base + loc - UFS_NDADDR) % NINDIR(fs);
933 	for ( ; loc < len; loc++, indiroff++) {
934 		if (indiroff >= NINDIR(fs)) {
935 			if (passno == 2)
936 				ibp->b_flags |= B_VALIDSUSPWRT;
937 			bawrite(ibp);
938 			error = UFS_BALLOC(vp,
939 			    lblktosize(fs, (off_t)(base + loc)),
940 			    fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
941 			if (error) {
942 				return (error);
943 			}
944 			indiroff = 0;
945 		}
946 		if (I_IS_UFS1(ip)) {
947 			if (ffs_isblock(fs, cg_blksfree(cgp), loc))
948 				((ufs1_daddr_t *)(ibp->b_data))[indiroff] =
949 				    BLK_NOCOPY;
950 			else if (passno == 2 && ((ufs1_daddr_t *)(ibp->b_data))
951 			    [indiroff] == BLK_NOCOPY)
952 				((ufs1_daddr_t *)(ibp->b_data))[indiroff] = 0;
953 			else if (passno == 1 && ((ufs1_daddr_t *)(ibp->b_data))
954 			    [indiroff] == BLK_NOCOPY)
955 				panic("ffs_snapshot: lost indirect block");
956 			continue;
957 		}
958 		if (ffs_isblock(fs, cg_blksfree(cgp), loc))
959 			((ufs2_daddr_t *)(ibp->b_data))[indiroff] = BLK_NOCOPY;
960 		else if (passno == 2 &&
961 		    ((ufs2_daddr_t *)(ibp->b_data)) [indiroff] == BLK_NOCOPY)
962 			((ufs2_daddr_t *)(ibp->b_data))[indiroff] = 0;
963 		else if (passno == 1 &&
964 		    ((ufs2_daddr_t *)(ibp->b_data)) [indiroff] == BLK_NOCOPY)
965 			panic("ffs_snapshot: lost indirect block");
966 	}
967 	if (passno == 2)
968 		ibp->b_flags |= B_VALIDSUSPWRT;
969 	bdwrite(ibp);
970 	return (0);
971 }
972 
973 /*
974  * Before expunging a snapshot inode, note all the
975  * blocks that it claims with BLK_SNAP so that fsck will
976  * be able to account for those blocks properly and so
977  * that this snapshot knows that it need not copy them
978  * if the other snapshot holding them is freed. This code
979  * is reproduced once each for UFS1 and UFS2.
980  */
981 static int
982 expunge_ufs1(snapvp, cancelip, fs, acctfunc, expungetype, clearmode)
983 	struct vnode *snapvp;
984 	struct inode *cancelip;
985 	struct fs *fs;
986 	int (*acctfunc)(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *,
987 	    struct fs *, ufs_lbn_t, int);
988 	int expungetype;
989 	int clearmode;
990 {
991 	int i, error, indiroff;
992 	ufs_lbn_t lbn, rlbn;
993 	ufs2_daddr_t len, blkno, numblks, blksperindir;
994 	struct ufs1_dinode *dip;
995 	struct thread *td = curthread;
996 	struct buf *bp;
997 
998 	/*
999 	 * Prepare to expunge the inode. If its inode block has not
1000 	 * yet been copied, then allocate and fill the copy.
1001 	 */
1002 	lbn = fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));
1003 	blkno = 0;
1004 	if (lbn < UFS_NDADDR) {
1005 		blkno = VTOI(snapvp)->i_din1->di_db[lbn];
1006 	} else {
1007 		if (DOINGSOFTDEP(snapvp))
1008 			softdep_prealloc(snapvp, MNT_WAIT);
1009 		td->td_pflags |= TDP_COWINPROGRESS;
1010 		error = ffs_balloc_ufs1(snapvp, lblktosize(fs, (off_t)lbn),
1011 		   fs->fs_bsize, KERNCRED, BA_METAONLY, &bp);
1012 		td->td_pflags &= ~TDP_COWINPROGRESS;
1013 		if (error)
1014 			return (error);
1015 		indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
1016 		blkno = ((ufs1_daddr_t *)(bp->b_data))[indiroff];
1017 		bqrelse(bp);
1018 	}
1019 	if (blkno != 0) {
1020 		if ((error = bread(snapvp, lbn, fs->fs_bsize, KERNCRED, &bp)))
1021 			return (error);
1022 	} else {
1023 		error = ffs_balloc_ufs1(snapvp, lblktosize(fs, (off_t)lbn),
1024 		    fs->fs_bsize, KERNCRED, 0, &bp);
1025 		if (error)
1026 			return (error);
1027 		if ((error = readblock(snapvp, bp, lbn)) != 0)
1028 			return (error);
1029 	}
1030 	/*
1031 	 * Set a snapshot inode to be a zero length file, regular files
1032 	 * or unlinked snapshots to be completely unallocated.
1033 	 */
1034 	dip = (struct ufs1_dinode *)bp->b_data +
1035 	    ino_to_fsbo(fs, cancelip->i_number);
1036 	if (clearmode || cancelip->i_effnlink == 0)
1037 		dip->di_mode = 0;
1038 	dip->di_size = 0;
1039 	dip->di_blocks = 0;
1040 	dip->di_flags &= ~SF_SNAPSHOT;
1041 	bzero(&dip->di_db[0], (UFS_NDADDR + UFS_NIADDR) * sizeof(ufs1_daddr_t));
1042 	bdwrite(bp);
1043 	/*
1044 	 * Now go through and expunge all the blocks in the file
1045 	 * using the function requested.
1046 	 */
1047 	numblks = howmany(cancelip->i_size, fs->fs_bsize);
1048 	if ((error = (*acctfunc)(snapvp, &cancelip->i_din1->di_db[0],
1049 	    &cancelip->i_din1->di_db[UFS_NDADDR], fs, 0, expungetype)))
1050 		return (error);
1051 	if ((error = (*acctfunc)(snapvp, &cancelip->i_din1->di_ib[0],
1052 	    &cancelip->i_din1->di_ib[UFS_NIADDR], fs, -1, expungetype)))
1053 		return (error);
1054 	blksperindir = 1;
1055 	lbn = -UFS_NDADDR;
1056 	len = numblks - UFS_NDADDR;
1057 	rlbn = UFS_NDADDR;
1058 	for (i = 0; len > 0 && i < UFS_NIADDR; i++) {
1059 		error = indiracct_ufs1(snapvp, ITOV(cancelip), i,
1060 		    cancelip->i_din1->di_ib[i], lbn, rlbn, len,
1061 		    blksperindir, fs, acctfunc, expungetype);
1062 		if (error)
1063 			return (error);
1064 		blksperindir *= NINDIR(fs);
1065 		lbn -= blksperindir + 1;
1066 		len -= blksperindir;
1067 		rlbn += blksperindir;
1068 	}
1069 	return (0);
1070 }
1071 
1072 /*
1073  * Descend an indirect block chain for vnode cancelvp accounting for all
1074  * its indirect blocks in snapvp.
1075  */
1076 static int
1077 indiracct_ufs1(snapvp, cancelvp, level, blkno, lbn, rlbn, remblks,
1078 	    blksperindir, fs, acctfunc, expungetype)
1079 	struct vnode *snapvp;
1080 	struct vnode *cancelvp;
1081 	int level;
1082 	ufs1_daddr_t blkno;
1083 	ufs_lbn_t lbn;
1084 	ufs_lbn_t rlbn;
1085 	ufs_lbn_t remblks;
1086 	ufs_lbn_t blksperindir;
1087 	struct fs *fs;
1088 	int (*acctfunc)(struct vnode *, ufs1_daddr_t *, ufs1_daddr_t *,
1089 	    struct fs *, ufs_lbn_t, int);
1090 	int expungetype;
1091 {
1092 	int error, num, i;
1093 	ufs_lbn_t subblksperindir;
1094 	struct indir indirs[UFS_NIADDR + 2];
1095 	ufs1_daddr_t last, *bap;
1096 	struct buf *bp;
1097 
1098 	if (blkno == 0) {
1099 		if (expungetype == BLK_NOCOPY)
1100 			return (0);
1101 		panic("indiracct_ufs1: missing indir");
1102 	}
1103 	if ((error = ufs_getlbns(cancelvp, rlbn, indirs, &num)) != 0)
1104 		return (error);
1105 	if (lbn != indirs[num - 1 - level].in_lbn || num < 2)
1106 		panic("indiracct_ufs1: botched params");
1107 	/*
1108 	 * We have to expand bread here since it will deadlock looking
1109 	 * up the block number for any blocks that are not in the cache.
1110 	 */
1111 	bp = getblk(cancelvp, lbn, fs->fs_bsize, 0, 0, 0);
1112 	bp->b_blkno = fsbtodb(fs, blkno);
1113 	if ((bp->b_flags & (B_DONE | B_DELWRI)) == 0 &&
1114 	    (error = readblock(cancelvp, bp, fragstoblks(fs, blkno)))) {
1115 		brelse(bp);
1116 		return (error);
1117 	}
1118 	/*
1119 	 * Account for the block pointers in this indirect block.
1120 	 */
1121 	last = howmany(remblks, blksperindir);
1122 	if (last > NINDIR(fs))
1123 		last = NINDIR(fs);
1124 	bap = malloc(fs->fs_bsize, M_DEVBUF, M_WAITOK);
1125 	bcopy(bp->b_data, (caddr_t)bap, fs->fs_bsize);
1126 	bqrelse(bp);
1127 	error = (*acctfunc)(snapvp, &bap[0], &bap[last], fs,
1128 	    level == 0 ? rlbn : -1, expungetype);
1129 	if (error || level == 0)
1130 		goto out;
1131 	/*
1132 	 * Account for the block pointers in each of the indirect blocks
1133 	 * in the levels below us.
1134 	 */
1135 	subblksperindir = blksperindir / NINDIR(fs);
1136 	for (lbn++, level--, i = 0; i < last; i++) {
1137 		error = indiracct_ufs1(snapvp, cancelvp, level, bap[i], lbn,
1138 		    rlbn, remblks, subblksperindir, fs, acctfunc, expungetype);
1139 		if (error)
1140 			goto out;
1141 		rlbn += blksperindir;
1142 		lbn -= blksperindir;
1143 		remblks -= blksperindir;
1144 	}
1145 out:
1146 	free(bap, M_DEVBUF);
1147 	return (error);
1148 }
1149 
1150 /*
1151  * Do both snap accounting and map accounting.
1152  */
1153 static int
1154 fullacct_ufs1(vp, oldblkp, lastblkp, fs, lblkno, exptype)
1155 	struct vnode *vp;
1156 	ufs1_daddr_t *oldblkp, *lastblkp;
1157 	struct fs *fs;
1158 	ufs_lbn_t lblkno;
1159 	int exptype;	/* BLK_SNAP or BLK_NOCOPY */
1160 {
1161 	int error;
1162 
1163 	if ((error = snapacct_ufs1(vp, oldblkp, lastblkp, fs, lblkno, exptype)))
1164 		return (error);
1165 	return (mapacct_ufs1(vp, oldblkp, lastblkp, fs, lblkno, exptype));
1166 }
1167 
1168 /*
1169  * Identify a set of blocks allocated in a snapshot inode.
1170  */
1171 static int
1172 snapacct_ufs1(vp, oldblkp, lastblkp, fs, lblkno, expungetype)
1173 	struct vnode *vp;
1174 	ufs1_daddr_t *oldblkp, *lastblkp;
1175 	struct fs *fs;
1176 	ufs_lbn_t lblkno;
1177 	int expungetype;	/* BLK_SNAP or BLK_NOCOPY */
1178 {
1179 	struct inode *ip = VTOI(vp);
1180 	ufs1_daddr_t blkno, *blkp;
1181 	ufs_lbn_t lbn;
1182 	struct buf *ibp;
1183 	int error;
1184 
1185 	for ( ; oldblkp < lastblkp; oldblkp++) {
1186 		blkno = *oldblkp;
1187 		if (blkno == 0 || blkno == BLK_NOCOPY || blkno == BLK_SNAP)
1188 			continue;
1189 		lbn = fragstoblks(fs, blkno);
1190 		if (lbn < UFS_NDADDR) {
1191 			blkp = &ip->i_din1->di_db[lbn];
1192 			ip->i_flag |= IN_CHANGE | IN_UPDATE;
1193 		} else {
1194 			error = ffs_balloc_ufs1(vp, lblktosize(fs, (off_t)lbn),
1195 			    fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
1196 			if (error)
1197 				return (error);
1198 			blkp = &((ufs1_daddr_t *)(ibp->b_data))
1199 			    [(lbn - UFS_NDADDR) % NINDIR(fs)];
1200 		}
1201 		/*
1202 		 * If we are expunging a snapshot vnode and we
1203 		 * find a block marked BLK_NOCOPY, then it is
1204 		 * one that has been allocated to this snapshot after
1205 		 * we took our current snapshot and can be ignored.
1206 		 */
1207 		if (expungetype == BLK_SNAP && *blkp == BLK_NOCOPY) {
1208 			if (lbn >= UFS_NDADDR)
1209 				brelse(ibp);
1210 		} else {
1211 			if (*blkp != 0)
1212 				panic("snapacct_ufs1: bad block");
1213 			*blkp = expungetype;
1214 			if (lbn >= UFS_NDADDR)
1215 				bdwrite(ibp);
1216 		}
1217 	}
1218 	return (0);
1219 }
1220 
1221 /*
1222  * Account for a set of blocks allocated in a snapshot inode.
1223  */
1224 static int
1225 mapacct_ufs1(vp, oldblkp, lastblkp, fs, lblkno, expungetype)
1226 	struct vnode *vp;
1227 	ufs1_daddr_t *oldblkp, *lastblkp;
1228 	struct fs *fs;
1229 	ufs_lbn_t lblkno;
1230 	int expungetype;
1231 {
1232 	ufs1_daddr_t blkno;
1233 	struct inode *ip;
1234 	ino_t inum;
1235 	int acctit;
1236 
1237 	ip = VTOI(vp);
1238 	inum = ip->i_number;
1239 	if (lblkno == -1)
1240 		acctit = 0;
1241 	else
1242 		acctit = 1;
1243 	for ( ; oldblkp < lastblkp; oldblkp++, lblkno++) {
1244 		blkno = *oldblkp;
1245 		if (blkno == 0 || blkno == BLK_NOCOPY)
1246 			continue;
1247 		if (acctit && expungetype == BLK_SNAP && blkno != BLK_SNAP)
1248 			*ip->i_snapblklist++ = lblkno;
1249 		if (blkno == BLK_SNAP)
1250 			blkno = blkstofrags(fs, lblkno);
1251 		ffs_blkfree(ITOUMP(ip), fs, vp, blkno, fs->fs_bsize, inum,
1252 		    vp->v_type, NULL);
1253 	}
1254 	return (0);
1255 }
1256 
1257 /*
1258  * Before expunging a snapshot inode, note all the
1259  * blocks that it claims with BLK_SNAP so that fsck will
1260  * be able to account for those blocks properly and so
1261  * that this snapshot knows that it need not copy them
1262  * if the other snapshot holding them is freed. This code
1263  * is reproduced once each for UFS1 and UFS2.
1264  */
1265 static int
1266 expunge_ufs2(snapvp, cancelip, fs, acctfunc, expungetype, clearmode)
1267 	struct vnode *snapvp;
1268 	struct inode *cancelip;
1269 	struct fs *fs;
1270 	int (*acctfunc)(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *,
1271 	    struct fs *, ufs_lbn_t, int);
1272 	int expungetype;
1273 	int clearmode;
1274 {
1275 	int i, error, indiroff;
1276 	ufs_lbn_t lbn, rlbn;
1277 	ufs2_daddr_t len, blkno, numblks, blksperindir;
1278 	struct ufs2_dinode *dip;
1279 	struct thread *td = curthread;
1280 	struct buf *bp;
1281 
1282 	/*
1283 	 * Prepare to expunge the inode. If its inode block has not
1284 	 * yet been copied, then allocate and fill the copy.
1285 	 */
1286 	lbn = fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));
1287 	blkno = 0;
1288 	if (lbn < UFS_NDADDR) {
1289 		blkno = VTOI(snapvp)->i_din2->di_db[lbn];
1290 	} else {
1291 		if (DOINGSOFTDEP(snapvp))
1292 			softdep_prealloc(snapvp, MNT_WAIT);
1293 		td->td_pflags |= TDP_COWINPROGRESS;
1294 		error = ffs_balloc_ufs2(snapvp, lblktosize(fs, (off_t)lbn),
1295 		   fs->fs_bsize, KERNCRED, BA_METAONLY, &bp);
1296 		td->td_pflags &= ~TDP_COWINPROGRESS;
1297 		if (error)
1298 			return (error);
1299 		indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
1300 		blkno = ((ufs2_daddr_t *)(bp->b_data))[indiroff];
1301 		bqrelse(bp);
1302 	}
1303 	if (blkno != 0) {
1304 		if ((error = bread(snapvp, lbn, fs->fs_bsize, KERNCRED, &bp)))
1305 			return (error);
1306 	} else {
1307 		error = ffs_balloc_ufs2(snapvp, lblktosize(fs, (off_t)lbn),
1308 		    fs->fs_bsize, KERNCRED, 0, &bp);
1309 		if (error)
1310 			return (error);
1311 		if ((error = readblock(snapvp, bp, lbn)) != 0)
1312 			return (error);
1313 	}
1314 	/*
1315 	 * Set a snapshot inode to be a zero length file, regular files
1316 	 * to be completely unallocated.
1317 	 */
1318 	dip = (struct ufs2_dinode *)bp->b_data +
1319 	    ino_to_fsbo(fs, cancelip->i_number);
1320 	if (clearmode || cancelip->i_effnlink == 0)
1321 		dip->di_mode = 0;
1322 	dip->di_size = 0;
1323 	dip->di_blocks = 0;
1324 	dip->di_flags &= ~SF_SNAPSHOT;
1325 	bzero(&dip->di_db[0], (UFS_NDADDR + UFS_NIADDR) * sizeof(ufs2_daddr_t));
1326 	bdwrite(bp);
1327 	/*
1328 	 * Now go through and expunge all the blocks in the file
1329 	 * using the function requested.
1330 	 */
1331 	numblks = howmany(cancelip->i_size, fs->fs_bsize);
1332 	if ((error = (*acctfunc)(snapvp, &cancelip->i_din2->di_db[0],
1333 	    &cancelip->i_din2->di_db[UFS_NDADDR], fs, 0, expungetype)))
1334 		return (error);
1335 	if ((error = (*acctfunc)(snapvp, &cancelip->i_din2->di_ib[0],
1336 	    &cancelip->i_din2->di_ib[UFS_NIADDR], fs, -1, expungetype)))
1337 		return (error);
1338 	blksperindir = 1;
1339 	lbn = -UFS_NDADDR;
1340 	len = numblks - UFS_NDADDR;
1341 	rlbn = UFS_NDADDR;
1342 	for (i = 0; len > 0 && i < UFS_NIADDR; i++) {
1343 		error = indiracct_ufs2(snapvp, ITOV(cancelip), i,
1344 		    cancelip->i_din2->di_ib[i], lbn, rlbn, len,
1345 		    blksperindir, fs, acctfunc, expungetype);
1346 		if (error)
1347 			return (error);
1348 		blksperindir *= NINDIR(fs);
1349 		lbn -= blksperindir + 1;
1350 		len -= blksperindir;
1351 		rlbn += blksperindir;
1352 	}
1353 	return (0);
1354 }
1355 
1356 /*
1357  * Descend an indirect block chain for vnode cancelvp accounting for all
1358  * its indirect blocks in snapvp.
1359  */
1360 static int
1361 indiracct_ufs2(snapvp, cancelvp, level, blkno, lbn, rlbn, remblks,
1362 	    blksperindir, fs, acctfunc, expungetype)
1363 	struct vnode *snapvp;
1364 	struct vnode *cancelvp;
1365 	int level;
1366 	ufs2_daddr_t blkno;
1367 	ufs_lbn_t lbn;
1368 	ufs_lbn_t rlbn;
1369 	ufs_lbn_t remblks;
1370 	ufs_lbn_t blksperindir;
1371 	struct fs *fs;
1372 	int (*acctfunc)(struct vnode *, ufs2_daddr_t *, ufs2_daddr_t *,
1373 	    struct fs *, ufs_lbn_t, int);
1374 	int expungetype;
1375 {
1376 	int error, num, i;
1377 	ufs_lbn_t subblksperindir;
1378 	struct indir indirs[UFS_NIADDR + 2];
1379 	ufs2_daddr_t last, *bap;
1380 	struct buf *bp;
1381 
1382 	if (blkno == 0) {
1383 		if (expungetype == BLK_NOCOPY)
1384 			return (0);
1385 		panic("indiracct_ufs2: missing indir");
1386 	}
1387 	if ((error = ufs_getlbns(cancelvp, rlbn, indirs, &num)) != 0)
1388 		return (error);
1389 	if (lbn != indirs[num - 1 - level].in_lbn || num < 2)
1390 		panic("indiracct_ufs2: botched params");
1391 	/*
1392 	 * We have to expand bread here since it will deadlock looking
1393 	 * up the block number for any blocks that are not in the cache.
1394 	 */
1395 	bp = getblk(cancelvp, lbn, fs->fs_bsize, 0, 0, 0);
1396 	bp->b_blkno = fsbtodb(fs, blkno);
1397 	if ((bp->b_flags & (B_DONE | B_DELWRI)) == 0 &&
1398 	    (error = readblock(cancelvp, bp, fragstoblks(fs, blkno)))) {
1399 		brelse(bp);
1400 		return (error);
1401 	}
1402 	/*
1403 	 * Account for the block pointers in this indirect block.
1404 	 */
1405 	last = howmany(remblks, blksperindir);
1406 	if (last > NINDIR(fs))
1407 		last = NINDIR(fs);
1408 	bap = malloc(fs->fs_bsize, M_DEVBUF, M_WAITOK);
1409 	bcopy(bp->b_data, (caddr_t)bap, fs->fs_bsize);
1410 	bqrelse(bp);
1411 	error = (*acctfunc)(snapvp, &bap[0], &bap[last], fs,
1412 	    level == 0 ? rlbn : -1, expungetype);
1413 	if (error || level == 0)
1414 		goto out;
1415 	/*
1416 	 * Account for the block pointers in each of the indirect blocks
1417 	 * in the levels below us.
1418 	 */
1419 	subblksperindir = blksperindir / NINDIR(fs);
1420 	for (lbn++, level--, i = 0; i < last; i++) {
1421 		error = indiracct_ufs2(snapvp, cancelvp, level, bap[i], lbn,
1422 		    rlbn, remblks, subblksperindir, fs, acctfunc, expungetype);
1423 		if (error)
1424 			goto out;
1425 		rlbn += blksperindir;
1426 		lbn -= blksperindir;
1427 		remblks -= blksperindir;
1428 	}
1429 out:
1430 	free(bap, M_DEVBUF);
1431 	return (error);
1432 }
1433 
1434 /*
1435  * Do both snap accounting and map accounting.
1436  */
1437 static int
1438 fullacct_ufs2(vp, oldblkp, lastblkp, fs, lblkno, exptype)
1439 	struct vnode *vp;
1440 	ufs2_daddr_t *oldblkp, *lastblkp;
1441 	struct fs *fs;
1442 	ufs_lbn_t lblkno;
1443 	int exptype;	/* BLK_SNAP or BLK_NOCOPY */
1444 {
1445 	int error;
1446 
1447 	if ((error = snapacct_ufs2(vp, oldblkp, lastblkp, fs, lblkno, exptype)))
1448 		return (error);
1449 	return (mapacct_ufs2(vp, oldblkp, lastblkp, fs, lblkno, exptype));
1450 }
1451 
1452 /*
1453  * Identify a set of blocks allocated in a snapshot inode.
1454  */
1455 static int
1456 snapacct_ufs2(vp, oldblkp, lastblkp, fs, lblkno, expungetype)
1457 	struct vnode *vp;
1458 	ufs2_daddr_t *oldblkp, *lastblkp;
1459 	struct fs *fs;
1460 	ufs_lbn_t lblkno;
1461 	int expungetype;	/* BLK_SNAP or BLK_NOCOPY */
1462 {
1463 	struct inode *ip = VTOI(vp);
1464 	ufs2_daddr_t blkno, *blkp;
1465 	ufs_lbn_t lbn;
1466 	struct buf *ibp;
1467 	int error;
1468 
1469 	for ( ; oldblkp < lastblkp; oldblkp++) {
1470 		blkno = *oldblkp;
1471 		if (blkno == 0 || blkno == BLK_NOCOPY || blkno == BLK_SNAP)
1472 			continue;
1473 		lbn = fragstoblks(fs, blkno);
1474 		if (lbn < UFS_NDADDR) {
1475 			blkp = &ip->i_din2->di_db[lbn];
1476 			ip->i_flag |= IN_CHANGE | IN_UPDATE;
1477 		} else {
1478 			error = ffs_balloc_ufs2(vp, lblktosize(fs, (off_t)lbn),
1479 			    fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
1480 			if (error)
1481 				return (error);
1482 			blkp = &((ufs2_daddr_t *)(ibp->b_data))
1483 			    [(lbn - UFS_NDADDR) % NINDIR(fs)];
1484 		}
1485 		/*
1486 		 * If we are expunging a snapshot vnode and we
1487 		 * find a block marked BLK_NOCOPY, then it is
1488 		 * one that has been allocated to this snapshot after
1489 		 * we took our current snapshot and can be ignored.
1490 		 */
1491 		if (expungetype == BLK_SNAP && *blkp == BLK_NOCOPY) {
1492 			if (lbn >= UFS_NDADDR)
1493 				brelse(ibp);
1494 		} else {
1495 			if (*blkp != 0)
1496 				panic("snapacct_ufs2: bad block");
1497 			*blkp = expungetype;
1498 			if (lbn >= UFS_NDADDR)
1499 				bdwrite(ibp);
1500 		}
1501 	}
1502 	return (0);
1503 }
1504 
1505 /*
1506  * Account for a set of blocks allocated in a snapshot inode.
1507  */
1508 static int
1509 mapacct_ufs2(vp, oldblkp, lastblkp, fs, lblkno, expungetype)
1510 	struct vnode *vp;
1511 	ufs2_daddr_t *oldblkp, *lastblkp;
1512 	struct fs *fs;
1513 	ufs_lbn_t lblkno;
1514 	int expungetype;
1515 {
1516 	ufs2_daddr_t blkno;
1517 	struct inode *ip;
1518 	ino_t inum;
1519 	int acctit;
1520 
1521 	ip = VTOI(vp);
1522 	inum = ip->i_number;
1523 	if (lblkno == -1)
1524 		acctit = 0;
1525 	else
1526 		acctit = 1;
1527 	for ( ; oldblkp < lastblkp; oldblkp++, lblkno++) {
1528 		blkno = *oldblkp;
1529 		if (blkno == 0 || blkno == BLK_NOCOPY)
1530 			continue;
1531 		if (acctit && expungetype == BLK_SNAP && blkno != BLK_SNAP)
1532 			*ip->i_snapblklist++ = lblkno;
1533 		if (blkno == BLK_SNAP)
1534 			blkno = blkstofrags(fs, lblkno);
1535 		ffs_blkfree(ITOUMP(ip), fs, vp, blkno, fs->fs_bsize, inum,
1536 		    vp->v_type, NULL);
1537 	}
1538 	return (0);
1539 }
1540 
1541 /*
1542  * Decrement extra reference on snapshot when last name is removed.
1543  * It will not be freed until the last open reference goes away.
1544  */
1545 void
1546 ffs_snapgone(ip)
1547 	struct inode *ip;
1548 {
1549 	struct inode *xp;
1550 	struct fs *fs;
1551 	int snaploc;
1552 	struct snapdata *sn;
1553 	struct ufsmount *ump;
1554 
1555 	/*
1556 	 * Find snapshot in incore list.
1557 	 */
1558 	xp = NULL;
1559 	sn = ITODEVVP(ip)->v_rdev->si_snapdata;
1560 	if (sn != NULL)
1561 		TAILQ_FOREACH(xp, &sn->sn_head, i_nextsnap)
1562 			if (xp == ip)
1563 				break;
1564 	if (xp != NULL)
1565 		vrele(ITOV(ip));
1566 	else if (snapdebug)
1567 		printf("ffs_snapgone: lost snapshot vnode %ju\n",
1568 		    (uintmax_t)ip->i_number);
1569 	/*
1570 	 * Delete snapshot inode from superblock. Keep list dense.
1571 	 */
1572 	ump = ITOUMP(ip);
1573 	fs = ump->um_fs;
1574 	UFS_LOCK(ump);
1575 	for (snaploc = 0; snaploc < FSMAXSNAP; snaploc++)
1576 		if (fs->fs_snapinum[snaploc] == ip->i_number)
1577 			break;
1578 	if (snaploc < FSMAXSNAP) {
1579 		for (snaploc++; snaploc < FSMAXSNAP; snaploc++) {
1580 			if (fs->fs_snapinum[snaploc] == 0)
1581 				break;
1582 			fs->fs_snapinum[snaploc - 1] = fs->fs_snapinum[snaploc];
1583 		}
1584 		fs->fs_snapinum[snaploc - 1] = 0;
1585 	}
1586 	UFS_UNLOCK(ump);
1587 }
1588 
1589 /*
1590  * Prepare a snapshot file for being removed.
1591  */
1592 void
1593 ffs_snapremove(vp)
1594 	struct vnode *vp;
1595 {
1596 	struct inode *ip;
1597 	struct vnode *devvp;
1598 	struct buf *ibp;
1599 	struct fs *fs;
1600 	ufs2_daddr_t numblks, blkno, dblk;
1601 	int error, loc, last;
1602 	struct snapdata *sn;
1603 
1604 	ip = VTOI(vp);
1605 	fs = ITOFS(ip);
1606 	devvp = ITODEVVP(ip);
1607 	/*
1608 	 * If active, delete from incore list (this snapshot may
1609 	 * already have been in the process of being deleted, so
1610 	 * would not have been active).
1611 	 *
1612 	 * Clear copy-on-write flag if last snapshot.
1613 	 */
1614 	VI_LOCK(devvp);
1615 	if (ip->i_nextsnap.tqe_prev != 0) {
1616 		sn = devvp->v_rdev->si_snapdata;
1617 		TAILQ_REMOVE(&sn->sn_head, ip, i_nextsnap);
1618 		ip->i_nextsnap.tqe_prev = 0;
1619 		VI_UNLOCK(devvp);
1620 		lockmgr(&vp->v_lock, LK_EXCLUSIVE, NULL);
1621 		KASSERT(vp->v_vnlock == &sn->sn_lock,
1622 			("ffs_snapremove: lost lock mutation"));
1623 		vp->v_vnlock = &vp->v_lock;
1624 		VI_LOCK(devvp);
1625 		lockmgr(&sn->sn_lock, LK_RELEASE, NULL);
1626 		try_free_snapdata(devvp);
1627 	} else
1628 		VI_UNLOCK(devvp);
1629 	/*
1630 	 * Clear all BLK_NOCOPY fields. Pass any block claims to other
1631 	 * snapshots that want them (see ffs_snapblkfree below).
1632 	 */
1633 	for (blkno = 1; blkno < UFS_NDADDR; blkno++) {
1634 		dblk = DIP(ip, i_db[blkno]);
1635 		if (dblk == 0)
1636 			continue;
1637 		if (dblk == BLK_NOCOPY || dblk == BLK_SNAP)
1638 			DIP_SET(ip, i_db[blkno], 0);
1639 		else if ((dblk == blkstofrags(fs, blkno) &&
1640 		     ffs_snapblkfree(fs, ITODEVVP(ip), dblk, fs->fs_bsize,
1641 		     ip->i_number, vp->v_type, NULL))) {
1642 			DIP_SET(ip, i_blocks, DIP(ip, i_blocks) -
1643 			    btodb(fs->fs_bsize));
1644 			DIP_SET(ip, i_db[blkno], 0);
1645 		}
1646 	}
1647 	numblks = howmany(ip->i_size, fs->fs_bsize);
1648 	for (blkno = UFS_NDADDR; blkno < numblks; blkno += NINDIR(fs)) {
1649 		error = UFS_BALLOC(vp, lblktosize(fs, (off_t)blkno),
1650 		    fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
1651 		if (error)
1652 			continue;
1653 		if (fs->fs_size - blkno > NINDIR(fs))
1654 			last = NINDIR(fs);
1655 		else
1656 			last = fs->fs_size - blkno;
1657 		for (loc = 0; loc < last; loc++) {
1658 			if (I_IS_UFS1(ip)) {
1659 				dblk = ((ufs1_daddr_t *)(ibp->b_data))[loc];
1660 				if (dblk == 0)
1661 					continue;
1662 				if (dblk == BLK_NOCOPY || dblk == BLK_SNAP)
1663 					((ufs1_daddr_t *)(ibp->b_data))[loc]= 0;
1664 				else if ((dblk == blkstofrags(fs, blkno) &&
1665 				     ffs_snapblkfree(fs, ITODEVVP(ip), dblk,
1666 				     fs->fs_bsize, ip->i_number, vp->v_type,
1667 				     NULL))) {
1668 					ip->i_din1->di_blocks -=
1669 					    btodb(fs->fs_bsize);
1670 					((ufs1_daddr_t *)(ibp->b_data))[loc]= 0;
1671 				}
1672 				continue;
1673 			}
1674 			dblk = ((ufs2_daddr_t *)(ibp->b_data))[loc];
1675 			if (dblk == 0)
1676 				continue;
1677 			if (dblk == BLK_NOCOPY || dblk == BLK_SNAP)
1678 				((ufs2_daddr_t *)(ibp->b_data))[loc] = 0;
1679 			else if ((dblk == blkstofrags(fs, blkno) &&
1680 			     ffs_snapblkfree(fs, ITODEVVP(ip), dblk,
1681 			     fs->fs_bsize, ip->i_number, vp->v_type, NULL))) {
1682 				ip->i_din2->di_blocks -= btodb(fs->fs_bsize);
1683 				((ufs2_daddr_t *)(ibp->b_data))[loc] = 0;
1684 			}
1685 		}
1686 		bawrite(ibp);
1687 	}
1688 	/*
1689 	 * Clear snapshot flag and drop reference.
1690 	 */
1691 	ip->i_flags &= ~SF_SNAPSHOT;
1692 	DIP_SET(ip, i_flags, ip->i_flags);
1693 	ip->i_flag |= IN_CHANGE | IN_UPDATE;
1694 	/*
1695 	 * The dirtied indirects must be written out before
1696 	 * softdep_setup_freeblocks() is called.  Otherwise indir_trunc()
1697 	 * may find indirect pointers using the magic BLK_* values.
1698 	 */
1699 	if (DOINGSOFTDEP(vp))
1700 		ffs_syncvnode(vp, MNT_WAIT, 0);
1701 #ifdef QUOTA
1702 	/*
1703 	 * Reenable disk quotas for ex-snapshot file.
1704 	 */
1705 	if (!getinoquota(ip))
1706 		(void) chkdq(ip, DIP(ip, i_blocks), KERNCRED, FORCE);
1707 #endif
1708 }
1709 
1710 /*
1711  * Notification that a block is being freed. Return zero if the free
1712  * should be allowed to proceed. Return non-zero if the snapshot file
1713  * wants to claim the block. The block will be claimed if it is an
1714  * uncopied part of one of the snapshots. It will be freed if it is
1715  * either a BLK_NOCOPY or has already been copied in all of the snapshots.
1716  * If a fragment is being freed, then all snapshots that care about
1717  * it must make a copy since a snapshot file can only claim full sized
1718  * blocks. Note that if more than one snapshot file maps the block,
1719  * we can pick one at random to claim it. Since none of the snapshots
1720  * can change, we are assurred that they will all see the same unmodified
1721  * image. When deleting a snapshot file (see ffs_snapremove above), we
1722  * must push any of these claimed blocks to one of the other snapshots
1723  * that maps it. These claimed blocks are easily identified as they will
1724  * have a block number equal to their logical block number within the
1725  * snapshot. A copied block can never have this property because they
1726  * must always have been allocated from a BLK_NOCOPY location.
1727  */
1728 int
1729 ffs_snapblkfree(fs, devvp, bno, size, inum, vtype, wkhd)
1730 	struct fs *fs;
1731 	struct vnode *devvp;
1732 	ufs2_daddr_t bno;
1733 	long size;
1734 	ino_t inum;
1735 	enum vtype vtype;
1736 	struct workhead *wkhd;
1737 {
1738 	struct buf *ibp, *cbp, *savedcbp = NULL;
1739 	struct thread *td = curthread;
1740 	struct inode *ip;
1741 	struct vnode *vp = NULL;
1742 	ufs_lbn_t lbn;
1743 	ufs2_daddr_t blkno;
1744 	int indiroff = 0, error = 0, claimedblk = 0;
1745 	struct snapdata *sn;
1746 
1747 	lbn = fragstoblks(fs, bno);
1748 retry:
1749 	VI_LOCK(devvp);
1750 	sn = devvp->v_rdev->si_snapdata;
1751 	if (sn == NULL) {
1752 		VI_UNLOCK(devvp);
1753 		return (0);
1754 	}
1755 	if (lockmgr(&sn->sn_lock, LK_INTERLOCK | LK_EXCLUSIVE | LK_SLEEPFAIL,
1756 	    VI_MTX(devvp)) != 0)
1757 		goto retry;
1758 	TAILQ_FOREACH(ip, &sn->sn_head, i_nextsnap) {
1759 		vp = ITOV(ip);
1760 		if (DOINGSOFTDEP(vp))
1761 			softdep_prealloc(vp, MNT_WAIT);
1762 		/*
1763 		 * Lookup block being written.
1764 		 */
1765 		if (lbn < UFS_NDADDR) {
1766 			blkno = DIP(ip, i_db[lbn]);
1767 		} else {
1768 			td->td_pflags |= TDP_COWINPROGRESS;
1769 			error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),
1770 			    fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
1771 			td->td_pflags &= ~TDP_COWINPROGRESS;
1772 			if (error)
1773 				break;
1774 			indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
1775 			if (I_IS_UFS1(ip))
1776 				blkno=((ufs1_daddr_t *)(ibp->b_data))[indiroff];
1777 			else
1778 				blkno=((ufs2_daddr_t *)(ibp->b_data))[indiroff];
1779 		}
1780 		/*
1781 		 * Check to see if block needs to be copied.
1782 		 */
1783 		if (blkno == 0) {
1784 			/*
1785 			 * A block that we map is being freed. If it has not
1786 			 * been claimed yet, we will claim or copy it (below).
1787 			 */
1788 			claimedblk = 1;
1789 		} else if (blkno == BLK_SNAP) {
1790 			/*
1791 			 * No previous snapshot claimed the block,
1792 			 * so it will be freed and become a BLK_NOCOPY
1793 			 * (don't care) for us.
1794 			 */
1795 			if (claimedblk)
1796 				panic("snapblkfree: inconsistent block type");
1797 			if (lbn < UFS_NDADDR) {
1798 				DIP_SET(ip, i_db[lbn], BLK_NOCOPY);
1799 				ip->i_flag |= IN_CHANGE | IN_UPDATE;
1800 			} else if (I_IS_UFS1(ip)) {
1801 				((ufs1_daddr_t *)(ibp->b_data))[indiroff] =
1802 				    BLK_NOCOPY;
1803 				bdwrite(ibp);
1804 			} else {
1805 				((ufs2_daddr_t *)(ibp->b_data))[indiroff] =
1806 				    BLK_NOCOPY;
1807 				bdwrite(ibp);
1808 			}
1809 			continue;
1810 		} else /* BLK_NOCOPY or default */ {
1811 			/*
1812 			 * If the snapshot has already copied the block
1813 			 * (default), or does not care about the block,
1814 			 * it is not needed.
1815 			 */
1816 			if (lbn >= UFS_NDADDR)
1817 				bqrelse(ibp);
1818 			continue;
1819 		}
1820 		/*
1821 		 * If this is a full size block, we will just grab it
1822 		 * and assign it to the snapshot inode. Otherwise we
1823 		 * will proceed to copy it. See explanation for this
1824 		 * routine as to why only a single snapshot needs to
1825 		 * claim this block.
1826 		 */
1827 		if (size == fs->fs_bsize) {
1828 #ifdef DEBUG
1829 			if (snapdebug)
1830 				printf("%s %ju lbn %jd from inum %ju\n",
1831 				    "Grabonremove: snapino",
1832 				    (uintmax_t)ip->i_number,
1833 				    (intmax_t)lbn, (uintmax_t)inum);
1834 #endif
1835 			/*
1836 			 * If journaling is tracking this write we must add
1837 			 * the work to the inode or indirect being written.
1838 			 */
1839 			if (wkhd != NULL) {
1840 				if (lbn < UFS_NDADDR)
1841 					softdep_inode_append(ip,
1842 					    curthread->td_ucred, wkhd);
1843 				else
1844 					softdep_buf_append(ibp, wkhd);
1845 			}
1846 			if (lbn < UFS_NDADDR) {
1847 				DIP_SET(ip, i_db[lbn], bno);
1848 			} else if (I_IS_UFS1(ip)) {
1849 				((ufs1_daddr_t *)(ibp->b_data))[indiroff] = bno;
1850 				bdwrite(ibp);
1851 			} else {
1852 				((ufs2_daddr_t *)(ibp->b_data))[indiroff] = bno;
1853 				bdwrite(ibp);
1854 			}
1855 			DIP_SET(ip, i_blocks, DIP(ip, i_blocks) + btodb(size));
1856 			ip->i_flag |= IN_CHANGE | IN_UPDATE;
1857 			lockmgr(vp->v_vnlock, LK_RELEASE, NULL);
1858 			return (1);
1859 		}
1860 		if (lbn >= UFS_NDADDR)
1861 			bqrelse(ibp);
1862 		/*
1863 		 * Allocate the block into which to do the copy. Note that this
1864 		 * allocation will never require any additional allocations for
1865 		 * the snapshot inode.
1866 		 */
1867 		td->td_pflags |= TDP_COWINPROGRESS;
1868 		error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),
1869 		    fs->fs_bsize, KERNCRED, 0, &cbp);
1870 		td->td_pflags &= ~TDP_COWINPROGRESS;
1871 		if (error)
1872 			break;
1873 #ifdef DEBUG
1874 		if (snapdebug)
1875 			printf("%s%ju lbn %jd %s %ju size %ld to blkno %jd\n",
1876 			    "Copyonremove: snapino ", (uintmax_t)ip->i_number,
1877 			    (intmax_t)lbn, "for inum", (uintmax_t)inum, size,
1878 			    (intmax_t)cbp->b_blkno);
1879 #endif
1880 		/*
1881 		 * If we have already read the old block contents, then
1882 		 * simply copy them to the new block. Note that we need
1883 		 * to synchronously write snapshots that have not been
1884 		 * unlinked, and hence will be visible after a crash,
1885 		 * to ensure their integrity. At a minimum we ensure the
1886 		 * integrity of the filesystem metadata, but use the
1887 		 * dopersistence sysctl-setable flag to decide on the
1888 		 * persistence needed for file content data.
1889 		 */
1890 		if (savedcbp != NULL) {
1891 			bcopy(savedcbp->b_data, cbp->b_data, fs->fs_bsize);
1892 			bawrite(cbp);
1893 			if ((vtype == VDIR || dopersistence) &&
1894 			    ip->i_effnlink > 0)
1895 				(void) ffs_syncvnode(vp, MNT_WAIT, NO_INO_UPDT);
1896 			continue;
1897 		}
1898 		/*
1899 		 * Otherwise, read the old block contents into the buffer.
1900 		 */
1901 		if ((error = readblock(vp, cbp, lbn)) != 0) {
1902 			bzero(cbp->b_data, fs->fs_bsize);
1903 			bawrite(cbp);
1904 			if ((vtype == VDIR || dopersistence) &&
1905 			    ip->i_effnlink > 0)
1906 				(void) ffs_syncvnode(vp, MNT_WAIT, NO_INO_UPDT);
1907 			break;
1908 		}
1909 		savedcbp = cbp;
1910 	}
1911 	/*
1912 	 * Note that we need to synchronously write snapshots that
1913 	 * have not been unlinked, and hence will be visible after
1914 	 * a crash, to ensure their integrity. At a minimum we
1915 	 * ensure the integrity of the filesystem metadata, but
1916 	 * use the dopersistence sysctl-setable flag to decide on
1917 	 * the persistence needed for file content data.
1918 	 */
1919 	if (savedcbp) {
1920 		vp = savedcbp->b_vp;
1921 		bawrite(savedcbp);
1922 		if ((vtype == VDIR || dopersistence) &&
1923 		    VTOI(vp)->i_effnlink > 0)
1924 			(void) ffs_syncvnode(vp, MNT_WAIT, NO_INO_UPDT);
1925 	}
1926 	/*
1927 	 * If we have been unable to allocate a block in which to do
1928 	 * the copy, then return non-zero so that the fragment will
1929 	 * not be freed. Although space will be lost, the snapshot
1930 	 * will stay consistent.
1931 	 */
1932 	if (error != 0 && wkhd != NULL)
1933 		softdep_freework(wkhd);
1934 	lockmgr(vp->v_vnlock, LK_RELEASE, NULL);
1935 	return (error);
1936 }
1937 
1938 /*
1939  * Associate snapshot files when mounting.
1940  */
1941 void
1942 ffs_snapshot_mount(mp)
1943 	struct mount *mp;
1944 {
1945 	struct ufsmount *ump = VFSTOUFS(mp);
1946 	struct vnode *devvp = ump->um_devvp;
1947 	struct fs *fs = ump->um_fs;
1948 	struct thread *td = curthread;
1949 	struct snapdata *sn;
1950 	struct vnode *vp;
1951 	struct vnode *lastvp;
1952 	struct inode *ip;
1953 	struct uio auio;
1954 	struct iovec aiov;
1955 	void *snapblklist;
1956 	char *reason;
1957 	daddr_t snaplistsize;
1958 	int error, snaploc, loc;
1959 
1960 	/*
1961 	 * XXX The following needs to be set before ffs_truncate or
1962 	 * VOP_READ can be called.
1963 	 */
1964 	mp->mnt_stat.f_iosize = fs->fs_bsize;
1965 	/*
1966 	 * Process each snapshot listed in the superblock.
1967 	 */
1968 	vp = NULL;
1969 	lastvp = NULL;
1970 	sn = NULL;
1971 	for (snaploc = 0; snaploc < FSMAXSNAP; snaploc++) {
1972 		if (fs->fs_snapinum[snaploc] == 0)
1973 			break;
1974 		if ((error = ffs_vget(mp, fs->fs_snapinum[snaploc],
1975 		    LK_EXCLUSIVE, &vp)) != 0){
1976 			printf("ffs_snapshot_mount: vget failed %d\n", error);
1977 			continue;
1978 		}
1979 		ip = VTOI(vp);
1980 		if (!IS_SNAPSHOT(ip) || ip->i_size ==
1981 		    lblktosize(fs, howmany(fs->fs_size, fs->fs_frag))) {
1982 			if (!IS_SNAPSHOT(ip)) {
1983 				reason = "non-snapshot";
1984 			} else {
1985 				reason = "old format snapshot";
1986 				(void)ffs_truncate(vp, (off_t)0, 0, NOCRED);
1987 				(void)ffs_syncvnode(vp, MNT_WAIT, 0);
1988 			}
1989 			printf("ffs_snapshot_mount: %s inode %d\n",
1990 			    reason, fs->fs_snapinum[snaploc]);
1991 			vput(vp);
1992 			vp = NULL;
1993 			for (loc = snaploc + 1; loc < FSMAXSNAP; loc++) {
1994 				if (fs->fs_snapinum[loc] == 0)
1995 					break;
1996 				fs->fs_snapinum[loc - 1] = fs->fs_snapinum[loc];
1997 			}
1998 			fs->fs_snapinum[loc - 1] = 0;
1999 			snaploc--;
2000 			continue;
2001 		}
2002 		/*
2003 		 * Acquire a lock on the snapdata structure, creating it if
2004 		 * necessary.
2005 		 */
2006 		sn = ffs_snapdata_acquire(devvp);
2007 		/*
2008 		 * Change vnode to use shared snapshot lock instead of the
2009 		 * original private lock.
2010 		 */
2011 		vp->v_vnlock = &sn->sn_lock;
2012 		lockmgr(&vp->v_lock, LK_RELEASE, NULL);
2013 		/*
2014 		 * Link it onto the active snapshot list.
2015 		 */
2016 		VI_LOCK(devvp);
2017 		if (ip->i_nextsnap.tqe_prev != 0)
2018 			panic("ffs_snapshot_mount: %ju already on list",
2019 			    (uintmax_t)ip->i_number);
2020 		else
2021 			TAILQ_INSERT_TAIL(&sn->sn_head, ip, i_nextsnap);
2022 		vp->v_vflag |= VV_SYSTEM;
2023 		VI_UNLOCK(devvp);
2024 		VOP_UNLOCK(vp, 0);
2025 		lastvp = vp;
2026 	}
2027 	vp = lastvp;
2028 	/*
2029 	 * No usable snapshots found.
2030 	 */
2031 	if (sn == NULL || vp == NULL)
2032 		return;
2033 	/*
2034 	 * Allocate the space for the block hints list. We always want to
2035 	 * use the list from the newest snapshot.
2036 	 */
2037 	auio.uio_iov = &aiov;
2038 	auio.uio_iovcnt = 1;
2039 	aiov.iov_base = (void *)&snaplistsize;
2040 	aiov.iov_len = sizeof(snaplistsize);
2041 	auio.uio_resid = aiov.iov_len;
2042 	auio.uio_offset =
2043 	    lblktosize(fs, howmany(fs->fs_size, fs->fs_frag));
2044 	auio.uio_segflg = UIO_SYSSPACE;
2045 	auio.uio_rw = UIO_READ;
2046 	auio.uio_td = td;
2047 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2048 	if ((error = VOP_READ(vp, &auio, IO_UNIT, td->td_ucred)) != 0) {
2049 		printf("ffs_snapshot_mount: read_1 failed %d\n", error);
2050 		VOP_UNLOCK(vp, 0);
2051 		return;
2052 	}
2053 	snapblklist = malloc(snaplistsize * sizeof(daddr_t),
2054 	    M_UFSMNT, M_WAITOK);
2055 	auio.uio_iovcnt = 1;
2056 	aiov.iov_base = snapblklist;
2057 	aiov.iov_len = snaplistsize * sizeof (daddr_t);
2058 	auio.uio_resid = aiov.iov_len;
2059 	auio.uio_offset -= sizeof(snaplistsize);
2060 	if ((error = VOP_READ(vp, &auio, IO_UNIT, td->td_ucred)) != 0) {
2061 		printf("ffs_snapshot_mount: read_2 failed %d\n", error);
2062 		VOP_UNLOCK(vp, 0);
2063 		free(snapblklist, M_UFSMNT);
2064 		return;
2065 	}
2066 	VOP_UNLOCK(vp, 0);
2067 	VI_LOCK(devvp);
2068 	ASSERT_VOP_LOCKED(devvp, "ffs_snapshot_mount");
2069 	sn->sn_listsize = snaplistsize;
2070 	sn->sn_blklist = (daddr_t *)snapblklist;
2071 	devvp->v_vflag |= VV_COPYONWRITE;
2072 	VI_UNLOCK(devvp);
2073 }
2074 
2075 /*
2076  * Disassociate snapshot files when unmounting.
2077  */
2078 void
2079 ffs_snapshot_unmount(mp)
2080 	struct mount *mp;
2081 {
2082 	struct vnode *devvp = VFSTOUFS(mp)->um_devvp;
2083 	struct snapdata *sn;
2084 	struct inode *xp;
2085 	struct vnode *vp;
2086 
2087 	VI_LOCK(devvp);
2088 	sn = devvp->v_rdev->si_snapdata;
2089 	while (sn != NULL && (xp = TAILQ_FIRST(&sn->sn_head)) != NULL) {
2090 		vp = ITOV(xp);
2091 		TAILQ_REMOVE(&sn->sn_head, xp, i_nextsnap);
2092 		xp->i_nextsnap.tqe_prev = 0;
2093 		lockmgr(&sn->sn_lock, LK_INTERLOCK | LK_EXCLUSIVE,
2094 		    VI_MTX(devvp));
2095 		lockmgr(&vp->v_lock, LK_EXCLUSIVE, NULL);
2096 		KASSERT(vp->v_vnlock == &sn->sn_lock,
2097 		("ffs_snapshot_unmount: lost lock mutation"));
2098 		vp->v_vnlock = &vp->v_lock;
2099 		lockmgr(&vp->v_lock, LK_RELEASE, NULL);
2100 		lockmgr(&sn->sn_lock, LK_RELEASE, NULL);
2101 		if (xp->i_effnlink > 0)
2102 			vrele(vp);
2103 		VI_LOCK(devvp);
2104 		sn = devvp->v_rdev->si_snapdata;
2105 	}
2106 	try_free_snapdata(devvp);
2107 	ASSERT_VOP_LOCKED(devvp, "ffs_snapshot_unmount");
2108 }
2109 
2110 /*
2111  * Check the buffer block to be belong to device buffer that shall be
2112  * locked after snaplk. devvp shall be locked on entry, and will be
2113  * leaved locked upon exit.
2114  */
2115 static int
2116 ffs_bp_snapblk(devvp, bp)
2117 	struct vnode *devvp;
2118 	struct buf *bp;
2119 {
2120 	struct snapdata *sn;
2121 	struct fs *fs;
2122 	ufs2_daddr_t lbn, *snapblklist;
2123 	int lower, upper, mid;
2124 
2125 	ASSERT_VI_LOCKED(devvp, "ffs_bp_snapblk");
2126 	KASSERT(devvp->v_type == VCHR, ("Not a device %p", devvp));
2127 	sn = devvp->v_rdev->si_snapdata;
2128 	if (sn == NULL || TAILQ_FIRST(&sn->sn_head) == NULL)
2129 		return (0);
2130 	fs = ITOFS(TAILQ_FIRST(&sn->sn_head));
2131 	lbn = fragstoblks(fs, dbtofsb(fs, bp->b_blkno));
2132 	snapblklist = sn->sn_blklist;
2133 	upper = sn->sn_listsize - 1;
2134 	lower = 1;
2135 	while (lower <= upper) {
2136 		mid = (lower + upper) / 2;
2137 		if (snapblklist[mid] == lbn)
2138 			break;
2139 		if (snapblklist[mid] < lbn)
2140 			lower = mid + 1;
2141 		else
2142 			upper = mid - 1;
2143 	}
2144 	if (lower <= upper)
2145 		return (1);
2146 	return (0);
2147 }
2148 
2149 void
2150 ffs_bdflush(bo, bp)
2151 	struct bufobj *bo;
2152 	struct buf *bp;
2153 {
2154 	struct thread *td;
2155 	struct vnode *vp, *devvp;
2156 	struct buf *nbp;
2157 	int bp_bdskip;
2158 
2159 	if (bo->bo_dirty.bv_cnt <= dirtybufthresh)
2160 		return;
2161 
2162 	td = curthread;
2163 	vp = bp->b_vp;
2164 	devvp = bo2vnode(bo);
2165 	KASSERT(vp == devvp, ("devvp != vp %p %p", bo, bp));
2166 
2167 	VI_LOCK(devvp);
2168 	bp_bdskip = ffs_bp_snapblk(devvp, bp);
2169 	if (bp_bdskip)
2170 		bdwriteskip++;
2171 	VI_UNLOCK(devvp);
2172 	if (bo->bo_dirty.bv_cnt > dirtybufthresh + 10 && !bp_bdskip) {
2173 		(void) VOP_FSYNC(vp, MNT_NOWAIT, td);
2174 		altbufferflushes++;
2175 	} else {
2176 		BO_LOCK(bo);
2177 		/*
2178 		 * Try to find a buffer to flush.
2179 		 */
2180 		TAILQ_FOREACH(nbp, &bo->bo_dirty.bv_hd, b_bobufs) {
2181 			if ((nbp->b_vflags & BV_BKGRDINPROG) ||
2182 			    BUF_LOCK(nbp,
2183 				     LK_EXCLUSIVE | LK_NOWAIT, NULL))
2184 				continue;
2185 			if (bp == nbp)
2186 				panic("bdwrite: found ourselves");
2187 			BO_UNLOCK(bo);
2188 			/*
2189 			 * Don't countdeps with the bo lock
2190 			 * held.
2191 			 */
2192 			if (buf_countdeps(nbp, 0)) {
2193 				BO_LOCK(bo);
2194 				BUF_UNLOCK(nbp);
2195 				continue;
2196 			}
2197 			if (bp_bdskip) {
2198 				VI_LOCK(devvp);
2199 				if (!ffs_bp_snapblk(vp, nbp)) {
2200 					VI_UNLOCK(devvp);
2201 					BO_LOCK(bo);
2202 					BUF_UNLOCK(nbp);
2203 					continue;
2204 				}
2205 				VI_UNLOCK(devvp);
2206 			}
2207 			if (nbp->b_flags & B_CLUSTEROK) {
2208 				vfs_bio_awrite(nbp);
2209 			} else {
2210 				bremfree(nbp);
2211 				bawrite(nbp);
2212 			}
2213 			dirtybufferflushes++;
2214 			break;
2215 		}
2216 		if (nbp == NULL)
2217 			BO_UNLOCK(bo);
2218 	}
2219 }
2220 
2221 /*
2222  * Check for need to copy block that is about to be written,
2223  * copying the block if necessary.
2224  */
2225 int
2226 ffs_copyonwrite(devvp, bp)
2227 	struct vnode *devvp;
2228 	struct buf *bp;
2229 {
2230 	struct snapdata *sn;
2231 	struct buf *ibp, *cbp, *savedcbp = NULL;
2232 	struct thread *td = curthread;
2233 	struct fs *fs;
2234 	struct inode *ip;
2235 	struct vnode *vp = NULL;
2236 	ufs2_daddr_t lbn, blkno, *snapblklist;
2237 	int lower, upper, mid, indiroff, error = 0;
2238 	int launched_async_io, prev_norunningbuf;
2239 	long saved_runningbufspace;
2240 
2241 	if (devvp != bp->b_vp && IS_SNAPSHOT(VTOI(bp->b_vp)))
2242 		return (0);		/* Update on a snapshot file */
2243 	if (td->td_pflags & TDP_COWINPROGRESS)
2244 		panic("ffs_copyonwrite: recursive call");
2245 	/*
2246 	 * First check to see if it is in the preallocated list.
2247 	 * By doing this check we avoid several potential deadlocks.
2248 	 */
2249 	VI_LOCK(devvp);
2250 	sn = devvp->v_rdev->si_snapdata;
2251 	if (sn == NULL ||
2252 	    TAILQ_EMPTY(&sn->sn_head)) {
2253 		VI_UNLOCK(devvp);
2254 		return (0);		/* No snapshot */
2255 	}
2256 	ip = TAILQ_FIRST(&sn->sn_head);
2257 	fs = ITOFS(ip);
2258 	lbn = fragstoblks(fs, dbtofsb(fs, bp->b_blkno));
2259 	snapblklist = sn->sn_blklist;
2260 	upper = sn->sn_listsize - 1;
2261 	lower = 1;
2262 	while (lower <= upper) {
2263 		mid = (lower + upper) / 2;
2264 		if (snapblklist[mid] == lbn)
2265 			break;
2266 		if (snapblklist[mid] < lbn)
2267 			lower = mid + 1;
2268 		else
2269 			upper = mid - 1;
2270 	}
2271 	if (lower <= upper) {
2272 		VI_UNLOCK(devvp);
2273 		return (0);
2274 	}
2275 	launched_async_io = 0;
2276 	prev_norunningbuf = td->td_pflags & TDP_NORUNNINGBUF;
2277 	/*
2278 	 * Since I/O on bp isn't yet in progress and it may be blocked
2279 	 * for a long time waiting on snaplk, back it out of
2280 	 * runningbufspace, possibly waking other threads waiting for space.
2281 	 */
2282 	saved_runningbufspace = bp->b_runningbufspace;
2283 	if (saved_runningbufspace != 0)
2284 		runningbufwakeup(bp);
2285 	/*
2286 	 * Not in the precomputed list, so check the snapshots.
2287 	 */
2288 	while (lockmgr(&sn->sn_lock, LK_INTERLOCK | LK_EXCLUSIVE | LK_SLEEPFAIL,
2289 	    VI_MTX(devvp)) != 0) {
2290 		VI_LOCK(devvp);
2291 		sn = devvp->v_rdev->si_snapdata;
2292 		if (sn == NULL ||
2293 		    TAILQ_EMPTY(&sn->sn_head)) {
2294 			VI_UNLOCK(devvp);
2295 			if (saved_runningbufspace != 0) {
2296 				bp->b_runningbufspace = saved_runningbufspace;
2297 				atomic_add_long(&runningbufspace,
2298 					       bp->b_runningbufspace);
2299 			}
2300 			return (0);		/* Snapshot gone */
2301 		}
2302 	}
2303 	TAILQ_FOREACH(ip, &sn->sn_head, i_nextsnap) {
2304 		vp = ITOV(ip);
2305 		if (DOINGSOFTDEP(vp))
2306 			softdep_prealloc(vp, MNT_WAIT);
2307 		/*
2308 		 * We ensure that everything of our own that needs to be
2309 		 * copied will be done at the time that ffs_snapshot is
2310 		 * called. Thus we can skip the check here which can
2311 		 * deadlock in doing the lookup in UFS_BALLOC.
2312 		 */
2313 		if (bp->b_vp == vp)
2314 			continue;
2315 		/*
2316 		 * Check to see if block needs to be copied. We do not have
2317 		 * to hold the snapshot lock while doing this lookup as it
2318 		 * will never require any additional allocations for the
2319 		 * snapshot inode.
2320 		 */
2321 		if (lbn < UFS_NDADDR) {
2322 			blkno = DIP(ip, i_db[lbn]);
2323 		} else {
2324 			td->td_pflags |= TDP_COWINPROGRESS | TDP_NORUNNINGBUF;
2325 			error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),
2326 			   fs->fs_bsize, KERNCRED, BA_METAONLY, &ibp);
2327 			td->td_pflags &= ~TDP_COWINPROGRESS;
2328 			if (error)
2329 				break;
2330 			indiroff = (lbn - UFS_NDADDR) % NINDIR(fs);
2331 			if (I_IS_UFS1(ip))
2332 				blkno=((ufs1_daddr_t *)(ibp->b_data))[indiroff];
2333 			else
2334 				blkno=((ufs2_daddr_t *)(ibp->b_data))[indiroff];
2335 			bqrelse(ibp);
2336 		}
2337 #ifdef INVARIANTS
2338 		if (blkno == BLK_SNAP && bp->b_lblkno >= 0)
2339 			panic("ffs_copyonwrite: bad copy block");
2340 #endif
2341 		if (blkno != 0)
2342 			continue;
2343 		/*
2344 		 * Allocate the block into which to do the copy. Since
2345 		 * multiple processes may all try to copy the same block,
2346 		 * we have to recheck our need to do a copy if we sleep
2347 		 * waiting for the lock.
2348 		 *
2349 		 * Because all snapshots on a filesystem share a single
2350 		 * lock, we ensure that we will never be in competition
2351 		 * with another process to allocate a block.
2352 		 */
2353 		td->td_pflags |= TDP_COWINPROGRESS | TDP_NORUNNINGBUF;
2354 		error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn),
2355 		    fs->fs_bsize, KERNCRED, 0, &cbp);
2356 		td->td_pflags &= ~TDP_COWINPROGRESS;
2357 		if (error)
2358 			break;
2359 #ifdef DEBUG
2360 		if (snapdebug) {
2361 			printf("Copyonwrite: snapino %ju lbn %jd for ",
2362 			    (uintmax_t)ip->i_number, (intmax_t)lbn);
2363 			if (bp->b_vp == devvp)
2364 				printf("fs metadata");
2365 			else
2366 				printf("inum %ju",
2367 				    (uintmax_t)VTOI(bp->b_vp)->i_number);
2368 			printf(" lblkno %jd to blkno %jd\n",
2369 			    (intmax_t)bp->b_lblkno, (intmax_t)cbp->b_blkno);
2370 		}
2371 #endif
2372 		/*
2373 		 * If we have already read the old block contents, then
2374 		 * simply copy them to the new block. Note that we need
2375 		 * to synchronously write snapshots that have not been
2376 		 * unlinked, and hence will be visible after a crash,
2377 		 * to ensure their integrity. At a minimum we ensure the
2378 		 * integrity of the filesystem metadata, but use the
2379 		 * dopersistence sysctl-setable flag to decide on the
2380 		 * persistence needed for file content data.
2381 		 */
2382 		if (savedcbp != NULL) {
2383 			bcopy(savedcbp->b_data, cbp->b_data, fs->fs_bsize);
2384 			bawrite(cbp);
2385 			if ((devvp == bp->b_vp || bp->b_vp->v_type == VDIR ||
2386 			    dopersistence) && ip->i_effnlink > 0)
2387 				(void) ffs_syncvnode(vp, MNT_WAIT, NO_INO_UPDT);
2388 			else
2389 				launched_async_io = 1;
2390 			continue;
2391 		}
2392 		/*
2393 		 * Otherwise, read the old block contents into the buffer.
2394 		 */
2395 		if ((error = readblock(vp, cbp, lbn)) != 0) {
2396 			bzero(cbp->b_data, fs->fs_bsize);
2397 			bawrite(cbp);
2398 			if ((devvp == bp->b_vp || bp->b_vp->v_type == VDIR ||
2399 			    dopersistence) && ip->i_effnlink > 0)
2400 				(void) ffs_syncvnode(vp, MNT_WAIT, NO_INO_UPDT);
2401 			else
2402 				launched_async_io = 1;
2403 			break;
2404 		}
2405 		savedcbp = cbp;
2406 	}
2407 	/*
2408 	 * Note that we need to synchronously write snapshots that
2409 	 * have not been unlinked, and hence will be visible after
2410 	 * a crash, to ensure their integrity. At a minimum we
2411 	 * ensure the integrity of the filesystem metadata, but
2412 	 * use the dopersistence sysctl-setable flag to decide on
2413 	 * the persistence needed for file content data.
2414 	 */
2415 	if (savedcbp) {
2416 		vp = savedcbp->b_vp;
2417 		bawrite(savedcbp);
2418 		if ((devvp == bp->b_vp || bp->b_vp->v_type == VDIR ||
2419 		    dopersistence) && VTOI(vp)->i_effnlink > 0)
2420 			(void) ffs_syncvnode(vp, MNT_WAIT, NO_INO_UPDT);
2421 		else
2422 			launched_async_io = 1;
2423 	}
2424 	lockmgr(vp->v_vnlock, LK_RELEASE, NULL);
2425 	td->td_pflags = (td->td_pflags & ~TDP_NORUNNINGBUF) |
2426 		prev_norunningbuf;
2427 	if (launched_async_io && (td->td_pflags & TDP_NORUNNINGBUF) == 0)
2428 		waitrunningbufspace();
2429 	/*
2430 	 * I/O on bp will now be started, so count it in runningbufspace.
2431 	 */
2432 	if (saved_runningbufspace != 0) {
2433 		bp->b_runningbufspace = saved_runningbufspace;
2434 		atomic_add_long(&runningbufspace, bp->b_runningbufspace);
2435 	}
2436 	return (error);
2437 }
2438 
2439 /*
2440  * sync snapshots to force freework records waiting on snapshots to claim
2441  * blocks to free.
2442  */
2443 void
2444 ffs_sync_snap(mp, waitfor)
2445 	struct mount *mp;
2446 	int waitfor;
2447 {
2448 	struct snapdata *sn;
2449 	struct vnode *devvp;
2450 	struct vnode *vp;
2451 	struct inode *ip;
2452 
2453 	devvp = VFSTOUFS(mp)->um_devvp;
2454 	if ((devvp->v_vflag & VV_COPYONWRITE) == 0)
2455 		return;
2456 	for (;;) {
2457 		VI_LOCK(devvp);
2458 		sn = devvp->v_rdev->si_snapdata;
2459 		if (sn == NULL) {
2460 			VI_UNLOCK(devvp);
2461 			return;
2462 		}
2463 		if (lockmgr(&sn->sn_lock,
2464 		    LK_INTERLOCK | LK_EXCLUSIVE | LK_SLEEPFAIL,
2465 		    VI_MTX(devvp)) == 0)
2466 			break;
2467 	}
2468 	TAILQ_FOREACH(ip, &sn->sn_head, i_nextsnap) {
2469 		vp = ITOV(ip);
2470 		ffs_syncvnode(vp, waitfor, NO_INO_UPDT);
2471 	}
2472 	lockmgr(&sn->sn_lock, LK_RELEASE, NULL);
2473 }
2474 
2475 /*
2476  * Read the specified block into the given buffer.
2477  * Much of this boiler-plate comes from bwrite().
2478  */
2479 static int
2480 readblock(vp, bp, lbn)
2481 	struct vnode *vp;
2482 	struct buf *bp;
2483 	ufs2_daddr_t lbn;
2484 {
2485 	struct inode *ip = VTOI(vp);
2486 	struct bio *bip;
2487 	struct fs *fs;
2488 
2489 	ip = VTOI(vp);
2490 	fs = ITOFS(ip);
2491 
2492 	bip = g_alloc_bio();
2493 	bip->bio_cmd = BIO_READ;
2494 	bip->bio_offset = dbtob(fsbtodb(fs, blkstofrags(fs, lbn)));
2495 	bip->bio_data = bp->b_data;
2496 	bip->bio_length = bp->b_bcount;
2497 	bip->bio_done = NULL;
2498 
2499 	g_io_request(bip, ITODEVVP(ip)->v_bufobj.bo_private);
2500 	bp->b_error = biowait(bip, "snaprdb");
2501 	g_destroy_bio(bip);
2502 	return (bp->b_error);
2503 }
2504 
2505 #endif
2506 
2507 /*
2508  * Process file deletes that were deferred by ufs_inactive() due to
2509  * the file system being suspended. Transfer IN_LAZYACCESS into
2510  * IN_MODIFIED for vnodes that were accessed during suspension.
2511  */
2512 void
2513 process_deferred_inactive(struct mount *mp)
2514 {
2515 	struct vnode *vp, *mvp;
2516 	struct inode *ip;
2517 	struct thread *td;
2518 	int error;
2519 
2520 	td = curthread;
2521 	(void) vn_start_secondary_write(NULL, &mp, V_WAIT);
2522  loop:
2523 	MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
2524 		/*
2525 		 * IN_LAZYACCESS is checked here without holding any
2526 		 * vnode lock, but this flag is set only while holding
2527 		 * vnode interlock.
2528 		 */
2529 		if (vp->v_type == VNON ||
2530 		    ((VTOI(vp)->i_flag & IN_LAZYACCESS) == 0 &&
2531 		    ((vp->v_iflag & VI_OWEINACT) == 0 || vp->v_usecount > 0))) {
2532 			VI_UNLOCK(vp);
2533 			continue;
2534 		}
2535 		vholdl(vp);
2536 		error = vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK);
2537 		if (error != 0) {
2538 			vdrop(vp);
2539 			if (error == ENOENT)
2540 				continue;	/* vnode recycled */
2541 			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
2542 			goto loop;
2543 		}
2544 		ip = VTOI(vp);
2545 		if ((ip->i_flag & IN_LAZYACCESS) != 0) {
2546 			ip->i_flag &= ~IN_LAZYACCESS;
2547 			ip->i_flag |= IN_MODIFIED;
2548 		}
2549 		VI_LOCK(vp);
2550 		if ((vp->v_iflag & VI_OWEINACT) == 0 || vp->v_usecount > 0) {
2551 			VI_UNLOCK(vp);
2552 			VOP_UNLOCK(vp, 0);
2553 			vdrop(vp);
2554 			continue;
2555 		}
2556 		vinactive(vp, td);
2557 		VNASSERT((vp->v_iflag & VI_OWEINACT) == 0, vp,
2558 			 ("process_deferred_inactive: got VI_OWEINACT"));
2559 		VI_UNLOCK(vp);
2560 		VOP_UNLOCK(vp, 0);
2561 		vdrop(vp);
2562 	}
2563 	vn_finished_secondary_write(mp);
2564 }
2565 
2566 #ifndef NO_FFS_SNAPSHOT
2567 
2568 static struct snapdata *
2569 ffs_snapdata_alloc(void)
2570 {
2571 	struct snapdata *sn;
2572 
2573 	/*
2574 	 * Fetch a snapdata from the free list if there is one available.
2575 	 */
2576 	mtx_lock(&snapfree_lock);
2577 	sn = LIST_FIRST(&snapfree);
2578 	if (sn != NULL)
2579 		LIST_REMOVE(sn, sn_link);
2580 	mtx_unlock(&snapfree_lock);
2581 	if (sn != NULL)
2582 		return (sn);
2583 	/*
2584  	 * If there were no free snapdatas allocate one.
2585 	 */
2586 	sn = malloc(sizeof *sn, M_UFSMNT, M_WAITOK | M_ZERO);
2587 	TAILQ_INIT(&sn->sn_head);
2588 	lockinit(&sn->sn_lock, PVFS, "snaplk", VLKTIMEOUT,
2589 	    LK_CANRECURSE | LK_NOSHARE);
2590 	return (sn);
2591 }
2592 
2593 /*
2594  * The snapdata is never freed because we can not be certain that
2595  * there are no threads sleeping on the snap lock.  Persisting
2596  * them permanently avoids costly synchronization in ffs_lock().
2597  */
2598 static void
2599 ffs_snapdata_free(struct snapdata *sn)
2600 {
2601 	mtx_lock(&snapfree_lock);
2602 	LIST_INSERT_HEAD(&snapfree, sn, sn_link);
2603 	mtx_unlock(&snapfree_lock);
2604 }
2605 
2606 /* Try to free snapdata associated with devvp */
2607 static void
2608 try_free_snapdata(struct vnode *devvp)
2609 {
2610 	struct snapdata *sn;
2611 	ufs2_daddr_t *snapblklist;
2612 
2613 	ASSERT_VI_LOCKED(devvp, "try_free_snapdata");
2614 	sn = devvp->v_rdev->si_snapdata;
2615 
2616 	if (sn == NULL || TAILQ_FIRST(&sn->sn_head) != NULL ||
2617 	    (devvp->v_vflag & VV_COPYONWRITE) == 0) {
2618 		VI_UNLOCK(devvp);
2619 		return;
2620 	}
2621 
2622 	devvp->v_rdev->si_snapdata = NULL;
2623 	devvp->v_vflag &= ~VV_COPYONWRITE;
2624 	lockmgr(&sn->sn_lock, LK_DRAIN|LK_INTERLOCK, VI_MTX(devvp));
2625 	snapblklist = sn->sn_blklist;
2626 	sn->sn_blklist = NULL;
2627 	sn->sn_listsize = 0;
2628 	lockmgr(&sn->sn_lock, LK_RELEASE, NULL);
2629 	if (snapblklist != NULL)
2630 		free(snapblklist, M_UFSMNT);
2631 	ffs_snapdata_free(sn);
2632 }
2633 
2634 static struct snapdata *
2635 ffs_snapdata_acquire(struct vnode *devvp)
2636 {
2637 	struct snapdata *nsn;
2638 	struct snapdata *sn;
2639 
2640 	/*
2641 	 * Allocate a free snapdata.  This is done before acquiring the
2642 	 * devvp lock to avoid allocation while the devvp interlock is
2643 	 * held.
2644 	 */
2645 	nsn = ffs_snapdata_alloc();
2646 	/*
2647 	 * If there snapshots already exist on this filesystem grab a
2648 	 * reference to the shared lock.  Otherwise this is the first
2649 	 * snapshot on this filesystem and we need to use our
2650 	 * pre-allocated snapdata.
2651 	 */
2652 	VI_LOCK(devvp);
2653 	if (devvp->v_rdev->si_snapdata == NULL) {
2654 		devvp->v_rdev->si_snapdata = nsn;
2655 		nsn = NULL;
2656 	}
2657 	sn = devvp->v_rdev->si_snapdata;
2658 	/*
2659 	 * Acquire the snapshot lock.
2660 	 */
2661 	lockmgr(&sn->sn_lock,
2662 	    LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY, VI_MTX(devvp));
2663 	/*
2664 	 * Free any unused snapdata.
2665 	 */
2666 	if (nsn != NULL)
2667 		ffs_snapdata_free(nsn);
2668 
2669 	return (sn);
2670 }
2671 
2672 #endif
2673