did you miss sys/wapbl.h ?
cc ... -D_KERNEL -MD -MP -c ../../../../kern/vfs_bio.c
../../../../kern/vfs_bio.c:59:23: error: sys/wapbl.h: No such file or
directory
../../../../kern/vfs_bio.c: In function 'bio_doread':
../../../../kern/vfs_bio.c:358: error: 'struct vnode' has no member named
'v_specmountpoint'
2015-10-23 17:19 GMT+02:00 Walter Neto <wsouz...@gmail.com>:
> Like recommended from other developers I started developing WAPBL support
> for
> OpenBSD.
>
> Looking at NetBSD and Bitrig I mage a first funcional patch.
>
> Index: sbin/mount/mntopts.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sbin/mount/mntopts.h,v
> retrieving revision 1.16
> diff -u -r1.16 mntopts.h
> --- sbin/mount/mntopts.h 13 Jul 2014 12:01:30 -0000 1.16
> +++ sbin/mount/mntopts.h 23 Oct 2015 15:07:07 -0000
> @@ -66,6 +66,8 @@
> | MFLAG_OPT }
> #define MOPT_SOFTDEP { "softdep", MNT_SOFTDEP, MFLAG_SET }
>
> +#define MOPT_LOG { "log", MNT_LOG, MFLAG_SET }
> +
> /* Control flags. */
> #define MOPT_FORCE { "force", MNT_FORCE, MFLAG_SET }
> #define MOPT_UPDATE { "update", MNT_UPDATE, MFLAG_SET }
> Index: sbin/mount/mount.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sbin/mount/mount.c,v
> retrieving revision 1.60
> diff -u -r1.60 mount.c
> --- sbin/mount/mount.c 16 Jan 2015 06:39:59 -0000 1.60
> +++ sbin/mount/mount.c 23 Oct 2015 15:07:07 -0000
> @@ -94,6 +94,7 @@
> { MNT_ROOTFS, 1, "root file system", "" },
> { MNT_SYNCHRONOUS, 0, "synchronous", "sync" },
> { MNT_SOFTDEP, 0, "softdep", "softdep"
> },
> + { MNT_LOG, 0, "log", "log" },
> { 0, 0, "", "" }
> };
>
> Index: sbin/mount_ffs/mount_ffs.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sbin/mount_ffs/mount_ffs.c,v
> retrieving revision 1.21
> diff -u -r1.21 mount_ffs.c
> --- sbin/mount_ffs/mount_ffs.c 16 Jan 2015 06:39:59 -0000 1.21
> +++ sbin/mount_ffs/mount_ffs.c 23 Oct 2015 15:07:07 -0000
> @@ -53,6 +53,7 @@
> MOPT_RELOAD,
> MOPT_FORCE,
> MOPT_SOFTDEP,
> + MOPT_LOG,
> { NULL }
> };
>
> Index: sys/conf/GENERIC
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/conf/GENERIC,v
> retrieving revision 1.220
> diff -u -r1.220 GENERIC
> --- sys/conf/GENERIC 10 Aug 2015 20:35:36 -0000 1.220
> +++ sys/conf/GENERIC 23 Oct 2015 15:07:07 -0000
> @@ -43,6 +43,7 @@
> option FIFO # FIFOs; RECOMMENDED
> option TMPFS # efficient memory file system
> option FUSE # FUSE
> +option WAPBL # Write Ahead Physical Block Logging
>
> option SOCKET_SPLICE # Socket Splicing for TCP and UDP
> option TCP_SACK # Selective Acknowledgements for TCP
> Index: sys/conf/files
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/conf/files,v
> retrieving revision 1.604
> diff -u -r1.604 files
> --- sys/conf/files 9 Oct 2015 01:17:21 -0000 1.604
> +++ sys/conf/files 23 Oct 2015 15:07:07 -0000
> @@ -732,6 +732,7 @@
> file kern/vfs_vops.c
> file kern/vfs_vnops.c
> file kern/vfs_getcwd.c
> +file kern/vfs_wapbl.c wapbl
> file kern/spec_vnops.c
> file miscfs/deadfs/dead_vnops.c
> file miscfs/fifofs/fifo_vnops.c fifo
> @@ -887,6 +888,7 @@
> file ufs/ffs/ffs_vfsops.c ffs | mfs
> file ufs/ffs/ffs_vnops.c ffs | mfs
> file ufs/ffs/ffs_softdep.c ffs_softupdates
> +file ufs/ffs/ffs_wapbl.c ffs & wapbl
> file ufs/mfs/mfs_vfsops.c mfs
> file ufs/mfs/mfs_vnops.c mfs
> file ufs/ufs/ufs_bmap.c ffs | mfs | ext2fs
> @@ -898,6 +900,7 @@
> file ufs/ufs/ufs_quota_stub.c ffs | mfs
> file ufs/ufs/ufs_vfsops.c ffs | mfs | ext2fs
> file ufs/ufs/ufs_vnops.c ffs | mfs | ext2fs
> +file ufs/ufs/ufs_wapbl.c ffs & wapbl
> file ufs/ext2fs/ext2fs_alloc.c ext2fs
> file ufs/ext2fs/ext2fs_balloc.c ext2fs
> file ufs/ext2fs/ext2fs_bmap.c ext2fs
> Index: sys/kern/spec_vnops.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/kern/spec_vnops.c,v
> retrieving revision 1.83
> diff -u -r1.83 spec_vnops.c
> --- sys/kern/spec_vnops.c 10 Feb 2015 21:56:09 -0000 1.83
> +++ sys/kern/spec_vnops.c 23 Oct 2015 15:07:07 -0000
> @@ -408,6 +408,10 @@
> return (EOPNOTSUPP);
> }
>
> +#ifdef WAPBL
> +extern int ffs_wapbl_fsync_vfs(struct vnode *, int);
> +#endif
> +
> /*
> * Synch buffers associated with a block device
> */
> @@ -422,6 +426,15 @@
>
> if (vp->v_type == VCHR)
> return (0);
> +
> +
> +#ifdef WAPBL
> + if (vp->v_type == VBLK &&
> + vp->v_specmountpoint != NULL &&
> + vp->v_specmountpoint->mnt_wapbl != NULL)
> + return (ffs_wapbl_fsync_vfs(vp, ap->a_waitfor));
> +#endif
> +
> /*
> * Flush all dirty buffers associated with a block device.
> */
> Index: sys/kern/vfs_bio.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/kern/vfs_bio.c,v
> retrieving revision 1.170
> diff -u -r1.170 vfs_bio.c
> --- sys/kern/vfs_bio.c 19 Jul 2015 16:21:11 -0000 1.170
> +++ sys/kern/vfs_bio.c 23 Oct 2015 15:07:07 -0000
> @@ -56,7 +56,7 @@
> #include <sys/resourcevar.h>
> #include <sys/conf.h>
> #include <sys/kernel.h>
> -#include <sys/specdev.h>
> +#include <sys/wapbl.h>
> #include <uvm/uvm_extern.h>
>
> int nobuffers;
> @@ -77,6 +77,7 @@
> struct buf *bio_doread(struct vnode *, daddr_t, int, int);
> struct buf *buf_get(struct vnode *, daddr_t, size_t);
> void bread_cluster_callback(struct buf *);
> +static inline int injournal(struct buf *);
>
> struct bcachestats bcstats; /* counters */
> long lodirtypages; /* dirty page count low water mark */
> @@ -556,6 +557,16 @@
> mp = NULL;
>
> /*
> + * If using WAPBL, convert it to a delayed write
> + */
> + if (mp && mp->mnt_wapbl && injournal(bp)) {
> + if (bp->b_iodone != mp->mnt_wapbl_op->wo_wapbl_biodone) {
> + bdwrite(bp);
> + return 0;
> + }
> + }
> +
> + /*
> * Remember buffer type, to switch on it later. If the write was
> * synchronous, but the file system was mounted with MNT_ASYNC,
> * convert it to a delayed write.
> @@ -628,6 +639,20 @@
> return (rv);
> }
>
> +/*
> + * Consider a buffer for an entry in the (WAPBL) journal. We do not want
> to log
> + * regular data blocks.
> + */
> +static inline int
> +injournal(struct buf *bp)
> +{
> + struct vnode *vp = bp->b_vp;
> +
> + if (wapbl_vphaswapbl(vp) && (vp->v_type != VREG || bp->b_lblkno <
> 0))
> + return (1);
> +
> + return (0);
> +}
>
> /*
> * Delayed write.
> @@ -647,6 +672,20 @@
> {
> int s;
>
> + /* If this is a tape block, write the block now. */
> + if (major(bp->b_dev) < nblkdev &&
> + bdevsw[major(bp->b_dev)].d_type == D_TAPE) {
> + bawrite(bp);
> + return;
> + }
> +
> + if (injournal(bp)) {
> + struct mount *mp = wapbl_vptomp(bp->b_vp);
> +
> + if (bp->b_iodone != mp->mnt_wapbl_op->wo_wapbl_biodone)
> + WAPBL_ADD_BUF(mp, bp);
> + }
> +
> /*
> * If the block hasn't been seen before:
> * (1) Mark it as having been seen,
> @@ -663,13 +702,6 @@
> curproc->p_ru.ru_oublock++; /* XXX */
> }
>
> - /* If this is a tape block, write the block now. */
> - if (major(bp->b_dev) < nblkdev &&
> - bdevsw[major(bp->b_dev)].d_type == D_TAPE) {
> - bawrite(bp);
> - return;
> - }
> -
> /* Otherwise, the "write" is done, so mark and release the buffer.
> */
> CLR(bp->b_flags, B_NEEDCOMMIT);
> SET(bp->b_flags, B_DONE);
> @@ -743,12 +775,28 @@
> * Determine which queue the buffer should be on, then put it
> there.
> */
>
> + /* If it's locked, don't report an error; try again later */
> + if (ISSET(bp->b_flags, (B_LOCKED|B_ERROR)) == (B_LOCKED|B_ERROR))
> + CLR(bp->b_flags, B_ERROR);
> +
> /* If it's not cacheable, or an error, mark it invalid. */
> if (ISSET(bp->b_flags, (B_NOCACHE|B_ERROR)))
> SET(bp->b_flags, B_INVAL);
>
> if (ISSET(bp->b_flags, B_INVAL)) {
> /*
> + * If using WAPBL
> + */
> + if (ISSET(bp->b_flags, B_LOCKED)) {
> + if (wapbl_vphaswapbl(bp->b_vp)) {
> + struct mount *mp = wapbl_vptomp(bp->b_vp);
> + KASSERT(bp->b_iodone
> + != mp->mnt_wapbl_op->wo_wapbl_biodone);
> + WAPBL_REMOVE_BUF(mp, bp);
> + }
> + }
> +
> + /*
> * If the buffer is invalid, free it now rather than
> leaving
> * it in a queue and wasting memory.
> */
> @@ -1079,6 +1127,19 @@
> if (!ISSET(bp->b_flags, B_DELWRI))
> panic("Clean buffer on dirty queue");
> #endif
> +
> +
> +#ifdef WAPBL
> + if (ISSET(bp->b_flags, B_LOCKED) &&
> + wapbl_vphaswapbl(bp->b_vp)) {
> + brelse(bp);
> + struct mount *mp = wapbl_vptomp(bp->b_vp);
> + wapbl_flush(mp->mnt_wapbl, 1);
> + s = splbio();
> + continue;
> + }
> +#endif /* WAPBL */
> +
> if (LIST_FIRST(&bp->b_dep) != NULL &&
> !ISSET(bp->b_flags, B_DEFERRED) &&
> buf_countdeps(bp, 0, 0)) {
> @@ -1206,6 +1267,17 @@
> }
> #endif
>
> +void
> +buf_adjcnt(struct buf *bp, long ncount)
> +{
> + KASSERT(ncount <= bp->b_bufsize);
> + long ocount = bp->b_bcount;
> + bp->b_bcount = ncount;
> + if (injournal(bp))
> + WAPBL_RESIZE_BUF(wapbl_vptomp(bp->b_vp), bp, bp->b_bufsize,
> + ocount);
> +}
> +
> /* bufcache freelist code below */
> /*
> * Copyright (c) 2014 Ted Unangst <t...@openbsd.org>
> Index: sys/kern/vfs_biomem.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/kern/vfs_biomem.c,v
> retrieving revision 1.34
> diff -u -r1.34 vfs_biomem.c
> --- sys/kern/vfs_biomem.c 19 Jul 2015 21:21:14 -0000 1.34
> +++ sys/kern/vfs_biomem.c 23 Oct 2015 15:07:07 -0000
> @@ -89,7 +89,7 @@
> {
> splassert(IPL_BIO);
> SET(bp->b_flags, B_BUSY);
> - if (bp->b_data != NULL) {
> + if (bp->b_data != NULL && !(bp->b_flags & B_LOCKED)) {
> TAILQ_REMOVE(&buf_valist, bp, b_valist);
> bcstats.kvaslots_avail--;
> bcstats.busymapped++;
> @@ -143,8 +143,11 @@
> pmap_update(pmap_kernel());
> bp->b_data = (caddr_t)va;
> } else {
> - TAILQ_REMOVE(&buf_valist, bp, b_valist);
> - bcstats.kvaslots_avail--;
> + if (!(bp->b_flags & B_LOCKED)) {
> + TAILQ_REMOVE(&buf_valist, bp, b_valist);
> + bcstats.kvaslots_avail--;
> + } else
> + return;
> }
>
> bcstats.busymapped++;
> @@ -157,7 +160,7 @@
> KASSERT(bp->b_flags & B_BUSY);
> splassert(IPL_BIO);
>
> - if (bp->b_data) {
> + if (bp->b_data && !(bp->b_flags & B_LOCKED)) {
> bcstats.busymapped--;
> TAILQ_INSERT_TAIL(&buf_valist, bp, b_valist);
> bcstats.kvaslots_avail++;
> @@ -191,6 +194,7 @@
> bp->b_data = NULL;
>
> if (data) {
> + KASSERT(!(bp->b_flags & B_LOCKED));
> if (bp->b_flags & B_BUSY)
> bcstats.busymapped--;
> pmap_kremove((vaddr_t)data, bp->b_bufsize);
> @@ -237,6 +241,7 @@
> * buffers read in by bread_cluster
> */
> bp->b_bufsize = newsize;
> + KASSERT(!(bp->b_flags & B_LOCKED));
> }
> }
>
> Index: sys/kern/vfs_init.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/kern/vfs_init.c,v
> retrieving revision 1.36
> diff -u -r1.36 vfs_init.c
> --- sys/kern/vfs_init.c 14 Mar 2015 03:38:51 -0000 1.36
> +++ sys/kern/vfs_init.c 23 Oct 2015 15:07:07 -0000
> @@ -42,6 +42,7 @@
> #include <sys/namei.h>
> #include <sys/vnode.h>
> #include <sys/pool.h>
> +#include <sys/wapbl.h>
>
> struct pool namei_pool;
>
> @@ -156,6 +157,10 @@
> /* Initialize the vnode name cache. */
> nchinit();
>
> +#ifdef WAPBL
> + wapbl_init();
> +#endif
> +
> /*
> * Stop using vfsconf and maxvfsconf as a temporary storage,
> * set them to their correct values now.
> Index: sys/kern/vfs_subr.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/kern/vfs_subr.c,v
> retrieving revision 1.236
> diff -u -r1.236 vfs_subr.c
> --- sys/kern/vfs_subr.c 13 Oct 2015 09:11:48 -0000 1.236
> +++ sys/kern/vfs_subr.c 23 Oct 2015 15:07:07 -0000
> @@ -62,7 +62,7 @@
> #include <sys/syscallargs.h>
> #include <sys/pool.h>
> #include <sys/tree.h>
> -#include <sys/specdev.h>
> +#include <sys/wapbl.h>
>
> #include <netinet/in.h>
>
> @@ -921,7 +921,7 @@
> void
> vclean(struct vnode *vp, int flags, struct proc *p)
> {
> - int active;
> + int active, error;
>
> /*
> * Check to see if the vnode is in use.
> @@ -955,8 +955,15 @@
> /*
> * Clean out any buffers associated with the vnode.
> */
> - if (flags & DOCLOSE)
> - vinvalbuf(vp, V_SAVE, NOCRED, p, 0, 0);
> + if (flags & DOCLOSE) {
> + error = vinvalbuf(vp, V_SAVE, NOCRED, p, 0, 0);
> + if (error != 0) {
> + if (wapbl_vphaswapbl(vp))
> + WAPBL_DISCARD(wapbl_vptomp(vp));
> + error = vinvalbuf(vp, 0, NOCRED, p, 0, 0);
> + }
> + KASSERT(error == 0);
> + }
> /*
> * If purging an active vnode, it must be closed and
> * deactivated before being reclaimed. Note that the
> @@ -1850,6 +1857,64 @@
> return (0);
> }
>
> +/*
> + * Destroy any in core blocks past the truncation length.
> + * Called with the underlying vnode locked, which should prevent new dirty
> + * buffers from being queued.
> + */
> +int
> +vtruncbuf(struct vnode *vp, daddr_t lbn, int slpflag, int slptimeo)
> +{
> + struct buf *bp, *nbp;
> + int s, error;
> +
> + s = splbio();
> +restart:
> + for (bp = LIST_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) {
> + nbp = LIST_NEXT(bp, b_vnbufs);
> + if (bp->b_lblkno < lbn)
> + continue;
> + if (bp->b_flags & B_BUSY) {
> + bp->b_flags |= B_WANTED;
> + error = tsleep(bp, slpflag | (PRIBIO + 1),
> + "vtruncbuf", slptimeo);
> + if (error) {
> + splx(s);
> + return (error);
> + }
> + goto restart;
> + }
> + bremfree(bp);
> + buf_acquire_nomap(bp);
> + bp->b_flags |= B_INVAL;
> + brelse(bp);
> + }
> +
> + for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
> + nbp = LIST_NEXT(bp, b_vnbufs);
> + if (bp->b_lblkno < lbn)
> + continue;
> + if (bp->b_flags & B_BUSY) {
> + bp->b_flags |= B_WANTED;
> + error = tsleep(bp, slpflag | (PRIBIO + 1),
> + "vtruncbuf", slptimeo);
> + if (error) {
> + splx(s);
> + return (error);
> + }
> + goto restart;
> + }
> + bremfree(bp);
> + buf_acquire_nomap(bp);
> + bp->b_flags |= B_INVAL;
> + brelse(bp);
> + }
> +
> + splx(s);
> +
> + return (0);
> +}
> +
> void
> vflushbuf(struct vnode *vp, int sync)
> {
> Index: sys/kern/vfs_sync.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/kern/vfs_sync.c,v
> retrieving revision 1.54
> diff -u -r1.54 vfs_sync.c
> --- sys/kern/vfs_sync.c 14 Mar 2015 03:38:51 -0000 1.54
> +++ sys/kern/vfs_sync.c 23 Oct 2015 15:07:07 -0000
> @@ -311,6 +311,18 @@
> }
>
> /*
> + * Return delay factor appropriate for the given file system. For
> + * WAPBL we use the sync vnode to burst out metadata updates: sync
> + * those file systems more frequently.
> + */
> +static inline int
> +sync_delay(struct mount *mp)
> +{
> +
> + return mp->mnt_wapbl != NULL ? syncdelay / 3 : syncdelay;
> +}
> +
> +/*
> * Do a lazy sync of the filesystem.
> */
> int
> @@ -330,7 +342,7 @@
> /*
> * Move ourselves to the back of the sync list.
> */
> - vn_syncer_add_to_worklist(syncvp, syncdelay);
> + vn_syncer_add_to_worklist(syncvp, sync_delay(mp));
>
> /*
> * Walk the list of vnodes pushing all that are dirty and
> Index: sys/kern/vfs_syscalls.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/kern/vfs_syscalls.c,v
> retrieving revision 1.232
> diff -u -r1.232 vfs_syscalls.c
> --- sys/kern/vfs_syscalls.c 20 Oct 2015 06:40:00 -0000 1.232
> +++ sys/kern/vfs_syscalls.c 23 Oct 2015 15:07:07 -0000
> @@ -253,10 +253,10 @@
> mp->mnt_flag |= MNT_WANTRDWR;
> mp->mnt_flag &=~ (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV |
> MNT_SYNCHRONOUS | MNT_ASYNC | MNT_SOFTDEP | MNT_NOATIME |
> - MNT_FORCE);
> + MNT_FORCE | MNT_LOG);
> mp->mnt_flag |= flags & (MNT_NOSUID | MNT_NOEXEC |
> MNT_NODEV | MNT_SYNCHRONOUS | MNT_ASYNC | MNT_SOFTDEP |
> - MNT_NOATIME | MNT_FORCE);
> + MNT_NOATIME | MNT_FORCE | MNT_LOG);
> /*
> * Mount the filesystem.
> */
> Index: sys/sys/buf.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/sys/buf.h,v
> retrieving revision 1.99
> diff -u -r1.99 buf.h
> --- sys/sys/buf.h 19 Jul 2015 16:21:11 -0000 1.99
> +++ sys/sys/buf.h 23 Oct 2015 15:07:07 -0000
> @@ -144,6 +144,7 @@
> LIST_ENTRY(buf) b_list; /* All allocated buffers. */
> LIST_ENTRY(buf) b_vnbufs; /* Buffer's associated vnode. */
> TAILQ_ENTRY(buf) b_freelist; /* Free list position if not
> active. */
> + LIST_ENTRY(buf) b_wapbllist; /* transaction buffer list */
> int cache; /* which cache are we in */
> struct proc *b_proc; /* Associated proc; NULL if
> kernel. */
> volatile long b_flags; /* B_* flags. */
> @@ -157,6 +158,8 @@
>
> TAILQ_ENTRY(buf) b_valist; /* LRU of va to reuse. */
>
> + void * b_private; /* private data for owner */
> +
> union bufq_data b_bufq;
> struct bufq *b_bq; /* What bufq this buf is on */
>
> @@ -221,12 +224,14 @@
> #define B_COLD 0x01000000 /* buffer is on the cold
> queue
> */
> #define B_BC 0x02000000 /* buffer is managed by the
> cache */
> #define B_DMA 0x04000000 /* buffer is DMA reachable
> */
> +#define B_LOCKED 0x08000000 /* Locked in core (not reusable).
> */
>
> #define B_BITS "\20\001AGE\002NEEDCOMMIT\003ASYNC\004BAD\005BUSY"
> \
> "\006CACHE\007CALL\010DELWRI\011DONE\012EINTR\013ERROR" \
> "\014INVAL\015NOCACHE\016PHYS\017RAW\020READ" \
> "\021WANTED\022WRITEINPROG\023XXX(FORMAT)\024DEFERRED" \
> - "\025SCANNED\026DAEMON\027RELEASED\030WARM\031COLD\032BC\033DMA"
> + "\025SCANNED\026DAEMON\027RELEASED\030WARM\031COLD\032BC\033DMA" \
> + "\034LOCKED"
>
> /*
> * This structure describes a clustered I/O. It is stored in the
> b_saveaddr
> @@ -254,6 +259,8 @@
> /* Flags to low-level allocation routines. */
> #define B_CLRBUF 0x01 /* Request allocated buffer be cleared. */
> #define B_SYNC 0x02 /* Do all allocations synchronously. */
> +#define B_METAONLY 0x04 /* return indirect block buffer */
> +#define B_CONTIG 0x08 /* allocate file contiguously */
>
> struct cluster_info {
> daddr_t ci_lastr; /* last read (read-ahead) */
> @@ -292,6 +299,7 @@
> void bufinit(void);
> void buf_dirty(struct buf *);
> void buf_undirty(struct buf *);
> +void buf_adjcnt(struct buf *, long);
> int bwrite(struct buf *);
> struct buf *getblk(struct vnode *, daddr_t, int, int, int);
> struct buf *geteblk(int);
> Index: sys/sys/dkio.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/sys/dkio.h,v
> retrieving revision 1.9
> diff -u -r1.9 dkio.h
> --- sys/sys/dkio.h 5 Jun 2011 18:40:33 -0000 1.9
> +++ sys/sys/dkio.h 23 Oct 2015 15:07:07 -0000
> @@ -83,4 +83,7 @@
>
> #define DIOCMAP _IOWR('d', 119, struct dk_diskmap)
>
> +/* sync disk cache */
> +#define DIOCCACHESYNC _IOW('d', 118, int) /* sync cache
> (force?)
> */
> +
> #endif /* _SYS_DKIO_H_ */
> Index: sys/sys/mount.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/sys/mount.h,v
> retrieving revision 1.121
> diff -u -r1.121 mount.h
> --- sys/sys/mount.h 8 Sep 2014 01:47:06 -0000 1.121
> +++ sys/sys/mount.h 23 Oct 2015 15:07:07 -0000
> @@ -358,6 +358,11 @@
> int mnt_maxsymlinklen; /* max size of short
> symlink */
> struct statfs mnt_stat; /* cache of filesystem
> stats */
> void *mnt_data; /* private data */
> + struct wapbl_ops
> + *mnt_wapbl_op; /* logging ops */
> + struct wapbl *mnt_wapbl; /* log info */
> + struct wapbl_replay
> + *mnt_wapbl_replay; /* replay support XXX:
> what? */
> };
>
> /*
> @@ -396,7 +401,7 @@
> /*
> * Mask of flags that are visible to statfs()
> */
> -#define MNT_VISFLAGMASK 0x0400ffff
> +#define MNT_VISFLAGMASK 0x1400ffff
>
> #define MNT_BITS \
> "\010\001RDONLY\002SYNCHRONOUS\003NOEXEC\004NOSUID\005NODEV" \
> @@ -413,6 +418,7 @@
> #define MNT_WANTRDWR 0x02000000 /* want upgrade to read/write */
> #define MNT_SOFTDEP 0x04000000 /* soft dependencies being done */
> #define MNT_DOOMED 0x08000000 /* device behind filesystem is
> gone */
> +#define MNT_LOG 0x10000000 /* use logging */
>
> /*
> * Flags for various system call interfaces.
> @@ -501,6 +507,51 @@
> extern int bufbackoff(struct uvm_constraint_range*, long);
>
> /*
> + * This operations vector is so wapbl can be wrapped into a filesystem
> lkm.
> + * XXX Eventually, we want to move this functionality
> + * down into the filesystems themselves so that this isn't needed.
> + */
> +struct wapbl_ops {
> + void (*wo_wapbl_discard)(struct wapbl *);
> + int (*wo_wapbl_replay_isopen)(struct wapbl_replay *);
> + int (*wo_wapbl_replay_can_read)(struct wapbl_replay *, daddr_t,
> long);
> + int (*wo_wapbl_replay_read)(struct wapbl_replay *, void *, daddr_t,
> + long);
> + void (*wo_wapbl_add_buf)(struct wapbl *, struct buf *);
> + void (*wo_wapbl_remove_buf)(struct wapbl *, struct buf *);
> + void (*wo_wapbl_resize_buf)(struct wapbl *, struct buf *, long,
> long);
> + int (*wo_wapbl_begin)(struct wapbl *, const char *, int);
> + void (*wo_wapbl_end)(struct wapbl *);
> + void (*wo_wapbl_junlock_assert)(struct wapbl *);
> + void (*wo_wapbl_biodone)(struct buf *);
> +};
> +#define WAPBL_DISCARD(MP) \
> + (*(MP)->mnt_wapbl_op->wo_wapbl_discard)((MP)->mnt_wapbl)
> +#define WAPBL_REPLAY_ISOPEN(MP)
> \
> + (*(MP)->mnt_wapbl_op->wo_wapbl_replay_isopen)((MP)->mnt_wapbl_replay)
> +#define WAPBL_REPLAY_CAN_READ(MP, BLK, LEN) \
> +
> (*(MP)->mnt_wapbl_op->wo_wapbl_replay_can_read)((MP)->mnt_wapbl_replay, \
> + (BLK), (LEN))
> +#define WAPBL_REPLAY_READ(MP, DATA, BLK, LEN) \
> + (*(MP)->mnt_wapbl_op->wo_wapbl_replay_read)((MP)->mnt_wapbl_replay,
> \
> + (DATA), (BLK), (LEN))
> +#define WAPBL_ADD_BUF(MP, BP) \
> + (*(MP)->mnt_wapbl_op->wo_wapbl_add_buf)((MP)->mnt_wapbl, (BP))
> +#define WAPBL_REMOVE_BUF(MP, BP) \
> + (*(MP)->mnt_wapbl_op->wo_wapbl_remove_buf)((MP)->mnt_wapbl, (BP))
> +#define WAPBL_RESIZE_BUF(MP, BP, OLDSZ, OLDCNT)
> \
> + (*(MP)->mnt_wapbl_op->wo_wapbl_resize_buf)((MP)->mnt_wapbl, (BP), \
> + (OLDSZ), (OLDCNT))
> +#define WAPBL_BEGIN(MP)
> \
> + (*(MP)->mnt_wapbl_op->wo_wapbl_begin)((MP)->mnt_wapbl, \
> + __FILE__, __LINE__)
> +#define WAPBL_END(MP) \
> + (*(MP)->mnt_wapbl_op->wo_wapbl_end)((MP)->mnt_wapbl)
> +#define WAPBL_JUNLOCK_ASSERT(MP) \
> + (*(MP)->mnt_wapbl_op->wo_wapbl_junlock_assert)((MP)->mnt_wapbl)
> +
> +
> +/*
> * Operations supported on mounted file system.
> */
> struct nameidata;
> Index: sys/sys/specdev.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/sys/specdev.h,v
> retrieving revision 1.34
> diff -u -r1.34 specdev.h
> --- sys/sys/specdev.h 2 Nov 2013 00:16:31 -0000 1.34
> +++ sys/sys/specdev.h 23 Oct 2015 15:07:07 -0000
> @@ -37,6 +37,10 @@
> * special devices. It is allocated in checkalias and freed
> * in vgone.
> */
> +
> +#ifndef _SYS_SPECDEV_H_
> +#define _SYS_SPECDEV_H_
> +
> struct specinfo {
> struct vnode **si_hashchain;
> struct vnode *si_specnext;
> @@ -108,3 +112,4 @@
> int spec_advlock(void *);
>
> #endif /* _KERNEL */
> +#endif /* _SYS_SPECDEV_H_ */
> Index: sys/sys/stat.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/sys/stat.h,v
> retrieving revision 1.28
> diff -u -r1.28 stat.h
> --- sys/sys/stat.h 4 Apr 2015 18:06:08 -0000 1.28
> +++ sys/sys/stat.h 23 Oct 2015 15:07:07 -0000
> @@ -173,6 +173,7 @@
> #define SF_ARCHIVED 0x00010000 /* file is archived */
> #define SF_IMMUTABLE 0x00020000 /* file may not be changed
> */
> #define SF_APPEND 0x00040000 /* writes to file may only
> append */
> +#define SF_LOG 0x00400000 /* WAPBL log file inode */
>
> #ifdef _KERNEL
> /*
> Index: sys/sys/vnode.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/sys/vnode.h,v
> retrieving revision 1.132
> diff -u -r1.132 vnode.h
> --- sys/sys/vnode.h 7 May 2015 08:53:33 -0000 1.132
> +++ sys/sys/vnode.h 23 Oct 2015 15:07:07 -0000
> @@ -185,13 +185,14 @@
> /*
> * Flags for ioflag.
> */
> -#define IO_UNIT 0x01 /* do I/O as atomic unit */
> -#define IO_APPEND 0x02 /* append write to end */
> -#define IO_SYNC 0x04 /* do I/O synchronously */
> -#define IO_NODELOCKED 0x08 /* underlying node already
> locked */
> -#define IO_NDELAY 0x10 /* FNDELAY flag set in file
> table */
> -#define IO_NOLIMIT 0x20 /* don't enforce limits on
> i/o
> */
> -#define IO_NOCACHE 0x40 /* don't cache result of
> this
> i/o */
> +#define IO_UNIT 0x01 /* I/O as atomic unit */
> +#define IO_APPEND 0x02 /* append write to end */
> +#define IO_SYNC 0x04 /* do I/O synchronously */
> +#define IO_NODELOCKED 0x08 /* underlying node already
> locked */
> +#define IO_NDELAY 0x10 /* FNDELAY flag set in file
> table */
> +#define IO_NOLIMIT 0x20 /* don't enforce limits on
> i/o
> */
> +#define IO_NOCACHE 0x40 /* don't cache result of
> this
> i/o */
> +#define IO_JOURNALLOCKED 0x80 /* journal is already locked */
>
> /*
> * Modes. Some values same as Ixxx entries from inode.h for now.
> @@ -596,6 +597,7 @@
> void vdevgone(int, int, int, enum vtype);
> int vcount(struct vnode *);
> int vfinddev(dev_t, enum vtype, struct vnode **);
> +int vtruncbuf(struct vnode *, daddr_t, int, int);
> void vflushbuf(struct vnode *, int);
> int vflush(struct mount *, struct vnode *, int);
> int vget(struct vnode *, int, struct proc *);
> Index: sys/ufs/ffs/ffs_alloc.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ffs/ffs_alloc.c,v
> retrieving revision 1.105
> diff -u -r1.105 ffs_alloc.c
> --- sys/ufs/ffs/ffs_alloc.c 27 Sep 2015 05:25:00 -0000 1.105
> +++ sys/ufs/ffs/ffs_alloc.c 23 Oct 2015 15:07:07 -0000
> @@ -49,11 +49,13 @@
> #include <sys/syslog.h>
> #include <sys/stdint.h>
> #include <sys/time.h>
> +#include <sys/wapbl.h>
>
> #include <ufs/ufs/quota.h>
> #include <ufs/ufs/inode.h>
> #include <ufs/ufs/ufsmount.h>
> #include <ufs/ufs/ufs_extern.h>
> +#include <ufs/ufs/ufs_wapbl.h>
>
> #include <ufs/ffs/fs.h>
> #include <ufs/ffs/ffs_extern.h>
> @@ -63,16 +65,19 @@
> (fs)->fs_fsmnt, (cp)); \
> } while (0)
>
> -daddr_t ffs_alloccg(struct inode *, int, daddr_t, int);
> -struct buf * ffs_cgread(struct fs *, struct inode *, int);
> -daddr_t ffs_alloccgblk(struct inode *, struct buf *,
> daddr_t);
> -daddr_t ffs_clusteralloc(struct inode *, int, daddr_t,
> int);
> +daddr_t ffs_alloccg(struct inode *, int, daddr_t, int,
> int);
> +struct buf * ffs_cgread(struct fs *, struct vnode *, int);
> +daddr_t ffs_alloccgblk(struct inode *, struct buf *,
> daddr_t,
> int);
> +daddr_t ffs_clusteralloc(struct inode *, int, daddr_t, int,
> int);
> ufsino_t ffs_dirpref(struct inode *);
> daddr_t ffs_fragextend(struct inode *, int, daddr_t, int,
> int);
> -daddr_t ffs_hashalloc(struct inode *, int, daddr_t, int,
> - daddr_t (*)(struct inode *, int, daddr_t, int));
> -daddr_t ffs_nodealloccg(struct inode *, int, daddr_t, int);
> +daddr_t ffs_hashalloc(struct inode *, int, daddr_t, int,
> int,
> + daddr_t (*)(struct inode *, int, daddr_t, int, int));
> +daddr_t ffs_nodealloccg(struct inode *, int, daddr_t, int,
> int);
> daddr_t ffs_mapsearch(struct fs *, struct cg *, daddr_t,
> int);
> +void ffs_blkfree_subr(struct fs *, struct vnode *,
> + struct inode *, daddr_t bno, long size);
> +
>
> int ffs1_reallocblks(void *);
> #ifdef FFS2
> @@ -106,7 +111,7 @@
> * available block is located.
> */
> int
> -ffs_alloc(struct inode *ip, daddr_t lbn, daddr_t bpref, int size,
> +ffs_alloc(struct inode *ip, daddr_t lbn, daddr_t bpref, int size, int
> flags,
> struct ucred *cred, daddr_t *bnp)
> {
> static struct timeval fsfull_last;
> @@ -147,7 +152,7 @@
> cg = dtog(fs, bpref);
>
> /* Try allocating a block. */
> - bno = ffs_hashalloc(ip, cg, bpref, size, ffs_alloccg);
> + bno = ffs_hashalloc(ip, cg, bpref, size, flags, ffs_alloccg);
> if (bno > 0) {
> /* allocation successful, update inode data */
> DIP_ADD(ip, blocks, btodb(size));
> @@ -159,6 +164,12 @@
> /* Restore user's disk quota because allocation failed. */
> (void) ufs_quota_free_blocks(ip, btodb(size), cred);
>
> + if (flags & B_CONTIG) {
> + /*
> + * Fail silently -- it's up to our caller to report errors.
> + */
> + return (ENOSPC);
> + }
> nospace:
> if (ratecheck(&fsfull_last, &fserr_interval)) {
> ffs_fserr(fs, cred->cr_uid, "file system full");
> @@ -178,7 +189,7 @@
> */
> int
> ffs_realloccg(struct inode *ip, daddr_t lbprev, daddr_t bpref, int osize,
> - int nsize, struct ucred *cred, struct buf **bpp, daddr_t *blknop)
> + int nsize, int flags, struct ucred *cred, struct buf **bpp, daddr_t
> *blknop)
> {
> static struct timeval fsfull_last;
> struct fs *fs;
> @@ -218,7 +229,7 @@
> if (bpp != NULL) {
> if ((error = bread(ITOV(ip), lbprev, fs->fs_bsize, &bp))
> != 0)
> goto error;
> - bp->b_bcount = osize;
> + buf_adjcnt(bp, osize);
> }
>
> if ((error = ufs_quota_alloc_blocks(ip, btodb(nsize - osize),
> cred))
> @@ -241,7 +252,7 @@
> if (nsize > bp->b_bufsize)
> panic("ffs_realloccg: small buf");
> #endif
> - bp->b_bcount = nsize;
> + buf_adjcnt(bp, nsize);
> bp->b_flags |= B_DONE;
> memset(bp->b_data + osize, 0, nsize - osize);
> *bpp = bp;
> @@ -295,16 +306,29 @@
> panic("ffs_realloccg: bad optim");
> /* NOTREACHED */
> }
> - bno = ffs_hashalloc(ip, cg, bpref, request, ffs_alloccg);
> + bno = ffs_hashalloc(ip, cg, bpref, request, flags, ffs_alloccg);
> if (bno <= 0)
> goto nospace;
>
> (void) uvm_vnp_uncache(ITOV(ip));
> - if (!DOINGSOFTDEP(ITOV(ip)))
> - ffs_blkfree(ip, bprev, (long)osize);
> - if (nsize < request)
> - ffs_blkfree(ip, bno + numfrags(fs, nsize),
> - (long)(request - nsize));
> + if (ip->i_ump->um_mountp->mnt_wapbl && ITOV(ip)->v_type != VREG) {
> + UFS_WAPBL_REGISTER_DEALLOCATION(ip->i_ump->um_mountp,
> + fsbtodb(fs, bprev), osize);
> + } else {
> + if (!DOINGSOFTDEP(ITOV(ip)))
> + ffs_blkfree(ip, bprev, (long)osize);
> + }
> + if (nsize < request) {
> + if (ip->i_ump->um_mountp->mnt_wapbl &&
> + ITOV(ip)->v_type != VREG) {
> +
> UFS_WAPBL_REGISTER_DEALLOCATION(ip->i_ump->um_mountp,
> + fsbtodb(fs, (bno + numfrags(fs, nsize))),
> + request - nsize);
> + } else {
> + ffs_blkfree(ip, bno + numfrags(fs, nsize),
> + (long)(request - nsize));
> + }
> + }
> DIP_ADD(ip, blocks, btodb(nsize - osize));
> ip->i_flag |= IN_CHANGE | IN_UPDATE;
> if (bpp != NULL) {
> @@ -313,7 +337,7 @@
> if (nsize > bp->b_bufsize)
> panic("ffs_realloccg: small buf 2");
> #endif
> - bp->b_bcount = nsize;
> + buf_adjcnt(bp, nsize);
> bp->b_flags |= B_DONE;
> memset(bp->b_data + osize, 0, nsize - osize);
> *bpp = bp;
> @@ -434,7 +458,7 @@
> /*
> * Find the preferred location for the cluster.
> */
> - pref = ffs1_blkpref(ip, start_lbn, soff, sbap);
> + pref = ffs1_blkpref(ip, start_lbn, soff, 0, sbap);
> /*
> * If the block range spans two block maps, get the second map.
> */
> @@ -454,7 +478,7 @@
> /*
> * Search the block map looking for an allocation of the desired
> size.
> */
> - if ((newblk = ffs_hashalloc(ip, dtog(fs, pref), pref, len,
> + if ((newblk = ffs_hashalloc(ip, dtog(fs, pref), pref, len, 0,
> ffs_clusteralloc)) == 0)
> goto fail;
> /*
> @@ -538,10 +562,17 @@
> printf("\n\tnew:");
> #endif
> for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) {
> + if (ip->i_ump->um_mountp->mnt_wapbl &&
> + ITOV(ip)->v_type != VREG) {
> +
> UFS_WAPBL_REGISTER_DEALLOCATION(ip->i_ump->um_mountp,
> + dbtofsb(fs, buflist->bs_children[i]->b_blkno),
> + fs->fs_bsize);
> + } else {
> if (!DOINGSOFTDEP(vp))
> ffs_blkfree(ip,
> - dbtofsb(fs, buflist->bs_children[i]->b_blkno),
> + buflist->bs_children[i]->b_blkno,
> fs->fs_bsize);
> + }
> buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno);
> #ifdef DIAGNOSTIC
> if (!ffs_checkblk(ip,
> @@ -660,13 +691,13 @@
> /*
> * Find the preferred location for the cluster.
> */
> - pref = ffs2_blkpref(ip, start_lbn, soff, sbap);
> + pref = ffs2_blkpref(ip, start_lbn, soff, 0, sbap);
>
> /*
> * Search the block map looking for an allocation of the desired
> size.
> */
> if ((newblk = ffs_hashalloc(ip, dtog(fs, pref), pref,
> - len, ffs_clusteralloc)) == 0)
> + len, 0, ffs_clusteralloc)) == 0)
> goto fail;
>
> /*
> @@ -753,9 +784,16 @@
> printf("\n\tnew:");
> #endif
> for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) {
> - if (!DOINGSOFTDEP(vp))
> - ffs_blkfree(ip, dbtofsb(fs,
> - buflist->bs_children[i]->b_blkno),
> fs->fs_bsize);
> + if (ip->i_ump->um_mountp->mnt_wapbl &&
> + ITOV(ip)->v_type != VREG) {
> +
> UFS_WAPBL_REGISTER_DEALLOCATION(ip->i_ump->um_mountp,
> + buflist->bs_children[i]->b_blkno,
> fs->fs_bsize);
> + } else {
> + if (!DOINGSOFTDEP(vp))
> + ffs_blkfree(ip, dbtofsb(fs,
> + buflist->bs_children[i]->b_blkno),
> + fs->fs_bsize);
> + }
> buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno);
> #ifdef DIAGNOSTIC
> if (!ffs_checkblk(ip,
> @@ -831,8 +869,15 @@
> ufsino_t ino, ipref;
> int cg, error;
>
> + UFS_WAPBL_JUNLOCK_ASSERT(pvp->v_mount);
> +
> *vpp = NULL;
> fs = pip->i_fs;
> +
> + error = UFS_WAPBL_BEGIN(pvp->v_mount);
> + if (error)
> + return error;
> +
> if (fs->fs_cstotal.cs_nifree == 0)
> goto noinodes;
>
> @@ -855,12 +900,18 @@
> if (fs->fs_contigdirs[cg] > 0)
> fs->fs_contigdirs[cg]--;
> }
> - ino = (ufsino_t)ffs_hashalloc(pip, cg, ipref, mode,
> ffs_nodealloccg);
> + ino = (ufsino_t)ffs_hashalloc(pip, cg, ipref, mode, 0,
> ffs_nodealloccg);
> if (ino == 0)
> goto noinodes;
> + UFS_WAPBL_END(pvp->v_mount);
> error = VFS_VGET(pvp->v_mount, ino, vpp);
> if (error) {
> - ffs_inode_free(pip, ino, mode);
> + int err;
> + err = UFS_WAPBL_BEGIN(pvp->v_mount);
> + if (err == 0) {
> + ffs_inode_free(pip, ino, mode);
> + UFS_WAPBL_END(pvp->v_mount);
> + }
> return (error);
> }
>
> @@ -896,6 +947,7 @@
> return (0);
>
> noinodes:
> + UFS_WAPBL_END(pvp->v_mount);
> if (ratecheck(&fsnoinodes_last, &fserr_interval)) {
> ffs_fserr(fs, cred->cr_uid, "out of inodes");
> uprintf("\n%s: create/symlink failed, no inodes free\n",
> @@ -1060,7 +1112,7 @@
> * allocated.
> */
> int32_t
> -ffs1_blkpref(struct inode *ip, daddr_t lbn, int indx, int32_t *bap)
> +ffs1_blkpref(struct inode *ip, daddr_t lbn, int indx, int flags, int32_t
> *bap)
> {
> struct fs *fs;
> int cg, inocg, avgbfree, startcg;
> @@ -1068,6 +1120,26 @@
>
> KASSERT(indx <= 0 || bap != NULL);
> fs = ip->i_fs;
> +
> + /*
> + * If allocating a contiguous file with B_CONTIG, use the hints
> + * in the inode extentions to return the desired block.
> + *
> + * For metadata (indirect blocks) return the address of where
> + * the first indirect block resides - we'll scan for the next
> + * available slot if we need to allocate more than one indirect
> + * block. For data, return the address of the actual block
> + * relative to the address of the first data block.
> + */
> + if (flags & B_CONTIG) {
> + KASSERT(ip->i_ffs_first_data_blk != 0);
> + KASSERT(ip->i_ffs_first_indir_blk != 0);
> + if (flags & B_METAONLY)
> + return ip->i_ffs_first_indir_blk;
> + else
> + return ip->i_ffs_first_data_blk + blkstofrags(fs,
> lbn);
> + }
> +
> /*
> * Allocation of indirect blocks is indicated by passing negative
> * values in indx: -1 for single indirect, -2 for double indirect,
> @@ -1160,7 +1232,7 @@
> */
> #ifdef FFS2
> int64_t
> -ffs2_blkpref(struct inode *ip, daddr_t lbn, int indx, int64_t *bap)
> +ffs2_blkpref(struct inode *ip, daddr_t lbn, int indx, int flags, int64_t
> *bap)
> {
> struct fs *fs;
> int cg, inocg, avgbfree, startcg;
> @@ -1168,6 +1240,26 @@
>
> KASSERT(indx <= 0 || bap != NULL);
> fs = ip->i_fs;
> +
> + /*
> + * If allocating a contiguous file with B_CONTIG, use the hints
> + * in the inode extentions to return the desired block.
> + *
> + * For metadata (indirect blocks) return the address of where
> + * the first indirect block resides - we'll scan for the next
> + * available slot if we need to allocate more than one indirect
> + * block. For data, return the address of the actual block
> + * relative to the address of the first data block.
> + */
> + if (flags & B_CONTIG) {
> + KASSERT(ip->i_ffs_first_data_blk != 0);
> + KASSERT(ip->i_ffs_first_indir_blk != 0);
> + if (flags & B_METAONLY)
> + return ip->i_ffs_first_indir_blk;
> + else
> + return ip->i_ffs_first_data_blk + blkstofrags(fs,
> lbn);
> + }
> +
> /*
> * Allocation of indirect blocks is indicated by passing negative
> * values in indx: -1 for single indirect, -2 for double indirect,
> @@ -1267,8 +1359,8 @@
> * 3) brute force search for a free block.
> */
> daddr_t
> -ffs_hashalloc(struct inode *ip, int cg, daddr_t pref, int size,
> - daddr_t (*allocator)(struct inode *, int, daddr_t, int))
> +ffs_hashalloc(struct inode *ip, int cg, daddr_t pref, int size, int flags,
> + daddr_t (*allocator)(struct inode *, int, daddr_t, int, int))
> {
> struct fs *fs;
> daddr_t result;
> @@ -1278,9 +1370,13 @@
> /*
> * 1: preferred cylinder group
> */
> - result = (*allocator)(ip, cg, pref, size);
> + result = (*allocator)(ip, cg, pref, size, flags);
> if (result)
> return (result);
> +
> + if (flags & B_CONTIG)
> + return (result);
> +
> /*
> * 2: quadratic rehash
> */
> @@ -1288,7 +1384,7 @@
> cg += i;
> if (cg >= fs->fs_ncg)
> cg -= fs->fs_ncg;
> - result = (*allocator)(ip, cg, 0, size);
> + result = (*allocator)(ip, cg, 0, size, flags);
> if (result)
> return (result);
> }
> @@ -1299,7 +1395,7 @@
> */
> cg = (icg + 2) % fs->fs_ncg;
> for (i = 2; i < fs->fs_ncg; i++) {
> - result = (*allocator)(ip, cg, 0, size);
> + result = (*allocator)(ip, cg, 0, size, flags);
> if (result)
> return (result);
> cg++;
> @@ -1310,11 +1406,11 @@
> }
>
> struct buf *
> -ffs_cgread(struct fs *fs, struct inode *ip, int cg)
> +ffs_cgread(struct fs *fs, struct vnode *devvp, int cg)
> {
> struct buf *bp;
>
> - if (bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
> + if (bread(devvp, fsbtodb(fs, cgtod(fs, cg)),
> (int)fs->fs_cgsize, &bp)) {
> brelse(bp);
> return (NULL);
> @@ -1353,7 +1449,7 @@
> return (0);
> }
>
> - if (!(bp = ffs_cgread(fs, ip, cg)))
> + if (!(bp = ffs_cgread(fs, ip->i_devvp, cg)))
> return (0);
>
> cgp = (struct cg *)bp->b_data;
> @@ -1398,7 +1494,7 @@
> * and if it is, allocate it.
> */
> daddr_t
> -ffs_alloccg(struct inode *ip, int cg, daddr_t bpref, int size)
> +ffs_alloccg(struct inode *ip, int cg, daddr_t bpref, int size, int flags)
> {
> struct fs *fs;
> struct cg *cgp;
> @@ -1410,7 +1506,7 @@
> if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
> return (0);
>
> - if (!(bp = ffs_cgread(fs, ip, cg)))
> + if (!(bp = ffs_cgread(fs, ip->i_devvp, cg)))
> return (0);
>
> cgp = (struct cg *)bp->b_data;
> @@ -1423,7 +1519,7 @@
>
> if (size == fs->fs_bsize) {
> /* allocate and return a complete data block */
> - bno = ffs_alloccgblk(ip, bp, bpref);
> + bno = ffs_alloccgblk(ip, bp, bpref, flags);
> bdwrite(bp);
> return (bno);
> }
> @@ -1445,7 +1541,7 @@
> brelse(bp);
> return (0);
> }
> - bno = ffs_alloccgblk(ip, bp, bpref);
> + bno = ffs_alloccgblk(ip, bp, bpref, flags);
> bpref = dtogd(fs, bno);
> for (i = frags; i < fs->fs_frag; i++)
> setbit(cg_blksfree(cgp), bpref + i);
> @@ -1487,7 +1583,7 @@
> * blocks may be fragmented by the routine that allocates them.
> */
> daddr_t
> -ffs_alloccgblk(struct inode *ip, struct buf *bp, daddr_t bpref)
> +ffs_alloccgblk(struct inode *ip, struct buf *bp, daddr_t bpref, int flags)
> {
> struct fs *fs;
> struct cg *cgp;
> @@ -1515,6 +1611,12 @@
> if (ffs_isblock(fs, blksfree, fragstoblks(fs, bno)))
> goto gotit;
> /*
> + * if the requested data block isn't available and we are trying to
> + * allocate a contiguous file, return an error.
> + */
> + if ((flags & (B_CONTIG | B_METAONLY)) == B_CONTIG)
> + return (0);
> + /*
> * Take the next available block in this cylinder group.
> */
> bno = ffs_mapsearch(fs, cgp, bpref, (int) fs->fs_frag);
> @@ -1556,7 +1658,7 @@
> * take the first one that we find following bpref.
> */
> daddr_t
> -ffs_clusteralloc(struct inode *ip, int cg, daddr_t bpref, int len)
> +ffs_clusteralloc(struct inode *ip, int cg, daddr_t bpref, int len, int
> flags)
> {
> struct fs *fs;
> struct cg *cgp;
> @@ -1569,7 +1671,7 @@
> if (fs->fs_maxcluster[cg] < len)
> return (0);
>
> - if (!(bp = ffs_cgread(fs, ip, cg)))
> + if (!(bp = ffs_cgread(fs, ip->i_devvp, cg)))
> return (0);
>
> cgp = (struct cg *)bp->b_data;
> @@ -1651,7 +1753,7 @@
>
> len = blkstofrags(fs, len);
> for (i = 0; i < len; i += fs->fs_frag)
> - if (ffs_alloccgblk(ip, bp, bno + i) != bno + i)
> + if (ffs_alloccgblk(ip, bp, bno + i, flags) != bno + i)
> panic("ffs_clusteralloc: lost block");
> bdwrite(bp);
> return (bno);
> @@ -1663,7 +1765,7 @@
>
> /* inode allocation routine */
> daddr_t
> -ffs_nodealloccg(struct inode *ip, int cg, daddr_t ipref, int mode)
> +ffs_nodealloccg(struct inode *ip, int cg, daddr_t ipref, int mode, int
> flags)
> {
> struct fs *fs;
> struct cg *cgp;
> @@ -1680,10 +1782,11 @@
> * and in the cylinder group itself.
> */
> fs = ip->i_fs;
> + UFS_WAPBL_JLOCK_ASSERT(ip->i_ump->um_mountp);
> if (fs->fs_cs(fs, cg).cs_nifree == 0)
> return (0);
>
> - if (!(bp = ffs_cgread(fs, ip, cg)))
> + if (!(bp = ffs_cgread(fs, ip->i_devvp, cg)))
> return (0);
>
> cgp = (struct cg *)bp->b_data;
> @@ -1758,6 +1861,9 @@
>
> gotit:
>
> + UFS_WAPBL_REGISTER_INODE(ip->i_ump->um_mountp, cg * fs->fs_ipg +
> ipref,
> + mode);
> +
> #ifdef FFS2
> /*
> * For FFS2, check if all inodes in this cylinder group have been
> used
> @@ -1819,6 +1925,119 @@
> }
>
> /*
> + * Allocate a block or fragment.
> + *
> + * The specified block or fragment is removed from the
> + * free map, possibly fragmenting a block in the process.
> + *
> + * This implementation should mirror fs_blkfree
> + */
> +int
> +ffs_blkalloc_ump(struct ufsmount *ump, daddr_t bno, long size)
> +{
> + struct fs *fs = ump->um_fs;
> + struct cg *cgp;
> + struct buf *bp;
> + int32_t fragno, cgbno;
> + int i, error, cg, blk, frags, bbase;
> + u_int8_t *blksfree;
> +
> + KASSERT((u_int)size <= fs->fs_bsize && fragoff(fs, size) == 0 &&
> + fragnum(fs, bno) + numfrags(fs, size) <= fs->fs_frag);
> + KASSERT(bno < fs->fs_size);
> +
> + cg = dtog(fs, bno);
> + error = bread(ump->um_devvp, fsbtodb(fs, cgtod(fs, cg)),
> + (int)fs->fs_cgsize, &bp);
> + if (error) {
> + brelse(bp);
> + return error;
> + }
> + cgp = (struct cg *)bp->b_data;
> + if (!cg_chkmagic(cgp)) {
> + brelse(bp);
> + return EIO;
> + }
> + cgp->cg_ffs2_time = time_second;
> + cgp->cg_time = (int32_t)cgp->cg_ffs2_time;
> + cgbno = dtogd(fs, bno);
> + blksfree = cg_blksfree(cgp);
> +
> + if (size == fs->fs_bsize) {
> + fragno = fragstoblks(fs, cgbno);
> + if (!ffs_isblock(fs, blksfree, fragno)) {
> + brelse(bp);
> + return EBUSY;
> + }
> + ffs_clrblock(fs, blksfree, fragno);
> + ffs_clusteracct(fs, cgp, fragno, -1);
> + cgp->cg_cs.cs_nbfree--;
> + fs->fs_cstotal.cs_nbfree--;
> + fs->fs_cs(fs, cg).cs_nbfree--;
> + } else {
> + bbase = cgbno - fragnum(fs, cgbno);
> +
> + frags = numfrags(fs, size);
> + for (i = 0; i < frags; i++) {
> + if (isclr(blksfree, cgbno + i)) {
> + brelse(bp);
> + return EBUSY;
> + }
> + }
> + /*
> + * if a complete block is being split, account for it
> + */
> + fragno = fragstoblks(fs, bbase);
> + if (ffs_isblock(fs, blksfree, fragno)) {
> + cgp->cg_cs.cs_nffree += fs->fs_frag;
> + fs->fs_cstotal.cs_nffree += fs->fs_frag;
> + fs->fs_cs(fs, cg).cs_nffree += fs->fs_frag;
> + ffs_clusteracct(fs, cgp, fragno, -1);
> + cgp->cg_cs.cs_nbfree--;
> + fs->fs_cstotal.cs_nbfree--;
> + fs->fs_cs(fs, cg).cs_nbfree--;
> + }
> + /*
> + * decrement the counts associated with the old frags
> + */
> + blk = blkmap(fs, blksfree, bbase);
> + ffs_fragacct(fs, blk, cgp->cg_frsum, -1);
> + /*
> + * allocate the fragment
> + */
> + for (i = 0; i < frags; i++) {
> + clrbit(blksfree, cgbno + i);
> + }
> + cgp->cg_cs.cs_nffree -= i;
> + fs->fs_cstotal.cs_nffree -= i;
> + fs->fs_cs(fs, cg).cs_nffree -= i;
> + /*
> + * add back in counts associated with the new frags
> + */
> + blk = blkmap(fs, blksfree, bbase);
> + ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
> + }
> + fs->fs_fmod = 1;
> + bdwrite(bp);
> + return 0;
> +}
> +
> +#ifdef WAPBL
> +void
> +ffs_wapbl_blkfree(struct fs *fs, struct vnode *devvp, daddr_t bno,
> + long size)
> +{
> + ffs_blkfree_subr(fs, devvp, NULL, bno, size);
> +}
> +#endif /* WAPBL */
> +
> +void
> +ffs_blkfree(struct inode *ip, daddr_t bno, long size)
> +{
> + ffs_blkfree_subr(NULL, NULL, ip, bno, size);
> +}
> +
> +/*
> * Free a block or fragment.
> *
> * The specified block or fragment is placed back in the
> @@ -1826,29 +2045,44 @@
> * block reassembly is checked.
> */
> void
> -ffs_blkfree(struct inode *ip, daddr_t bno, long size)
> +ffs_blkfree_subr(struct fs *fs, struct vnode *devvp, struct inode *ip,
> + daddr_t bno, long size)
> {
> - struct fs *fs;
> struct cg *cgp;
> struct buf *bp;
> daddr_t blkno;
> int i, cg, blk, frags, bbase;
>
> - fs = ip->i_fs;
> + KASSERT((fs != NULL && devvp != NULL) ^ (ip != NULL));
> +
> + if (fs == NULL) {
> + fs = ip->i_fs;
> + devvp = ip->i_devvp;
> + }
> +
> if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0 ||
> fragnum(fs, bno) + numfrags(fs, size) > fs->fs_frag) {
> - printf("dev = 0x%x, bsize = %d, size = %ld, fs = %s\n",
> - ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt);
> + if (ip == NULL)
> + printf("bsize = %d, size = %ld, fs = %s\n",
> + fs->fs_bsize, size, fs->fs_fsmnt);
> + else
> + printf("dev = 0x%x, bsize = %d, size = %ld, fs =
> %s\n",
> + ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt);
> panic("ffs_blkfree: bad size");
> }
> cg = dtog(fs, bno);
> if ((u_int)bno >= fs->fs_size) {
> - printf("bad block %lld, ino %u\n", (long long)bno,
> - ip->i_number);
> - ffs_fserr(fs, DIP(ip, uid), "bad block");
> + if (ip == NULL) {
> + printf("bad block %lld\n", (long long)bno);
> + ffs_fserr(fs, 0, "bad block");
> + } else {
> + printf("bad block %lld, ino %u\n", (long long)bno,
> + ip->i_number);
> + ffs_fserr(fs, DIP(ip, uid), "bad block");
> + }
> return;
> }
> - if (!(bp = ffs_cgread(fs, ip, cg)))
> + if (!(bp = ffs_cgread(fs, devvp, cg)))
> return;
>
> cgp = (struct cg *)bp->b_data;
> @@ -1858,8 +2092,12 @@
> if (size == fs->fs_bsize) {
> blkno = fragstoblks(fs, bno);
> if (!ffs_isfreeblock(fs, cg_blksfree(cgp), blkno)) {
> - printf("dev = 0x%x, block = %lld, fs = %s\n",
> - ip->i_dev, (long long)bno, fs->fs_fsmnt);
> + if (ip == NULL)
> + printf("block = %lld, fs = %s\n",
> + (long long)bno, fs->fs_fsmnt);
> + else
> + printf("dev = 0x%x, block = %lld, fs =
> %s\n",
> + ip->i_dev, (long long)bno,
> fs->fs_fsmnt);
> panic("ffs_blkfree: freeing free block");
> }
> ffs_setblock(fs, cg_blksfree(cgp), blkno);
> @@ -1887,9 +2125,13 @@
> frags = numfrags(fs, size);
> for (i = 0; i < frags; i++) {
> if (isset(cg_blksfree(cgp), bno + i)) {
> - printf("dev = 0x%x, block = %lld, fs =
> %s\n",
> - ip->i_dev, (long long)(bno + i),
> - fs->fs_fsmnt);
> + if (ip == NULL)
> + printf("block = %lld, fs = %s\n",
> + (long long)(bno + i),
> fs->fs_fsmnt);
> + else
> + printf("dev = 0x%x, block = %lld, "
> + "fs = %s\n", ip->i_dev,
> + (long long)(bno + i),
> fs->fs_fsmnt);
> panic("ffs_blkfree: freeing free frag");
> }
> setbit(cg_blksfree(cgp), bno + i);
> @@ -1957,7 +2199,7 @@
> pip->i_dev, ino, fs->fs_fsmnt);
>
> cg = ino_to_cg(fs, ino);
> - if (!(bp = ffs_cgread(fs, pip, cg)))
> + if (!(bp = ffs_cgread(fs, pip->i_devvp, cg)))
> return (0);
>
> cgp = (struct cg *)bp->b_data;
> @@ -1971,6 +2213,8 @@
> panic("ffs_freefile: freeing free inode");
> }
> clrbit(cg_inosused(cgp), ino);
> + UFS_WAPBL_UNREGISTER_INODE(pip->i_ump->um_mountp,
> + ino + cg * fs->fs_ipg, mode);
> if (ino < cgp->cg_irotor)
> cgp->cg_irotor = ino;
> cgp->cg_cs.cs_nifree++;
> @@ -2008,7 +2252,7 @@
> if ((u_int)bno >= fs->fs_size)
> panic("ffs_checkblk: bad block %lld", (long long)bno);
>
> - if (!(bp = ffs_cgread(fs, ip, dtog(fs, bno))))
> + if (!(bp = ffs_cgread(fs, ip->i_devvp, dtog(fs, bno))))
> return (0);
>
> cgp = (struct cg *)bp->b_data;
> Index: sys/ufs/ffs/ffs_balloc.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ffs/ffs_balloc.c,v
> retrieving revision 1.43
> diff -u -r1.43 ffs_balloc.c
> --- sys/ufs/ffs/ffs_balloc.c 14 Mar 2015 03:38:52 -0000 1.43
> +++ sys/ufs/ffs/ffs_balloc.c 23 Oct 2015 15:07:07 -0000
> @@ -103,8 +103,9 @@
> osize = blksize(fs, ip, nb);
> if (osize < fs->fs_bsize && osize > 0) {
> error = ffs_realloccg(ip, nb,
> - ffs1_blkpref(ip, nb, (int)nb,
> &ip->i_ffs1_db[0]),
> - osize, (int)fs->fs_bsize, cred, bpp, &newb);
> + ffs1_blkpref(ip, nb, (int)nb, flags,
> + &ip->i_ffs1_db[0]), osize, (int)fs->fs_bsize,
> + flags, cred, bpp, &newb);
> if (error)
> return (error);
> if (DOINGSOFTDEP(vp))
> @@ -165,7 +166,7 @@
> brelse(*bpp);
> return (error);
> }
> - (*bpp)->b_bcount = osize;
> + buf_adjcnt((*bpp), osize);
> }
> return (0);
> } else {
> @@ -174,9 +175,9 @@
> * want, grow it.
> */
> error = ffs_realloccg(ip, lbn,
> - ffs1_blkpref(ip, lbn, (int)lbn,
> + ffs1_blkpref(ip, lbn, (int)lbn, flags,
> &ip->i_ffs1_db[0]),
> - osize, nsize, cred, bpp, &newb);
> + osize, nsize, flags, cred, bpp, &newb);
> if (error)
> return (error);
> if (DOINGSOFTDEP(vp))
> @@ -195,8 +196,8 @@
> else
> nsize = fs->fs_bsize;
> error = ffs_alloc(ip, lbn,
> - ffs1_blkpref(ip, lbn, (int)lbn,
> &ip->i_ffs1_db[0]),
> - nsize, cred, &newb);
> + ffs1_blkpref(ip, lbn, (int)lbn, flags,
> + &ip->i_ffs1_db[0]), nsize, flags, cred, &newb);
> if (error)
> return (error);
> if (bpp != NULL) {
> @@ -235,9 +236,10 @@
> allocib = NULL;
> allocblk = allociblk;
> if (nb == 0) {
> - pref = ffs1_blkpref(ip, lbn, -indirs[0].in_off - 1, NULL);
> + pref = ffs1_blkpref(ip, lbn, -indirs[0].in_off - 1,
> + flags | B_METAONLY, NULL);
> error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,
> - cred, &newb);
> + flags | B_METAONLY, cred, &newb);
> if (error)
> goto fail;
> nb = newb;
> @@ -283,9 +285,10 @@
> continue;
> }
> if (pref == 0)
> - pref = ffs1_blkpref(ip, lbn, i - num - 1, NULL);
> - error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred,
> - &newb);
> + pref = ffs1_blkpref(ip, lbn, i - num - 1,
> + flags | B_METAONLY, NULL);
> + error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,
> + flags | B_METAONLY, cred, &newb);
> if (error) {
> brelse(bp);
> goto fail;
> @@ -323,13 +326,20 @@
> bdwrite(bp);
> }
> }
> +
> + if (flags & B_METAONLY) {
> + KASSERT(bpp != NULL);
> + *bpp = bp;
> + return (0);
> + }
> +
> /*
> * Get the data block, allocating if necessary.
> */
> if (nb == 0) {
> - pref = ffs1_blkpref(ip, lbn, indirs[i].in_off, &bap[0]);
> - error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred,
> - &newb);
> + pref = ffs1_blkpref(ip, lbn, indirs[i].in_off, flags,
> &bap[0]);
> + error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, flags,
> + cred, &newb);
> if (error) {
> brelse(bp);
> goto fail;
> @@ -468,8 +478,8 @@
> osize = blksize(fs, ip, nb);
> if (osize < fs->fs_bsize && osize > 0) {
> error = ffs_realloccg(ip, nb, ffs2_blkpref(ip,
> - lastlbn, nb, &ip->i_ffs2_db[0]), osize,
> - (int) fs->fs_bsize, cred, bpp, &newb);
> + lastlbn, nb, flags, &ip->i_ffs2_db[0]), osize,
> + (int) fs->fs_bsize, flags, cred, bpp, &newb);
> if (error)
> return (error);
>
> @@ -535,7 +545,7 @@
> brelse(*bpp);
> return (error);
> }
> - (*bpp)->b_bcount = osize;
> + buf_adjcnt((*bpp), osize);
> }
>
> return (0);
> @@ -545,9 +555,9 @@
> * grow it.
> */
> error = ffs_realloccg(ip, lbn,
> - ffs2_blkpref(ip, lbn, (int) lbn,
> - &ip->i_ffs2_db[0]), osize, nsize, cred,
> - bpp, &newb);
> + ffs2_blkpref(ip, lbn, (int) lbn, flags,
> + &ip->i_ffs2_db[0]), osize, nsize,
> flags,
> + cred, bpp, &newb);
> if (error)
> return (error);
>
> @@ -567,7 +577,8 @@
> nsize = fs->fs_bsize;
>
> error = ffs_alloc(ip, lbn, ffs2_blkpref(ip, lbn,
> - (int) lbn, &ip->i_ffs2_db[0]), nsize, cred,
> &newb);
> + (int) lbn, flags, &ip->i_ffs2_db[0]), nsize,
> flags,
> + cred, &newb);
> if (error)
> return (error);
>
> @@ -614,9 +625,10 @@
> allocblk = allociblk;
>
> if (nb == 0) {
> - pref = ffs2_blkpref(ip, lbn, -indirs[0].in_off - 1, NULL);
> - error = ffs_alloc(ip, lbn, pref, (int) fs->fs_bsize, cred,
> - &newb);
> + pref = ffs2_blkpref(ip, lbn, -indirs[0].in_off - 1,
> + flags | B_METAONLY, NULL);
> + error = ffs_alloc(ip, lbn, pref, (int) fs->fs_bsize,
> + flags | B_METAONLY, cred, &newb);
> if (error)
> goto fail;
>
> @@ -670,10 +682,11 @@
> }
>
> if (pref == 0)
> - pref = ffs2_blkpref(ip, lbn, i - num - 1, NULL);
> + pref = ffs2_blkpref(ip, lbn, i - num - 1,
> + flags | B_METAONLY, NULL);
>
> - error = ffs_alloc(ip, lbn, pref, (int) fs->fs_bsize, cred,
> - &newb);
> + error = ffs_alloc(ip, lbn, pref, (int) fs->fs_bsize,
> + flags | B_METAONLY, cred, &newb);
> if (error) {
> brelse(bp);
> goto fail;
> @@ -716,14 +729,21 @@
> bdwrite(bp);
> }
>
> + if (flags & B_METAONLY) {
> + KASSERT(bpp != NULL);
> + *bpp = bp;
> + return (0);
> + }
> +
> /*
> * Get the data block, allocating if necessary.
> */
> if (nb == 0) {
> - pref = ffs2_blkpref(ip, lbn, indirs[num].in_off, &bap[0]);
> + pref = ffs2_blkpref(ip, lbn, indirs[num].in_off, flags,
> + &bap[0]);
>
> - error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred,
> - &newb);
> + error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, flags,
> + cred, &newb);
> if (error) {
> brelse(bp);
> goto fail;
> Index: sys/ufs/ffs/ffs_extern.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ffs/ffs_extern.h,v
> retrieving revision 1.40
> diff -u -r1.40 ffs_extern.h
> --- sys/ufs/ffs/ffs_extern.h 25 Jan 2014 23:31:12 -0000 1.40
> +++ sys/ufs/ffs/ffs_extern.h 23 Oct 2015 15:07:07 -0000
> @@ -99,19 +99,20 @@
> extern struct vops ffs_fifovops;
>
> /* ffs_alloc.c */
> -int ffs_alloc(struct inode *, daddr_t, daddr_t , int, struct ucred *,
> - daddr_t *);
> -int ffs_realloccg(struct inode *, daddr_t, daddr_t, int, int ,
> - struct ucred *, struct buf **, daddr_t *);
> +int ffs_alloc(struct inode *, daddr_t, daddr_t , int, int, struct ucred *,
> + daddr_t *);
> +int ffs_realloccg(struct inode *, daddr_t, daddr_t, int, int, int,
> + struct ucred *, struct buf **, daddr_t *);
> int ffs_reallocblks(void *);
> int ffs_inode_alloc(struct inode *, mode_t, struct ucred *, struct vnode
> **);
> int ffs_inode_free(struct inode *, ufsino_t, mode_t);
> int ffs_freefile(struct inode *, ufsino_t, mode_t);
>
> -int32_t ffs1_blkpref(struct inode *, daddr_t, int, int32_t *);
> +int32_t ffs1_blkpref(struct inode *, daddr_t, int, int, int32_t *);
> #ifdef FFS2
> -int64_t ffs2_blkpref(struct inode *, daddr_t, int, int64_t *);
> +int64_t ffs2_blkpref(struct inode *, daddr_t, int, int, int64_t *);
> #endif
> +int ffs_blkalloc_ump(struct ufsmount *, daddr_t, long);
> void ffs_blkfree(struct inode *, daddr_t, long);
> void ffs_clusteracct(struct fs *, struct cg *, daddr_t, int);
>
> @@ -160,6 +161,18 @@
> int ffs_reclaim(void *);
> int ffsfifo_reclaim(void *);
>
> +/* ffs_wapbl.c -- write ahead physical block logging */
> +void ffs_wapbl_verify_inodes(struct mount *, const char *);
> +void ffs_wapbl_replay_finish(struct mount *);
> +int ffs_wapbl_start(struct mount *);
> +int ffs_wapbl_stop(struct mount *, int);
> +int ffs_wapbl_replay_start(struct mount *, struct fs *, struct vnode
> *);
> +void ffs_wapbl_blkalloc(struct fs *, struct vnode *, daddr_t, int);
> +
> +void ffs_wapbl_sync_metadata(struct mount *, daddr_t *, int *, int);
> +void ffs_wapbl_abort_sync_metadata(struct mount *, daddr_t *, int *,
> int);
> +void ffs_wapbl_blkfree(struct fs *, struct vnode *, daddr_t, long);
> +
> /*
> * Soft dependency function prototypes.
> */
> Index: sys/ufs/ffs/ffs_inode.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ffs/ffs_inode.c,v
> retrieving revision 1.74
> diff -u -r1.74 ffs_inode.c
> --- sys/ufs/ffs/ffs_inode.c 14 Mar 2015 03:38:52 -0000 1.74
> +++ sys/ufs/ffs/ffs_inode.c 23 Oct 2015 15:07:07 -0000
> @@ -41,11 +41,13 @@
> #include <sys/kernel.h>
> #include <sys/malloc.h>
> #include <sys/resourcevar.h>
> +#include <sys/wapbl.h>
>
> #include <ufs/ufs/quota.h>
> #include <ufs/ufs/inode.h>
> #include <ufs/ufs/ufsmount.h>
> #include <ufs/ufs/ufs_extern.h>
> +#include <ufs/ufs/ufs_wapbl.h>
>
> #include <ufs/ffs/fs.h>
> #include <ufs/ffs/ffs_extern.h>
> @@ -95,6 +97,16 @@
> return (error);
> }
>
> + if (DIP(ip, mode)) {
> + if (DIP(ip, nlink) > 0) {
> + UFS_WAPBL_UNREGISTER_INODE(ip->i_ump->um_mountp,
> + ip->i_number, DIP(ip, mode));
> + } else {
> + UFS_WAPBL_REGISTER_INODE(ip->i_ump->um_mountp,
> + ip->i_number, DIP(ip, mode));
> + }
> + }
> +
> if (DOINGSOFTDEP(vp))
> softdep_update_inodeblock(ip, bp, waitfor);
> else if (ip->i_effnlink != DIP(ip, nlink))
> @@ -135,7 +147,7 @@
> struct fs *fs;
> struct buf *bp;
> int offset, size, level;
> - long count, nblocks, vflags, blocksreleased = 0;
> + long count, nblocks, blocksreleased = 0;
> int i, aflags, error, allerror;
> off_t osize;
>
> @@ -262,7 +274,7 @@
> (void) uvm_vnp_uncache(ovp);
> if (ovp->v_type != VDIR)
> memset(bp->b_data + offset, 0, size - offset);
> - bp->b_bcount = size;
> + buf_adjcnt(bp, size);
> if (aflags & B_SYNC)
> bwrite(bp);
> else
> @@ -321,8 +333,7 @@
> }
>
> DIP_ASSIGN(oip, size, osize);
> - vflags = ((length > 0) ? V_SAVE : 0) | V_SAVEMETA;
> - allerror = vinvalbuf(ovp, vflags, cred, curproc, 0, 0);
> + allerror = vtruncbuf(ovp, lastblock + 1, 0, 0);
>
> /*
> * Indirect blocks first.
> @@ -340,7 +351,12 @@
> blocksreleased += count;
> if (lastiblock[level] < 0) {
> DIP_ASSIGN(oip, ib[level], 0);
> - ffs_blkfree(oip, bn, fs->fs_bsize);
> + if (oip->i_ump->um_mountp->mnt_wapbl) {
> + UFS_WAPBL_REGISTER_DEALLOCATION(
> + oip->i_ump->um_mountp,
> + fsbtodb(fs, bn), fs->fs_bsize);
> + } else
> + ffs_blkfree(oip, bn, fs->fs_bsize);
> blocksreleased += nblocks;
> }
> }
> @@ -360,7 +376,12 @@
>
> DIP_ASSIGN(oip, db[i], 0);
> bsize = blksize(fs, oip, i);
> - ffs_blkfree(oip, bn, bsize);
> + if ((oip->i_ump->um_mountp->mnt_wapbl) &&
> + (ovp->v_type != VREG)) {
> +
> UFS_WAPBL_REGISTER_DEALLOCATION(oip->i_ump->um_mountp,
> + fsbtodb(fs, bn), bsize);
> + } else
> + ffs_blkfree(oip, bn, bsize);
> blocksreleased += btodb(bsize);
> }
> if (lastblock < 0)
> @@ -390,7 +411,13 @@
> * required for the storage we're keeping.
> */
> bn += numfrags(fs, newspace);
> - ffs_blkfree(oip, bn, oldspace - newspace);
> + if ((oip->i_ump->um_mountp->mnt_wapbl) &&
> + (ovp->v_type != VREG)) {
> + UFS_WAPBL_REGISTER_DEALLOCATION(
> + oip->i_ump->um_mountp, fsbtodb(fs, bn),
> + oldspace - newspace);
> + } else
> + ffs_blkfree(oip, bn, oldspace - newspace);
> blocksreleased += btodb(oldspace - newspace);
> }
> }
> @@ -412,6 +439,7 @@
> else /* sanity */
> DIP_ASSIGN(oip, blocks, 0);
> oip->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(oip, 0);
> (void)ufs_quota_free_blocks(oip, blocksreleased, NOCRED);
> return (allerror);
> }
> @@ -541,7 +569,12 @@
> allerror = error;
> blocksreleased += blkcount;
> }
> - ffs_blkfree(ip, nb, fs->fs_bsize);
> + if (ip->i_ump->um_mountp->mnt_wapbl &&
> + ((level > SINGLE) || ITOV(ip)->v_type != VREG)) {
> +
> UFS_WAPBL_REGISTER_DEALLOCATION(ip->i_ump->um_mountp,
> + fsbtodb(fs, nb), fs->fs_bsize);
> + } else
> + ffs_blkfree(ip, nb, fs->fs_bsize);
> blocksreleased += nblocks;
> }
>
> Index: sys/ufs/ffs/ffs_subr.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ffs/ffs_subr.c,v
> retrieving revision 1.29
> diff -u -r1.29 ffs_subr.c
> --- sys/ufs/ffs/ffs_subr.c 2 Nov 2013 00:08:17 -0000 1.29
> +++ sys/ufs/ffs/ffs_subr.c 23 Oct 2015 15:07:07 -0000
> @@ -72,7 +72,7 @@
> brelse(bp);
> return (error);
> }
> - bp->b_bcount = bsize;
> + buf_adjcnt(bp, bsize);
> if (res)
> *res = (char *)bp->b_data + blkoff(fs, offset);
> *bpp = bp;
> Index: sys/ufs/ffs/ffs_vfsops.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ffs/ffs_vfsops.c,v
> retrieving revision 1.149
> diff -u -r1.149 ffs_vfsops.c
> --- sys/ufs/ffs/ffs_vfsops.c 14 Mar 2015 03:38:52 -0000 1.149
> +++ sys/ufs/ffs/ffs_vfsops.c 23 Oct 2015 15:07:07 -0000
> @@ -50,7 +50,7 @@
> #include <sys/pool.h>
> #include <sys/dkio.h>
> #include <sys/disk.h>
> -#include <sys/specdev.h>
> +#include <sys/wapbl.h>
>
> #include <ufs/ufs/quota.h>
> #include <ufs/ufs/ufsmount.h>
> @@ -58,6 +58,7 @@
> #include <ufs/ufs/dir.h>
> #include <ufs/ufs/ufs_extern.h>
> #include <ufs/ufs/dirhash.h>
> +#include <ufs/ufs/ufs_wapbl.h>
>
> #include <ufs/ffs/fs.h>
> #include <ufs/ffs/ffs_extern.h>
> @@ -178,6 +179,15 @@
> if (error)
> return (error);
>
> +#ifdef WAPBL
> + /* WAPBL can only be enabled on a r/w mount. */
> + if ((mp->mnt_flag & MNT_RDONLY) && !(mp->mnt_flag & MNT_WANTRDWR))
> {
> + mp->mnt_flag &= ~MNT_LOG;
> + }
> +#else /* !WAPBL */
> + mp->mnt_flag &= ~MNT_LOG;
> +#endif /* !WAPBL */
> +
> #ifndef FFS_SOFTUPDATES
> if (mp->mnt_flag & MNT_SOFTDEP) {
> printf("WARNING: soft updates isn't compiled in\n");
> @@ -194,6 +204,16 @@
> (MNT_SOFTDEP | MNT_ASYNC)) {
> return (EINVAL);
> }
> +
> +#ifdef WAPBL
> + /*
> + * Likewise, WAPBL is incompatible with MNT_ASYNC and MNT_SOFTDEP.
> + */
> + if (mp->mnt_flag & MNT_LOG)
> + if (mp->mnt_flag & (MNT_ASYNC|MNT_SOFTDEP))
> + return (EINVAL);
> +#endif /* WAPBL */
> +
> /*
> * If updating, check whether changing from read-only to
> * read/write; if there is no device name, that's all we do.
> @@ -220,11 +240,30 @@
> if (fs->fs_flags & FS_DOSOFTDEP) {
> error = softdep_flushfiles(mp, flags, p);
> mp->mnt_flag &= ~MNT_SOFTDEP;
> - } else
> + } else {
> error = ffs_flushfiles(mp, flags, p);
> + if (error == 0)
> + error = UFS_WAPBL_BEGIN(mp);
> + if (error == 0 &&
> + ffs_cgupdate(ump, MNT_WAIT) == 0 &&
> + fs->fs_clean & FS_WASCLEAN) {
> + fs->fs_clean = FS_ISCLEAN;
> + (void) ffs_sbupdate(ump, MNT_WAIT);
> + }
> + if (error == 0)
> + UFS_WAPBL_END(mp);
> + }
> ronly = 1;
> }
>
> +#ifdef WAPBL
> + if (error == 0 && (mp->mnt_flag & MNT_LOG) == 0) {
> + error = ffs_wapbl_stop(mp, mp->mnt_flag &
> MNT_FORCE);
> + if (error)
> + return (error);
> + }
> +#endif /* WAPBL */
> +
> /*
> * Flush soft dependencies if disabling it via an update
> * mount. This may leave some items to be processed,
> @@ -277,6 +316,31 @@
> goto error_1;
> }
>
> + fs->fs_contigdirs = malloc((u_long)fs->fs_ncg,
> + M_UFSMNT, M_WAITOK|M_ZERO);
> +
> +#ifdef WAPBL
> + if (mp->mnt_flag & MNT_LOG) {
> + fs->fs_ronly = 0;
> + fs->fs_fmod = 1;
> + }
> +
> + if (fs->fs_flags & FS_DOWAPBL) {
> + printf("%s: replaying log to disk\n",
> + mp->mnt_stat.f_mntonname);
> + KASSERT(mp->mnt_wapbl_replay);
> + error =
> wapbl_replay_write(mp->mnt_wapbl_replay,
> + devvp);
> + if (error) {
> + free(fs->fs_contigdirs, M_UFSMNT,
> 0);
> + return (error);
> + }
> + wapbl_replay_stop(mp->mnt_wapbl_replay);
> + fs->fs_clean = FS_WASCLEAN;
> + goto logok;
> + }
> +#endif /* WAPBL */
> +
> if (fs->fs_clean == 0) {
> #if 0
> /*
> @@ -313,8 +377,18 @@
> fs->fs_contigdirs = malloc((u_long)fs->fs_ncg,
> M_UFSMNT, M_WAITOK|M_ZERO);
>
> +#ifdef WAPBL
> +logok:
> +#endif /* WAPBL */
> ronly = 0;
> }
> +
> +#ifdef WAPBL
> + error = ffs_wapbl_start(mp);
> + if (error)
> + return error;
> +#endif /* WAPBL */
> +
> if (args.fspec == NULL) {
> /*
> * Process export requests.
> @@ -323,8 +397,12 @@
> &args.export_info);
> if (error)
> goto error_1;
> - else
> + else {
> + error = UFS_WAPBL_BEGIN(mp);
> + if (error)
> + goto error_1;
> goto success;
> + }
> }
> }
>
> @@ -417,6 +495,10 @@
> if (error)
> goto error_2;
>
> + error = UFS_WAPBL_BEGIN(mp);
> + if (error)
> + goto error_2;
> +
> /*
> * Initialize FS stat information in mount struct; uses both
> * mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
> @@ -445,6 +527,7 @@
> }
> ffs_sbupdate(ump, MNT_WAIT);
> }
> + UFS_WAPBL_END(mp);
> return (0);
>
> error_2: /* error with devvp held */
> @@ -693,6 +776,10 @@
> bp = NULL;
> ump = NULL;
>
> +#ifdef WAPBL
> +sbagain:
> +#endif /* WAPBL */
> +
> /*
> * Try reading the super-block in each of its possible locations.
> */
> @@ -735,6 +822,43 @@
> goto out;
> }
>
> +#ifdef WAPBL
> + if ((mp->mnt_wapbl_replay == 0) && (fs->fs_flags & FS_DOWAPBL)) {
> + error = ffs_wapbl_replay_start(mp, fs, devvp);
> + if (error && (mp->mnt_flag & MNT_FORCE) == 0)
> + goto out;
> + if (!error) {
> + if (!ronly) {
> + /* XXX fsmnt may be stale. */
> + printf("%s: replaying log to disk\n",
> + fs->fs_fsmnt);
> + error =
> wapbl_replay_write(mp->mnt_wapbl_replay,
> + devvp);
> + if (error)
> + goto out;
> + wapbl_replay_stop(mp->mnt_wapbl_replay);
> + fs->fs_clean = FS_WASCLEAN;
> + } else {
> + /* XXX fsmnt may be stale */
> + printf("%s: replaying log to memory\n",
> + fs->fs_fsmnt);
> + }
> +
> + /* Force a re-read of the superblock */
> + bp->b_flags |= B_INVAL;
> + brelse(bp);
> + bp = NULL;
> + fs = NULL;
> + goto sbagain;
> + }
> + }
> +#else /* !WAPBL */
> + if ((fs->fs_flags & FS_DOWAPBL) && (mp->mnt_flag & MNT_FORCE) ==
> 0) {
> + error = EPERM;
> + goto out;
> + }
> +#endif /* !WAPBL */
> +
> fs->fs_fmod = 0;
> fs->fs_flags &= ~FS_UNCLEAN;
> if (fs->fs_clean == 0) {
> @@ -793,6 +917,13 @@
>
> ffs1_compat_read(fs, ump, sbloc);
>
> + /* Don't bump fs_clean if we're replaying journal */
> + if (!((fs->fs_flags & FS_DOWAPBL) && (fs->fs_clean & FS_WASCLEAN)))
> + if (ronly == 0) {
> + fs->fs_clean <<= 1;
> + fs->fs_fmod = 1;
> + }
> +
> if (fs->fs_clean == 0)
> fs->fs_flags |= FS_UNCLEAN;
> fs->fs_ronly = ronly;
> @@ -879,6 +1010,38 @@
> if (fs->fs_maxfilesize > maxfilesize) /* XXX */
> fs->fs_maxfilesize = maxfilesize; /* XXX */
> if (ronly == 0) {
> +#ifdef WAPBL
> + KASSERT(fs->fs_ronly == 0);
> + /*
> + * verify that we can access the last block in the fs if
> we're
> + * mounting read/write.
> + */
> + error = bread(devvp, fsbtodb(fs, fs->fs_size - 1),
> + fs->fs_fsize, &bp);
> + if (bp->b_bcount != fs->fs_fsize)
> + error = EINVAL;
> + bp->b_flags |= B_INVAL;
> + if (error) {
> + free(fs->fs_csp, M_UFSMNT, 0);
> + free(fs->fs_contigdirs, M_UFSMNT, 0);
> + goto out;
> + }
> + brelse(bp);
> + bp = NULL;
> + /*
> + * ffs_wapbl_start() needs mp->mnt_stat initialised if it
> + * needs to create a new log file in-filesystem.
> + */
> + ffs_statfs(mp, &mp->mnt_stat, curproc);
> +
> + error = ffs_wapbl_start(mp);
> + if (error) {
> + free(fs->fs_csp, M_UFSMNT, 0);
> + free(fs->fs_contigdirs, M_UFSMNT, 0);
> + goto out;
> + }
> +#endif /* WAPBL */
> +
> if ((fs->fs_flags & FS_DOSOFTDEP) &&
> (error = softdep_mount(devvp, mp, fs, cred)) != 0) {
> free(fs->fs_csp, M_UFSMNT, 0);
> @@ -891,12 +1054,30 @@
> fs->fs_flags |= FS_DOSOFTDEP;
> else
> fs->fs_flags &= ~FS_DOSOFTDEP;
> + error = UFS_WAPBL_BEGIN(mp);
> + if (error) {
> + free(fs->fs_csp, M_UFSMNT, 0);
> + free(fs->fs_contigdirs, M_UFSMNT, 0);
> + goto out;
> + }
> error = ffs_sbupdate(ump, MNT_WAIT);
> - if (error == EROFS)
> + UFS_WAPBL_END(mp);
> + if (error == EROFS) {
> + free(fs->fs_csp, M_UFSMNT, 0);
> + free(fs->fs_contigdirs, M_UFSMNT, 0);
> goto out;
> + }
> }
> return (0);
> out:
> +#ifdef WAPBL
> + if (mp->mnt_wapbl_replay) {
> + wapbl_replay_stop(mp->mnt_wapbl_replay);
> + wapbl_replay_free(mp->mnt_wapbl_replay);
> + mp->mnt_wapbl_replay = NULL;
> + }
> +#endif /* WAPBL */
> +
> devvp->v_specmountpoint = NULL;
> if (bp)
> brelse(bp);
> @@ -994,7 +1175,10 @@
> struct ufsmount *ump;
> struct fs *fs;
> int error, flags;
> -
> +#ifdef WAPBL
> + extern int doforce;
> +#endif /* WAPBL */
> +
> flags = 0;
> if (mntflags & MNT_FORCE)
> flags |= FORCECLOSE;
> @@ -1007,6 +1191,9 @@
> error = ffs_flushfiles(mp, flags, p);
> if (error != 0)
> return (error);
> + error = UFS_WAPBL_BEGIN(mp);
> + if (error)
> + goto logfail;
>
> if (fs->fs_ronly == 0) {
> fs->fs_clean = (fs->fs_flags & FS_UNCLEAN) ? 0 : 1;
> @@ -1018,6 +1205,21 @@
> }
> free(fs->fs_contigdirs, M_UFSMNT, 0);
> }
> + UFS_WAPBL_END(mp);
> +logfail:
> +#ifdef WAPBL
> + KASSERT(!(mp->mnt_wapbl_replay && mp->mnt_wapbl));
> + if (mp->mnt_wapbl_replay) {
> + KASSERT(fs->fs_ronly);
> + wapbl_replay_stop(mp->mnt_wapbl_replay);
> + wapbl_replay_free(mp->mnt_wapbl_replay);
> + mp->mnt_wapbl_replay = NULL;
> + }
> + error = ffs_wapbl_stop(mp, doforce && (mntflags & MNT_FORCE));
> + if (error) {
> + return error;
> + }
> +#endif /* WAPBL */
> ump->um_devvp->v_specmountpoint = NULL;
>
> vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p);
> @@ -1069,6 +1271,17 @@
> vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p);
> error = VOP_FSYNC(ump->um_devvp, p->p_ucred, MNT_WAIT, p);
> VOP_UNLOCK(ump->um_devvp, 0, p);
> +
> +#ifdef WAPBL
> + if (error)
> + return error;
> + if (mp->mnt_wapbl) {
> + error = wapbl_flush(mp->mnt_wapbl, 1);
> + if (flags & FORCECLOSE)
> + error = 0;
> + }
> +#endif
> +
> return (error);
> }
>
> @@ -1202,9 +1415,26 @@
> * Write back modified superblock.
> */
>
> - if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0)
> - allerror = error;
> + if (fs->fs_fmod != 0) {
> + error = UFS_WAPBL_BEGIN(mp);
> + if (error)
> + allerror = error;
> + else {
> + error = ffs_cgupdate(ump, waitfor);
> + if (error)
> + allerror = error;
> + UFS_WAPBL_END(mp);
> + }
> + }
>
> +#ifdef WAPBL
> + if (mp->mnt_wapbl) {
> + error = wapbl_flush(mp->mnt_wapbl, waitfor != MNT_NOWAIT);
> + if (error)
> + allerror = error;
> + }
> +#endif /* WAPBL */
> +
> return (allerror);
> }
>
> @@ -1466,6 +1696,42 @@
> }
>
> int
> +ffs_cgupdate(struct ufsmount *mp, int waitfor)
> +{
> + struct fs *fs = mp->um_fs;
> + struct buf *bp;
> + int blks;
> + void *space;
> + int i, size, error = 0, allerror = 0;
> +
> + allerror = ffs_sbupdate(mp, waitfor);
> + blks = howmany(fs->fs_cssize, fs->fs_fsize);
> + space = fs->fs_csp;
> + for (i = 0; i < blks; i += fs->fs_frag) {
> + size = fs->fs_bsize;
> + if (i + fs->fs_frag > blks)
> + size = (blks - i) * fs->fs_fsize;
> + bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
> size,
> + 0, 0);
> +#ifdef FFS_EI
> + if (mp->um_flags & UFS_NEEDSWAP)
> + ffs_csum_swap((struct csum*)space,
> + (struct csum*)bp->b_data, size);
> + else
> +#endif
> + memcpy(bp->b_data, space, (u_int)size);
> + space = (char *)space + size;
> + if (waitfor == MNT_WAIT)
> + error = bwrite(bp);
> + else
> + bawrite(bp);
> + }
> + if (!allerror && error)
> + allerror = error;
> + return (allerror);
> +}
> +
> +int
> ffs_init(struct vfsconf *vfsp)
> {
> static int done;
> Index: sys/ufs/ffs/ffs_vnops.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ffs/ffs_vnops.c,v
> retrieving revision 1.80
> diff -u -r1.80 ffs_vnops.c
> --- sys/ufs/ffs/ffs_vnops.c 14 Mar 2015 03:38:52 -0000 1.80
> +++ sys/ufs/ffs/ffs_vnops.c 23 Oct 2015 15:07:07 -0000
> @@ -45,7 +45,7 @@
> #include <sys/signalvar.h>
> #include <sys/pool.h>
> #include <sys/event.h>
> -#include <sys/specdev.h>
> +#include <sys/wapbl.h>
>
> #include <miscfs/fifofs/fifo.h>
>
> @@ -54,6 +54,7 @@
> #include <ufs/ufs/dir.h>
> #include <ufs/ufs/ufs_extern.h>
> #include <ufs/ufs/ufsmount.h>
> +#include <ufs/ufs/ufs_wapbl.h>
>
> #include <ufs/ffs/fs.h>
> #include <ufs/ffs/ffs_extern.h>
> @@ -274,6 +275,13 @@
> if (!(vp->v_mount->mnt_flag & MNT_NOATIME) ||
> (ip->i_flag & (IN_CHANGE | IN_UPDATE))) {
> ip->i_flag |= IN_ACCESS;
> + if ((ap->a_ioflag & IO_SYNC) == IO_SYNC) {
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error)
> + return (error);
> + error = UFS_UPDATE(ip, MNT_WAIT);
> + UFS_WAPBL_END(vp->v_mount);
> + }
> }
> return (error);
> }
> @@ -343,6 +351,12 @@
> osize = DIP(ip, size);
> flags = ioflag & IO_SYNC ? B_SYNC : 0;
>
> + if ((ioflag & IO_JOURNALLOCKED) == 0) {
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error)
> + return (error);
> + }
> +
> for (error = 0; uio->uio_resid > 0;) {
> lbn = lblkno(fs, uio->uio_offset);
> blkoffset = blkoff(fs, uio->uio_offset);
> @@ -410,12 +424,232 @@
> }
> } else if (resid > uio->uio_resid && (ioflag & IO_SYNC)) {
> error = UFS_UPDATE(ip, 1);
> - }
> + } else
> + UFS_WAPBL_UPDATE(ip, 0);
> + if ((ioflag & IO_JOURNALLOCKED) == 0)
> + UFS_WAPBL_END(vp->v_mount);
> /* correct the result for writes clamped by vn_fsizechk() */
> uio->uio_resid += overrun;
> return (error);
> }
>
> +#ifdef WAPBL
> +int ffs_wapbl_fsync_full(void *);
> +int ffs_wapbl_fsync(void *);
> +int ffs_wapbl_fsync_vfs(struct vnode *, int);
> +int ffs_wapbl_fsync_device(void *);
> +
> +int
> +ffs_wapbl_fsync_full(void *v)
> +{
> + struct vop_fsync_args *ap = v;
> + struct vnode *vp = ap->a_vp;
> + struct inode *ip = VTOI(vp);
> + struct mount *mp = vp->v_mount;
> + int waitfor = ap->a_waitfor;
> + int s, error = 0;
> +
> + KASSERT(vp->v_type != VREG);
> + KASSERT(mp->mnt_wapbl != NULL);
> +
> +#ifdef DIAGNOSTIC
> + s = splbio();
> + struct buf *bp, *nbp;
> + for (bp = LIST_FIRST(&vp->v_dirtyblkhd);
> + bp != LIST_END(&vp->v_dirtyblkhd); bp = nbp) {
> + nbp = LIST_NEXT(bp, b_vnbufs);
> + if ((bp->b_flags & B_LOCKED) == 0)
> + panic("ffs_wapbl_fsync_full: non-WAPBL buffer %p "
> + "on vnode %p", bp, vp);
> + }
> + splx(s);
> +#endif
> +
> + /*
> + * Don't bother writing out metadata if the syncer is making the
> + * request. We will let the sync vnode write it out in a single
> burst
> + * through a call to VFS_SYNC().
> + */
> + if (waitfor == MNT_LAZY)
> + return (0);
> +
> + if ((ip->i_flag &
> + (IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFIED)) != 0) {
> + error = UFS_WAPBL_BEGIN(mp);
> + if (error)
> + return (error);
> + error = UFS_UPDATE(ip, waitfor == MNT_WAIT);
> + UFS_WAPBL_END(mp);
> + if (error)
> + return (error);
> + }
> +
> + /*
> + * Don't flush the log if the vnode being flushed contains no dirty
> + * buffers that could be in the log.
> + */
> + s = splbio();
> + if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
> + splx(s);
> + error = wapbl_flush(mp->mnt_wapbl, 0);
> + if (error)
> + return (error);
> + s = splbio();
> + }
> +
> + if (waitfor == MNT_WAIT)
> + error = vwaitforio(vp, 0, "wapblfsy", 0);
> +
> + splx(s);
> +
> + return (error);
> +}
> +
> +int
> +ffs_wapbl_fsync(void *v)
> +{
> + struct vop_fsync_args *ap = v;
> + struct vnode *vp = ap->a_vp;
> + struct inode *ip = VTOI(vp);
> + struct mount *mp = vp->v_mount;
> + struct buf *bp, *nbp;
> + int waitfor = ap->a_waitfor;
> + int s, error;
> +
> + KASSERT(vp->v_type == VREG);
> + KASSERT(mp->mnt_wapbl != NULL);
> +
> + /*
> + * Flush all data blocks.
> + */
> +loop:
> + s = splbio();
> + for (bp = LIST_FIRST(&vp->v_dirtyblkhd);
> + bp != LIST_END(&vp->v_dirtyblkhd); bp = nbp) {
> + nbp = LIST_NEXT(bp, b_vnbufs);
> + if ((bp->b_flags & B_BUSY) || bp->b_lblkno < 0)
> + continue;
> +#ifdef DIAGNOSTIC
> + if ((bp->b_flags & B_DELWRI) == 0)
> + panic("ffs_wapbl_fsync: not dirty");
> +#endif
> + bremfree(bp);
> + buf_acquire(bp);
> + splx(s);
> + bawrite(bp);
> + goto loop;
> + }
> +
> + if (waitfor == MNT_WAIT) {
> + error = vwaitforio(vp, 0, "wapblsy", 0);
> + if (error) {
> + splx(s);
> + return (error);
> + }
> + }
> +
> + splx(s);
> +
> + /*
> + * Don't bother writing out metadata if the syncer is making the
> + * request. We will let the sync vnode write it out in a single
> burst
> + * through a call to VFS_SYNC().
> + */
> + if (waitfor == MNT_LAZY)
> + return (0);
> +
> + if ((ip->i_flag &
> + (IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFIED)) != 0) {
> + error = UFS_WAPBL_BEGIN(mp);
> + if (error)
> + return (error);
> + error = UFS_UPDATE(ip, waitfor == MNT_WAIT);
> + UFS_WAPBL_END(mp);
> + if (error)
> + return (error);
> + }
> +
> + return (wapbl_flush(mp->mnt_wapbl, 0));
> +}
> +
> +/*
> + * Synch vnode for a mounted file system.
> + */
> +int
> +ffs_wapbl_fsync_vfs(struct vnode *vp, int waitfor)
> +{
> + int s, error = 0;
> +
> + KASSERT(vp->v_type == VBLK);
> + KASSERT(vp->v_specmountpoint != NULL);
> + KASSERT(vp->v_specmountpoint->mnt_wapbl != NULL);
> +
> +#ifdef DIAGNOSTIC
> + s = splbio();
> +
> + struct buf *bp, *nbp;
> + for (bp = LIST_FIRST(&vp->v_dirtyblkhd);
> + bp != LIST_END(&vp->v_dirtyblkhd); bp = nbp) {
> + nbp = LIST_NEXT(bp, b_vnbufs);
> + if ((bp->b_flags & B_LOCKED) == 0)
> + panic("ffs_wapbl_fsync_vfs: non-WAPBL buffer %p "
> + "on vnode %p", bp, vp);
> + }
> + splx(s);
> +#endif
> +
> + /*
> + * Don't bother writing out metadata if the syncer is making the
> + * request. We will let the sync vnode write it out in a single
> burst
> + * through a call to VFS_SYNC().
> + */
> + if (waitfor == MNT_LAZY)
> + return (0);
> +
> + /*
> + * Don't flush the log if the vnode being flushed contains no dirty
> + * buffers that could be in the log.
> + */
> + s = splbio();
> + if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
> + struct mount *mp = vp->v_specmountpoint;
> + splx(s);
> + error = wapbl_flush(mp->mnt_wapbl, 0);
> + if (error)
> + return (error);
> + s = splbio();
> + }
> +
> + if (waitfor == MNT_WAIT)
> + error = vwaitforio(vp, 0, "wapblvfs", 0);
> +
> + splx(s);
> +
> + return (error);
> +}
> +
> +int
> +ffs_wapbl_fsync_device(void *v)
> +{
> + struct vop_fsync_args *ap = v;
> + struct vnode *vp = ap->a_vp;
> +
> + KASSERT(vp->v_mount != NULL && vp->v_mount->mnt_wapbl != NULL);
> +
> + if (vp->v_type == VCHR)
> + return (0);
> +
> + /* Are we mounted somewhere with WAPBL? */
> + if (vp->v_specmountpoint != NULL &&
> + vp->v_specmountpoint->mnt_wapbl != NULL)
> + return (ffs_wapbl_fsync_vfs(vp, ap->a_waitfor));
> +
> + vflushbuf(vp, ap->a_waitfor == MNT_WAIT);
> +
> + return (0);
> +}
> +#endif /* WAPBL */
> +
> /*
> * Synch an open file.
> */
> @@ -427,6 +661,21 @@
> struct buf *bp, *nbp;
> int s, error, passes, skipmeta;
>
> +#if WAPBL
> + if (vp->v_mount && vp->v_mount->mnt_wapbl) {
> + if (vn_isdisk(vp, NULL))
> + return (ffs_wapbl_fsync_device(ap));
> + if (vp->v_type != VREG)
> + return (ffs_wapbl_fsync_full(ap));
> + return (ffs_wapbl_fsync(ap));
> + }
> +
> + if (vp->v_type == VBLK &&
> + vp->v_specmountpoint != NULL &&
> + vp->v_specmountpoint->mnt_wapbl != NULL)
> + return (ffs_wapbl_fsync_vfs(vp, ap->a_waitfor));
> +#endif /* WAPBL */
> +
> if (vp->v_type == VBLK &&
> vp->v_specmountpoint != NULL &&
> (vp->v_specmountpoint->mnt_flag & MNT_SOFTDEP))
> @@ -523,6 +772,7 @@
> }
> }
> splx(s);
> +
> return (UFS_UPDATE(VTOI(vp), ap->a_waitfor == MNT_WAIT));
> }
>
> Index: sys/ufs/ffs/fs.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ffs/fs.h,v
> retrieving revision 1.41
> diff -u -r1.41 fs.h
> --- sys/ufs/ffs/fs.h 20 Jan 2015 18:08:16 -0000 1.41
> +++ sys/ufs/ffs/fs.h 23 Oct 2015 15:07:07 -0000
> @@ -270,7 +270,12 @@
> int32_t fs_cpc; /* cyl per cycle in postbl */
> /* this area is only allocated if fs_ffs1_flags & FS_FLAGS_UPDATED */
> int32_t fs_maxbsize; /* maximum blocking factor
> permitted */
> - int64_t fs_spareconf64[17]; /* old rotation block list head */
> + uint8_t fs_journal_version; /* journal forma version */
> + uint8_t fs_journal_location; /* journal location type */
> + uint8_t fs_journal_reserved[2];/* reserver for future */
> + uint32_t fs_journal_flags; /* journal flags */
> + uint64_t fs_journallocs[4]; /* location info for journal */
> + int64_t fs_spareconf64[12]; /* old rotation block list head */
> int64_t fs_sblockloc; /* offset of standard super block
> */
> struct csum_total fs_cstotal; /* cylinder summary information */
> int64_t fs_time; /* time last written */
> @@ -329,6 +334,7 @@
> */
> #define FS_UNCLEAN 0x01 /* filesystem not clean at mount */
> #define FS_DOSOFTDEP 0x02 /* filesystem using soft dependencies */
> +#define FS_DOWAPBL 0x04 /* write-ahead physical block logging */
> /*
> * The following flag is used to detect a FFS1 file system that had its
> flags
> * moved to the new (FFS2) location for compatibility.
> @@ -518,6 +524,8 @@
> ((loc) & (fs)->fs_qbmask)
> #define fragoff(fs, loc) /* calculates (loc % fs->fs_fsize) */ \
> ((loc) & (fs)->fs_qfmask)
> +#define lfragtosize(fs, frag) /* calculates ((off_t)frag *
> fs->fs_fsize) */ \
> + (((off_t)(frag)) << (fs)->fs_fshift)
> #define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize)
> */ \
> ((off_t)(blk) << (fs)->fs_bshift)
> #define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize)
> */ \
> Index: sys/ufs/ufs/inode.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ufs/inode.h,v
> retrieving revision 1.49
> diff -u -r1.49 inode.h
> --- sys/ufs/ufs/inode.h 14 Jul 2014 08:54:13 -0000 1.49
> +++ sys/ufs/ufs/inode.h 23 Oct 2015 15:07:07 -0000
> @@ -48,6 +48,13 @@
> /*
> * Per-filesystem inode extensions.
> */
> +struct ffs_inode_ext {
> + daddr_t *ffs_snapblklist; /* Collect expunged snapshot
> blocks. */
> + /* follow two fields are used by contiguous allocation code only.
> */
> + daddr_t ffs_first_data_blk; /* first data block on disk. */
> + daddr_t ffs_first_indir_blk; /* first indirect block on disk. */
> +};
> +
> struct ext2fs_inode_ext {
> u_int32_t ext2fs_last_lblk; /* last logical blk
> allocated */
> u_int32_t ext2fs_last_blk; /* last blk allocated on
> disk */
> @@ -102,10 +109,13 @@
> */
> union {
> /* Other extensions could go here... */
> + struct ffs_inode_ext ffs;
> struct ext2fs_inode_ext e2fs;
> struct dirhash *dirhash;
> } inode_ext;
>
> +#define i_ffs_first_data_blk inode_ext.ffs.ffs_first_data_blk
> +#define i_ffs_first_indir_blk inode_ext.ffs.ffs_first_indir_blk
> #define i_e2fs_last_lblk inode_ext.e2fs.ext2fs_last_lblk
> #define i_e2fs_last_blk inode_ext.e2fs.ext2fs_last_blk
> #define i_e2fs_uid inode_ext.e2fs.ext2fs_effective_uid
> Index: sys/ufs/ufs/ufs_extern.h
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ufs/ufs_extern.h,v
> retrieving revision 1.35
> diff -u -r1.35 ufs_extern.h
> --- sys/ufs/ufs/ufs_extern.h 25 Jan 2014 23:31:13 -0000 1.35
> +++ sys/ufs/ufs/ufs_extern.h 23 Oct 2015 15:07:07 -0000
> @@ -134,7 +134,7 @@
> void ufs_itimes(struct vnode *);
> int ufs_makeinode(int, struct vnode *, struct vnode **,
> struct componentname *);
> -
> +int ufs_gop_alloc(struct vnode *, off_t, off_t, int, struct ucred *);
>
> /*
> * Soft dependency function prototypes.
> Index: sys/ufs/ufs/ufs_inode.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ufs/ufs_inode.c,v
> retrieving revision 1.41
> diff -u -r1.41 ufs_inode.c
> --- sys/ufs/ufs/ufs_inode.c 14 Mar 2015 03:38:53 -0000 1.41
> +++ sys/ufs/ufs/ufs_inode.c 23 Oct 2015 15:07:07 -0000
> @@ -43,16 +43,20 @@
> #include <sys/mount.h>
> #include <sys/malloc.h>
> #include <sys/namei.h>
> +#include <sys/wapbl.h>
>
> #include <ufs/ufs/quota.h>
> #include <ufs/ufs/inode.h>
> #include <ufs/ufs/ufsmount.h>
> #include <ufs/ufs/ufs_extern.h>
> +#include <ufs/ufs/ufs_wapbl.h>
> #ifdef UFS_DIRHASH
> #include <ufs/ufs/dir.h>
> #include <ufs/ufs/dirhash.h>
> #endif
>
> +#include <ufs/ffs/fs.h>
> +
> /*
> * Last reference to an inode. If necessary, write or delete it.
> */
> @@ -62,9 +66,10 @@
> struct vop_inactive_args *ap = v;
> struct vnode *vp = ap->a_vp;
> struct inode *ip = VTOI(vp);
> + struct fs *fs = ip->i_fs;
> struct proc *p = ap->a_p;
> mode_t mode;
> - int error = 0;
> + int error = 0, logged = 0;
> #ifdef DIAGNOSTIC
> extern int prtactive;
>
> @@ -72,6 +77,8 @@
> vprint("ufs_inactive: pushing active", vp);
> #endif
>
> + UFS_WAPBL_JUNLOCK_ASSERT(vp->v_mount);
> +
> /*
> * Ignore inodes related to stale file handles.
> */
> @@ -79,9 +86,42 @@
> goto out;
>
> if (DIP(ip, nlink) <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) ==
> 0) {
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error)
> + goto out;
> + logged = 1;
> if (getinoquota(ip) == 0)
> (void)ufs_quota_free_inode(ip, NOCRED);
>
> + if (DIP(ip, size) != 0) {
> + /*
> + * When journaling, only truncate one indirect
> block
> + * at a time
> + */
> + if (vp->v_mount->mnt_wapbl) {
> + uint64_t incr = MNINDIR(ip->i_ump) <<
> + fs->fs_bshift;
> + uint64_t base = NDADDR << fs->fs_bshift;
> + while (!error && DIP(ip, size) > base +
> incr) {
> + /*
> + * round down to next full indirect
> + * block boundary.
> + */
> + uint64_t nsize = base +
> + ((DIP(ip, size) - base - 1) &
> + ~(incr - 1));
> + error = UFS_TRUNCATE(ip, nsize, 0,
> + NOCRED);
> + if (error)
> + break;
> + UFS_WAPBL_END(vp->v_mount);
> + error =
> UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error)
> + goto out;
> + }
> + }
> + }
> +
> error = UFS_TRUNCATE(ip, (off_t)0, 0, NOCRED);
>
> DIP_ASSIGN(ip, rdev, 0);
> @@ -108,8 +148,16 @@
> }
>
> if (ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED |
> IN_UPDATE)) {
> + if (!logged++) {
> + int err;
> + err = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (err)
> + goto out;
> + }
> UFS_UPDATE(ip, 0);
> }
> + if (logged)
> + UFS_WAPBL_END(vp->v_mount);
> out:
> VOP_UNLOCK(vp, 0, p);
>
> @@ -143,8 +191,12 @@
> * Stop deferring timestamp writes
> */
> if (ip->i_flag & IN_LAZYMOD) {
> + int err = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (err)
> + return (err);
> ip->i_flag |= IN_MODIFIED;
> UFS_UPDATE(ip, 0);
> + UFS_WAPBL_END(vp->v_mount);
> }
>
> /*
> Index: sys/ufs/ufs/ufs_lookup.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ufs/ufs_lookup.c,v
> retrieving revision 1.47
> diff -u -r1.47 ufs_lookup.c
> --- sys/ufs/ufs/ufs_lookup.c 14 Mar 2015 03:38:53 -0000 1.47
> +++ sys/ufs/ufs/ufs_lookup.c 23 Oct 2015 15:07:07 -0000
> @@ -46,6 +46,7 @@
> #include <sys/mount.h>
> #include <sys/proc.h>
> #include <sys/vnode.h>
> +#include <sys/wapbl.h>
>
> #include <ufs/ufs/quota.h>
> #include <ufs/ufs/inode.h>
> @@ -55,6 +56,7 @@
> #endif
> #include <ufs/ufs/ufsmount.h>
> #include <ufs/ufs/ufs_extern.h>
> +#include <ufs/ufs/ufs_wapbl.h>
>
> extern struct nchstats nchstats;
>
> @@ -445,6 +447,7 @@
> ufs_dirbad(dp, dp->i_offset, "i_ffs_size too small");
> DIP_ASSIGN(dp, size, dp->i_offset + DIRSIZ(FSFMT(vdp),
> ep));
> dp->i_flag |= IN_CHANGE | IN_UPDATE;
> + UFS_WAPBL_UPDATE(dp, MNT_WAIT);
> }
> brelse(bp);
>
> @@ -704,6 +707,8 @@
> int error, ret, blkoff, loc, spacefree, flags;
> char *dirbuf;
>
> + UFS_WAPBL_JLOCK_ASSERT(dvp->v_mount);
> +
> error = 0;
> cr = cnp->cn_cred;
> p = cnp->cn_proc;
> @@ -805,8 +810,11 @@
> *
> * N.B. - THIS IS AN ARTIFACT OF 4.2 AND SHOULD NEVER HAPPEN.
> */
> - if (dp->i_offset + dp->i_count > DIP(dp, size))
> + if (dp->i_offset + dp->i_count > DIP(dp, size)) {
> DIP_ASSIGN(dp, size, dp->i_offset + dp->i_count);
> + dp->i_flag |= IN_CHANGE | IN_UPDATE;
> + UFS_WAPBL_UPDATE(dp, MNT_WAIT);
> + }
> /*
> * Get the block containing the space for the new directory entry.
> */
> @@ -925,6 +933,7 @@
> if (tvp != NULL)
> vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p);
> }
> + UFS_WAPBL_UPDATE(dp, MNT_WAIT);
> return (error);
> }
>
> @@ -948,6 +957,8 @@
> struct buf *bp;
> int error;
>
> + UFS_WAPBL_JLOCK_ASSERT(dvp->v_mount);
> +
> dp = VTOI(dvp);
>
> if ((error = UFS_BUFATOFF(dp,
> @@ -997,6 +1008,7 @@
> ip->i_effnlink--;
> DIP_ADD(ip, nlink, -1);
> ip->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(ip, 0);
> }
> if (DOINGASYNC(dvp) && dp->i_count != 0) {
> bdwrite(bp);
> @@ -1005,6 +1017,7 @@
> error = bwrite(bp);
> }
> dp->i_flag |= IN_CHANGE | IN_UPDATE;
> + UFS_WAPBL_UPDATE(dp, 0);
> return (error);
> }
>
> @@ -1036,6 +1049,7 @@
> } else {
> DIP_ADD(oip, nlink, -1);
> oip->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(oip, MNT_WAIT);
> if (DOINGASYNC(vdp)) {
> bdwrite(bp);
> error = 0;
> @@ -1044,6 +1058,7 @@
> }
> }
> dp->i_flag |= IN_CHANGE | IN_UPDATE;
> + UFS_WAPBL_UPDATE(dp, MNT_WAIT);
> return (error);
> }
>
> Index: sys/ufs/ufs/ufs_vnops.c
> ===================================================================
> RCS file: /Volumes/CSP/cvs/src/sys/ufs/ufs/ufs_vnops.c,v
> retrieving revision 1.122
> diff -u -r1.122 ufs_vnops.c
> --- sys/ufs/ufs/ufs_vnops.c 23 Sep 2015 15:37:26 -0000 1.122
> +++ sys/ufs/ufs/ufs_vnops.c 23 Oct 2015 15:07:07 -0000
> @@ -54,8 +54,8 @@
> #include <sys/lockf.h>
> #include <sys/event.h>
> #include <sys/poll.h>
> -#include <sys/specdev.h>
> #include <sys/unistd.h>
> +#include <sys/wapbl.h>
>
> #include <miscfs/fifofs/fifo.h>
>
> @@ -64,6 +64,8 @@
> #include <ufs/ufs/dir.h>
> #include <ufs/ufs/ufsmount.h>
> #include <ufs/ufs/ufs_extern.h>
> +#include <ufs/ufs/ufs_wapbl.h>
> +#include <ufs/ffs/fs.h>
> #ifdef UFS_DIRHASH
> #include <ufs/ufs/dirhash.h>
> #endif
> @@ -165,11 +167,13 @@
> struct vop_create_args *ap = v;
> int error;
>
> + /* UFS_WAPBL_BEGIN1(dvp) performed by successful ufs_makeinode() */
> error =
> ufs_makeinode(MAKEIMODE(ap->a_vap->va_type,
> ap->a_vap->va_mode),
> ap->a_dvp, ap->a_vpp, ap->a_cnp);
> if (error)
> return (error);
> + UFS_WAPBL_END1(ap->a_dvp->v_mount, ap->a_dvp);
> VN_KNOTE(ap->a_dvp, NOTE_WRITE);
> return (0);
> }
> @@ -186,6 +190,10 @@
> struct inode *ip;
> int error;
>
> + /*
> + * UFS_WAPBL_BEGIN1(dvp->v_mount, dvp) performed by successful
> + * ufs_makeinode
> + */
> if ((error =
> ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode),
> ap->a_dvp, vpp, ap->a_cnp)) != 0)
> @@ -200,6 +208,8 @@
> */
> DIP_ASSIGN(ip, rdev, vap->va_rdev);
> }
> + UFS_WAPBL_UPDATE(VTOI(*vpp), 0);
> + UFS_WAPBL_END1(ap->a_dvp->v_mount, ap->a_dvp);
> /*
> * Remove inode so that it will be reloaded by VFS_VGET and
> * checked to see if it is an alias of an existing entry in
> @@ -348,6 +358,7 @@
> struct vattr *vap = ap->a_vap;
> struct vnode *vp = ap->a_vp;
> struct inode *ip = VTOI(vp);
> + struct fs *fs = ip->i_fs;
> struct ucred *cred = ap->a_cred;
> struct proc *p = ap->a_p;
> int error;
> @@ -369,19 +380,28 @@
> if (cred->cr_uid != DIP(ip, uid) &&
> (error = suser_ucred(cred)))
> return (error);
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error)
> + return (error);
> if (cred->cr_uid == 0) {
> if ((DIP(ip, flags) & (SF_IMMUTABLE | SF_APPEND))
> &&
> - securelevel > 0)
> + securelevel > 0) {
> + UFS_WAPBL_END(vp->v_mount);
> return (EPERM);
> + }
> DIP_ASSIGN(ip, flags, vap->va_flags);
> } else {
> if (DIP(ip, flags) & (SF_IMMUTABLE | SF_APPEND) ||
> - (vap->va_flags & UF_SETTABLE) != vap->va_flags)
> + (vap->va_flags & UF_SETTABLE) !=
> vap->va_flags) {
> + UFS_WAPBL_END(vp->v_mount);
> return (EPERM);
> + }
> DIP_AND(ip, flags, SF_SETTABLE);
> DIP_OR(ip, flags, vap->va_flags & UF_SETTABLE);
> }
> ip->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(ip, 0);
> + UFS_WAPBL_END(vp->v_mount);
> if (vap->va_flags & (IMMUTABLE | APPEND))
> return (0);
> }
> @@ -393,7 +413,11 @@
> if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
> if (vp->v_mount->mnt_flag & MNT_RDONLY)
> return (EROFS);
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error)
> + return (error);
> error = ufs_chown(vp, vap->va_uid, vap->va_gid, cred, p);
> + UFS_WAPBL_END(vp->v_mount);
> if (error)
> return (error);
> }
> @@ -415,8 +439,36 @@
> default:
> break;
> }
> - if ((error = UFS_TRUNCATE(ip, vap->va_size, 0, cred)) != 0)
> - return (error);
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error)
> + return (error);
> + /*
> + * When journaling, only truncate one indirect block at a
> time.
> + */
> + if (vp->v_mount->mnt_wapbl) {
> + uint64_t incr = MNINDIR(ip->i_ump) <<
> fs->fs_bshift;
> + uint64_t base = NDADDR << fs->fs_bshift;
> + while (!error && DIP(ip, size) > base + incr &&
> + DIP(ip, size) > vap->va_size + incr) {
> + /*
> + * round down to next full indirect
> + * block boundary.
> + */
> + uint64_t nsize = base +
> + ((DIP(ip, size) - base - 1) &
> + ~(incr - 1));
> + error = UFS_TRUNCATE(ip, nsize, 0, cred);
> + if (error == 0) {
> + UFS_WAPBL_END(vp->v_mount);
> + error =
> UFS_WAPBL_BEGIN(vp->v_mount);
> + }
> + }
> + }
> + if (!error)
> + error = UFS_TRUNCATE(ip, vap->va_size, 0, cred);
> + UFS_WAPBL_END(vp->v_mount);
> + if (error)
> + return (error);
> if (vap->va_size < oldsize)
> hint |= NOTE_TRUNCATE;
> }
> @@ -430,6 +482,9 @@
> ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
> (error = VOP_ACCESS(vp, VWRITE, cred, p))))
> return (error);
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error)
> + return (error);
> if (vap->va_mtime.tv_nsec != VNOVAL)
> ip->i_flag |= IN_CHANGE | IN_UPDATE;
> else if (vap->va_vaflags & VA_UTIMES_CHANGE)
> @@ -449,6 +504,7 @@
> DIP_ASSIGN(ip, atimensec, vap->va_atime.tv_nsec);
> }
> error = UFS_UPDATE(ip, 0);
> + UFS_WAPBL_END(vp->v_mount);
> if (error)
> return (error);
> }
> @@ -456,7 +512,11 @@
> if (vap->va_mode != (mode_t)VNOVAL) {
> if (vp->v_mount->mnt_flag & MNT_RDONLY)
> return (EROFS);
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error)
> + return (error);
> error = ufs_chmod(vp, (int)vap->va_mode, cred, p);
> + UFS_WAPBL_END(vp->v_mount);
> }
> VN_KNOTE(vp, hint);
> return (error);
> @@ -472,6 +532,8 @@
> struct inode *ip = VTOI(vp);
> int error;
>
> + UFS_WAPBL_JLOCK_ASSERT(vp->v_mount);
> +
> if (cred->cr_uid != DIP(ip, uid) &&
> (error = suser_ucred(cred)))
> return (error);
> @@ -484,6 +546,7 @@
> DIP_AND(ip, mode, ~ALLPERMS);
> DIP_OR(ip, mode, mode & ALLPERMS);
> ip->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(ip, 0);
> if ((vp->v_flag & VTEXT) && (DIP(ip, mode) & S_ISTXT) == 0)
> (void) uvm_vnp_uncache(vp);
> return (0);
> @@ -553,8 +616,10 @@
> if (getinoquota(ip))
> panic("chown: lost quota");
>
> - if (ouid != uid || ogid != gid)
> + if (ouid != uid || ogid != gid) {
> ip->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(ip, 0);
> + }
> if (ouid != uid && cred->cr_uid != 0)
> DIP_AND(ip, mode, ~ISUID);
> if (ogid != gid && cred->cr_uid != 0)
> @@ -612,12 +677,16 @@
> if (vp->v_type == VDIR || (DIP(ip, flags) & (IMMUTABLE | APPEND))
> ||
> (DIP(VTOI(dvp), flags) & APPEND)) {
> error = EPERM;
> - goto out;
> + } else {
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error == 0) {
> + error = ufs_dirremove(dvp, ip,
> ap->a_cnp->cn_flags, 0);
> + VN_KNOTE(vp, NOTE_DELETE);
> + VN_KNOTE(dvp, NOTE_WRITE);
> + UFS_WAPBL_END(vp->v_mount);
> + }
> }
> - error = ufs_dirremove(dvp, ip, ap->a_cnp->cn_flags, 0);
> - VN_KNOTE(vp, NOTE_DELETE);
> - VN_KNOTE(dvp, NOTE_WRITE);
> - out:
> +
> if (dvp == vp)
> vrele(vp);
> else
> @@ -670,6 +739,11 @@
> error = EPERM;
> goto out1;
> }
> + error = UFS_WAPBL_BEGIN(vp->v_mount);
> + if (error) {
> + VOP_ABORTOP(dvp, cnp);
> + goto out1;
> + }
> ip->i_effnlink++;
> DIP_ADD(ip, nlink, 1);
> ip->i_flag |= IN_CHANGE;
> @@ -683,9 +757,11 @@
> ip->i_effnlink--;
> DIP_ADD(ip, nlink, -1);
> ip->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(ip, MNT_WAIT);
> if (DOINGSOFTDEP(vp))
> softdep_change_linkcnt(ip, 0);
> }
> + UFS_WAPBL_END(vp->v_mount);
> pool_put(&namei_pool, cnp->cn_pnbuf);
> VN_KNOTE(vp, NOTE_LINK);
> VN_KNOTE(dvp, NOTE_WRITE);
> @@ -729,6 +805,7 @@
> struct vnode *tdvp = ap->a_tdvp;
> struct vnode *fvp = ap->a_fvp;
> struct vnode *fdvp = ap->a_fdvp;
> + struct mount *mp = fdvp->v_mount;
> struct componentname *tcnp = ap->a_tcnp;
> struct componentname *fcnp = ap->a_fcnp;
> struct proc *p = fcnp->cn_proc;
> @@ -742,6 +819,9 @@
> (fcnp->cn_flags & HASBUF) == 0)
> panic("ufs_rename: no name");
> #endif
> +
> + KASSERT(mp != NULL);
> +
> /*
> * Check for cross-device rename.
> */
> @@ -862,6 +942,12 @@
> if (tvp)
> xp = VTOI(tvp);
>
> + error = UFS_WAPBL_BEGIN(mp);
> + if (error) {
> + VOP_UNLOCK(fvp, 0, p);
> + goto bad;
> + }
> +
> /*
> * 1) Bump link count while we're moving stuff
> * around. If we crash somewhere before
> @@ -1037,6 +1123,7 @@
> if (!newparent) {
> DIP_ADD(dp, nlink, -1);
> dp->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(dp, 0);
> }
>
> DIP_ADD(xp, nlink, -1);
> @@ -1061,6 +1148,7 @@
> panic("ufs_rename: lost from startdir");
> if ((error = vfs_relookup(fdvp, &fvp, fcnp)) != 0) {
> vrele(ap->a_fvp);
> + UFS_WAPBL_END(mp);
> return (error);
> }
> vrele(fdvp);
> @@ -1071,6 +1159,7 @@
> if (doingdirectory)
> panic("ufs_rename: lost dir entry");
> vrele(ap->a_fvp);
> + UFS_WAPBL_END(mp);
> return (0);
> }
>
> @@ -1110,6 +1199,7 @@
> if (xp)
> vput(fvp);
> vrele(ap->a_fvp);
> + UFS_WAPBL_END(mp);
> return (error);
>
> bad:
> @@ -1125,11 +1215,13 @@
> DIP_ADD(ip, nlink, -1);
> ip->i_flag |= IN_CHANGE;
> ip->i_flag &= ~IN_RENAME;
> + UFS_WAPBL_UPDATE(ip, 0);
> if (DOINGSOFTDEP(fvp))
> softdep_change_linkcnt(ip, 0);
> vput(fvp);
> } else
> vrele(fvp);
> + UFS_WAPBL_END(mp);
> return (error);
> }
>
> @@ -1171,6 +1263,14 @@
>
> ip = VTOI(tvp);
>
> + error = UFS_WAPBL_BEGIN(dvp->v_mount);
> + if (error) {
> + UFS_INODE_FREE(ip, ip->i_number, dmode);
> + vput(tvp);
> + vput(dvp);
> + return (error);
> + }
> +
> DIP_ASSIGN(ip, uid, cnp->cn_cred->cr_uid);
> DIP_ASSIGN(ip, gid, DIP(dp, gid));
>
> @@ -1178,6 +1278,7 @@
> (error = ufs_quota_alloc_inode(ip, cnp->cn_cred))) {
> pool_put(&namei_pool, cnp->cn_pnbuf);
> UFS_INODE_FREE(ip, ip->i_number, dmode);
> + UFS_WAPBL_END(dvp->v_mount);
> vput(tvp);
> vput(dvp);
> return (error);
> @@ -1261,10 +1362,12 @@
> if (error == 0) {
> VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
> *ap->a_vpp = tvp;
> + UFS_WAPBL_END(dvp->v_mount);
> } else {
> dp->i_effnlink--;
> DIP_ADD(dp, nlink, -1);
> dp->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(dp, MNT_WAIT);
> if (DOINGSOFTDEP(dvp))
> softdep_change_linkcnt(dp, 0);
> /*
> @@ -1274,6 +1377,8 @@
> ip->i_effnlink = 0;
> DIP_ASSIGN(ip, nlink, 0);
> ip->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(ip, MNT_WAIT);
> + UFS_WAPBL_END(dvp->v_mount);
> if (DOINGSOFTDEP(tvp))
> softdep_change_linkcnt(ip, 0);
> vput(tvp);
> @@ -1332,21 +1437,26 @@
> error = EPERM;
> goto out;
> }
> + error = UFS_WAPBL_BEGIN(dvp->v_mount);
> + if (error)
> + goto out;
> +
> /*
> * Delete reference to directory before purging
> * inode. If we crash in between, the directory
> * will be reattached to lost+found,
> */
> - dp->i_effnlink--;
> - ip->i_effnlink--;
> if (DOINGSOFTDEP(vp)) {
> + dp->i_effnlink--;
> + ip->i_effnlink--;
> softdep_change_linkcnt(dp, 0);
> softdep_change_linkcnt(ip, 0);
> }
> if ((error = ufs_dirremove(dvp, ip, cnp->cn_flags, 1)) != 0) {
> - dp->i_effnlink++;
> - ip->i_effnlink++;
> + UFS_WAPBL_END(dvp->v_mount);
> if (DOINGSOFTDEP(vp)) {
> + dp->i_effnlink++;
> + ip->i_effnlink++;
> softdep_change_linkcnt(dp, 0);
> softdep_change_linkcnt(ip, 0);
> }
> @@ -1365,14 +1475,22 @@
> if (!DOINGSOFTDEP(vp)) {
> int ioflag;
>
> + dp->i_effnlink--;
> DIP_ADD(dp, nlink, -1);
> dp->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(dp, MNT_WAIT);
> + ip->i_effnlink--;
> DIP_ADD(ip, nlink, -1);
> ip->i_flag |= IN_CHANGE;
> ioflag = DOINGASYNC(vp) ? 0 : IO_SYNC;
> error = UFS_TRUNCATE(ip, (off_t)0, ioflag, cnp->cn_cred);
> }
> cache_purge(vp);
> + /*
> + * Unlock the log while we still have reference to the unlinked
> + * directory vp so that it will not get locked for recycling
> + */
> + UFS_WAPBL_END(dvp->v_mount);
> #ifdef UFS_DIRHASH
> /* Kill any active hash; i_effnlink == 0, so it will not come
> back. */
> if (ip->i_dirhash != NULL)
> @@ -1397,6 +1515,7 @@
> struct inode *ip;
> int len, error;
>
> + /* UFS_WAPBL_BEGIN1(dvp) performed by successful ufs_makeinode() */
> error = ufs_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp,
> vpp, ap->a_cnp);
> if (error)
> @@ -1409,10 +1528,12 @@
> memcpy(SHORTLINK(ip), ap->a_target, len);
> DIP_ASSIGN(ip, size, len);
> ip->i_flag |= IN_CHANGE | IN_UPDATE;
> + UFS_WAPBL_UPDATE(ip, 0);
> } else
> error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0,
> - UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred, NULL,
> - curproc);
> + UIO_SYSSPACE, IO_NODELOCKED | IO_JOURNALLOCKED,
> + ap->a_cnp->cn_cred, NULL, curproc);
> + UFS_WAPBL_END1(ap->a_dvp->v_mount, ap->a_dvp);
> vput(vp);
> return (error);
> }
> @@ -1593,6 +1714,7 @@
> struct buf *bp = ap->a_bp;
> struct vnode *vp = bp->b_vp;
> struct inode *ip;
> + struct mount *mp;
> int error;
> int s;
>
> @@ -1622,7 +1744,28 @@
> vp = ip->i_devvp;
> bp->b_dev = vp->v_rdev;
> (vp->v_op->vop_strategy)(ap);
> - return (0);
> +
> + if ((bp->b_flags & B_READ) == 0)
> + return (0);
> +
> + mp = wapbl_vptomp(vp);
> + if (mp == NULL || mp->mnt_wapbl_replay == NULL ||
> + !WAPBL_REPLAY_ISOPEN(mp) ||
> + !WAPBL_REPLAY_CAN_READ(mp, bp->b_blkno, bp->b_bcount))
> + return (0);
> +
> + error = biowait(bp);
> + if (error)
> + return (error);
> +
> + error = WAPBL_REPLAY_READ(mp, bp->b_data, bp->b_blkno,
> bp->b_bcount);
> + if (error) {
> + s = splbio();
> + SET(bp->b_flags, B_INVAL);
> + splx(s);
> + }
> +
> + return (error);
> }
>
> /*
> @@ -1897,6 +2040,8 @@
> struct vnode *tvp;
> int error;
>
> + UFS_WAPBL_JUNLOCK_ASSERT(dvp->v_mount);
> +
> pdir = VTOI(dvp);
> #ifdef DIAGNOSTIC
> if ((cnp->cn_flags & HASBUF) == 0)
> @@ -1917,10 +2062,23 @@
> DIP_ASSIGN(ip, gid, DIP(pdir, gid));
> DIP_ASSIGN(ip, uid, cnp->cn_cred->cr_uid);
>
> + error = UFS_WAPBL_BEGIN1(dvp->v_mount, dvp);
> + if (error) {
> + /*
> + * Note, we can't UFS_INODE_FREE() here like we should
> because
> + * we can't write to the disk. Instead, we leave the vnode
> + * dangling from the journal.
> + */
> + vput(tvp);
> + vput(dvp);
> + return (error);
> + }
> +
> if ((error = getinoquota(ip)) ||
> (error = ufs_quota_alloc_inode(ip, cnp->cn_cred))) {
> pool_put(&namei_pool, cnp->cn_pnbuf);
> UFS_INODE_FREE(ip, ip->i_number, mode);
> + UFS_WAPBL_END1(dvp->v_mount, dvp);
> vput(tvp);
> vput(dvp);
> return (error);
> @@ -1964,14 +2122,61 @@
> ip->i_effnlink = 0;
> DIP_ASSIGN(ip, nlink, 0);
> ip->i_flag |= IN_CHANGE;
> + UFS_WAPBL_UPDATE(VTOI(tvp), 0);
> if (DOINGSOFTDEP(tvp))
> softdep_change_linkcnt(ip, 0);
> tvp->v_type = VNON;
> + UFS_WAPBL_END1(dvp->v_mount, dvp);
> vput(tvp);
>
> return (error);
> }
>
> +/*
> + * Allocate len bytes at offset off.
> + */
> +int
> +ufs_gop_alloc(struct vnode *vp, off_t off, off_t len, int flags,
> + struct ucred *cred)
> +{
> + struct inode *ip = VTOI(vp);
> + int error, delta, bshift, bsize;
> +
> + error = 0;
> + bshift = ip->i_fs->fs_bshift;
> + bsize = 1 << bshift;
> +
> + delta = off & (bsize - 1);
> + off -= delta;
> + len += delta;
> +
> + while (len > 0) {
> + bsize = MIN(bsize, len);
> +
> + error = UFS_BUF_ALLOC(ip, off, bsize, cred, flags, NULL);
> + if (error) {
> + goto out;
> + }
> +
> + /*
> + * increase file size now, UFS_BUF_ALLOC() requires that
> + * EOF be up-to-date before each call.
> + */
> +
> + if (DIP(ip, size) < off + bsize) {
> + /* ip->i_size = off + bsize; */
> + DIP_ASSIGN(ip, size, off + bsize);
> + }
> +
> + off += bsize;
> + len -= bsize;
> + }
> +
> +out:
> + UFS_WAPBL_UPDATE(ip, 0);
> + return error;
> +}
> +
> struct filterops ufsread_filtops =
> { 1, NULL, filt_ufsdetach, filt_ufsread };
> struct filterops ufswrite_filtops =
>
>
--
May the most significant bit of your life be positive.
