1/* $NetBSD: ffs_snapshot.c,v 1.143 2016/10/28 20:38:12 jdolecek Exp $ */
2
3/*
4 * Copyright 2000 Marshall Kirk McKusick. All Rights Reserved.
5 *
6 * Further information about snapshots can be obtained from:
7 *
8 * Marshall Kirk McKusick http://www.mckusick.com/softdep/
9 * 1614 Oxford Street mckusick@mckusick.com
10 * Berkeley, CA 94709-1608 +1-510-843-9542
11 * USA
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 *
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in the
21 * documentation and/or other materials provided with the distribution.
22 *
23 * THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND ANY
24 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 * DISCLAIMED. IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE FOR
27 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 *
35 * @(#)ffs_snapshot.c 8.11 (McKusick) 7/23/00
36 *
37 * from FreeBSD: ffs_snapshot.c,v 1.79 2004/02/13 02:02:06 kuriyama Exp
38 */
39
40#include <sys/cdefs.h>
41__KERNEL_RCSID(0, "$NetBSD: ffs_snapshot.c,v 1.143 2016/10/28 20:38:12 jdolecek Exp $");
42
43#if defined(_KERNEL_OPT)
44#include "opt_ffs.h"
45#include "opt_quota.h"
46#endif
47
48#include <sys/param.h>
49#include <sys/kernel.h>
50#include <sys/systm.h>
51#include <sys/conf.h>
52#include <sys/buf.h>
53#include <sys/proc.h>
54#include <sys/namei.h>
55#include <sys/sched.h>
56#include <sys/stat.h>
57#include <sys/malloc.h>
58#include <sys/mount.h>
59#include <sys/resource.h>
60#include <sys/resourcevar.h>
61#include <sys/vnode.h>
62#include <sys/kauth.h>
63#include <sys/fstrans.h>
64#include <sys/wapbl.h>
65
66#include <miscfs/specfs/specdev.h>
67
68#include <ufs/ufs/quota.h>
69#include <ufs/ufs/ufsmount.h>
70#include <ufs/ufs/inode.h>
71#include <ufs/ufs/ufs_extern.h>
72#include <ufs/ufs/ufs_bswap.h>
73#include <ufs/ufs/ufs_wapbl.h>
74
75#include <ufs/ffs/fs.h>
76#include <ufs/ffs/ffs_extern.h>
77
78#include <uvm/uvm.h>
79
80TAILQ_HEAD(inodelst, inode); /* List of active snapshots */
81
82struct snap_info {
83 kmutex_t si_lock; /* Lock this snapinfo */
84 kmutex_t si_snaplock; /* Snapshot vnode common lock */
85 lwp_t *si_owner; /* Snaplock owner */
86 struct inodelst si_snapshots; /* List of active snapshots */
87 daddr_t *si_snapblklist; /* Snapshot block hints list */
88 uint32_t si_gen; /* Incremented on change */
89};
90
91#if !defined(FFS_NO_SNAPSHOT)
92typedef int (*acctfunc_t)
93 (struct vnode *, void *, int, int, struct fs *, daddr_t, int);
94
95static int snapshot_setup(struct mount *, struct vnode *);
96static int snapshot_copyfs(struct mount *, struct vnode *, void **);
97static int snapshot_expunge(struct mount *, struct vnode *,
98 struct fs *, daddr_t *, daddr_t **);
99static int snapshot_expunge_snap(struct mount *, struct vnode *,
100 struct fs *, daddr_t);
101static int snapshot_writefs(struct mount *, struct vnode *, void *);
102static int cgaccount(struct vnode *, int, int *);
103static int cgaccount1(int, struct vnode *, void *, int);
104static int expunge(struct vnode *, struct inode *, struct fs *,
105 acctfunc_t, int);
106static int indiracct(struct vnode *, struct vnode *, int, daddr_t,
107 daddr_t, daddr_t, daddr_t, daddr_t, struct fs *, acctfunc_t, int);
108static int fullacct(struct vnode *, void *, int, int, struct fs *,
109 daddr_t, int);
110static int snapacct(struct vnode *, void *, int, int, struct fs *,
111 daddr_t, int);
112static int mapacct(struct vnode *, void *, int, int, struct fs *,
113 daddr_t, int);
114#endif /* !defined(FFS_NO_SNAPSHOT) */
115
116static int ffs_copyonwrite(void *, struct buf *, bool);
117static int snapblkaddr(struct vnode *, daddr_t, daddr_t *);
118static int rwfsblk(struct vnode *, int, void *, daddr_t);
119static int syncsnap(struct vnode *);
120static int wrsnapblk(struct vnode *, void *, daddr_t);
121#if !defined(FFS_NO_SNAPSHOT)
122static int blocks_in_journal(struct fs *);
123#endif
124
125static inline bool is_active_snapshot(struct snap_info *, struct inode *);
126static inline daddr_t db_get(struct inode *, int);
127static inline void db_assign(struct inode *, int, daddr_t);
128static inline daddr_t ib_get(struct inode *, int);
129static inline daddr_t idb_get(struct inode *, void *, int);
130static inline void idb_assign(struct inode *, void *, int, daddr_t);
131
132#ifdef DEBUG
133static int snapdebug = 0;
134#endif
135
136int
137ffs_snapshot_init(struct ufsmount *ump)
138{
139 struct snap_info *si;
140
141 si = ump->um_snapinfo = kmem_alloc(sizeof(*si), KM_SLEEP);
142 if (si == NULL)
143 return ENOMEM;
144
145 TAILQ_INIT(&si->si_snapshots);
146 mutex_init(&si->si_lock, MUTEX_DEFAULT, IPL_NONE);
147 mutex_init(&si->si_snaplock, MUTEX_DEFAULT, IPL_NONE);
148 si->si_owner = NULL;
149 si->si_gen = 0;
150 si->si_snapblklist = NULL;
151
152 return 0;
153}
154
155void
156ffs_snapshot_fini(struct ufsmount *ump)
157{
158 struct snap_info *si;
159
160 si = ump->um_snapinfo;
161 ump->um_snapinfo = NULL;
162
163 KASSERT(TAILQ_EMPTY(&si->si_snapshots));
164 mutex_destroy(&si->si_lock);
165 mutex_destroy(&si->si_snaplock);
166 KASSERT(si->si_snapblklist == NULL);
167 kmem_free(si, sizeof(*si));
168}
169
170/*
171 * Create a snapshot file and initialize it for the filesystem.
172 * Vnode is locked on entry and return.
173 */
174int
175ffs_snapshot(struct mount *mp, struct vnode *vp, struct timespec *ctime)
176{
177#if defined(FFS_NO_SNAPSHOT)
178 return EOPNOTSUPP;
179}
180#else /* defined(FFS_NO_SNAPSHOT) */
181 bool suspended = false;
182 int error, redo = 0, snaploc;
183 void *sbbuf = NULL;
184 daddr_t *snaplist = NULL, snaplistsize = 0;
185 struct buf *bp, *nbp;
186 struct fs *copy_fs = NULL;
187 struct fs *fs = VFSTOUFS(mp)->um_fs;
188 struct inode *ip = VTOI(vp);
189 struct lwp *l = curlwp;
190 struct snap_info *si = VFSTOUFS(mp)->um_snapinfo;
191 struct timespec ts;
192 struct timeval starttime;
193#ifdef DEBUG
194 struct timeval endtime;
195#endif
196 struct vnode *devvp = ip->i_devvp;
197
198 /*
199 * If the vnode already is a snapshot, return.
200 */
201 if ((ip->i_flags & SF_SNAPSHOT)) {
202 if ((ip->i_flags & SF_SNAPINVAL))
203 return EINVAL;
204 if (ctime) {
205 ctime->tv_sec = DIP(ip, mtime);
206 ctime->tv_nsec = DIP(ip, mtimensec);
207 }
208 return 0;
209 }
210 /*
211 * Check for free snapshot slot in the superblock.
212 */
213 for (snaploc = 0; snaploc < FSMAXSNAP; snaploc++)
214 if (fs->fs_snapinum[snaploc] == 0)
215 break;
216 if (snaploc == FSMAXSNAP)
217 return (ENOSPC);
218 /*
219 * Prepare the vnode to become a snapshot.
220 */
221 error = snapshot_setup(mp, vp);
222 if (error)
223 goto out;
224
225 /*
226 * Copy all the cylinder group maps. Although the
227 * filesystem is still active, we hope that only a few
228 * cylinder groups will change between now and when we
229 * suspend operations. Thus, we will be able to quickly
230 * touch up the few cylinder groups that changed during
231 * the suspension period.
232 */
233 error = cgaccount(vp, 1, NULL);
234 if (error)
235 goto out;
236
237 /*
238 * snapshot is now valid
239 */
240 ip->i_flags &= ~SF_SNAPINVAL;
241 DIP_ASSIGN(ip, flags, ip->i_flags);
242 ip->i_flag |= IN_CHANGE | IN_UPDATE;
243
244 /*
245 * Ensure that the snapshot is completely on disk.
246 * Since we have marked it as a snapshot it is safe to
247 * unlock it as no process will be allowed to write to it.
248 */
249 error = VOP_FSYNC(vp, l->l_cred, FSYNC_WAIT, 0, 0);
250 if (error)
251 goto out;
252 VOP_UNLOCK(vp);
253 /*
254 * All allocations are done, so we can now suspend the filesystem.
255 */
256 error = vfs_suspend(vp->v_mount, 0);
257 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
258 if (error)
259 goto out;
260 suspended = true;
261 getmicrotime(&starttime);
262 /*
263 * First, copy all the cylinder group maps that have changed.
264 */
265 error = cgaccount(vp, 2, &redo);
266 if (error)
267 goto out;
268 /*
269 * Create a copy of the superblock and its summary information.
270 */
271 error = snapshot_copyfs(mp, vp, &sbbuf);
272 if (error)
273 goto out;
274 copy_fs = (struct fs *)((char *)sbbuf + ffs_blkoff(fs, fs->fs_sblockloc));
275 /*
276 * Expunge unlinked files from our view.
277 */
278 error = snapshot_expunge(mp, vp, copy_fs, &snaplistsize, &snaplist);
279 if (error)
280 goto out;
281 /*
282 * Record snapshot inode. Since this is the newest snapshot,
283 * it must be placed at the end of the list.
284 */
285 if (ip->i_nlink > 0)
286 fs->fs_snapinum[snaploc] = ip->i_number;
287
288 mutex_enter(&si->si_lock);
289 if (is_active_snapshot(si, ip))
290 panic("ffs_snapshot: %"PRIu64" already on list", ip->i_number);
291 TAILQ_INSERT_TAIL(&si->si_snapshots, ip, i_nextsnap);
292 if (TAILQ_FIRST(&si->si_snapshots) == ip) {
293 /*
294 * If this is the first snapshot on this filesystem, put the
295 * preliminary list in place and establish the cow handler.
296 */
297 si->si_snapblklist = snaplist;
298 fscow_establish(mp, ffs_copyonwrite, devvp);
299 }
300 si->si_gen++;
301 mutex_exit(&si->si_lock);
302
303 vp->v_vflag |= VV_SYSTEM;
304 /*
305 * Set the mtime to the time the snapshot has been taken.
306 */
307 TIMEVAL_TO_TIMESPEC(&starttime, &ts);
308 if (ctime)
309 *ctime = ts;
310 DIP_ASSIGN(ip, mtime, ts.tv_sec);
311 DIP_ASSIGN(ip, mtimensec, ts.tv_nsec);
312 ip->i_flag |= IN_CHANGE | IN_UPDATE;
313 /*
314 * Copy allocation information from all snapshots and then
315 * expunge them from our view.
316 */
317 error = snapshot_expunge_snap(mp, vp, copy_fs, snaplistsize);
318 if (error)
319 goto out;
320 /*
321 * Write the superblock and its summary information to the snapshot.
322 */
323 error = snapshot_writefs(mp, vp, sbbuf);
324 if (error)
325 goto out;
326 /*
327 * We're nearly done, ensure that the snapshot is completely on disk.
328 */
329 error = VOP_FSYNC(vp, l->l_cred, FSYNC_WAIT, 0, 0);
330 if (error)
331 goto out;
332 /*
333 * Invalidate and free all pages on the snapshot vnode.
334 * We will read and write through the buffercache.
335 */
336 mutex_enter(vp->v_interlock);
337 error = VOP_PUTPAGES(vp, 0, 0,
338 PGO_ALLPAGES | PGO_CLEANIT | PGO_SYNCIO | PGO_FREE);
339 if (error)
340 goto out;
341 /*
342 * Invalidate short ( < fs_bsize ) buffers. We will always read
343 * full size buffers later.
344 */
345 mutex_enter(&bufcache_lock);
346 KASSERT(LIST_FIRST(&vp->v_dirtyblkhd) == NULL);
347 for (bp = LIST_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) {
348 nbp = LIST_NEXT(bp, b_vnbufs);
349 if (bp->b_bcount == fs->fs_bsize)
350 continue;
351 error = bbusy(bp, false, 0, NULL);
352 if (error != 0) {
353 if (error == EPASSTHROUGH) {
354 nbp = LIST_FIRST(&vp->v_cleanblkhd);
355 continue;
356 }
357 break;
358 }
359 brelsel(bp, BC_INVAL | BC_VFLUSH);
360 }
361 mutex_exit(&bufcache_lock);
362
363out:
364 if (sbbuf != NULL) {
365 free(copy_fs->fs_csp, M_UFSMNT);
366 free(sbbuf, M_UFSMNT);
367 }
368 if (fs->fs_active != NULL) {
369 free(fs->fs_active, M_DEVBUF);
370 fs->fs_active = NULL;
371 }
372
373 mutex_enter(&si->si_lock);
374 if (snaplist != NULL) {
375 if (si->si_snapblklist == snaplist)
376 si->si_snapblklist = NULL;
377 free(snaplist, M_UFSMNT);
378 }
379 if (error) {
380 fs->fs_snapinum[snaploc] = 0;
381 } else {
382 /*
383 * As this is the newest list, it is the most inclusive, so
384 * should replace the previous list.
385 */
386 si->si_snapblklist = ip->i_snapblklist;
387 }
388 si->si_gen++;
389 mutex_exit(&si->si_lock);
390
391 if (suspended) {
392 VOP_UNLOCK(vp);
393 vfs_resume(vp->v_mount);
394 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
395#ifdef DEBUG
396 getmicrotime(&endtime);
397 timersub(&endtime, &starttime, &endtime);
398 printf("%s: suspended %lld.%03d sec, redo %d of %d\n",
399 mp->mnt_stat.f_mntonname, (long long)endtime.tv_sec,
400 endtime.tv_usec / 1000, redo, fs->fs_ncg);
401#endif
402 }
403 if (error) {
404 if (UFS_WAPBL_BEGIN(mp) == 0) {
405 /*
406 * We depend on ffs_truncate() to call ffs_snapremove()
407 * before it may return an error. On failed
408 * ffs_truncate() we have normal file with leaked
409 * (meta-) data, but no snapshot to use.
410 */
411 (void) ffs_truncate(vp, (off_t)0, 0, NOCRED);
412 UFS_WAPBL_END(mp);
413 }
414 } else if (ip->i_nlink > 0)
415 vref(vp);
416 return (error);
417}
418
419/*
420 * Prepare vnode to become a snapshot.
421 */
422static int
423snapshot_setup(struct mount *mp, struct vnode *vp)
424{
425 int error, n, len, loc, cg;
426 daddr_t blkno, numblks;
427 struct buf *ibp, *nbp;
428 struct fs *fs = VFSTOUFS(mp)->um_fs;
429 struct lwp *l = curlwp;
430 const int wbreak = blocks_in_journal(fs)/8;
431 struct inode *ip = VTOI(vp);
432
433 /*
434 * Check mount, readonly reference and owner.
435 */
436 if (vp->v_mount != mp)
437 return EXDEV;
438 if (vp->v_writecount != 0)
439 return EBUSY;
440 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_SNAPSHOT,
441 0, mp, vp, NULL);
442 if (error)
443 return EACCES;
444
445 if (vp->v_size != 0) {
446 /*
447 * Must completely truncate the file here. Allocated
448 * blocks on a snapshot mean that block has been copied
449 * on write, see ffs_copyonwrite() testing "blkno != 0"
450 */
451 error = ufs_truncate_retry(vp, 0, NOCRED);
452 if (error)
453 return error;
454 }
455
456 /* Change inode to snapshot type file. */
457 error = UFS_WAPBL_BEGIN(mp);
458 if (error)
459 return error;
460#if defined(QUOTA) || defined(QUOTA2)
461 /* shapshot inodes are not accounted in quotas */
462 chkiq(ip, -1, l->l_cred, 0);
463#endif
464 ip->i_flags |= (SF_SNAPSHOT | SF_SNAPINVAL);
465 DIP_ASSIGN(ip, flags, ip->i_flags);
466 ip->i_flag |= IN_CHANGE | IN_UPDATE;
467 ffs_update(vp, NULL, NULL, UPDATE_WAIT);
468 UFS_WAPBL_END(mp);
469
470 KASSERT(ip->i_flags & SF_SNAPSHOT);
471 /*
472 * Write an empty list of preallocated blocks to the end of
473 * the snapshot to set size to at least that of the filesystem.
474 */
475 numblks = howmany(fs->fs_size, fs->fs_frag);
476 blkno = 1;
477 blkno = ufs_rw64(blkno, UFS_FSNEEDSWAP(fs));
478 error = vn_rdwr(UIO_WRITE, vp,
479 (void *)&blkno, sizeof(blkno), ffs_lblktosize(fs, (off_t)numblks),
480 UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, l->l_cred, NULL, NULL);
481 if (error)
482 return error;
483 /*
484 * Preallocate critical data structures so that we can copy
485 * them in without further allocation after we suspend all
486 * operations on the filesystem. We would like to just release
487 * the allocated buffers without writing them since they will
488 * be filled in below once we are ready to go, but this upsets
489 * the soft update code, so we go ahead and write the new buffers.
490 *
491 * Allocate all indirect blocks and mark all of them as not
492 * needing to be copied.
493 */
494 error = UFS_WAPBL_BEGIN(mp);
495 if (error)
496 return error;
497 for (blkno = UFS_NDADDR, n = 0; blkno < numblks; blkno += FFS_NINDIR(fs)) {
498 error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)blkno),
499 fs->fs_bsize, l->l_cred, B_METAONLY, &ibp);
500 if (error)
501 goto out;
502 brelse(ibp, 0);
503 if (wbreak > 0 && (++n % wbreak) == 0) {
504 UFS_WAPBL_END(mp);
505 error = UFS_WAPBL_BEGIN(mp);
506 if (error)
507 return error;
508 }
509 }
510 /*
511 * Allocate copies for the superblock and its summary information.
512 */
513 error = ffs_balloc(vp, fs->fs_sblockloc, fs->fs_sbsize, l->l_cred,
514 0, &nbp);
515 if (error)
516 goto out;
517 bawrite(nbp);
518 blkno = ffs_fragstoblks(fs, fs->fs_csaddr);
519 len = howmany(fs->fs_cssize, fs->fs_bsize);
520 for (loc = 0; loc < len; loc++) {
521 error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)(blkno + loc)),
522 fs->fs_bsize, l->l_cred, 0, &nbp);
523 if (error)
524 goto out;
525 bawrite(nbp);
526 if (wbreak > 0 && (++n % wbreak) == 0) {
527 UFS_WAPBL_END(mp);
528 error = UFS_WAPBL_BEGIN(mp);
529 if (error)
530 return error;
531 }
532 }
533 /*
534 * Allocate all cylinder group blocks.
535 */
536 for (cg = 0; cg < fs->fs_ncg; cg++) {
537 error = ffs_balloc(vp, ffs_lfragtosize(fs, cgtod(fs, cg)),
538 fs->fs_bsize, l->l_cred, 0, &nbp);
539 if (error)
540 goto out;
541 bawrite(nbp);
542 if (wbreak > 0 && (++n % wbreak) == 0) {
543 UFS_WAPBL_END(mp);
544 error = UFS_WAPBL_BEGIN(mp);
545 if (error)
546 return error;
547 }
548 }
549
550out:
551 UFS_WAPBL_END(mp);
552 return error;
553}
554
555/*
556 * Create a copy of the superblock and its summary information.
557 * It is up to the caller to free copyfs and copy_fs->fs_csp.
558 */
559static int
560snapshot_copyfs(struct mount *mp, struct vnode *vp, void **sbbuf)
561{
562 int error, i, len, loc, size;
563 void *space;
564 int32_t *lp;
565 struct buf *bp;
566 struct fs *copyfs, *fs = VFSTOUFS(mp)->um_fs;
567 struct vnode *devvp = VTOI(vp)->i_devvp;
568
569 /*
570 * Grab a copy of the superblock and its summary information.
571 * We delay writing it until the suspension is released below.
572 */
573 *sbbuf = malloc(fs->fs_bsize, M_UFSMNT, M_WAITOK);
574 loc = ffs_blkoff(fs, fs->fs_sblockloc);
575 if (loc > 0)
576 memset(*sbbuf, 0, loc);
577 copyfs = (struct fs *)((char *)(*sbbuf) + loc);
578 memcpy(copyfs, fs, fs->fs_sbsize);
579 size = fs->fs_bsize < SBLOCKSIZE ? fs->fs_bsize : SBLOCKSIZE;
580 if (fs->fs_sbsize < size)
581 memset((char *)(*sbbuf) + loc + fs->fs_sbsize, 0,
582 size - fs->fs_sbsize);
583 size = ffs_blkroundup(fs, fs->fs_cssize);
584 if (fs->fs_contigsumsize > 0)
585 size += fs->fs_ncg * sizeof(int32_t);
586 space = malloc(size, M_UFSMNT, M_WAITOK);
587 copyfs->fs_csp = space;
588 memcpy(copyfs->fs_csp, fs->fs_csp, fs->fs_cssize);
589 space = (char *)space + fs->fs_cssize;
590 loc = howmany(fs->fs_cssize, fs->fs_fsize);
591 i = fs->fs_frag - loc % fs->fs_frag;
592 len = (i == fs->fs_frag) ? 0 : i * fs->fs_fsize;
593 if (len > 0) {
594 if ((error = bread(devvp, FFS_FSBTODB(fs, fs->fs_csaddr + loc),
595 len, 0, &bp)) != 0) {
596 free(copyfs->fs_csp, M_UFSMNT);
597 free(*sbbuf, M_UFSMNT);
598 *sbbuf = NULL;
599 return error;
600 }
601 memcpy(space, bp->b_data, (u_int)len);
602 space = (char *)space + len;
603 brelse(bp, BC_INVAL | BC_NOCACHE);
604 }
605 if (fs->fs_contigsumsize > 0) {
606 copyfs->fs_maxcluster = lp = space;
607 for (i = 0; i < fs->fs_ncg; i++)
608 *lp++ = fs->fs_contigsumsize;
609 }
610 if (mp->mnt_wapbl)
611 copyfs->fs_flags &= ~FS_DOWAPBL;
612 return 0;
613}
614
615struct snapshot_expunge_ctx {
616 struct vnode *logvp;
617 struct lwp *l;
618 struct vnode *vp;
619 struct fs *copy_fs;
620};
621
622static bool
623snapshot_expunge_selector(void *cl, struct vnode *xvp)
624{
625 struct vattr vat;
626 struct snapshot_expunge_ctx *c = cl;
627 struct inode *xp;
628
629 xp = VTOI(xvp);
630 if (xvp->v_type == VNON || VTOI(xvp) == NULL ||
631 (xp->i_flags & SF_SNAPSHOT))
632 return false;
633#ifdef DEBUG
634 if (snapdebug)
635 vprint("ffs_snapshot: busy vnode", xvp);
636#endif
637
638 if (xvp == c->logvp)
639 return true;
640
641 if (VOP_GETATTR(xvp, &vat, c->l->l_cred) == 0 &&
642 vat.va_nlink > 0)
643 return false;
644
645 if (ffs_checkfreefile(c->copy_fs, c->vp, xp->i_number))
646 return false;
647
648 return true;
649}
650
651/*
652 * We must check for active files that have been unlinked (e.g., with a zero
653 * link count). We have to expunge all trace of these files from the snapshot
654 * so that they are not reclaimed prematurely by fsck or unnecessarily dumped.
655 * Note that we skip unlinked snapshot files as they will be handled separately.
656 * Calculate the snapshot list size and create a preliminary list.
657 */
658static int
659snapshot_expunge(struct mount *mp, struct vnode *vp, struct fs *copy_fs,
660 daddr_t *snaplistsize, daddr_t **snaplist)
661{
662 int cg, error = 0, len, loc;
663 daddr_t blkno, *blkp;
664 struct fs *fs = VFSTOUFS(mp)->um_fs;
665 struct inode *xp;
666 struct lwp *l = curlwp;
667 struct vnode *logvp = NULL, *xvp;
668 struct vnode_iterator *marker;
669 struct snapshot_expunge_ctx ctx;
670
671 *snaplist = NULL;
672 /*
673 * Get the log inode if any.
674 */
675 if ((fs->fs_flags & FS_DOWAPBL) &&
676 fs->fs_journal_location == UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM) {
677 error = VFS_VGET(mp,
678 fs->fs_journallocs[UFS_WAPBL_INFS_INO], &logvp);
679 if (error)
680 goto out;
681 }
682 /*
683 * We also calculate the needed size for the snapshot list.
684 */
685 *snaplistsize = fs->fs_ncg + howmany(fs->fs_cssize, fs->fs_bsize) +
686 FSMAXSNAP + 1 /* superblock */ + 1 /* last block */ + 1 /* size */;
687
688 vfs_vnode_iterator_init(mp, &marker);
689 ctx.logvp = logvp;
690 ctx.l = l;
691 ctx.vp = vp;
692 ctx.copy_fs = copy_fs;
693 while ((xvp = vfs_vnode_iterator_next(marker, snapshot_expunge_selector,
694 &ctx)))
695 {
696 /*
697 * If there is a fragment, clear it here.
698 */
699 xp = VTOI(xvp);
700 blkno = 0;
701 loc = howmany(xp->i_size, fs->fs_bsize) - 1;
702 if (loc < UFS_NDADDR) {
703 len = ffs_fragroundup(fs, ffs_blkoff(fs, xp->i_size));
704 if (len > 0 && len < fs->fs_bsize) {
705 error = UFS_WAPBL_BEGIN(mp);
706 if (error) {
707 vrele(xvp);
708 vfs_vnode_iterator_destroy(marker);
709 goto out;
710 }
711 ffs_blkfree_snap(copy_fs, vp, db_get(xp, loc),
712 len, xp->i_number);
713 blkno = db_get(xp, loc);
714 db_assign(xp, loc, 0);
715 UFS_WAPBL_END(mp);
716 }
717 }
718 *snaplistsize += 1;
719 error = expunge(vp, xp, copy_fs, fullacct, BLK_NOCOPY);
720 if (blkno)
721 db_assign(xp, loc, blkno);
722 if (!error) {
723 error = UFS_WAPBL_BEGIN(mp);
724 if (!error) {
725 error = ffs_freefile_snap(copy_fs, vp,
726 xp->i_number, xp->i_mode);
727 UFS_WAPBL_END(mp);
728 }
729 }
730 vrele(xvp);
731 if (error) {
732 vfs_vnode_iterator_destroy(marker);
733 goto out;
734 }
735 }
736 vfs_vnode_iterator_destroy(marker);
737
738 /*
739 * Create a preliminary list of preallocated snapshot blocks.
740 */
741 *snaplist = malloc(*snaplistsize * sizeof(daddr_t), M_UFSMNT, M_WAITOK);
742 blkp = &(*snaplist)[1];
743 *blkp++ = ffs_lblkno(fs, fs->fs_sblockloc);
744 blkno = ffs_fragstoblks(fs, fs->fs_csaddr);
745 for (cg = 0; cg < fs->fs_ncg; cg++) {
746 if (ffs_fragstoblks(fs, cgtod(fs, cg)) > blkno)
747 break;
748 *blkp++ = ffs_fragstoblks(fs, cgtod(fs, cg));
749 }
750 len = howmany(fs->fs_cssize, fs->fs_bsize);
751 for (loc = 0; loc < len; loc++)
752 *blkp++ = blkno + loc;
753 for (; cg < fs->fs_ncg; cg++)
754 *blkp++ = ffs_fragstoblks(fs, cgtod(fs, cg));
755 (*snaplist)[0] = blkp - &(*snaplist)[0];
756
757out:
758 if (logvp != NULL)
759 vput(logvp);
760 if (error && *snaplist != NULL) {
761 free(*snaplist, M_UFSMNT);
762 *snaplist = NULL;
763 }
764
765 return error;
766}
767
768/*
769 * Copy allocation information from all the snapshots in this snapshot and
770 * then expunge them from its view. Also, collect the list of allocated
771 * blocks in i_snapblklist.
772 */
773static int
774snapshot_expunge_snap(struct mount *mp, struct vnode *vp,
775 struct fs *copy_fs, daddr_t snaplistsize)
776{
777 int error = 0, i;
778 daddr_t numblks, *snaplist = NULL;
779 struct fs *fs = VFSTOUFS(mp)->um_fs;
780 struct inode *ip = VTOI(vp), *xp;
781 struct lwp *l = curlwp;
782 struct snap_info *si = VFSTOUFS(mp)->um_snapinfo;
783
784 TAILQ_FOREACH(xp, &si->si_snapshots, i_nextsnap) {
785 if (xp != ip) {
786 error = expunge(vp, xp, fs, snapacct, BLK_SNAP);
787 if (error)
788 break;
789 }
790 if (xp->i_nlink != 0)
791 continue;
792 error = UFS_WAPBL_BEGIN(mp);
793 if (error)
794 break;
795 error = ffs_freefile_snap(copy_fs, vp, xp->i_number, xp->i_mode);
796 UFS_WAPBL_END(mp);
797 if (error)
798 break;
799 }
800 if (error)
801 goto out;
802 /*
803 * Allocate space for the full list of preallocated snapshot blocks.
804 */
805 snaplist = malloc(snaplistsize * sizeof(daddr_t), M_UFSMNT, M_WAITOK);
806 ip->i_snapblklist = &snaplist[1];
807 /*
808 * Expunge the blocks used by the snapshots from the set of
809 * blocks marked as used in the snapshot bitmaps. Also, collect
810 * the list of allocated blocks in i_snapblklist.
811 */
812 error = expunge(vp, ip, copy_fs, mapacct, BLK_SNAP);
813 if (error)
814 goto out;
815 if (snaplistsize < ip->i_snapblklist - snaplist)
816 panic("ffs_snapshot: list too small");
817 snaplistsize = ip->i_snapblklist - snaplist;
818 snaplist[0] = snaplistsize;
819 ip->i_snapblklist = &snaplist[0];
820 /*
821 * Write out the list of allocated blocks to the end of the snapshot.
822 */
823 numblks = howmany(fs->fs_size, fs->fs_frag);
824 for (i = 0; i < snaplistsize; i++)
825 snaplist[i] = ufs_rw64(snaplist[i], UFS_FSNEEDSWAP(fs));
826 error = vn_rdwr(UIO_WRITE, vp, (void *)snaplist,
827 snaplistsize * sizeof(daddr_t), ffs_lblktosize(fs, (off_t)numblks),
828 UIO_SYSSPACE, IO_NODELOCKED | IO_UNIT, l->l_cred, NULL, NULL);
829 for (i = 0; i < snaplistsize; i++)
830 snaplist[i] = ufs_rw64(snaplist[i], UFS_FSNEEDSWAP(fs));
831out:
832 if (error && snaplist != NULL) {
833 free(snaplist, M_UFSMNT);
834 ip->i_snapblklist = NULL;
835 }
836 return error;
837}
838
839/*
840 * Write the superblock and its summary information to the snapshot.
841 * Make sure, the first UFS_NDADDR blocks get copied to the snapshot.
842 */
843static int
844snapshot_writefs(struct mount *mp, struct vnode *vp, void *sbbuf)
845{
846 int error, len, loc;
847 void *space;
848 daddr_t blkno;
849 struct buf *bp;
850 struct fs *copyfs, *fs = VFSTOUFS(mp)->um_fs;
851 struct inode *ip = VTOI(vp);
852 struct lwp *l = curlwp;
853
854 copyfs = (struct fs *)((char *)sbbuf + ffs_blkoff(fs, fs->fs_sblockloc));
855
856 /*
857 * Write the superblock and its summary information
858 * to the snapshot.
859 */
860 blkno = ffs_fragstoblks(fs, fs->fs_csaddr);
861 len = howmany(fs->fs_cssize, fs->fs_bsize);
862 space = copyfs->fs_csp;
863#ifdef FFS_EI
864 if (UFS_FSNEEDSWAP(fs)) {
865 ffs_sb_swap(copyfs, copyfs);
866 ffs_csum_swap(space, space, fs->fs_cssize);
867 }
868#endif
869 error = UFS_WAPBL_BEGIN(mp);
870 if (error)
871 return error;
872 for (loc = 0; loc < len; loc++) {
873 error = bread(vp, blkno + loc, fs->fs_bsize,
874 B_MODIFY, &bp);
875 if (error) {
876 break;
877 }
878 memcpy(bp->b_data, space, fs->fs_bsize);
879 space = (char *)space + fs->fs_bsize;
880 bawrite(bp);
881 }
882 if (error)
883 goto out;
884 error = bread(vp, ffs_lblkno(fs, fs->fs_sblockloc),
885 fs->fs_bsize, B_MODIFY, &bp);
886 if (error) {
887 goto out;
888 } else {
889 memcpy(bp->b_data, sbbuf, fs->fs_bsize);
890 bawrite(bp);
891 }
892 /*
893 * Copy the first UFS_NDADDR blocks to the snapshot so
894 * ffs_copyonwrite() and ffs_snapblkfree() will always work on
895 * indirect blocks.
896 */
897 for (loc = 0; loc < UFS_NDADDR; loc++) {
898 if (db_get(ip, loc) != 0)
899 continue;
900 error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)loc),
901 fs->fs_bsize, l->l_cred, 0, &bp);
902 if (error)
903 break;
904 error = rwfsblk(vp, B_READ, bp->b_data, loc);
905 if (error) {
906 brelse(bp, 0);
907 break;
908 }
909 bawrite(bp);
910 }
911
912out:
913 UFS_WAPBL_END(mp);
914 return error;
915}
916
917/*
918 * Copy all cylinder group maps.
919 */
920static int
921cgaccount(struct vnode *vp, int passno, int *redo)
922{
923 int cg, error = 0;
924 struct buf *nbp;
925 struct fs *fs = VTOI(vp)->i_fs;
926
927 if (redo != NULL)
928 *redo = 0;
929 if (passno == 1)
930 fs->fs_active = malloc(howmany(fs->fs_ncg, NBBY),
931 M_DEVBUF, M_WAITOK | M_ZERO);
932 for (cg = 0; cg < fs->fs_ncg; cg++) {
933 if (passno == 2 && ACTIVECG_ISSET(fs, cg))
934 continue;
935
936 if (redo != NULL)
937 *redo += 1;
938 error = UFS_WAPBL_BEGIN(vp->v_mount);
939 if (error)
940 return error;
941 error = ffs_balloc(vp, ffs_lfragtosize(fs, cgtod(fs, cg)),
942 fs->fs_bsize, curlwp->l_cred, 0, &nbp);
943 if (error) {
944 UFS_WAPBL_END(vp->v_mount);
945 break;
946 }
947 error = cgaccount1(cg, vp, nbp->b_data, passno);
948 bawrite(nbp);
949 UFS_WAPBL_END(vp->v_mount);
950 if (error)
951 break;
952 }
953 return error;
954}
955
956/*
957 * Copy a cylinder group map. All the unallocated blocks are marked
958 * BLK_NOCOPY so that the snapshot knows that it need not copy them
959 * if they are later written. If passno is one, then this is a first
960 * pass, so only setting needs to be done. If passno is 2, then this
961 * is a revision to a previous pass which must be undone as the
962 * replacement pass is done.
963 */
964static int
965cgaccount1(int cg, struct vnode *vp, void *data, int passno)
966{
967 struct buf *bp, *ibp;
968 struct inode *ip;
969 struct cg *cgp;
970 struct fs *fs;
971 struct lwp *l = curlwp;
972 daddr_t base, numblks;
973 int error, len, loc, ns __unused, indiroff;
974
975 ip = VTOI(vp);
976 fs = ip->i_fs;
977 ns = UFS_FSNEEDSWAP(fs);
978 error = bread(ip->i_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),
979 (int)fs->fs_cgsize, 0, &bp);
980 if (error) {
981 return (error);
982 }
983 cgp = (struct cg *)bp->b_data;
984 if (!cg_chkmagic(cgp, ns)) {
985 brelse(bp, 0);
986 return (EIO);
987 }
988 ACTIVECG_SET(fs, cg);
989
990 memcpy(data, bp->b_data, fs->fs_cgsize);
991 brelse(bp, 0);
992 if (fs->fs_cgsize < fs->fs_bsize)
993 memset((char *)data + fs->fs_cgsize, 0,
994 fs->fs_bsize - fs->fs_cgsize);
995 numblks = howmany(fs->fs_size, fs->fs_frag);
996 len = howmany(fs->fs_fpg, fs->fs_frag);
997 base = cg * fs->fs_fpg / fs->fs_frag;
998 if (base + len >= numblks)
999 len = numblks - base - 1;
1000 loc = 0;
1001 if (base < UFS_NDADDR) {
1002 for ( ; loc < UFS_NDADDR; loc++) {
1003 if (ffs_isblock(fs, cg_blksfree(cgp, ns), loc))
1004 db_assign(ip, loc, BLK_NOCOPY);
1005 else if (db_get(ip, loc) == BLK_NOCOPY) {
1006 if (passno == 2)
1007 db_assign(ip, loc, 0);
1008 else if (passno == 1)
1009 panic("ffs_snapshot: lost direct block");
1010 }
1011 }
1012 }
1013 if ((error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)(base + loc)),
1014 fs->fs_bsize, l->l_cred, B_METAONLY, &ibp)) != 0)
1015 return (error);
1016 indiroff = (base + loc - UFS_NDADDR) % FFS_NINDIR(fs);
1017 for ( ; loc < len; loc++, indiroff++) {
1018 if (indiroff >= FFS_NINDIR(fs)) {
1019 bawrite(ibp);
1020 if ((error = ffs_balloc(vp,
1021 ffs_lblktosize(fs, (off_t)(base + loc)),
1022 fs->fs_bsize, l->l_cred, B_METAONLY, &ibp)) != 0)
1023 return (error);
1024 indiroff = 0;
1025 }
1026 if (ffs_isblock(fs, cg_blksfree(cgp, ns), loc))
1027 idb_assign(ip, ibp->b_data, indiroff, BLK_NOCOPY);
1028 else if (idb_get(ip, ibp->b_data, indiroff) == BLK_NOCOPY) {
1029 if (passno == 2)
1030 idb_assign(ip, ibp->b_data, indiroff, 0);
1031 else if (passno == 1)
1032 panic("ffs_snapshot: lost indirect block");
1033 }
1034 }
1035 bdwrite(ibp);
1036 return (0);
1037}
1038
1039/*
1040 * Before expunging a snapshot inode, note all the
1041 * blocks that it claims with BLK_SNAP so that fsck will
1042 * be able to account for those blocks properly and so
1043 * that this snapshot knows that it need not copy them
1044 * if the other snapshot holding them is freed.
1045 */
1046static int
1047expunge(struct vnode *snapvp, struct inode *cancelip, struct fs *fs,
1048 acctfunc_t acctfunc, int expungetype)
1049{
1050 int i, error, ns __unused;
1051 daddr_t lbn, rlbn;
1052 daddr_t len, blkno, numblks, blksperindir;
1053 struct ufs1_dinode *dip1;
1054 struct ufs2_dinode *dip2;
1055 struct lwp *l = curlwp;
1056 void *bap;
1057 struct buf *bp;
1058 struct mount *mp;
1059
1060 ns = UFS_FSNEEDSWAP(fs);
1061 mp = snapvp->v_mount;
1062
1063 error = UFS_WAPBL_BEGIN(mp);
1064 if (error)
1065 return error;
1066 /*
1067 * Prepare to expunge the inode. If its inode block has not
1068 * yet been copied, then allocate and fill the copy.
1069 */
1070 lbn = ffs_fragstoblks(fs, ino_to_fsba(fs, cancelip->i_number));
1071 error = snapblkaddr(snapvp, lbn, &blkno);
1072 if (error)
1073 return error;
1074 if (blkno != 0) {
1075 error = bread(snapvp, lbn, fs->fs_bsize,
1076 B_MODIFY, &bp);
1077 } else {
1078 error = ffs_balloc(snapvp, ffs_lblktosize(fs, (off_t)lbn),
1079 fs->fs_bsize, l->l_cred, 0, &bp);
1080 if (! error)
1081 error = rwfsblk(snapvp, B_READ, bp->b_data, lbn);
1082 }
1083 if (error) {
1084 UFS_WAPBL_END(mp);
1085 return error;
1086 }
1087 /*
1088 * Set a snapshot inode to be a zero length file, regular files
1089 * or unlinked snapshots to be completely unallocated.
1090 */
1091 if (fs->fs_magic == FS_UFS1_MAGIC) {
1092 dip1 = (struct ufs1_dinode *)bp->b_data +
1093 ino_to_fsbo(fs, cancelip->i_number);
1094 if (cancelip->i_flags & SF_SNAPSHOT) {
1095 dip1->di_flags =
1096 ufs_rw32(ufs_rw32(dip1->di_flags, ns) |
1097 SF_SNAPINVAL, ns);
1098 }
1099 if (expungetype == BLK_NOCOPY || cancelip->i_nlink == 0)
1100 dip1->di_mode = 0;
1101 dip1->di_size = 0;
1102 dip1->di_blocks = 0;
1103 memset(&dip1->di_db[0], 0, (UFS_NDADDR + UFS_NIADDR) * sizeof(int32_t));
1104 } else {
1105 dip2 = (struct ufs2_dinode *)bp->b_data +
1106 ino_to_fsbo(fs, cancelip->i_number);
1107 if (cancelip->i_flags & SF_SNAPSHOT) {
1108 dip2->di_flags =
1109 ufs_rw32(ufs_rw32(dip2->di_flags, ns) |
1110 SF_SNAPINVAL, ns);
1111 }
1112 if (expungetype == BLK_NOCOPY || cancelip->i_nlink == 0)
1113 dip2->di_mode = 0;
1114 dip2->di_size = 0;
1115 dip2->di_blocks = 0;
1116 memset(&dip2->di_db[0], 0, (UFS_NDADDR + UFS_NIADDR) * sizeof(int64_t));
1117 }
1118 bdwrite(bp);
1119 UFS_WAPBL_END(mp);
1120 /*
1121 * Now go through and expunge all the blocks in the file
1122 * using the function requested.
1123 */
1124 numblks = howmany(cancelip->i_size, fs->fs_bsize);
1125 if (fs->fs_magic == FS_UFS1_MAGIC)
1126 bap = &cancelip->i_ffs1_db[0];
1127 else
1128 bap = &cancelip->i_ffs2_db[0];
1129 error = (*acctfunc)(snapvp, bap, 0, UFS_NDADDR, fs, 0, expungetype);
1130 if (error)
1131 return (error);
1132 if (fs->fs_magic == FS_UFS1_MAGIC)
1133 bap = &cancelip->i_ffs1_ib[0];
1134 else
1135 bap = &cancelip->i_ffs2_ib[0];
1136 error = (*acctfunc)(snapvp, bap, 0, UFS_NIADDR, fs, -1, expungetype);
1137 if (error)
1138 return (error);
1139 blksperindir = 1;
1140 lbn = -UFS_NDADDR;
1141 len = numblks - UFS_NDADDR;
1142 rlbn = UFS_NDADDR;
1143 for (i = 0; len > 0 && i < UFS_NIADDR; i++) {
1144 error = indiracct(snapvp, ITOV(cancelip), i,
1145 ib_get(cancelip, i), lbn, rlbn, len,
1146 blksperindir, fs, acctfunc, expungetype);
1147 if (error)
1148 return (error);
1149 blksperindir *= FFS_NINDIR(fs);
1150 lbn -= blksperindir + 1;
1151 len -= blksperindir;
1152 rlbn += blksperindir;
1153 }
1154 return (0);
1155}
1156
1157/*
1158 * Descend an indirect block chain for vnode cancelvp accounting for all
1159 * its indirect blocks in snapvp.
1160 */
1161static int
1162indiracct(struct vnode *snapvp, struct vnode *cancelvp, int level,
1163 daddr_t blkno, daddr_t lbn, daddr_t rlbn, daddr_t remblks,
1164 daddr_t blksperindir, struct fs *fs, acctfunc_t acctfunc, int expungetype)
1165{
1166 int error, num, i;
1167 daddr_t subblksperindir;
1168 struct indir indirs[UFS_NIADDR + 2];
1169 daddr_t last;
1170 void *bap;
1171 struct buf *bp;
1172
1173 if (blkno == 0) {
1174 if (expungetype == BLK_NOCOPY)
1175 return (0);
1176 panic("indiracct: missing indir");
1177 }
1178 if ((error = ufs_getlbns(cancelvp, rlbn, indirs, &num)) != 0)
1179 return (error);
1180 if (lbn != indirs[num - 1 - level].in_lbn || num < 2)
1181 panic("indiracct: botched params");
1182 /*
1183 * We have to expand bread here since it will deadlock looking
1184 * up the block number for any blocks that are not in the cache.
1185 */
1186 error = ffs_getblk(cancelvp, lbn, FFS_FSBTODB(fs, blkno), fs->fs_bsize,
1187 false, &bp);
1188 if (error)
1189 return error;
1190 if ((bp->b_oflags & (BO_DONE | BO_DELWRI)) == 0 && (error =
1191 rwfsblk(bp->b_vp, B_READ, bp->b_data, ffs_fragstoblks(fs, blkno)))) {
1192 brelse(bp, 0);
1193 return (error);
1194 }
1195 /*
1196 * Account for the block pointers in this indirect block.
1197 */
1198 last = howmany(remblks, blksperindir);
1199 if (last > FFS_NINDIR(fs))
1200 last = FFS_NINDIR(fs);
1201 bap = malloc(fs->fs_bsize, M_DEVBUF, M_WAITOK | M_ZERO);
1202 memcpy((void *)bap, bp->b_data, fs->fs_bsize);
1203 brelse(bp, 0);
1204 error = (*acctfunc)(snapvp, bap, 0, last,
1205 fs, level == 0 ? rlbn : -1, expungetype);
1206 if (error || level == 0)
1207 goto out;
1208 /*
1209 * Account for the block pointers in each of the indirect blocks
1210 * in the levels below us.
1211 */
1212 subblksperindir = blksperindir / FFS_NINDIR(fs);
1213 for (lbn++, level--, i = 0; i < last; i++) {
1214 error = indiracct(snapvp, cancelvp, level,
1215 idb_get(VTOI(snapvp), bap, i), lbn, rlbn, remblks,
1216 subblksperindir, fs, acctfunc, expungetype);
1217 if (error)
1218 goto out;
1219 rlbn += blksperindir;
1220 lbn -= blksperindir;
1221 remblks -= blksperindir;
1222 }
1223out:
1224 free(bap, M_DEVBUF);
1225 return (error);
1226}
1227
1228/*
1229 * Do both snap accounting and map accounting.
1230 */
1231static int
1232fullacct(struct vnode *vp, void *bap, int oldblkp, int lastblkp,
1233 struct fs *fs, daddr_t lblkno,
1234 int exptype /* BLK_SNAP or BLK_NOCOPY */)
1235{
1236 int error;
1237
1238 if ((error = snapacct(vp, bap, oldblkp, lastblkp, fs, lblkno, exptype)))
1239 return (error);
1240 return (mapacct(vp, bap, oldblkp, lastblkp, fs, lblkno, exptype));
1241}
1242
1243/*
1244 * Identify a set of blocks allocated in a snapshot inode.
1245 */
1246static int
1247snapacct(struct vnode *vp, void *bap, int oldblkp, int lastblkp,
1248 struct fs *fs, daddr_t lblkno,
1249 int expungetype /* BLK_SNAP or BLK_NOCOPY */)
1250{
1251 struct inode *ip = VTOI(vp);
1252 struct lwp *l = curlwp;
1253 struct mount *mp = vp->v_mount;
1254 daddr_t blkno;
1255 daddr_t lbn;
1256 struct buf *ibp;
1257 int error, n;
1258 const int wbreak = blocks_in_journal(VFSTOUFS(mp)->um_fs)/8;
1259
1260 error = UFS_WAPBL_BEGIN(mp);
1261 if (error)
1262 return error;
1263 for ( n = 0; oldblkp < lastblkp; oldblkp++) {
1264 blkno = idb_get(ip, bap, oldblkp);
1265 if (blkno == 0 || blkno == BLK_NOCOPY || blkno == BLK_SNAP)
1266 continue;
1267 lbn = ffs_fragstoblks(fs, blkno);
1268 if (lbn < UFS_NDADDR) {
1269 blkno = db_get(ip, lbn);
1270 ip->i_flag |= IN_CHANGE | IN_UPDATE;
1271 } else {
1272 error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)lbn),
1273 fs->fs_bsize, l->l_cred, B_METAONLY, &ibp);
1274 if (error)
1275 break;
1276 blkno = idb_get(ip, ibp->b_data,
1277 (lbn - UFS_NDADDR) % FFS_NINDIR(fs));
1278 }
1279 /*
1280 * If we are expunging a snapshot vnode and we
1281 * find a block marked BLK_NOCOPY, then it is
1282 * one that has been allocated to this snapshot after
1283 * we took our current snapshot and can be ignored.
1284 */
1285 if (expungetype == BLK_SNAP && blkno == BLK_NOCOPY) {
1286 if (lbn >= UFS_NDADDR)
1287 brelse(ibp, 0);
1288 } else {
1289 if (blkno != 0)
1290 panic("snapacct: bad block");
1291 if (lbn < UFS_NDADDR)
1292 db_assign(ip, lbn, expungetype);
1293 else {
1294 idb_assign(ip, ibp->b_data,
1295 (lbn - UFS_NDADDR) % FFS_NINDIR(fs), expungetype);
1296 bdwrite(ibp);
1297 }
1298 }
1299 if (wbreak > 0 && (++n % wbreak) == 0) {
1300 UFS_WAPBL_END(mp);
1301 error = UFS_WAPBL_BEGIN(mp);
1302 if (error)
1303 return error;
1304 }
1305 }
1306 UFS_WAPBL_END(mp);
1307 return error;
1308}
1309
1310/*
1311 * Account for a set of blocks allocated in a snapshot inode.
1312 */
1313static int
1314mapacct(struct vnode *vp, void *bap, int oldblkp, int lastblkp,
1315 struct fs *fs, daddr_t lblkno, int expungetype)
1316{
1317 daddr_t blkno;
1318 struct inode *ip;
1319 struct mount *mp = vp->v_mount;
1320 ino_t inum;
1321 int acctit, error, n;
1322 const int wbreak = blocks_in_journal(VFSTOUFS(mp)->um_fs)/8;
1323
1324 error = UFS_WAPBL_BEGIN(mp);
1325 if (error)
1326 return error;
1327 ip = VTOI(vp);
1328 inum = ip->i_number;
1329 if (lblkno == -1)
1330 acctit = 0;
1331 else
1332 acctit = 1;
1333 for ( n = 0; oldblkp < lastblkp; oldblkp++, lblkno++) {
1334 blkno = idb_get(ip, bap, oldblkp);
1335 if (blkno == 0 || blkno == BLK_NOCOPY)
1336 continue;
1337 if (acctit && expungetype == BLK_SNAP && blkno != BLK_SNAP)
1338 *ip->i_snapblklist++ = lblkno;
1339 if (blkno == BLK_SNAP)
1340 blkno = ffs_blkstofrags(fs, lblkno);
1341 ffs_blkfree_snap(fs, vp, blkno, fs->fs_bsize, inum);
1342 if (wbreak > 0 && (++n % wbreak) == 0) {
1343 UFS_WAPBL_END(mp);
1344 error = UFS_WAPBL_BEGIN(mp);
1345 if (error)
1346 return error;
1347 }
1348 }
1349 UFS_WAPBL_END(mp);
1350 return (0);
1351}
1352
1353/*
1354 * Number of blocks that fit into the journal or zero if not logging.
1355 */
1356static int
1357blocks_in_journal(struct fs *fs)
1358{
1359 off_t bpj;
1360
1361 if ((fs->fs_flags & FS_DOWAPBL) == 0)
1362 return 0;
1363 bpj = 1;
1364 if (fs->fs_journal_version == UFS_WAPBL_VERSION) {
1365 switch (fs->fs_journal_location) {
1366 case UFS_WAPBL_JOURNALLOC_END_PARTITION:
1367 bpj = (off_t)fs->fs_journallocs[UFS_WAPBL_EPART_BLKSZ]*
1368 fs->fs_journallocs[UFS_WAPBL_EPART_COUNT];
1369 break;
1370 case UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM:
1371 bpj = (off_t)fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ]*
1372 fs->fs_journallocs[UFS_WAPBL_INFS_COUNT];
1373 break;
1374 }
1375 }
1376 bpj /= fs->fs_bsize;
1377 return (bpj > 0 ? bpj : 1);
1378}
1379#endif /* defined(FFS_NO_SNAPSHOT) */
1380
1381/*
1382 * Decrement extra reference on snapshot when last name is removed.
1383 * It will not be freed until the last open reference goes away.
1384 */
1385void
1386ffs_snapgone(struct vnode *vp)
1387{
1388 struct inode *xp, *ip = VTOI(vp);
1389 struct mount *mp = spec_node_getmountedfs(ip->i_devvp);
1390 struct fs *fs;
1391 struct snap_info *si;
1392 int snaploc;
1393
1394 si = VFSTOUFS(mp)->um_snapinfo;
1395
1396 /*
1397 * Find snapshot in incore list.
1398 */
1399 mutex_enter(&si->si_lock);
1400 TAILQ_FOREACH(xp, &si->si_snapshots, i_nextsnap)
1401 if (xp == ip)
1402 break;
1403 mutex_exit(&si->si_lock);
1404 if (xp != NULL)
1405 vrele(ITOV(ip));
1406#ifdef DEBUG
1407 else if (snapdebug)
1408 printf("ffs_snapgone: lost snapshot vnode %llu\n",
1409 (unsigned long long)ip->i_number);
1410#endif
1411 /*
1412 * Delete snapshot inode from superblock. Keep list dense.
1413 */
1414 mutex_enter(&si->si_lock);
1415 fs = ip->i_fs;
1416 for (snaploc = 0; snaploc < FSMAXSNAP; snaploc++)
1417 if (fs->fs_snapinum[snaploc] == ip->i_number)
1418 break;
1419 if (snaploc < FSMAXSNAP) {
1420 for (snaploc++; snaploc < FSMAXSNAP; snaploc++) {
1421 if (fs->fs_snapinum[snaploc] == 0)
1422 break;
1423 fs->fs_snapinum[snaploc - 1] = fs->fs_snapinum[snaploc];
1424 }
1425 fs->fs_snapinum[snaploc - 1] = 0;
1426 }
1427 si->si_gen++;
1428 mutex_exit(&si->si_lock);
1429}
1430
1431/*
1432 * Prepare a snapshot file for being removed.
1433 */
1434void
1435ffs_snapremove(struct vnode *vp)
1436{
1437 struct inode *ip = VTOI(vp), *xp;
1438 struct vnode *devvp = ip->i_devvp;
1439 struct fs *fs = ip->i_fs;
1440 struct mount *mp = spec_node_getmountedfs(devvp);
1441 struct buf *ibp;
1442 struct snap_info *si;
1443 struct lwp *l = curlwp;
1444 daddr_t numblks, blkno, dblk;
1445 int error, loc, last;
1446
1447 si = VFSTOUFS(mp)->um_snapinfo;
1448 /*
1449 * If active, delete from incore list (this snapshot may
1450 * already have been in the process of being deleted, so
1451 * would not have been active).
1452 *
1453 * Clear copy-on-write flag if last snapshot.
1454 */
1455 mutex_enter(&si->si_snaplock);
1456 mutex_enter(&si->si_lock);
1457 if (is_active_snapshot(si, ip)) {
1458 TAILQ_REMOVE(&si->si_snapshots, ip, i_nextsnap);
1459 if (TAILQ_FIRST(&si->si_snapshots) != 0) {
1460 /* Roll back the list of preallocated blocks. */
1461 xp = TAILQ_LAST(&si->si_snapshots, inodelst);
1462 si->si_snapblklist = xp->i_snapblklist;
1463 si->si_gen++;
1464 mutex_exit(&si->si_lock);
1465 mutex_exit(&si->si_snaplock);
1466 } else {
1467 si->si_snapblklist = 0;
1468 si->si_gen++;
1469 mutex_exit(&si->si_lock);
1470 mutex_exit(&si->si_snaplock);
1471 fscow_disestablish(mp, ffs_copyonwrite, devvp);
1472 }
1473 if (ip->i_snapblklist != NULL) {
1474 free(ip->i_snapblklist, M_UFSMNT);
1475 ip->i_snapblklist = NULL;
1476 }
1477 } else {
1478 mutex_exit(&si->si_lock);
1479 mutex_exit(&si->si_snaplock);
1480 }
1481 /*
1482 * Clear all BLK_NOCOPY fields. Pass any block claims to other
1483 * snapshots that want them (see ffs_snapblkfree below).
1484 */
1485 for (blkno = 1; blkno < UFS_NDADDR; blkno++) {
1486 dblk = db_get(ip, blkno);
1487 if (dblk == BLK_NOCOPY || dblk == BLK_SNAP)
1488 db_assign(ip, blkno, 0);
1489 else if ((dblk == ffs_blkstofrags(fs, blkno) &&
1490 ffs_snapblkfree(fs, ip->i_devvp, dblk, fs->fs_bsize,
1491 ip->i_number))) {
1492 DIP_ADD(ip, blocks, -btodb(fs->fs_bsize));
1493 db_assign(ip, blkno, 0);
1494 }
1495 }
1496 numblks = howmany(ip->i_size, fs->fs_bsize);
1497 for (blkno = UFS_NDADDR; blkno < numblks; blkno += FFS_NINDIR(fs)) {
1498 error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)blkno),
1499 fs->fs_bsize, l->l_cred, B_METAONLY, &ibp);
1500 if (error)
1501 continue;
1502 if (fs->fs_size - blkno > FFS_NINDIR(fs))
1503 last = FFS_NINDIR(fs);
1504 else
1505 last = fs->fs_size - blkno;
1506 for (loc = 0; loc < last; loc++) {
1507 dblk = idb_get(ip, ibp->b_data, loc);
1508 if (dblk == BLK_NOCOPY || dblk == BLK_SNAP)
1509 idb_assign(ip, ibp->b_data, loc, 0);
1510 else if (dblk == ffs_blkstofrags(fs, blkno) &&
1511 ffs_snapblkfree(fs, ip->i_devvp, dblk,
1512 fs->fs_bsize, ip->i_number)) {
1513 DIP_ADD(ip, blocks, -btodb(fs->fs_bsize));
1514 idb_assign(ip, ibp->b_data, loc, 0);
1515 }
1516 }
1517 bawrite(ibp);
1518 UFS_WAPBL_END(mp);
1519 error = UFS_WAPBL_BEGIN(mp);
1520 KASSERT(error == 0);
1521 }
1522 /*
1523 * Clear snapshot flag and drop reference.
1524 */
1525 ip->i_flags &= ~(SF_SNAPSHOT | SF_SNAPINVAL);
1526 DIP_ASSIGN(ip, flags, ip->i_flags);
1527 ip->i_flag |= IN_CHANGE | IN_UPDATE;
1528#if defined(QUOTA) || defined(QUOTA2)
1529 chkdq(ip, DIP(ip, blocks), l->l_cred, FORCE);
1530 chkiq(ip, 1, l->l_cred, FORCE);
1531#endif
1532}
1533
1534/*
1535 * Notification that a block is being freed. Return zero if the free
1536 * should be allowed to proceed. Return non-zero if the snapshot file
1537 * wants to claim the block. The block will be claimed if it is an
1538 * uncopied part of one of the snapshots. It will be freed if it is
1539 * either a BLK_NOCOPY or has already been copied in all of the snapshots.
1540 * If a fragment is being freed, then all snapshots that care about
1541 * it must make a copy since a snapshot file can only claim full sized
1542 * blocks. Note that if more than one snapshot file maps the block,
1543 * we can pick one at random to claim it. Since none of the snapshots
1544 * can change, we are assurred that they will all see the same unmodified
1545 * image. When deleting a snapshot file (see ffs_snapremove above), we
1546 * must push any of these claimed blocks to one of the other snapshots
1547 * that maps it. These claimed blocks are easily identified as they will
1548 * have a block number equal to their logical block number within the
1549 * snapshot. A copied block can never have this property because they
1550 * must always have been allocated from a BLK_NOCOPY location.
1551 */
1552int
1553ffs_snapblkfree(struct fs *fs, struct vnode *devvp, daddr_t bno,
1554 long size, ino_t inum)
1555{
1556 struct mount *mp = spec_node_getmountedfs(devvp);
1557 struct buf *ibp;
1558 struct inode *ip;
1559 struct vnode *vp = NULL;
1560 struct snap_info *si;
1561 void *saved_data = NULL;
1562 daddr_t lbn;
1563 daddr_t blkno;
1564 uint32_t gen;
1565 int indiroff = 0, error = 0, claimedblk = 0;
1566
1567 si = VFSTOUFS(mp)->um_snapinfo;
1568 lbn = ffs_fragstoblks(fs, bno);
1569 mutex_enter(&si->si_snaplock);
1570 mutex_enter(&si->si_lock);
1571 si->si_owner = curlwp;
1572
1573retry:
1574 gen = si->si_gen;
1575 TAILQ_FOREACH(ip, &si->si_snapshots, i_nextsnap) {
1576 vp = ITOV(ip);
1577 /*
1578 * Lookup block being written.
1579 */
1580 if (lbn < UFS_NDADDR) {
1581 blkno = db_get(ip, lbn);
1582 } else {
1583 mutex_exit(&si->si_lock);
1584 error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)lbn),
1585 fs->fs_bsize, FSCRED, B_METAONLY, &ibp);
1586 if (error) {
1587 mutex_enter(&si->si_lock);
1588 break;
1589 }
1590 indiroff = (lbn - UFS_NDADDR) % FFS_NINDIR(fs);
1591 blkno = idb_get(ip, ibp->b_data, indiroff);
1592 mutex_enter(&si->si_lock);
1593 if (gen != si->si_gen) {
1594 brelse(ibp, 0);
1595 goto retry;
1596 }
1597 }
1598 /*
1599 * Check to see if block needs to be copied.
1600 */
1601 if (blkno == 0) {
1602 /*
1603 * A block that we map is being freed. If it has not
1604 * been claimed yet, we will claim or copy it (below).
1605 */
1606 claimedblk = 1;
1607 } else if (blkno == BLK_SNAP) {
1608 /*
1609 * No previous snapshot claimed the block,
1610 * so it will be freed and become a BLK_NOCOPY
1611 * (don't care) for us.
1612 */
1613 if (claimedblk)
1614 panic("snapblkfree: inconsistent block type");
1615 if (lbn < UFS_NDADDR) {
1616 db_assign(ip, lbn, BLK_NOCOPY);
1617 ip->i_flag |= IN_CHANGE | IN_UPDATE;
1618 } else {
1619 idb_assign(ip, ibp->b_data, indiroff,
1620 BLK_NOCOPY);
1621 mutex_exit(&si->si_lock);
1622 if (ip->i_nlink > 0)
1623 bwrite(ibp);
1624 else
1625 bdwrite(ibp);
1626 mutex_enter(&si->si_lock);
1627 if (gen != si->si_gen)
1628 goto retry;
1629 }
1630 continue;
1631 } else /* BLK_NOCOPY or default */ {
1632 /*
1633 * If the snapshot has already copied the block
1634 * (default), or does not care about the block,
1635 * it is not needed.
1636 */
1637 if (lbn >= UFS_NDADDR)
1638 brelse(ibp, 0);
1639 continue;
1640 }
1641 /*
1642 * If this is a full size block, we will just grab it
1643 * and assign it to the snapshot inode. Otherwise we
1644 * will proceed to copy it. See explanation for this
1645 * routine as to why only a single snapshot needs to
1646 * claim this block.
1647 */
1648 if (size == fs->fs_bsize) {
1649#ifdef DEBUG
1650 if (snapdebug)
1651 printf("%s %llu lbn %" PRId64
1652 "from inum %llu\n",
1653 "Grabonremove: snapino",
1654 (unsigned long long)ip->i_number,
1655 lbn, (unsigned long long)inum);
1656#endif
1657 mutex_exit(&si->si_lock);
1658 if (lbn < UFS_NDADDR) {
1659 db_assign(ip, lbn, bno);
1660 } else {
1661 idb_assign(ip, ibp->b_data, indiroff, bno);
1662 if (ip->i_nlink > 0)
1663 bwrite(ibp);
1664 else
1665 bdwrite(ibp);
1666 }
1667 DIP_ADD(ip, blocks, btodb(size));
1668 ip->i_flag |= IN_CHANGE | IN_UPDATE;
1669 if (ip->i_nlink > 0 && mp->mnt_wapbl)
1670 error = syncsnap(vp);
1671 else
1672 error = 0;
1673 mutex_enter(&si->si_lock);
1674 si->si_owner = NULL;
1675 mutex_exit(&si->si_lock);
1676 mutex_exit(&si->si_snaplock);
1677 return (error == 0);
1678 }
1679 if (lbn >= UFS_NDADDR)
1680 brelse(ibp, 0);
1681#ifdef DEBUG
1682 if (snapdebug)
1683 printf("%s%llu lbn %" PRId64 " %s %llu size %ld\n",
1684 "Copyonremove: snapino ",
1685 (unsigned long long)ip->i_number,
1686 lbn, "for inum", (unsigned long long)inum, size);
1687#endif
1688 /*
1689 * If we have already read the old block contents, then
1690 * simply copy them to the new block. Note that we need
1691 * to synchronously write snapshots that have not been
1692 * unlinked, and hence will be visible after a crash,
1693 * to ensure their integrity.
1694 */
1695 mutex_exit(&si->si_lock);
1696 if (saved_data == NULL) {
1697 saved_data = malloc(fs->fs_bsize, M_UFSMNT, M_WAITOK);
1698 error = rwfsblk(vp, B_READ, saved_data, lbn);
1699 if (error) {
1700 free(saved_data, M_UFSMNT);
1701 saved_data = NULL;
1702 mutex_enter(&si->si_lock);
1703 break;
1704 }
1705 }
1706 error = wrsnapblk(vp, saved_data, lbn);
1707 if (error == 0 && ip->i_nlink > 0 && mp->mnt_wapbl)
1708 error = syncsnap(vp);
1709 mutex_enter(&si->si_lock);
1710 if (error)
1711 break;
1712 if (gen != si->si_gen)
1713 goto retry;
1714 }
1715 si->si_owner = NULL;
1716 mutex_exit(&si->si_lock);
1717 mutex_exit(&si->si_snaplock);
1718 if (saved_data)
1719 free(saved_data, M_UFSMNT);
1720 /*
1721 * If we have been unable to allocate a block in which to do
1722 * the copy, then return non-zero so that the fragment will
1723 * not be freed. Although space will be lost, the snapshot
1724 * will stay consistent.
1725 */
1726 return (error);
1727}
1728
1729/*
1730 * Associate snapshot files when mounting.
1731 */
1732void
1733ffs_snapshot_mount(struct mount *mp)
1734{
1735 struct vnode *devvp = VFSTOUFS(mp)->um_devvp;
1736 struct fs *fs = VFSTOUFS(mp)->um_fs;
1737 struct lwp *l = curlwp;
1738 struct vnode *vp;
1739 struct inode *ip, *xp;
1740 struct snap_info *si;
1741 daddr_t snaplistsize, *snapblklist;
1742 int i, error, ns __unused, snaploc, loc;
1743
1744 /*
1745 * No persistent snapshots on apple ufs file systems.
1746 */
1747 if (UFS_MPISAPPLEUFS(VFSTOUFS(mp)))
1748 return;
1749
1750 si = VFSTOUFS(mp)->um_snapinfo;
1751 ns = UFS_FSNEEDSWAP(fs);
1752 /*
1753 * XXX The following needs to be set before ffs_truncate or
1754 * VOP_READ can be called.
1755 */
1756 mp->mnt_stat.f_iosize = fs->fs_bsize;
1757 /*
1758 * Process each snapshot listed in the superblock.
1759 */
1760 vp = NULL;
1761 mutex_enter(&si->si_lock);
1762 for (snaploc = 0; snaploc < FSMAXSNAP; snaploc++) {
1763 if (fs->fs_snapinum[snaploc] == 0)
1764 break;
1765 if ((error = VFS_VGET(mp, fs->fs_snapinum[snaploc],
1766 &vp)) != 0) {
1767 printf("ffs_snapshot_mount: vget failed %d\n", error);
1768 continue;
1769 }
1770 ip = VTOI(vp);
1771 if ((ip->i_flags & (SF_SNAPSHOT | SF_SNAPINVAL)) !=
1772 SF_SNAPSHOT) {
1773 printf("ffs_snapshot_mount: non-snapshot inode %d\n",
1774 fs->fs_snapinum[snaploc]);
1775 vput(vp);
1776 vp = NULL;
1777 for (loc = snaploc + 1; loc < FSMAXSNAP; loc++) {
1778 if (fs->fs_snapinum[loc] == 0)
1779 break;
1780 fs->fs_snapinum[loc - 1] = fs->fs_snapinum[loc];
1781 }
1782 fs->fs_snapinum[loc - 1] = 0;
1783 snaploc--;
1784 continue;
1785 }
1786
1787 /*
1788 * Read the block hints list. Use an empty list on
1789 * read errors.
1790 */
1791 error = vn_rdwr(UIO_READ, vp,
1792 (void *)&snaplistsize, sizeof(snaplistsize),
1793 ffs_lblktosize(fs, howmany(fs->fs_size, fs->fs_frag)),
1794 UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT|IO_ALTSEMANTICS,
1795 l->l_cred, NULL, NULL);
1796 if (error) {
1797 printf("ffs_snapshot_mount: read_1 failed %d\n", error);
1798 snaplistsize = 1;
1799 } else
1800 snaplistsize = ufs_rw64(snaplistsize, ns);
1801 snapblklist = malloc(
1802 snaplistsize * sizeof(daddr_t), M_UFSMNT, M_WAITOK);
1803 if (error)
1804 snapblklist[0] = 1;
1805 else {
1806 error = vn_rdwr(UIO_READ, vp, (void *)snapblklist,
1807 snaplistsize * sizeof(daddr_t),
1808 ffs_lblktosize(fs, howmany(fs->fs_size, fs->fs_frag)),
1809 UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT|IO_ALTSEMANTICS,
1810 l->l_cred, NULL, NULL);
1811 for (i = 0; i < snaplistsize; i++)
1812 snapblklist[i] = ufs_rw64(snapblklist[i], ns);
1813 if (error) {
1814 printf("ffs_snapshot_mount: read_2 failed %d\n",
1815 error);
1816 snapblklist[0] = 1;
1817 }
1818 }
1819 ip->i_snapblklist = &snapblklist[0];
1820
1821 /*
1822 * Link it onto the active snapshot list.
1823 */
1824 if (is_active_snapshot(si, ip))
1825 panic("ffs_snapshot_mount: %"PRIu64" already on list",
1826 ip->i_number);
1827 else
1828 TAILQ_INSERT_TAIL(&si->si_snapshots, ip, i_nextsnap);
1829 vp->v_vflag |= VV_SYSTEM;
1830 VOP_UNLOCK(vp);
1831 }
1832 /*
1833 * No usable snapshots found.
1834 */
1835 if (vp == NULL) {
1836 mutex_exit(&si->si_lock);
1837 return;
1838 }
1839 /*
1840 * Attach the block hints list. We always want to
1841 * use the list from the newest snapshot.
1842 */
1843 xp = TAILQ_LAST(&si->si_snapshots, inodelst);
1844 si->si_snapblklist = xp->i_snapblklist;
1845 fscow_establish(mp, ffs_copyonwrite, devvp);
1846 si->si_gen++;
1847 mutex_exit(&si->si_lock);
1848}
1849
1850/*
1851 * Disassociate snapshot files when unmounting.
1852 */
1853void
1854ffs_snapshot_unmount(struct mount *mp)
1855{
1856 struct vnode *devvp = VFSTOUFS(mp)->um_devvp;
1857 struct inode *xp;
1858 struct vnode *vp = NULL;
1859 struct snap_info *si;
1860
1861 si = VFSTOUFS(mp)->um_snapinfo;
1862 mutex_enter(&si->si_lock);
1863 while ((xp = TAILQ_FIRST(&si->si_snapshots)) != 0) {
1864 vp = ITOV(xp);
1865 TAILQ_REMOVE(&si->si_snapshots, xp, i_nextsnap);
1866 if (xp->i_snapblklist == si->si_snapblklist)
1867 si->si_snapblklist = NULL;
1868 free(xp->i_snapblklist, M_UFSMNT);
1869 if (xp->i_nlink > 0) {
1870 si->si_gen++;
1871 mutex_exit(&si->si_lock);
1872 vrele(vp);
1873 mutex_enter(&si->si_lock);
1874 }
1875 }
1876 si->si_gen++;
1877 mutex_exit(&si->si_lock);
1878 if (vp)
1879 fscow_disestablish(mp, ffs_copyonwrite, devvp);
1880}
1881
1882/*
1883 * Check for need to copy block that is about to be written,
1884 * copying the block if necessary.
1885 */
1886static int
1887ffs_copyonwrite(void *v, struct buf *bp, bool data_valid)
1888{
1889 struct fs *fs;
1890 struct inode *ip;
1891 struct vnode *devvp = v, *vp = NULL;
1892 struct mount *mp = spec_node_getmountedfs(devvp);
1893 struct snap_info *si;
1894 void *saved_data = NULL;
1895 daddr_t lbn, blkno, *snapblklist;
1896 uint32_t gen;
1897 int lower, upper, mid, snapshot_locked = 0, error = 0;
1898
1899 /*
1900 * Check for valid snapshots.
1901 */
1902 si = VFSTOUFS(mp)->um_snapinfo;
1903 mutex_enter(&si->si_lock);
1904 ip = TAILQ_FIRST(&si->si_snapshots);
1905 if (ip == NULL) {
1906 mutex_exit(&si->si_lock);
1907 return 0;
1908 }
1909 /*
1910 * First check to see if it is after the file system,
1911 * in the journal or in the preallocated list.
1912 * By doing these checks we avoid several potential deadlocks.
1913 */
1914 fs = ip->i_fs;
1915 lbn = ffs_fragstoblks(fs, FFS_DBTOFSB(fs, bp->b_blkno));
1916 if (bp->b_blkno >= FFS_FSBTODB(fs, fs->fs_size)) {
1917 mutex_exit(&si->si_lock);
1918 return 0;
1919 }
1920 if ((fs->fs_flags & FS_DOWAPBL) &&
1921 fs->fs_journal_location == UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM) {
1922 off_t blk_off, log_start, log_end;
1923
1924 log_start = (off_t)fs->fs_journallocs[UFS_WAPBL_INFS_ADDR] *
1925 fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ];
1926 log_end = log_start + fs->fs_journallocs[UFS_WAPBL_INFS_COUNT] *
1927 fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ];
1928 blk_off = dbtob(bp->b_blkno);
1929 if (blk_off >= log_start && blk_off < log_end) {
1930 mutex_exit(&si->si_lock);
1931 return 0;
1932 }
1933 }
1934 snapblklist = si->si_snapblklist;
1935 upper = (snapblklist != NULL ? snapblklist[0] - 1 : 0);
1936 lower = 1;
1937 while (lower <= upper) {
1938 mid = (lower + upper) / 2;
1939 if (snapblklist[mid] == lbn)
1940 break;
1941 if (snapblklist[mid] < lbn)
1942 lower = mid + 1;
1943 else
1944 upper = mid - 1;
1945 }
1946 if (lower <= upper) {
1947 mutex_exit(&si->si_lock);
1948 return 0;
1949 }
1950 /*
1951 * Not in the precomputed list, so check the snapshots.
1952 */
1953 if (si->si_owner != curlwp) {
1954 if (!mutex_tryenter(&si->si_snaplock)) {
1955 mutex_exit(&si->si_lock);
1956 mutex_enter(&si->si_snaplock);
1957 mutex_enter(&si->si_lock);
1958 }
1959 si->si_owner = curlwp;
1960 snapshot_locked = 1;
1961 }
1962 if (data_valid && bp->b_bcount == fs->fs_bsize)
1963 saved_data = bp->b_data;
1964retry:
1965 gen = si->si_gen;
1966 TAILQ_FOREACH(ip, &si->si_snapshots, i_nextsnap) {
1967 vp = ITOV(ip);
1968 /*
1969 * We ensure that everything of our own that needs to be
1970 * copied will be done at the time that ffs_snapshot is
1971 * called. Thus we can skip the check here which can
1972 * deadlock in doing the lookup in ffs_balloc.
1973 */
1974 if (bp->b_vp == vp)
1975 continue;
1976 /*
1977 * Check to see if block needs to be copied.
1978 */
1979 if (lbn < UFS_NDADDR) {
1980 blkno = db_get(ip, lbn);
1981 } else {
1982 mutex_exit(&si->si_lock);
1983 blkno = 0; /* XXX: GCC */
1984 if ((error = snapblkaddr(vp, lbn, &blkno)) != 0) {
1985 mutex_enter(&si->si_lock);
1986 break;
1987 }
1988 mutex_enter(&si->si_lock);
1989 if (gen != si->si_gen)
1990 goto retry;
1991 }
1992#ifdef DIAGNOSTIC
1993 if (blkno == BLK_SNAP && bp->b_lblkno >= 0)
1994 panic("ffs_copyonwrite: bad copy block");
1995#endif
1996 if (blkno != 0)
1997 continue;
1998
1999 if (curlwp == uvm.pagedaemon_lwp) {
2000 error = ENOMEM;
2001 break;
2002 }
2003 /* Only one level of recursion allowed. */
2004 KASSERT(snapshot_locked);
2005 /*
2006 * Allocate the block into which to do the copy. Since
2007 * multiple processes may all try to copy the same block,
2008 * we have to recheck our need to do a copy if we sleep
2009 * waiting for the lock.
2010 *
2011 * Because all snapshots on a filesystem share a single
2012 * lock, we ensure that we will never be in competition
2013 * with another process to allocate a block.
2014 */
2015#ifdef DEBUG
2016 if (snapdebug) {
2017 printf("Copyonwrite: snapino %llu lbn %" PRId64 " for ",
2018 (unsigned long long)ip->i_number, lbn);
2019 if (bp->b_vp == devvp)
2020 printf("fs metadata");
2021 else
2022 printf("inum %llu", (unsigned long long)
2023 VTOI(bp->b_vp)->i_number);
2024 printf(" lblkno %" PRId64 "\n", bp->b_lblkno);
2025 }
2026#endif
2027 /*
2028 * If we have already read the old block contents, then
2029 * simply copy them to the new block. Note that we need
2030 * to synchronously write snapshots that have not been
2031 * unlinked, and hence will be visible after a crash,
2032 * to ensure their integrity.
2033 */
2034 mutex_exit(&si->si_lock);
2035 if (saved_data == NULL) {
2036 saved_data = malloc(fs->fs_bsize, M_UFSMNT, M_WAITOK);
2037 error = rwfsblk(vp, B_READ, saved_data, lbn);
2038 if (error) {
2039 free(saved_data, M_UFSMNT);
2040 saved_data = NULL;
2041 mutex_enter(&si->si_lock);
2042 break;
2043 }
2044 }
2045 error = wrsnapblk(vp, saved_data, lbn);
2046 if (error == 0 && ip->i_nlink > 0 && mp->mnt_wapbl)
2047 error = syncsnap(vp);
2048 mutex_enter(&si->si_lock);
2049 if (error)
2050 break;
2051 if (gen != si->si_gen)
2052 goto retry;
2053 }
2054 /*
2055 * Note that we need to synchronously write snapshots that
2056 * have not been unlinked, and hence will be visible after
2057 * a crash, to ensure their integrity.
2058 */
2059 if (snapshot_locked) {
2060 si->si_owner = NULL;
2061 mutex_exit(&si->si_lock);
2062 mutex_exit(&si->si_snaplock);
2063 } else
2064 mutex_exit(&si->si_lock);
2065 if (saved_data && saved_data != bp->b_data)
2066 free(saved_data, M_UFSMNT);
2067 return error;
2068}
2069
2070/*
2071 * Read from a snapshot.
2072 */
2073int
2074ffs_snapshot_read(struct vnode *vp, struct uio *uio, int ioflag)
2075{
2076 struct inode *ip = VTOI(vp);
2077 struct fs *fs = ip->i_fs;
2078 struct snap_info *si = VFSTOUFS(vp->v_mount)->um_snapinfo;
2079 struct buf *bp;
2080 daddr_t lbn, nextlbn;
2081 off_t fsbytes, bytesinfile;
2082 long size, xfersize, blkoffset;
2083 int error;
2084
2085 fstrans_start(vp->v_mount, FSTRANS_SHARED);
2086 mutex_enter(&si->si_snaplock);
2087
2088 if (ioflag & IO_ALTSEMANTICS)
2089 fsbytes = ip->i_size;
2090 else
2091 fsbytes = ffs_lfragtosize(fs, fs->fs_size);
2092 for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
2093 bytesinfile = fsbytes - uio->uio_offset;
2094 if (bytesinfile <= 0)
2095 break;
2096 lbn = ffs_lblkno(fs, uio->uio_offset);
2097 nextlbn = lbn + 1;
2098 size = fs->fs_bsize;
2099 blkoffset = ffs_blkoff(fs, uio->uio_offset);
2100 xfersize = MIN(MIN(fs->fs_bsize - blkoffset, uio->uio_resid),
2101 bytesinfile);
2102
2103 if (ffs_lblktosize(fs, nextlbn + 1) >= fsbytes) {
2104 if (ffs_lblktosize(fs, lbn) + size > fsbytes)
2105 size = ffs_fragroundup(fs,
2106 fsbytes - ffs_lblktosize(fs, lbn));
2107 error = bread(vp, lbn, size, 0, &bp);
2108 } else {
2109 int nextsize = fs->fs_bsize;
2110 error = breadn(vp, lbn,
2111 size, &nextlbn, &nextsize, 1, 0, &bp);
2112 }
2113 if (error)
2114 break;
2115
2116 /*
2117 * We should only get non-zero b_resid when an I/O error
2118 * has occurred, which should cause us to break above.
2119 * However, if the short read did not cause an error,
2120 * then we want to ensure that we do not uiomove bad
2121 * or uninitialized data.
2122 */
2123 size -= bp->b_resid;
2124 if (size < blkoffset + xfersize) {
2125 xfersize = size - blkoffset;
2126 if (xfersize <= 0)
2127 break;
2128 }
2129 error = uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
2130 if (error)
2131 break;
2132 brelse(bp, BC_AGE);
2133 }
2134 if (bp != NULL)
2135 brelse(bp, BC_AGE);
2136
2137 mutex_exit(&si->si_snaplock);
2138 fstrans_done(vp->v_mount);
2139 return error;
2140}
2141
2142/*
2143 * Lookup a snapshots data block address.
2144 * Simpler than UFS_BALLOC() as we know all metadata is already allocated
2145 * and safe even for the pagedaemon where we cannot bread().
2146 */
2147static int
2148snapblkaddr(struct vnode *vp, daddr_t lbn, daddr_t *res)
2149{
2150 struct indir indirs[UFS_NIADDR + 2];
2151 struct inode *ip = VTOI(vp);
2152 struct fs *fs = ip->i_fs;
2153 struct buf *bp;
2154 int error, num;
2155
2156 KASSERT(lbn >= 0);
2157
2158 if (lbn < UFS_NDADDR) {
2159 *res = db_get(ip, lbn);
2160 return 0;
2161 }
2162 if ((error = ufs_getlbns(vp, lbn, indirs, &num)) != 0)
2163 return error;
2164 if (curlwp == uvm.pagedaemon_lwp) {
2165 mutex_enter(&bufcache_lock);
2166 bp = incore(vp, indirs[num-1].in_lbn);
2167 if (bp && (bp->b_oflags & (BO_DONE | BO_DELWRI))) {
2168 *res = idb_get(ip, bp->b_data, indirs[num-1].in_off);
2169 error = 0;
2170 } else
2171 error = ENOMEM;
2172 mutex_exit(&bufcache_lock);
2173 return error;
2174 }
2175 error = bread(vp, indirs[num-1].in_lbn, fs->fs_bsize, 0, &bp);
2176 if (error == 0) {
2177 *res = idb_get(ip, bp->b_data, indirs[num-1].in_off);
2178 brelse(bp, 0);
2179 }
2180
2181 return error;
2182}
2183
2184/*
2185 * Read or write the specified block of the filesystem vp resides on
2186 * from or to the disk bypassing the buffer cache.
2187 */
2188static int
2189rwfsblk(struct vnode *vp, int flags, void *data, daddr_t lbn)
2190{
2191 int error;
2192 struct inode *ip = VTOI(vp);
2193 struct fs *fs = ip->i_fs;
2194 struct buf *nbp;
2195
2196 nbp = getiobuf(NULL, true);
2197 nbp->b_flags = flags;
2198 nbp->b_bcount = nbp->b_bufsize = fs->fs_bsize;
2199 nbp->b_error = 0;
2200 nbp->b_data = data;
2201 nbp->b_blkno = nbp->b_rawblkno = FFS_FSBTODB(fs, ffs_blkstofrags(fs, lbn));
2202 nbp->b_proc = NULL;
2203 nbp->b_dev = ip->i_devvp->v_rdev;
2204 SET(nbp->b_cflags, BC_BUSY); /* mark buffer busy */
2205
2206 bdev_strategy(nbp);
2207
2208 error = biowait(nbp);
2209
2210 putiobuf(nbp);
2211
2212 return error;
2213}
2214
2215/*
2216 * Write all dirty buffers to disk and invalidate them.
2217 */
2218static int
2219syncsnap(struct vnode *vp)
2220{
2221 int error;
2222 buf_t *bp;
2223 struct fs *fs = VTOI(vp)->i_fs;
2224
2225 mutex_enter(&bufcache_lock);
2226 while ((bp = LIST_FIRST(&vp->v_dirtyblkhd))) {
2227 error = bbusy(bp, false, 0, NULL);
2228 if (error == EPASSTHROUGH)
2229 continue;
2230 else if (error != 0) {
2231 mutex_exit(&bufcache_lock);
2232 return error;
2233 }
2234 KASSERT(bp->b_bcount == fs->fs_bsize);
2235 mutex_exit(&bufcache_lock);
2236 error = rwfsblk(vp, B_WRITE, bp->b_data,
2237 ffs_fragstoblks(fs, FFS_DBTOFSB(fs, bp->b_blkno)));
2238 brelse(bp, BC_INVAL | BC_VFLUSH);
2239 if (error)
2240 return error;
2241 mutex_enter(&bufcache_lock);
2242 }
2243 mutex_exit(&bufcache_lock);
2244
2245 return 0;
2246}
2247
2248/*
2249 * Write the specified block to a snapshot.
2250 */
2251static int
2252wrsnapblk(struct vnode *vp, void *data, daddr_t lbn)
2253{
2254 struct inode *ip = VTOI(vp);
2255 struct fs *fs = ip->i_fs;
2256 struct buf *bp;
2257 int error;
2258
2259 error = ffs_balloc(vp, ffs_lblktosize(fs, (off_t)lbn), fs->fs_bsize,
2260 FSCRED, (ip->i_nlink > 0 ? B_SYNC : 0), &bp);
2261 if (error)
2262 return error;
2263 memcpy(bp->b_data, data, fs->fs_bsize);
2264 if (ip->i_nlink > 0)
2265 error = bwrite(bp);
2266 else
2267 bawrite(bp);
2268
2269 return error;
2270}
2271
2272/*
2273 * Check if this inode is present on the active snapshot list.
2274 * Must be called with snapinfo locked.
2275 */
2276static inline bool
2277is_active_snapshot(struct snap_info *si, struct inode *ip)
2278{
2279 struct inode *xp;
2280
2281 KASSERT(mutex_owned(&si->si_lock));
2282
2283 TAILQ_FOREACH(xp, &si->si_snapshots, i_nextsnap)
2284 if (xp == ip)
2285 return true;
2286 return false;
2287}
2288
2289/*
2290 * Get/Put direct block from inode or buffer containing disk addresses. Take
2291 * care for fs type (UFS1/UFS2) and byte swapping. These functions should go
2292 * into a global include.
2293 */
2294static inline daddr_t
2295db_get(struct inode *ip, int loc)
2296{
2297 if (ip->i_ump->um_fstype == UFS1)
2298 return ufs_rw32(ip->i_ffs1_db[loc], UFS_IPNEEDSWAP(ip));
2299 else
2300 return ufs_rw64(ip->i_ffs2_db[loc], UFS_IPNEEDSWAP(ip));
2301}
2302
2303static inline void
2304db_assign(struct inode *ip, int loc, daddr_t val)
2305{
2306 if (ip->i_ump->um_fstype == UFS1)
2307 ip->i_ffs1_db[loc] = ufs_rw32(val, UFS_IPNEEDSWAP(ip));
2308 else
2309 ip->i_ffs2_db[loc] = ufs_rw64(val, UFS_IPNEEDSWAP(ip));
2310}
2311
2312__unused static inline daddr_t
2313ib_get(struct inode *ip, int loc)
2314{
2315 if (ip->i_ump->um_fstype == UFS1)
2316 return ufs_rw32(ip->i_ffs1_ib[loc], UFS_IPNEEDSWAP(ip));
2317 else
2318 return ufs_rw64(ip->i_ffs2_ib[loc], UFS_IPNEEDSWAP(ip));
2319}
2320
2321static inline daddr_t
2322idb_get(struct inode *ip, void *bf, int loc)
2323{
2324 if (ip->i_ump->um_fstype == UFS1)
2325 return ufs_rw32(((int32_t *)(bf))[loc], UFS_IPNEEDSWAP(ip));
2326 else
2327 return ufs_rw64(((int64_t *)(bf))[loc], UFS_IPNEEDSWAP(ip));
2328}
2329
2330static inline void
2331idb_assign(struct inode *ip, void *bf, int loc, daddr_t val)
2332{
2333 if (ip->i_ump->um_fstype == UFS1)
2334 ((int32_t *)(bf))[loc] = ufs_rw32(val, UFS_IPNEEDSWAP(ip));
2335 else
2336 ((int64_t *)(bf))[loc] = ufs_rw64(val, UFS_IPNEEDSWAP(ip));
2337}
2338