 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_wapbl.c,v 1.86 2016/11/10 20:56:32 jdolecek Exp $	*/
+/*	$NetBSD: vfs_wapbl.c,v 1.87 2017/03/05 13:57:29 jdolecek Exp $	*/
 /*-
  * Copyright (c) 2003, 2008, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Wasabi Systems, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -26,27 +26,27 @@
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * This implements file system independent write ahead filesystem logging.
  */
 #define WAPBL_INTERNAL
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_wapbl.c,v 1.86 2016/11/10 20:56:32 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_wapbl.c,v 1.87 2017/03/05 13:57:29 jdolecek Exp $");
 #include <sys/param.h>
 #include <sys/bitops.h>
 #include <sys/time.h>
 #include <sys/wapbl.h>
 #include <sys/wapbl_replay.h>
 #ifdef _KERNEL
 #include <sys/atomic.h>
 #include <sys/conf.h>
 #include <sys/file.h>
 #include <sys/kauth.h>
 @@ -166,34 +166,41 @@ struct wapbl {
 	 */
 	struct wapbl_wc_header *wl_wc_header;	/* l	*/
 	void *wl_wc_scratch;	/* l:	scratch space (XXX: por que?!?) */
 	kmutex_t wl_mtx;	/* u:	short-term lock */
 	krwlock_t wl_rwlock;	/* u:	File system transaction lock */
 	/*
 	 * Must be held while accessing
 	 * wl_count or wl_bufs or head or tail
 	 */
 #if _KERNEL
 	/*
 	 * Callback called from within the flush routine to flush any extra
 	 * bits.  Note that flush may be skipped without calling this if
 	 * there are no outstanding buffers in the transaction.
 	 */
 #if _KERNEL
 	wapbl_flush_fn_t wl_flush;	/* r	*/
 	wapbl_flush_fn_t wl_flush_abort;/* r	*/
 	/* Event counters */
 	char wl_ev_group[EVCNT_STRING_MAX];	/* r	*/
 	struct evcnt wl_ev_commit;		/* l	*/
 	struct evcnt wl_ev_journalwrite;	/* l	*/
 	struct evcnt wl_ev_metawrite;		/* lm	*/
 	struct evcnt wl_ev_cacheflush;		/* l	*/
 #endif
 	size_t wl_bufbytes;	/* m:	Byte count of pages in wl_bufs */
 	size_t wl_bufcount;	/* m:	Count of buffers in wl_bufs */
 	size_t wl_bcount;	/* m:	Total bcount of wl_bufs */
 	LIST_HEAD(, buf) wl_bufs; /* m:	Buffers in current transaction */
 	kcondvar_t wl_reclaimable_cv;	/* m (obviously) */
 	size_t wl_reclaimable_bytes; /* m:	Amount of space available for
 						reclamation by truncate */
 	int wl_error_count;	/* m:	# of wl_entries with errors */
 	size_t wl_reserved_bytes; /* never truncate log smaller than this */
 @@ -260,26 +267,29 @@ struct wapbl_ino {
 	mode_t wi_mode;
 };
 static void wapbl_inodetrk_init(struct wapbl *wl, u_int size);
 static void wapbl_inodetrk_free(struct wapbl *wl);
 static struct wapbl_ino *wapbl_inodetrk_get(struct wapbl *wl, ino_t ino);
 static size_t wapbl_transaction_len(struct wapbl *wl);
 static inline size_t wapbl_transaction_inodes_len(struct wapbl *wl);
 static void wapbl_deallocation_free(struct wapbl *, struct wapbl_dealloc *,
 	bool);
 static void wapbl_evcnt_init(struct wapbl *);
 static void wapbl_evcnt_free(struct wapbl *);
 #if 0
 int wapbl_replay_verify(struct wapbl_replay *, struct vnode *);
 #endif
 static int wapbl_replay_isopen1(struct wapbl_replay *);
 struct wapbl_ops wapbl_ops = {
 	.wo_wapbl_discard	= wapbl_discard,
 	.wo_wapbl_replay_isopen	= wapbl_replay_isopen1,
 	.wo_wapbl_replay_can_read = wapbl_replay_can_read,
 	.wo_wapbl_replay_read	= wapbl_replay_read,
 	.wo_wapbl_add_buf	= wapbl_add_buf,
 	.wo_wapbl_remove_buf	= wapbl_remove_buf,
 @@ -342,26 +352,54 @@ wapbl_init(void)
 static int
 wapbl_fini(void)
+{
 	if (wapbl_sysctl != NULL)
 		 sysctl_teardown(&wapbl_sysctl);
 	pool_destroy(&wapbl_dealloc_pool);
 	pool_destroy(&wapbl_entry_pool);
 	return 0;
+}
 static void
 wapbl_evcnt_init(struct wapbl *wl)
+{
 	snprintf(wl->wl_ev_group, sizeof(wl->wl_ev_group),
 	    "wapbl fsid 0x%x/0x%x",
 	    wl->wl_mount->mnt_stat.f_fsidx.__fsid_val[0],
 	    wl->wl_mount->mnt_stat.f_fsidx.__fsid_val[1]
 	);
 	evcnt_attach_dynamic(&wl->wl_ev_commit, EVCNT_TYPE_MISC,
 	    NULL, wl->wl_ev_group, "commit");
 	evcnt_attach_dynamic(&wl->wl_ev_journalwrite, EVCNT_TYPE_MISC,
 	    NULL, wl->wl_ev_group, "journal sync block write");
 	evcnt_attach_dynamic(&wl->wl_ev_metawrite, EVCNT_TYPE_MISC,
 	    NULL, wl->wl_ev_group, "metadata finished block write");
 	evcnt_attach_dynamic(&wl->wl_ev_cacheflush, EVCNT_TYPE_MISC,
 	    NULL, wl->wl_ev_group, "cache flush");
+}
 static void
 wapbl_evcnt_free(struct wapbl *wl)
+{
 	evcnt_detach(&wl->wl_ev_commit);
 	evcnt_detach(&wl->wl_ev_journalwrite);
 	evcnt_detach(&wl->wl_ev_metawrite);
 	evcnt_detach(&wl->wl_ev_cacheflush);
+}
 static int
 wapbl_start_flush_inodes(struct wapbl *wl, struct wapbl_replay *wr)
+{
 	int error, i;
 	WAPBL_PRINTF(WAPBL_PRINT_REPLAY,
 	    ("wapbl_start: reusing log with %d inodes\n", wr->wr_inodescnt));
 	/*
 	 * Its only valid to reuse the replay log if its
 	 * the same as the new log we just opened.
 	 */
 	KDASSERT(!wapbl_replay_isopen(wr));
 @@ -512,26 +550,28 @@ wapbl_start(struct wapbl ** wlp, struct
 	    - offsetof(struct wapbl_wc_blocklist, wc_blocks)) /
 	    sizeof(((struct wapbl_wc_blocklist *)0)->wc_blocks[0]);
 	KASSERT(wl->wl_brperjblock > 0);
 	/* XXX tie this into resource estimation */
 	wl->wl_dealloclim = wl->wl_bufbytes_max / mp->mnt_stat.f_bsize / 2;
 	TAILQ_INIT(&wl->wl_dealloclist);
 	wl->wl_buffer = wapbl_alloc(MAXPHYS);
 	wl->wl_buffer_used = 0;
 	wapbl_inodetrk_init(wl, WAPBL_INODETRK_SIZE);
 	wapbl_evcnt_init(wl);
 	/* Initialize the commit header */
+	{
 		struct wapbl_wc_header *wc;
 		size_t len = 1 << wl->wl_log_dev_bshift;
 		wc = wapbl_calloc(1, len);
 		wc->wc_type = WAPBL_WC_HEADER;
 		wc->wc_len = len;
 		wc->wc_circ_off = wl->wl_circ_off;
 		wc->wc_circ_size = wl->wl_circ_size;
 		/* XXX wc->wc_fsid */
 		wc->wc_log_dev_bshift = wl->wl_log_dev_bshift;
 		wc->wc_fs_dev_bshift = wl->wl_fs_dev_bshift;
 		wl->wl_wc_header = wc;
 @@ -736,26 +776,28 @@ wapbl_stop(struct wapbl *wl, int force)
 	KASSERT(wl->wl_bufcount == 0);
 	KASSERT(LIST_EMPTY(&wl->wl_bufs));
 	KASSERT(wl->wl_dealloccnt == 0);
 	KASSERT(SIMPLEQ_EMPTY(&wl->wl_entries));
 	KASSERT(wl->wl_inohashcnt == 0);
 	KASSERT(TAILQ_EMPTY(&wl->wl_dealloclist));
 	KASSERT(wl->wl_dealloccnt == 0);
 	wapbl_free(wl->wl_wc_scratch, wl->wl_wc_header->wc_len);
 	wapbl_free(wl->wl_wc_header, wl->wl_wc_header->wc_len);
 	wapbl_free(wl->wl_buffer, MAXPHYS);
 	wapbl_inodetrk_free(wl);
 	wapbl_evcnt_free(wl);
 	cv_destroy(&wl->wl_reclaimable_cv);
 	mutex_destroy(&wl->wl_mtx);
 	rw_destroy(&wl->wl_rwlock);
 	wapbl_free(wl, sizeof(*wl));
 	return 0;
+}
 /****************************************************************/
 /*
  * Unbuffered disk I/O
  */
 @@ -848,26 +890,28 @@ wapbl_read(void *data, size_t len, struc
  */
 static int
 wapbl_buffered_flush(struct wapbl *wl)
+{
 	int error;
 	if (wl->wl_buffer_used == 0)
 		return 0;
 	error = wapbl_doio(wl->wl_buffer, wl->wl_buffer_used,
 	    wl->wl_devvp, wl->wl_buffer_dblk, B_WRITE);
 	wl->wl_buffer_used = 0;
 	wl->wl_ev_journalwrite.ev_count++;
 	return error;
+}
 /*
  * wapbl_buffered_write(data, len, wl, pbn)
+ *
  *	Write len bytes from data to physical block pbn on
  *	wl->wl_devvp.  The write may not complete until
  *	wapbl_buffered_flush.
  */
 static int
 wapbl_buffered_write(void *data, size_t len, struct wapbl *wl, daddr_t pbn)
+{
 @@ -1461,26 +1505,27 @@ wapbl_biodone(struct buf *bp)
 	 */
 	brelse(bp, 0);
 	mutex_enter(&wl->wl_mtx);
 	KASSERT(we->we_bufcount > 0);
 	we->we_bufcount--;
 #ifdef WAPBL_DEBUG_BUFBYTES
 	KASSERT(we->we_unsynced_bufbytes >= bufsize);
 	we->we_unsynced_bufbytes -= bufsize;
 	KASSERT(wl->wl_unsynced_bufbytes >= bufsize);
 	wl->wl_unsynced_bufbytes -= bufsize;
 #endif
 	wl->wl_ev_metawrite.ev_count++;
 	/*
 	 * If the current transaction can be reclaimed, start
 	 * at the beginning and reclaim any consecutive reclaimable
 	 * transactions.  If we successfully reclaim anything,
 	 * then wakeup anyone waiting for the reclaim.
 	 */
 	if (we->we_bufcount == 0) {
 		size_t delta = 0;
 		int errcnt = 0;
 #ifdef WAPBL_DEBUG_BUFBYTES
 		KDASSERT(we->we_unsynced_bufbytes == 0);
 #endif
 @@ -2169,26 +2214,29 @@ wapbl_cache_sync(struct wapbl *wl, const
 		    "returned %d\n", (uintmax_t)wl->wl_devvp->v_rdev, error));
+	}
 	if (verbose) {
 		struct bintime d;
 		struct timespec ts;
 		bintime(&d);
 		bintime_sub(&d, &start_time);
 		bintime2timespec(&d, &ts);
 		printf("wapbl_cache_sync: %s: dev 0x%jx %ju.%09lu\n",
 		    msg, (uintmax_t)wl->wl_devvp->v_rdev,
 		    (uintmax_t)ts.tv_sec, ts.tv_nsec);
+	}
 	wl->wl_ev_cacheflush.ev_count++;
 	return error;
+}
 /*
  * wapbl_write_commit(wl, head, tail)
+ *
  *	Issue a disk cache sync to wait for all pending writes to the
  *	log to complete, and then synchronously commit the current
  *	circular queue head and tail to the log, in the next of two
  *	locations for commit headers on disk.
+ *
  *	Increment the generation number.  If the generation number
  *	rolls over to zero, then a subsequent commit would appear to
 @@ -2259,26 +2307,29 @@ wapbl_write_commit(struct wapbl *wl, off
 	 * This handles initialization and generation number rollover
 	 */
 	if (wc->wc_generation++ == 0) {
 		error = wapbl_write_commit(wl, head, tail);
 		/*
 		 * This panic should be able to be removed if we do the
 		 * zero'ing mentioned above, and we are certain to roll
 		 * back generation number on failure.
 		 */
 		if (error)
 			panic("wapbl_write_commit: error writing duplicate "
 			      "log header: %d", error);
+	}
 	wl->wl_ev_commit.ev_count++;
 	return 0;
+}
 /*
  * wapbl_write_blocks(wl, offp)
+ *
  *	Write all pending physical blocks in the current transaction
  *	from wapbl_add_buf to the log on disk, adding to the circular
  *	queue head at byte offset *offp, and returning the new head's
  *	byte offset in *offp.
  */
 static int
 wapbl_write_blocks(struct wapbl *wl, off_t *offp)