vfs_wapbl.c revision 1.25.2.5
1 1.25.2.5 yamt /* $NetBSD: vfs_wapbl.c,v 1.25.2.5 2010/08/11 22:54:45 yamt Exp $ */ 2 1.25.2.2 yamt 3 1.25.2.2 yamt /*- 4 1.25.2.2 yamt * Copyright (c) 2003, 2008, 2009 The NetBSD Foundation, Inc. 5 1.25.2.2 yamt * All rights reserved. 6 1.25.2.2 yamt * 7 1.25.2.2 yamt * This code is derived from software contributed to The NetBSD Foundation 8 1.25.2.2 yamt * by Wasabi Systems, Inc. 9 1.25.2.2 yamt * 10 1.25.2.2 yamt * Redistribution and use in source and binary forms, with or without 11 1.25.2.2 yamt * modification, are permitted provided that the following conditions 12 1.25.2.2 yamt * are met: 13 1.25.2.2 yamt * 1. Redistributions of source code must retain the above copyright 14 1.25.2.2 yamt * notice, this list of conditions and the following disclaimer. 15 1.25.2.2 yamt * 2. Redistributions in binary form must reproduce the above copyright 16 1.25.2.2 yamt * notice, this list of conditions and the following disclaimer in the 17 1.25.2.2 yamt * documentation and/or other materials provided with the distribution. 18 1.25.2.2 yamt * 19 1.25.2.2 yamt * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 1.25.2.2 yamt * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 1.25.2.2 yamt * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 1.25.2.2 yamt * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 1.25.2.2 yamt * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 1.25.2.2 yamt * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 1.25.2.2 yamt * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 1.25.2.2 yamt * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 1.25.2.2 yamt * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 1.25.2.2 yamt * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 1.25.2.2 yamt * POSSIBILITY OF SUCH DAMAGE. 30 1.25.2.2 yamt */ 31 1.25.2.2 yamt 32 1.25.2.2 yamt /* 33 1.25.2.2 yamt * This implements file system independent write ahead filesystem logging. 34 1.25.2.2 yamt */ 35 1.25.2.2 yamt 36 1.25.2.2 yamt #define WAPBL_INTERNAL 37 1.25.2.2 yamt 38 1.25.2.2 yamt #include <sys/cdefs.h> 39 1.25.2.5 yamt __KERNEL_RCSID(0, "$NetBSD: vfs_wapbl.c,v 1.25.2.5 2010/08/11 22:54:45 yamt Exp $"); 40 1.25.2.2 yamt 41 1.25.2.2 yamt #include <sys/param.h> 42 1.25.2.4 yamt #include <sys/bitops.h> 43 1.25.2.2 yamt 44 1.25.2.2 yamt #ifdef _KERNEL 45 1.25.2.2 yamt #include <sys/param.h> 46 1.25.2.2 yamt #include <sys/namei.h> 47 1.25.2.2 yamt #include <sys/proc.h> 48 1.25.2.2 yamt #include <sys/uio.h> 49 1.25.2.2 yamt #include <sys/vnode.h> 50 1.25.2.2 yamt #include <sys/file.h> 51 1.25.2.2 yamt #include <sys/malloc.h> 52 1.25.2.5 yamt #include <sys/module.h> 53 1.25.2.2 yamt #include <sys/resourcevar.h> 54 1.25.2.2 yamt #include <sys/conf.h> 55 1.25.2.2 yamt #include <sys/mount.h> 56 1.25.2.2 yamt #include <sys/kernel.h> 57 1.25.2.2 yamt #include <sys/kauth.h> 58 1.25.2.2 yamt #include <sys/mutex.h> 59 1.25.2.2 yamt #include <sys/atomic.h> 60 1.25.2.2 yamt #include <sys/wapbl.h> 61 1.25.2.2 yamt #include <sys/wapbl_replay.h> 62 1.25.2.2 yamt 63 1.25.2.2 yamt #include <miscfs/specfs/specdev.h> 64 1.25.2.2 yamt 65 1.25.2.2 yamt #if 0 /* notyet */ 66 1.25.2.2 yamt #define wapbl_malloc(s) kmem_alloc((s), KM_SLEEP) 67 1.25.2.2 yamt #define wapbl_free(a, s) kmem_free((a), (s)) 68 1.25.2.2 yamt #define wapbl_calloc(n, s) kmem_zalloc((n)*(s), KM_SLEEP) 69 1.25.2.2 yamt #else 70 1.25.2.2 yamt MALLOC_JUSTDEFINE(M_WAPBL, "wapbl", "write-ahead physical block logging"); 71 1.25.2.2 yamt #define wapbl_malloc(s) malloc((s), M_WAPBL, M_WAITOK) 72 1.25.2.2 yamt #define wapbl_free(a, s) free((a), M_WAPBL) 73 1.25.2.2 yamt #define wapbl_calloc(n, s) malloc((n)*(s), M_WAPBL, M_WAITOK | M_ZERO) 74 1.25.2.2 yamt #endif 75 1.25.2.2 yamt 76 1.25.2.2 yamt #else /* !_KERNEL */ 77 1.25.2.2 yamt #include <assert.h> 78 1.25.2.2 yamt #include <errno.h> 79 1.25.2.2 yamt #include <stdio.h> 80 1.25.2.2 yamt #include <stdbool.h> 81 1.25.2.2 yamt #include <stdlib.h> 82 1.25.2.2 yamt #include <string.h> 83 1.25.2.2 yamt 84 1.25.2.2 yamt #include <sys/time.h> 85 1.25.2.2 yamt #include <sys/wapbl.h> 86 1.25.2.2 yamt #include <sys/wapbl_replay.h> 87 1.25.2.2 yamt 88 1.25.2.2 yamt #define KDASSERT(x) assert(x) 89 1.25.2.2 yamt #define KASSERT(x) assert(x) 90 1.25.2.2 yamt #define wapbl_malloc(s) malloc(s) 91 1.25.2.2 yamt #define wapbl_free(a, s) free(a) 92 1.25.2.2 yamt #define wapbl_calloc(n, s) calloc((n), (s)) 93 1.25.2.2 yamt 94 1.25.2.2 yamt #endif /* !_KERNEL */ 95 1.25.2.2 yamt 96 1.25.2.2 yamt /* 97 1.25.2.2 yamt * INTERNAL DATA STRUCTURES 98 1.25.2.2 yamt */ 99 1.25.2.2 yamt 100 1.25.2.2 yamt /* 101 1.25.2.2 yamt * This structure holds per-mount log information. 102 1.25.2.2 yamt * 103 1.25.2.2 yamt * Legend: a = atomic access only 104 1.25.2.2 yamt * r = read-only after init 105 1.25.2.2 yamt * l = rwlock held 106 1.25.2.2 yamt * m = mutex held 107 1.25.2.2 yamt * u = unlocked access ok 108 1.25.2.2 yamt * b = bufcache_lock held 109 1.25.2.2 yamt */ 110 1.25.2.2 yamt struct wapbl { 111 1.25.2.2 yamt struct vnode *wl_logvp; /* r: log here */ 112 1.25.2.2 yamt struct vnode *wl_devvp; /* r: log on this device */ 113 1.25.2.2 yamt struct mount *wl_mount; /* r: mountpoint wl is associated with */ 114 1.25.2.2 yamt daddr_t wl_logpbn; /* r: Physical block number of start of log */ 115 1.25.2.2 yamt int wl_log_dev_bshift; /* r: logarithm of device block size of log 116 1.25.2.2 yamt device */ 117 1.25.2.2 yamt int wl_fs_dev_bshift; /* r: logarithm of device block size of 118 1.25.2.2 yamt filesystem device */ 119 1.25.2.2 yamt 120 1.25.2.2 yamt unsigned wl_lock_count; /* m: Count of transactions in progress */ 121 1.25.2.2 yamt 122 1.25.2.2 yamt size_t wl_circ_size; /* r: Number of bytes in buffer of log */ 123 1.25.2.2 yamt size_t wl_circ_off; /* r: Number of bytes reserved at start */ 124 1.25.2.2 yamt 125 1.25.2.2 yamt size_t wl_bufcount_max; /* r: Number of buffers reserved for log */ 126 1.25.2.2 yamt size_t wl_bufbytes_max; /* r: Number of buf bytes reserved for log */ 127 1.25.2.2 yamt 128 1.25.2.2 yamt off_t wl_head; /* l: Byte offset of log head */ 129 1.25.2.2 yamt off_t wl_tail; /* l: Byte offset of log tail */ 130 1.25.2.2 yamt /* 131 1.25.2.2 yamt * head == tail == 0 means log is empty 132 1.25.2.2 yamt * head == tail != 0 means log is full 133 1.25.2.2 yamt * see assertions in wapbl_advance() for other boundary conditions. 134 1.25.2.2 yamt * only truncate moves the tail, except when flush sets it to 135 1.25.2.2 yamt * wl_header_size only flush moves the head, except when truncate 136 1.25.2.2 yamt * sets it to 0. 137 1.25.2.2 yamt */ 138 1.25.2.2 yamt 139 1.25.2.2 yamt struct wapbl_wc_header *wl_wc_header; /* l */ 140 1.25.2.2 yamt void *wl_wc_scratch; /* l: scratch space (XXX: por que?!?) */ 141 1.25.2.2 yamt 142 1.25.2.2 yamt kmutex_t wl_mtx; /* u: short-term lock */ 143 1.25.2.2 yamt krwlock_t wl_rwlock; /* u: File system transaction lock */ 144 1.25.2.2 yamt 145 1.25.2.2 yamt /* 146 1.25.2.2 yamt * Must be held while accessing 147 1.25.2.2 yamt * wl_count or wl_bufs or head or tail 148 1.25.2.2 yamt */ 149 1.25.2.2 yamt 150 1.25.2.2 yamt /* 151 1.25.2.2 yamt * Callback called from within the flush routine to flush any extra 152 1.25.2.2 yamt * bits. Note that flush may be skipped without calling this if 153 1.25.2.2 yamt * there are no outstanding buffers in the transaction. 154 1.25.2.2 yamt */ 155 1.25.2.2 yamt #if _KERNEL 156 1.25.2.2 yamt wapbl_flush_fn_t wl_flush; /* r */ 157 1.25.2.2 yamt wapbl_flush_fn_t wl_flush_abort;/* r */ 158 1.25.2.2 yamt #endif 159 1.25.2.2 yamt 160 1.25.2.2 yamt size_t wl_bufbytes; /* m: Byte count of pages in wl_bufs */ 161 1.25.2.2 yamt size_t wl_bufcount; /* m: Count of buffers in wl_bufs */ 162 1.25.2.2 yamt size_t wl_bcount; /* m: Total bcount of wl_bufs */ 163 1.25.2.2 yamt 164 1.25.2.2 yamt LIST_HEAD(, buf) wl_bufs; /* m: Buffers in current transaction */ 165 1.25.2.2 yamt 166 1.25.2.2 yamt kcondvar_t wl_reclaimable_cv; /* m (obviously) */ 167 1.25.2.2 yamt size_t wl_reclaimable_bytes; /* m: Amount of space available for 168 1.25.2.2 yamt reclamation by truncate */ 169 1.25.2.2 yamt int wl_error_count; /* m: # of wl_entries with errors */ 170 1.25.2.2 yamt size_t wl_reserved_bytes; /* never truncate log smaller than this */ 171 1.25.2.2 yamt 172 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 173 1.25.2.2 yamt size_t wl_unsynced_bufbytes; /* Byte count of unsynced buffers */ 174 1.25.2.2 yamt #endif 175 1.25.2.2 yamt 176 1.25.2.2 yamt daddr_t *wl_deallocblks;/* l: address of block */ 177 1.25.2.2 yamt int *wl_dealloclens; /* l: size of block */ 178 1.25.2.2 yamt int wl_dealloccnt; /* l: total count */ 179 1.25.2.2 yamt int wl_dealloclim; /* l: max count */ 180 1.25.2.2 yamt 181 1.25.2.2 yamt /* hashtable of inode numbers for allocated but unlinked inodes */ 182 1.25.2.2 yamt /* synch ??? */ 183 1.25.2.2 yamt LIST_HEAD(wapbl_ino_head, wapbl_ino) *wl_inohash; 184 1.25.2.2 yamt u_long wl_inohashmask; 185 1.25.2.2 yamt int wl_inohashcnt; 186 1.25.2.2 yamt 187 1.25.2.2 yamt SIMPLEQ_HEAD(, wapbl_entry) wl_entries; /* On disk transaction 188 1.25.2.2 yamt accounting */ 189 1.25.2.2 yamt }; 190 1.25.2.2 yamt 191 1.25.2.2 yamt #ifdef WAPBL_DEBUG_PRINT 192 1.25.2.2 yamt int wapbl_debug_print = WAPBL_DEBUG_PRINT; 193 1.25.2.2 yamt #endif 194 1.25.2.2 yamt 195 1.25.2.2 yamt /****************************************************************/ 196 1.25.2.2 yamt #ifdef _KERNEL 197 1.25.2.2 yamt 198 1.25.2.2 yamt #ifdef WAPBL_DEBUG 199 1.25.2.2 yamt struct wapbl *wapbl_debug_wl; 200 1.25.2.2 yamt #endif 201 1.25.2.2 yamt 202 1.25.2.2 yamt static int wapbl_write_commit(struct wapbl *wl, off_t head, off_t tail); 203 1.25.2.2 yamt static int wapbl_write_blocks(struct wapbl *wl, off_t *offp); 204 1.25.2.2 yamt static int wapbl_write_revocations(struct wapbl *wl, off_t *offp); 205 1.25.2.2 yamt static int wapbl_write_inodes(struct wapbl *wl, off_t *offp); 206 1.25.2.2 yamt #endif /* _KERNEL */ 207 1.25.2.2 yamt 208 1.25.2.2 yamt static int wapbl_replay_process(struct wapbl_replay *wr, off_t, off_t); 209 1.25.2.2 yamt 210 1.25.2.4 yamt static inline size_t wapbl_space_free(size_t avail, off_t head, 211 1.25.2.2 yamt off_t tail); 212 1.25.2.4 yamt static inline size_t wapbl_space_used(size_t avail, off_t head, 213 1.25.2.2 yamt off_t tail); 214 1.25.2.2 yamt 215 1.25.2.2 yamt #ifdef _KERNEL 216 1.25.2.2 yamt 217 1.25.2.2 yamt #define WAPBL_INODETRK_SIZE 83 218 1.25.2.2 yamt static int wapbl_ino_pool_refcount; 219 1.25.2.2 yamt static struct pool wapbl_ino_pool; 220 1.25.2.2 yamt struct wapbl_ino { 221 1.25.2.2 yamt LIST_ENTRY(wapbl_ino) wi_hash; 222 1.25.2.2 yamt ino_t wi_ino; 223 1.25.2.2 yamt mode_t wi_mode; 224 1.25.2.2 yamt }; 225 1.25.2.2 yamt 226 1.25.2.2 yamt static void wapbl_inodetrk_init(struct wapbl *wl, u_int size); 227 1.25.2.2 yamt static void wapbl_inodetrk_free(struct wapbl *wl); 228 1.25.2.2 yamt static struct wapbl_ino *wapbl_inodetrk_get(struct wapbl *wl, ino_t ino); 229 1.25.2.2 yamt 230 1.25.2.2 yamt static size_t wapbl_transaction_len(struct wapbl *wl); 231 1.25.2.4 yamt static inline size_t wapbl_transaction_inodes_len(struct wapbl *wl); 232 1.25.2.2 yamt 233 1.25.2.2 yamt #if 0 234 1.25.2.2 yamt int wapbl_replay_verify(struct wapbl_replay *, struct vnode *); 235 1.25.2.2 yamt #endif 236 1.25.2.2 yamt 237 1.25.2.2 yamt static int wapbl_replay_isopen1(struct wapbl_replay *); 238 1.25.2.2 yamt 239 1.25.2.2 yamt /* 240 1.25.2.2 yamt * This is useful for debugging. If set, the log will 241 1.25.2.2 yamt * only be truncated when necessary. 242 1.25.2.2 yamt */ 243 1.25.2.2 yamt int wapbl_lazy_truncate = 0; 244 1.25.2.2 yamt 245 1.25.2.2 yamt struct wapbl_ops wapbl_ops = { 246 1.25.2.2 yamt .wo_wapbl_discard = wapbl_discard, 247 1.25.2.2 yamt .wo_wapbl_replay_isopen = wapbl_replay_isopen1, 248 1.25.2.2 yamt .wo_wapbl_replay_can_read = wapbl_replay_can_read, 249 1.25.2.2 yamt .wo_wapbl_replay_read = wapbl_replay_read, 250 1.25.2.2 yamt .wo_wapbl_add_buf = wapbl_add_buf, 251 1.25.2.2 yamt .wo_wapbl_remove_buf = wapbl_remove_buf, 252 1.25.2.2 yamt .wo_wapbl_resize_buf = wapbl_resize_buf, 253 1.25.2.2 yamt .wo_wapbl_begin = wapbl_begin, 254 1.25.2.2 yamt .wo_wapbl_end = wapbl_end, 255 1.25.2.2 yamt .wo_wapbl_junlock_assert= wapbl_junlock_assert, 256 1.25.2.2 yamt 257 1.25.2.2 yamt /* XXX: the following is only used to say "this is a wapbl buf" */ 258 1.25.2.2 yamt .wo_wapbl_biodone = wapbl_biodone, 259 1.25.2.2 yamt }; 260 1.25.2.2 yamt 261 1.25.2.2 yamt static int 262 1.25.2.2 yamt wapbl_start_flush_inodes(struct wapbl *wl, struct wapbl_replay *wr) 263 1.25.2.2 yamt { 264 1.25.2.2 yamt int error, i; 265 1.25.2.2 yamt 266 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_REPLAY, 267 1.25.2.2 yamt ("wapbl_start: reusing log with %d inodes\n", wr->wr_inodescnt)); 268 1.25.2.2 yamt 269 1.25.2.2 yamt /* 270 1.25.2.2 yamt * Its only valid to reuse the replay log if its 271 1.25.2.2 yamt * the same as the new log we just opened. 272 1.25.2.2 yamt */ 273 1.25.2.2 yamt KDASSERT(!wapbl_replay_isopen(wr)); 274 1.25.2.2 yamt KASSERT(wl->wl_devvp->v_rdev == wr->wr_devvp->v_rdev); 275 1.25.2.2 yamt KASSERT(wl->wl_logpbn == wr->wr_logpbn); 276 1.25.2.2 yamt KASSERT(wl->wl_circ_size == wr->wr_circ_size); 277 1.25.2.2 yamt KASSERT(wl->wl_circ_off == wr->wr_circ_off); 278 1.25.2.2 yamt KASSERT(wl->wl_log_dev_bshift == wr->wr_log_dev_bshift); 279 1.25.2.2 yamt KASSERT(wl->wl_fs_dev_bshift == wr->wr_fs_dev_bshift); 280 1.25.2.2 yamt 281 1.25.2.2 yamt wl->wl_wc_header->wc_generation = wr->wr_generation + 1; 282 1.25.2.2 yamt 283 1.25.2.2 yamt for (i = 0; i < wr->wr_inodescnt; i++) 284 1.25.2.2 yamt wapbl_register_inode(wl, wr->wr_inodes[i].wr_inumber, 285 1.25.2.2 yamt wr->wr_inodes[i].wr_imode); 286 1.25.2.2 yamt 287 1.25.2.2 yamt /* Make sure new transaction won't overwrite old inodes list */ 288 1.25.2.2 yamt KDASSERT(wapbl_transaction_len(wl) <= 289 1.25.2.2 yamt wapbl_space_free(wl->wl_circ_size, wr->wr_inodeshead, 290 1.25.2.2 yamt wr->wr_inodestail)); 291 1.25.2.2 yamt 292 1.25.2.2 yamt wl->wl_head = wl->wl_tail = wr->wr_inodeshead; 293 1.25.2.2 yamt wl->wl_reclaimable_bytes = wl->wl_reserved_bytes = 294 1.25.2.2 yamt wapbl_transaction_len(wl); 295 1.25.2.2 yamt 296 1.25.2.2 yamt error = wapbl_write_inodes(wl, &wl->wl_head); 297 1.25.2.2 yamt if (error) 298 1.25.2.2 yamt return error; 299 1.25.2.2 yamt 300 1.25.2.2 yamt KASSERT(wl->wl_head != wl->wl_tail); 301 1.25.2.2 yamt KASSERT(wl->wl_head != 0); 302 1.25.2.2 yamt 303 1.25.2.2 yamt return 0; 304 1.25.2.2 yamt } 305 1.25.2.2 yamt 306 1.25.2.2 yamt int 307 1.25.2.2 yamt wapbl_start(struct wapbl ** wlp, struct mount *mp, struct vnode *vp, 308 1.25.2.2 yamt daddr_t off, size_t count, size_t blksize, struct wapbl_replay *wr, 309 1.25.2.2 yamt wapbl_flush_fn_t flushfn, wapbl_flush_fn_t flushabortfn) 310 1.25.2.2 yamt { 311 1.25.2.2 yamt struct wapbl *wl; 312 1.25.2.2 yamt struct vnode *devvp; 313 1.25.2.2 yamt daddr_t logpbn; 314 1.25.2.2 yamt int error; 315 1.25.2.4 yamt int log_dev_bshift = ilog2(blksize); 316 1.25.2.4 yamt int fs_dev_bshift = log_dev_bshift; 317 1.25.2.2 yamt int run; 318 1.25.2.2 yamt 319 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_OPEN, ("wapbl_start: vp=%p off=%" PRId64 320 1.25.2.2 yamt " count=%zu blksize=%zu\n", vp, off, count, blksize)); 321 1.25.2.2 yamt 322 1.25.2.2 yamt if (log_dev_bshift > fs_dev_bshift) { 323 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_OPEN, 324 1.25.2.2 yamt ("wapbl: log device's block size cannot be larger " 325 1.25.2.2 yamt "than filesystem's\n")); 326 1.25.2.2 yamt /* 327 1.25.2.2 yamt * Not currently implemented, although it could be if 328 1.25.2.2 yamt * needed someday. 329 1.25.2.2 yamt */ 330 1.25.2.2 yamt return ENOSYS; 331 1.25.2.2 yamt } 332 1.25.2.2 yamt 333 1.25.2.2 yamt if (off < 0) 334 1.25.2.2 yamt return EINVAL; 335 1.25.2.2 yamt 336 1.25.2.2 yamt if (blksize < DEV_BSIZE) 337 1.25.2.2 yamt return EINVAL; 338 1.25.2.2 yamt if (blksize % DEV_BSIZE) 339 1.25.2.2 yamt return EINVAL; 340 1.25.2.2 yamt 341 1.25.2.2 yamt /* XXXTODO: verify that the full load is writable */ 342 1.25.2.2 yamt 343 1.25.2.2 yamt /* 344 1.25.2.2 yamt * XXX check for minimum log size 345 1.25.2.2 yamt * minimum is governed by minimum amount of space 346 1.25.2.2 yamt * to complete a transaction. (probably truncate) 347 1.25.2.2 yamt */ 348 1.25.2.2 yamt /* XXX for now pick something minimal */ 349 1.25.2.2 yamt if ((count * blksize) < MAXPHYS) { 350 1.25.2.2 yamt return ENOSPC; 351 1.25.2.2 yamt } 352 1.25.2.2 yamt 353 1.25.2.2 yamt if ((error = VOP_BMAP(vp, off, &devvp, &logpbn, &run)) != 0) { 354 1.25.2.2 yamt return error; 355 1.25.2.2 yamt } 356 1.25.2.2 yamt 357 1.25.2.2 yamt wl = wapbl_calloc(1, sizeof(*wl)); 358 1.25.2.2 yamt rw_init(&wl->wl_rwlock); 359 1.25.2.2 yamt mutex_init(&wl->wl_mtx, MUTEX_DEFAULT, IPL_NONE); 360 1.25.2.2 yamt cv_init(&wl->wl_reclaimable_cv, "wapblrec"); 361 1.25.2.2 yamt LIST_INIT(&wl->wl_bufs); 362 1.25.2.2 yamt SIMPLEQ_INIT(&wl->wl_entries); 363 1.25.2.2 yamt 364 1.25.2.2 yamt wl->wl_logvp = vp; 365 1.25.2.2 yamt wl->wl_devvp = devvp; 366 1.25.2.2 yamt wl->wl_mount = mp; 367 1.25.2.2 yamt wl->wl_logpbn = logpbn; 368 1.25.2.2 yamt wl->wl_log_dev_bshift = log_dev_bshift; 369 1.25.2.2 yamt wl->wl_fs_dev_bshift = fs_dev_bshift; 370 1.25.2.2 yamt 371 1.25.2.2 yamt wl->wl_flush = flushfn; 372 1.25.2.2 yamt wl->wl_flush_abort = flushabortfn; 373 1.25.2.2 yamt 374 1.25.2.2 yamt /* Reserve two log device blocks for the commit headers */ 375 1.25.2.2 yamt wl->wl_circ_off = 2<<wl->wl_log_dev_bshift; 376 1.25.2.2 yamt wl->wl_circ_size = ((count * blksize) - wl->wl_circ_off); 377 1.25.2.2 yamt /* truncate the log usage to a multiple of log_dev_bshift */ 378 1.25.2.2 yamt wl->wl_circ_size >>= wl->wl_log_dev_bshift; 379 1.25.2.2 yamt wl->wl_circ_size <<= wl->wl_log_dev_bshift; 380 1.25.2.2 yamt 381 1.25.2.2 yamt /* 382 1.25.2.2 yamt * wl_bufbytes_max limits the size of the in memory transaction space. 383 1.25.2.2 yamt * - Since buffers are allocated and accounted for in units of 384 1.25.2.2 yamt * PAGE_SIZE it is required to be a multiple of PAGE_SIZE 385 1.25.2.2 yamt * (i.e. 1<<PAGE_SHIFT) 386 1.25.2.2 yamt * - Since the log device has to be written in units of 387 1.25.2.2 yamt * 1<<wl_log_dev_bshift it is required to be a mulitple of 388 1.25.2.2 yamt * 1<<wl_log_dev_bshift. 389 1.25.2.2 yamt * - Since filesystem will provide data in units of 1<<wl_fs_dev_bshift, 390 1.25.2.2 yamt * it is convenient to be a multiple of 1<<wl_fs_dev_bshift. 391 1.25.2.2 yamt * Therefore it must be multiple of the least common multiple of those 392 1.25.2.2 yamt * three quantities. Fortunately, all of those quantities are 393 1.25.2.2 yamt * guaranteed to be a power of two, and the least common multiple of 394 1.25.2.2 yamt * a set of numbers which are all powers of two is simply the maximum 395 1.25.2.2 yamt * of those numbers. Finally, the maximum logarithm of a power of two 396 1.25.2.2 yamt * is the same as the log of the maximum power of two. So we can do 397 1.25.2.2 yamt * the following operations to size wl_bufbytes_max: 398 1.25.2.2 yamt */ 399 1.25.2.2 yamt 400 1.25.2.2 yamt /* XXX fix actual number of pages reserved per filesystem. */ 401 1.25.2.2 yamt wl->wl_bufbytes_max = MIN(wl->wl_circ_size, buf_memcalc() / 2); 402 1.25.2.2 yamt 403 1.25.2.2 yamt /* Round wl_bufbytes_max to the largest power of two constraint */ 404 1.25.2.2 yamt wl->wl_bufbytes_max >>= PAGE_SHIFT; 405 1.25.2.2 yamt wl->wl_bufbytes_max <<= PAGE_SHIFT; 406 1.25.2.2 yamt wl->wl_bufbytes_max >>= wl->wl_log_dev_bshift; 407 1.25.2.2 yamt wl->wl_bufbytes_max <<= wl->wl_log_dev_bshift; 408 1.25.2.2 yamt wl->wl_bufbytes_max >>= wl->wl_fs_dev_bshift; 409 1.25.2.2 yamt wl->wl_bufbytes_max <<= wl->wl_fs_dev_bshift; 410 1.25.2.2 yamt 411 1.25.2.2 yamt /* XXX maybe use filesystem fragment size instead of 1024 */ 412 1.25.2.2 yamt /* XXX fix actual number of buffers reserved per filesystem. */ 413 1.25.2.2 yamt wl->wl_bufcount_max = (nbuf / 2) * 1024; 414 1.25.2.2 yamt 415 1.25.2.2 yamt /* XXX tie this into resource estimation */ 416 1.25.2.2 yamt wl->wl_dealloclim = 2 * btodb(wl->wl_bufbytes_max); 417 1.25.2.2 yamt 418 1.25.2.2 yamt wl->wl_deallocblks = wapbl_malloc(sizeof(*wl->wl_deallocblks) * 419 1.25.2.2 yamt wl->wl_dealloclim); 420 1.25.2.2 yamt wl->wl_dealloclens = wapbl_malloc(sizeof(*wl->wl_dealloclens) * 421 1.25.2.2 yamt wl->wl_dealloclim); 422 1.25.2.2 yamt 423 1.25.2.2 yamt wapbl_inodetrk_init(wl, WAPBL_INODETRK_SIZE); 424 1.25.2.2 yamt 425 1.25.2.2 yamt /* Initialize the commit header */ 426 1.25.2.2 yamt { 427 1.25.2.2 yamt struct wapbl_wc_header *wc; 428 1.25.2.2 yamt size_t len = 1 << wl->wl_log_dev_bshift; 429 1.25.2.2 yamt wc = wapbl_calloc(1, len); 430 1.25.2.2 yamt wc->wc_type = WAPBL_WC_HEADER; 431 1.25.2.2 yamt wc->wc_len = len; 432 1.25.2.2 yamt wc->wc_circ_off = wl->wl_circ_off; 433 1.25.2.2 yamt wc->wc_circ_size = wl->wl_circ_size; 434 1.25.2.2 yamt /* XXX wc->wc_fsid */ 435 1.25.2.2 yamt wc->wc_log_dev_bshift = wl->wl_log_dev_bshift; 436 1.25.2.2 yamt wc->wc_fs_dev_bshift = wl->wl_fs_dev_bshift; 437 1.25.2.2 yamt wl->wl_wc_header = wc; 438 1.25.2.2 yamt wl->wl_wc_scratch = wapbl_malloc(len); 439 1.25.2.2 yamt } 440 1.25.2.2 yamt 441 1.25.2.2 yamt /* 442 1.25.2.2 yamt * if there was an existing set of unlinked but 443 1.25.2.2 yamt * allocated inodes, preserve it in the new 444 1.25.2.2 yamt * log. 445 1.25.2.2 yamt */ 446 1.25.2.2 yamt if (wr && wr->wr_inodescnt) { 447 1.25.2.2 yamt error = wapbl_start_flush_inodes(wl, wr); 448 1.25.2.2 yamt if (error) 449 1.25.2.2 yamt goto errout; 450 1.25.2.2 yamt } 451 1.25.2.2 yamt 452 1.25.2.2 yamt error = wapbl_write_commit(wl, wl->wl_head, wl->wl_tail); 453 1.25.2.2 yamt if (error) { 454 1.25.2.2 yamt goto errout; 455 1.25.2.2 yamt } 456 1.25.2.2 yamt 457 1.25.2.2 yamt *wlp = wl; 458 1.25.2.2 yamt #if defined(WAPBL_DEBUG) 459 1.25.2.2 yamt wapbl_debug_wl = wl; 460 1.25.2.2 yamt #endif 461 1.25.2.2 yamt 462 1.25.2.2 yamt return 0; 463 1.25.2.2 yamt errout: 464 1.25.2.2 yamt wapbl_discard(wl); 465 1.25.2.2 yamt wapbl_free(wl->wl_wc_scratch, wl->wl_wc_header->wc_len); 466 1.25.2.2 yamt wapbl_free(wl->wl_wc_header, wl->wl_wc_header->wc_len); 467 1.25.2.2 yamt wapbl_free(wl->wl_deallocblks, 468 1.25.2.2 yamt sizeof(*wl->wl_deallocblks) * wl->wl_dealloclim); 469 1.25.2.2 yamt wapbl_free(wl->wl_dealloclens, 470 1.25.2.2 yamt sizeof(*wl->wl_dealloclens) * wl->wl_dealloclim); 471 1.25.2.2 yamt wapbl_inodetrk_free(wl); 472 1.25.2.2 yamt wapbl_free(wl, sizeof(*wl)); 473 1.25.2.2 yamt 474 1.25.2.2 yamt return error; 475 1.25.2.2 yamt } 476 1.25.2.2 yamt 477 1.25.2.2 yamt /* 478 1.25.2.2 yamt * Like wapbl_flush, only discards the transaction 479 1.25.2.2 yamt * completely 480 1.25.2.2 yamt */ 481 1.25.2.2 yamt 482 1.25.2.2 yamt void 483 1.25.2.2 yamt wapbl_discard(struct wapbl *wl) 484 1.25.2.2 yamt { 485 1.25.2.2 yamt struct wapbl_entry *we; 486 1.25.2.2 yamt struct buf *bp; 487 1.25.2.2 yamt int i; 488 1.25.2.2 yamt 489 1.25.2.2 yamt /* 490 1.25.2.2 yamt * XXX we may consider using upgrade here 491 1.25.2.2 yamt * if we want to call flush from inside a transaction 492 1.25.2.2 yamt */ 493 1.25.2.2 yamt rw_enter(&wl->wl_rwlock, RW_WRITER); 494 1.25.2.2 yamt wl->wl_flush(wl->wl_mount, wl->wl_deallocblks, wl->wl_dealloclens, 495 1.25.2.2 yamt wl->wl_dealloccnt); 496 1.25.2.2 yamt 497 1.25.2.2 yamt #ifdef WAPBL_DEBUG_PRINT 498 1.25.2.2 yamt { 499 1.25.2.2 yamt pid_t pid = -1; 500 1.25.2.2 yamt lwpid_t lid = -1; 501 1.25.2.2 yamt if (curproc) 502 1.25.2.2 yamt pid = curproc->p_pid; 503 1.25.2.2 yamt if (curlwp) 504 1.25.2.2 yamt lid = curlwp->l_lid; 505 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 506 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_DISCARD, 507 1.25.2.2 yamt ("wapbl_discard: thread %d.%d discarding " 508 1.25.2.2 yamt "transaction\n" 509 1.25.2.2 yamt "\tbufcount=%zu bufbytes=%zu bcount=%zu " 510 1.25.2.2 yamt "deallocs=%d inodes=%d\n" 511 1.25.2.2 yamt "\terrcnt = %u, reclaimable=%zu reserved=%zu " 512 1.25.2.2 yamt "unsynced=%zu\n", 513 1.25.2.2 yamt pid, lid, wl->wl_bufcount, wl->wl_bufbytes, 514 1.25.2.2 yamt wl->wl_bcount, wl->wl_dealloccnt, 515 1.25.2.2 yamt wl->wl_inohashcnt, wl->wl_error_count, 516 1.25.2.2 yamt wl->wl_reclaimable_bytes, wl->wl_reserved_bytes, 517 1.25.2.2 yamt wl->wl_unsynced_bufbytes)); 518 1.25.2.2 yamt SIMPLEQ_FOREACH(we, &wl->wl_entries, we_entries) { 519 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_DISCARD, 520 1.25.2.2 yamt ("\tentry: bufcount = %zu, reclaimable = %zu, " 521 1.25.2.2 yamt "error = %d, unsynced = %zu\n", 522 1.25.2.2 yamt we->we_bufcount, we->we_reclaimable_bytes, 523 1.25.2.2 yamt we->we_error, we->we_unsynced_bufbytes)); 524 1.25.2.2 yamt } 525 1.25.2.2 yamt #else /* !WAPBL_DEBUG_BUFBYTES */ 526 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_DISCARD, 527 1.25.2.2 yamt ("wapbl_discard: thread %d.%d discarding transaction\n" 528 1.25.2.2 yamt "\tbufcount=%zu bufbytes=%zu bcount=%zu " 529 1.25.2.2 yamt "deallocs=%d inodes=%d\n" 530 1.25.2.2 yamt "\terrcnt = %u, reclaimable=%zu reserved=%zu\n", 531 1.25.2.2 yamt pid, lid, wl->wl_bufcount, wl->wl_bufbytes, 532 1.25.2.2 yamt wl->wl_bcount, wl->wl_dealloccnt, 533 1.25.2.2 yamt wl->wl_inohashcnt, wl->wl_error_count, 534 1.25.2.2 yamt wl->wl_reclaimable_bytes, wl->wl_reserved_bytes)); 535 1.25.2.2 yamt SIMPLEQ_FOREACH(we, &wl->wl_entries, we_entries) { 536 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_DISCARD, 537 1.25.2.2 yamt ("\tentry: bufcount = %zu, reclaimable = %zu, " 538 1.25.2.2 yamt "error = %d\n", 539 1.25.2.2 yamt we->we_bufcount, we->we_reclaimable_bytes, 540 1.25.2.2 yamt we->we_error)); 541 1.25.2.2 yamt } 542 1.25.2.2 yamt #endif /* !WAPBL_DEBUG_BUFBYTES */ 543 1.25.2.2 yamt } 544 1.25.2.2 yamt #endif /* WAPBL_DEBUG_PRINT */ 545 1.25.2.2 yamt 546 1.25.2.2 yamt for (i = 0; i <= wl->wl_inohashmask; i++) { 547 1.25.2.2 yamt struct wapbl_ino_head *wih; 548 1.25.2.2 yamt struct wapbl_ino *wi; 549 1.25.2.2 yamt 550 1.25.2.2 yamt wih = &wl->wl_inohash[i]; 551 1.25.2.2 yamt while ((wi = LIST_FIRST(wih)) != NULL) { 552 1.25.2.2 yamt LIST_REMOVE(wi, wi_hash); 553 1.25.2.2 yamt pool_put(&wapbl_ino_pool, wi); 554 1.25.2.2 yamt KASSERT(wl->wl_inohashcnt > 0); 555 1.25.2.2 yamt wl->wl_inohashcnt--; 556 1.25.2.2 yamt } 557 1.25.2.2 yamt } 558 1.25.2.2 yamt 559 1.25.2.2 yamt /* 560 1.25.2.2 yamt * clean buffer list 561 1.25.2.2 yamt */ 562 1.25.2.2 yamt mutex_enter(&bufcache_lock); 563 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 564 1.25.2.2 yamt while ((bp = LIST_FIRST(&wl->wl_bufs)) != NULL) { 565 1.25.2.2 yamt if (bbusy(bp, 0, 0, &wl->wl_mtx) == 0) { 566 1.25.2.2 yamt /* 567 1.25.2.2 yamt * The buffer will be unlocked and 568 1.25.2.2 yamt * removed from the transaction in brelse 569 1.25.2.2 yamt */ 570 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 571 1.25.2.2 yamt brelsel(bp, 0); 572 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 573 1.25.2.2 yamt } 574 1.25.2.2 yamt } 575 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 576 1.25.2.2 yamt mutex_exit(&bufcache_lock); 577 1.25.2.2 yamt 578 1.25.2.2 yamt /* 579 1.25.2.2 yamt * Remove references to this wl from wl_entries, free any which 580 1.25.2.2 yamt * no longer have buffers, others will be freed in wapbl_biodone 581 1.25.2.2 yamt * when they no longer have any buffers. 582 1.25.2.2 yamt */ 583 1.25.2.2 yamt while ((we = SIMPLEQ_FIRST(&wl->wl_entries)) != NULL) { 584 1.25.2.2 yamt SIMPLEQ_REMOVE_HEAD(&wl->wl_entries, we_entries); 585 1.25.2.2 yamt /* XXX should we be accumulating wl_error_count 586 1.25.2.2 yamt * and increasing reclaimable bytes ? */ 587 1.25.2.2 yamt we->we_wapbl = NULL; 588 1.25.2.2 yamt if (we->we_bufcount == 0) { 589 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 590 1.25.2.2 yamt KASSERT(we->we_unsynced_bufbytes == 0); 591 1.25.2.2 yamt #endif 592 1.25.2.2 yamt wapbl_free(we, sizeof(*we)); 593 1.25.2.2 yamt } 594 1.25.2.2 yamt } 595 1.25.2.2 yamt 596 1.25.2.2 yamt /* Discard list of deallocs */ 597 1.25.2.2 yamt wl->wl_dealloccnt = 0; 598 1.25.2.2 yamt /* XXX should we clear wl_reserved_bytes? */ 599 1.25.2.2 yamt 600 1.25.2.2 yamt KASSERT(wl->wl_bufbytes == 0); 601 1.25.2.2 yamt KASSERT(wl->wl_bcount == 0); 602 1.25.2.2 yamt KASSERT(wl->wl_bufcount == 0); 603 1.25.2.2 yamt KASSERT(LIST_EMPTY(&wl->wl_bufs)); 604 1.25.2.2 yamt KASSERT(SIMPLEQ_EMPTY(&wl->wl_entries)); 605 1.25.2.2 yamt KASSERT(wl->wl_inohashcnt == 0); 606 1.25.2.2 yamt 607 1.25.2.2 yamt rw_exit(&wl->wl_rwlock); 608 1.25.2.2 yamt } 609 1.25.2.2 yamt 610 1.25.2.2 yamt int 611 1.25.2.2 yamt wapbl_stop(struct wapbl *wl, int force) 612 1.25.2.2 yamt { 613 1.25.2.2 yamt struct vnode *vp; 614 1.25.2.2 yamt int error; 615 1.25.2.2 yamt 616 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_OPEN, ("wapbl_stop called\n")); 617 1.25.2.2 yamt error = wapbl_flush(wl, 1); 618 1.25.2.2 yamt if (error) { 619 1.25.2.2 yamt if (force) 620 1.25.2.2 yamt wapbl_discard(wl); 621 1.25.2.2 yamt else 622 1.25.2.2 yamt return error; 623 1.25.2.2 yamt } 624 1.25.2.2 yamt 625 1.25.2.2 yamt /* Unlinked inodes persist after a flush */ 626 1.25.2.2 yamt if (wl->wl_inohashcnt) { 627 1.25.2.2 yamt if (force) { 628 1.25.2.2 yamt wapbl_discard(wl); 629 1.25.2.2 yamt } else { 630 1.25.2.2 yamt return EBUSY; 631 1.25.2.2 yamt } 632 1.25.2.2 yamt } 633 1.25.2.2 yamt 634 1.25.2.2 yamt KASSERT(wl->wl_bufbytes == 0); 635 1.25.2.2 yamt KASSERT(wl->wl_bcount == 0); 636 1.25.2.2 yamt KASSERT(wl->wl_bufcount == 0); 637 1.25.2.2 yamt KASSERT(LIST_EMPTY(&wl->wl_bufs)); 638 1.25.2.2 yamt KASSERT(wl->wl_dealloccnt == 0); 639 1.25.2.2 yamt KASSERT(SIMPLEQ_EMPTY(&wl->wl_entries)); 640 1.25.2.2 yamt KASSERT(wl->wl_inohashcnt == 0); 641 1.25.2.2 yamt 642 1.25.2.2 yamt vp = wl->wl_logvp; 643 1.25.2.2 yamt 644 1.25.2.2 yamt wapbl_free(wl->wl_wc_scratch, wl->wl_wc_header->wc_len); 645 1.25.2.2 yamt wapbl_free(wl->wl_wc_header, wl->wl_wc_header->wc_len); 646 1.25.2.2 yamt wapbl_free(wl->wl_deallocblks, 647 1.25.2.2 yamt sizeof(*wl->wl_deallocblks) * wl->wl_dealloclim); 648 1.25.2.2 yamt wapbl_free(wl->wl_dealloclens, 649 1.25.2.2 yamt sizeof(*wl->wl_dealloclens) * wl->wl_dealloclim); 650 1.25.2.2 yamt wapbl_inodetrk_free(wl); 651 1.25.2.2 yamt 652 1.25.2.2 yamt cv_destroy(&wl->wl_reclaimable_cv); 653 1.25.2.2 yamt mutex_destroy(&wl->wl_mtx); 654 1.25.2.2 yamt rw_destroy(&wl->wl_rwlock); 655 1.25.2.2 yamt wapbl_free(wl, sizeof(*wl)); 656 1.25.2.2 yamt 657 1.25.2.2 yamt return 0; 658 1.25.2.2 yamt } 659 1.25.2.2 yamt 660 1.25.2.2 yamt static int 661 1.25.2.2 yamt wapbl_doio(void *data, size_t len, struct vnode *devvp, daddr_t pbn, int flags) 662 1.25.2.2 yamt { 663 1.25.2.2 yamt struct pstats *pstats = curlwp->l_proc->p_stats; 664 1.25.2.2 yamt struct buf *bp; 665 1.25.2.2 yamt int error; 666 1.25.2.2 yamt 667 1.25.2.2 yamt KASSERT((flags & ~(B_WRITE | B_READ)) == 0); 668 1.25.2.2 yamt KASSERT(devvp->v_type == VBLK); 669 1.25.2.2 yamt 670 1.25.2.2 yamt if ((flags & (B_WRITE | B_READ)) == B_WRITE) { 671 1.25.2.2 yamt mutex_enter(&devvp->v_interlock); 672 1.25.2.2 yamt devvp->v_numoutput++; 673 1.25.2.2 yamt mutex_exit(&devvp->v_interlock); 674 1.25.2.2 yamt pstats->p_ru.ru_oublock++; 675 1.25.2.2 yamt } else { 676 1.25.2.2 yamt pstats->p_ru.ru_inblock++; 677 1.25.2.2 yamt } 678 1.25.2.2 yamt 679 1.25.2.2 yamt bp = getiobuf(devvp, true); 680 1.25.2.2 yamt bp->b_flags = flags; 681 1.25.2.2 yamt bp->b_cflags = BC_BUSY; /* silly & dubious */ 682 1.25.2.2 yamt bp->b_dev = devvp->v_rdev; 683 1.25.2.2 yamt bp->b_data = data; 684 1.25.2.2 yamt bp->b_bufsize = bp->b_resid = bp->b_bcount = len; 685 1.25.2.2 yamt bp->b_blkno = pbn; 686 1.25.2.2 yamt 687 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_IO, 688 1.25.2.4 yamt ("wapbl_doio: %s %d bytes at block %"PRId64" on dev 0x%"PRIx64"\n", 689 1.25.2.2 yamt BUF_ISWRITE(bp) ? "write" : "read", bp->b_bcount, 690 1.25.2.2 yamt bp->b_blkno, bp->b_dev)); 691 1.25.2.2 yamt 692 1.25.2.2 yamt VOP_STRATEGY(devvp, bp); 693 1.25.2.2 yamt 694 1.25.2.2 yamt error = biowait(bp); 695 1.25.2.2 yamt putiobuf(bp); 696 1.25.2.2 yamt 697 1.25.2.2 yamt if (error) { 698 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_ERROR, 699 1.25.2.2 yamt ("wapbl_doio: %s %zu bytes at block %" PRId64 700 1.25.2.4 yamt " on dev 0x%"PRIx64" failed with error %d\n", 701 1.25.2.2 yamt (((flags & (B_WRITE | B_READ)) == B_WRITE) ? 702 1.25.2.2 yamt "write" : "read"), 703 1.25.2.2 yamt len, pbn, devvp->v_rdev, error)); 704 1.25.2.2 yamt } 705 1.25.2.2 yamt 706 1.25.2.2 yamt return error; 707 1.25.2.2 yamt } 708 1.25.2.2 yamt 709 1.25.2.2 yamt int 710 1.25.2.2 yamt wapbl_write(void *data, size_t len, struct vnode *devvp, daddr_t pbn) 711 1.25.2.2 yamt { 712 1.25.2.2 yamt 713 1.25.2.2 yamt return wapbl_doio(data, len, devvp, pbn, B_WRITE); 714 1.25.2.2 yamt } 715 1.25.2.2 yamt 716 1.25.2.2 yamt int 717 1.25.2.2 yamt wapbl_read(void *data, size_t len, struct vnode *devvp, daddr_t pbn) 718 1.25.2.2 yamt { 719 1.25.2.2 yamt 720 1.25.2.2 yamt return wapbl_doio(data, len, devvp, pbn, B_READ); 721 1.25.2.2 yamt } 722 1.25.2.2 yamt 723 1.25.2.2 yamt /* 724 1.25.2.2 yamt * Off is byte offset returns new offset for next write 725 1.25.2.2 yamt * handles log wraparound 726 1.25.2.2 yamt */ 727 1.25.2.2 yamt static int 728 1.25.2.2 yamt wapbl_circ_write(struct wapbl *wl, void *data, size_t len, off_t *offp) 729 1.25.2.2 yamt { 730 1.25.2.2 yamt size_t slen; 731 1.25.2.2 yamt off_t off = *offp; 732 1.25.2.2 yamt int error; 733 1.25.2.4 yamt daddr_t pbn; 734 1.25.2.2 yamt 735 1.25.2.2 yamt KDASSERT(((len >> wl->wl_log_dev_bshift) << 736 1.25.2.2 yamt wl->wl_log_dev_bshift) == len); 737 1.25.2.2 yamt 738 1.25.2.2 yamt if (off < wl->wl_circ_off) 739 1.25.2.2 yamt off = wl->wl_circ_off; 740 1.25.2.2 yamt slen = wl->wl_circ_off + wl->wl_circ_size - off; 741 1.25.2.2 yamt if (slen < len) { 742 1.25.2.4 yamt pbn = wl->wl_logpbn + (off >> wl->wl_log_dev_bshift); 743 1.25.2.4 yamt #ifdef _KERNEL 744 1.25.2.4 yamt pbn = btodb(pbn << wl->wl_log_dev_bshift); 745 1.25.2.4 yamt #endif 746 1.25.2.4 yamt error = wapbl_write(data, slen, wl->wl_devvp, pbn); 747 1.25.2.2 yamt if (error) 748 1.25.2.2 yamt return error; 749 1.25.2.2 yamt data = (uint8_t *)data + slen; 750 1.25.2.2 yamt len -= slen; 751 1.25.2.2 yamt off = wl->wl_circ_off; 752 1.25.2.2 yamt } 753 1.25.2.4 yamt pbn = wl->wl_logpbn + (off >> wl->wl_log_dev_bshift); 754 1.25.2.4 yamt #ifdef _KERNEL 755 1.25.2.4 yamt pbn = btodb(pbn << wl->wl_log_dev_bshift); 756 1.25.2.4 yamt #endif 757 1.25.2.4 yamt error = wapbl_write(data, len, wl->wl_devvp, pbn); 758 1.25.2.2 yamt if (error) 759 1.25.2.2 yamt return error; 760 1.25.2.2 yamt off += len; 761 1.25.2.2 yamt if (off >= wl->wl_circ_off + wl->wl_circ_size) 762 1.25.2.2 yamt off = wl->wl_circ_off; 763 1.25.2.2 yamt *offp = off; 764 1.25.2.2 yamt return 0; 765 1.25.2.2 yamt } 766 1.25.2.2 yamt 767 1.25.2.2 yamt /****************************************************************/ 768 1.25.2.2 yamt 769 1.25.2.2 yamt int 770 1.25.2.2 yamt wapbl_begin(struct wapbl *wl, const char *file, int line) 771 1.25.2.2 yamt { 772 1.25.2.2 yamt int doflush; 773 1.25.2.2 yamt unsigned lockcount; 774 1.25.2.2 yamt 775 1.25.2.2 yamt KDASSERT(wl); 776 1.25.2.2 yamt 777 1.25.2.2 yamt /* 778 1.25.2.2 yamt * XXX this needs to be made much more sophisticated. 779 1.25.2.2 yamt * perhaps each wapbl_begin could reserve a specified 780 1.25.2.2 yamt * number of buffers and bytes. 781 1.25.2.2 yamt */ 782 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 783 1.25.2.2 yamt lockcount = wl->wl_lock_count; 784 1.25.2.2 yamt doflush = ((wl->wl_bufbytes + (lockcount * MAXPHYS)) > 785 1.25.2.2 yamt wl->wl_bufbytes_max / 2) || 786 1.25.2.2 yamt ((wl->wl_bufcount + (lockcount * 10)) > 787 1.25.2.2 yamt wl->wl_bufcount_max / 2) || 788 1.25.2.4 yamt (wapbl_transaction_len(wl) > wl->wl_circ_size / 2) || 789 1.25.2.4 yamt (wl->wl_dealloccnt >= 790 1.25.2.4 yamt (wl->wl_dealloclim - (wl->wl_dealloclim >> 8))); 791 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 792 1.25.2.2 yamt 793 1.25.2.2 yamt if (doflush) { 794 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_FLUSH, 795 1.25.2.2 yamt ("force flush lockcnt=%d bufbytes=%zu " 796 1.25.2.4 yamt "(max=%zu) bufcount=%zu (max=%zu) " 797 1.25.2.4 yamt "dealloccnt %d (lim=%d)\n", 798 1.25.2.2 yamt lockcount, wl->wl_bufbytes, 799 1.25.2.2 yamt wl->wl_bufbytes_max, wl->wl_bufcount, 800 1.25.2.4 yamt wl->wl_bufcount_max, 801 1.25.2.4 yamt wl->wl_dealloccnt, wl->wl_dealloclim)); 802 1.25.2.2 yamt } 803 1.25.2.2 yamt 804 1.25.2.2 yamt if (doflush) { 805 1.25.2.2 yamt int error = wapbl_flush(wl, 0); 806 1.25.2.2 yamt if (error) 807 1.25.2.2 yamt return error; 808 1.25.2.2 yamt } 809 1.25.2.2 yamt 810 1.25.2.2 yamt rw_enter(&wl->wl_rwlock, RW_READER); 811 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 812 1.25.2.2 yamt wl->wl_lock_count++; 813 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 814 1.25.2.2 yamt 815 1.25.2.2 yamt #if defined(WAPBL_DEBUG_PRINT) 816 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_TRANSACTION, 817 1.25.2.2 yamt ("wapbl_begin thread %d.%d with bufcount=%zu " 818 1.25.2.2 yamt "bufbytes=%zu bcount=%zu at %s:%d\n", 819 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid, wl->wl_bufcount, 820 1.25.2.2 yamt wl->wl_bufbytes, wl->wl_bcount, file, line)); 821 1.25.2.2 yamt #endif 822 1.25.2.2 yamt 823 1.25.2.2 yamt return 0; 824 1.25.2.2 yamt } 825 1.25.2.2 yamt 826 1.25.2.2 yamt void 827 1.25.2.2 yamt wapbl_end(struct wapbl *wl) 828 1.25.2.2 yamt { 829 1.25.2.2 yamt 830 1.25.2.2 yamt #if defined(WAPBL_DEBUG_PRINT) 831 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_TRANSACTION, 832 1.25.2.2 yamt ("wapbl_end thread %d.%d with bufcount=%zu " 833 1.25.2.2 yamt "bufbytes=%zu bcount=%zu\n", 834 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid, wl->wl_bufcount, 835 1.25.2.2 yamt wl->wl_bufbytes, wl->wl_bcount)); 836 1.25.2.2 yamt #endif 837 1.25.2.2 yamt 838 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 839 1.25.2.2 yamt KASSERT(wl->wl_lock_count > 0); 840 1.25.2.2 yamt wl->wl_lock_count--; 841 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 842 1.25.2.2 yamt 843 1.25.2.2 yamt rw_exit(&wl->wl_rwlock); 844 1.25.2.2 yamt } 845 1.25.2.2 yamt 846 1.25.2.2 yamt void 847 1.25.2.2 yamt wapbl_add_buf(struct wapbl *wl, struct buf * bp) 848 1.25.2.2 yamt { 849 1.25.2.2 yamt 850 1.25.2.2 yamt KASSERT(bp->b_cflags & BC_BUSY); 851 1.25.2.2 yamt KASSERT(bp->b_vp); 852 1.25.2.2 yamt 853 1.25.2.2 yamt wapbl_jlock_assert(wl); 854 1.25.2.2 yamt 855 1.25.2.2 yamt #if 0 856 1.25.2.2 yamt /* 857 1.25.2.2 yamt * XXX this might be an issue for swapfiles. 858 1.25.2.2 yamt * see uvm_swap.c:1702 859 1.25.2.2 yamt * 860 1.25.2.2 yamt * XXX2 why require it then? leap of semantics? 861 1.25.2.2 yamt */ 862 1.25.2.2 yamt KASSERT((bp->b_cflags & BC_NOCACHE) == 0); 863 1.25.2.2 yamt #endif 864 1.25.2.2 yamt 865 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 866 1.25.2.2 yamt if (bp->b_flags & B_LOCKED) { 867 1.25.2.2 yamt LIST_REMOVE(bp, b_wapbllist); 868 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_BUFFER2, 869 1.25.2.2 yamt ("wapbl_add_buf thread %d.%d re-adding buf %p " 870 1.25.2.2 yamt "with %d bytes %d bcount\n", 871 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid, bp, bp->b_bufsize, 872 1.25.2.2 yamt bp->b_bcount)); 873 1.25.2.2 yamt } else { 874 1.25.2.2 yamt /* unlocked by dirty buffers shouldn't exist */ 875 1.25.2.2 yamt KASSERT(!(bp->b_oflags & BO_DELWRI)); 876 1.25.2.2 yamt wl->wl_bufbytes += bp->b_bufsize; 877 1.25.2.2 yamt wl->wl_bcount += bp->b_bcount; 878 1.25.2.2 yamt wl->wl_bufcount++; 879 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_BUFFER, 880 1.25.2.2 yamt ("wapbl_add_buf thread %d.%d adding buf %p " 881 1.25.2.2 yamt "with %d bytes %d bcount\n", 882 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid, bp, bp->b_bufsize, 883 1.25.2.2 yamt bp->b_bcount)); 884 1.25.2.2 yamt } 885 1.25.2.2 yamt LIST_INSERT_HEAD(&wl->wl_bufs, bp, b_wapbllist); 886 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 887 1.25.2.2 yamt 888 1.25.2.2 yamt bp->b_flags |= B_LOCKED; 889 1.25.2.2 yamt } 890 1.25.2.2 yamt 891 1.25.2.2 yamt static void 892 1.25.2.2 yamt wapbl_remove_buf_locked(struct wapbl * wl, struct buf *bp) 893 1.25.2.2 yamt { 894 1.25.2.2 yamt 895 1.25.2.2 yamt KASSERT(mutex_owned(&wl->wl_mtx)); 896 1.25.2.2 yamt KASSERT(bp->b_cflags & BC_BUSY); 897 1.25.2.2 yamt wapbl_jlock_assert(wl); 898 1.25.2.2 yamt 899 1.25.2.2 yamt #if 0 900 1.25.2.2 yamt /* 901 1.25.2.2 yamt * XXX this might be an issue for swapfiles. 902 1.25.2.2 yamt * see uvm_swap.c:1725 903 1.25.2.2 yamt * 904 1.25.2.2 yamt * XXXdeux: see above 905 1.25.2.2 yamt */ 906 1.25.2.2 yamt KASSERT((bp->b_flags & BC_NOCACHE) == 0); 907 1.25.2.2 yamt #endif 908 1.25.2.2 yamt KASSERT(bp->b_flags & B_LOCKED); 909 1.25.2.2 yamt 910 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_BUFFER, 911 1.25.2.2 yamt ("wapbl_remove_buf thread %d.%d removing buf %p with " 912 1.25.2.2 yamt "%d bytes %d bcount\n", 913 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid, bp, bp->b_bufsize, bp->b_bcount)); 914 1.25.2.2 yamt 915 1.25.2.2 yamt KASSERT(wl->wl_bufbytes >= bp->b_bufsize); 916 1.25.2.2 yamt wl->wl_bufbytes -= bp->b_bufsize; 917 1.25.2.2 yamt KASSERT(wl->wl_bcount >= bp->b_bcount); 918 1.25.2.2 yamt wl->wl_bcount -= bp->b_bcount; 919 1.25.2.2 yamt KASSERT(wl->wl_bufcount > 0); 920 1.25.2.2 yamt wl->wl_bufcount--; 921 1.25.2.2 yamt KASSERT((wl->wl_bufcount == 0) == (wl->wl_bufbytes == 0)); 922 1.25.2.2 yamt KASSERT((wl->wl_bufcount == 0) == (wl->wl_bcount == 0)); 923 1.25.2.2 yamt LIST_REMOVE(bp, b_wapbllist); 924 1.25.2.2 yamt 925 1.25.2.2 yamt bp->b_flags &= ~B_LOCKED; 926 1.25.2.2 yamt } 927 1.25.2.2 yamt 928 1.25.2.2 yamt /* called from brelsel() in vfs_bio among other places */ 929 1.25.2.2 yamt void 930 1.25.2.2 yamt wapbl_remove_buf(struct wapbl * wl, struct buf *bp) 931 1.25.2.2 yamt { 932 1.25.2.2 yamt 933 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 934 1.25.2.2 yamt wapbl_remove_buf_locked(wl, bp); 935 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 936 1.25.2.2 yamt } 937 1.25.2.2 yamt 938 1.25.2.2 yamt void 939 1.25.2.2 yamt wapbl_resize_buf(struct wapbl *wl, struct buf *bp, long oldsz, long oldcnt) 940 1.25.2.2 yamt { 941 1.25.2.2 yamt 942 1.25.2.2 yamt KASSERT(bp->b_cflags & BC_BUSY); 943 1.25.2.2 yamt 944 1.25.2.2 yamt /* 945 1.25.2.2 yamt * XXX: why does this depend on B_LOCKED? otherwise the buf 946 1.25.2.2 yamt * is not for a transaction? if so, why is this called in the 947 1.25.2.2 yamt * first place? 948 1.25.2.2 yamt */ 949 1.25.2.2 yamt if (bp->b_flags & B_LOCKED) { 950 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 951 1.25.2.2 yamt wl->wl_bufbytes += bp->b_bufsize - oldsz; 952 1.25.2.2 yamt wl->wl_bcount += bp->b_bcount - oldcnt; 953 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 954 1.25.2.2 yamt } 955 1.25.2.2 yamt } 956 1.25.2.2 yamt 957 1.25.2.2 yamt #endif /* _KERNEL */ 958 1.25.2.2 yamt 959 1.25.2.2 yamt /****************************************************************/ 960 1.25.2.2 yamt /* Some utility inlines */ 961 1.25.2.2 yamt 962 1.25.2.2 yamt /* This is used to advance the pointer at old to new value at old+delta */ 963 1.25.2.4 yamt static inline off_t 964 1.25.2.2 yamt wapbl_advance(size_t size, size_t off, off_t old, size_t delta) 965 1.25.2.2 yamt { 966 1.25.2.2 yamt off_t new; 967 1.25.2.2 yamt 968 1.25.2.2 yamt /* Define acceptable ranges for inputs. */ 969 1.25.2.2 yamt KASSERT(delta <= size); 970 1.25.2.2 yamt KASSERT((old == 0) || (old >= off)); 971 1.25.2.2 yamt KASSERT(old < (size + off)); 972 1.25.2.2 yamt 973 1.25.2.2 yamt if ((old == 0) && (delta != 0)) 974 1.25.2.2 yamt new = off + delta; 975 1.25.2.2 yamt else if ((old + delta) < (size + off)) 976 1.25.2.2 yamt new = old + delta; 977 1.25.2.2 yamt else 978 1.25.2.2 yamt new = (old + delta) - size; 979 1.25.2.2 yamt 980 1.25.2.2 yamt /* Note some interesting axioms */ 981 1.25.2.2 yamt KASSERT((delta != 0) || (new == old)); 982 1.25.2.2 yamt KASSERT((delta == 0) || (new != 0)); 983 1.25.2.2 yamt KASSERT((delta != (size)) || (new == old)); 984 1.25.2.2 yamt 985 1.25.2.2 yamt /* Define acceptable ranges for output. */ 986 1.25.2.2 yamt KASSERT((new == 0) || (new >= off)); 987 1.25.2.2 yamt KASSERT(new < (size + off)); 988 1.25.2.2 yamt return new; 989 1.25.2.2 yamt } 990 1.25.2.2 yamt 991 1.25.2.4 yamt static inline size_t 992 1.25.2.2 yamt wapbl_space_used(size_t avail, off_t head, off_t tail) 993 1.25.2.2 yamt { 994 1.25.2.2 yamt 995 1.25.2.2 yamt if (tail == 0) { 996 1.25.2.2 yamt KASSERT(head == 0); 997 1.25.2.2 yamt return 0; 998 1.25.2.2 yamt } 999 1.25.2.2 yamt return ((head + (avail - 1) - tail) % avail) + 1; 1000 1.25.2.2 yamt } 1001 1.25.2.2 yamt 1002 1.25.2.4 yamt static inline size_t 1003 1.25.2.2 yamt wapbl_space_free(size_t avail, off_t head, off_t tail) 1004 1.25.2.2 yamt { 1005 1.25.2.2 yamt 1006 1.25.2.2 yamt return avail - wapbl_space_used(avail, head, tail); 1007 1.25.2.2 yamt } 1008 1.25.2.2 yamt 1009 1.25.2.4 yamt static inline void 1010 1.25.2.2 yamt wapbl_advance_head(size_t size, size_t off, size_t delta, off_t *headp, 1011 1.25.2.2 yamt off_t *tailp) 1012 1.25.2.2 yamt { 1013 1.25.2.2 yamt off_t head = *headp; 1014 1.25.2.2 yamt off_t tail = *tailp; 1015 1.25.2.2 yamt 1016 1.25.2.2 yamt KASSERT(delta <= wapbl_space_free(size, head, tail)); 1017 1.25.2.2 yamt head = wapbl_advance(size, off, head, delta); 1018 1.25.2.2 yamt if ((tail == 0) && (head != 0)) 1019 1.25.2.2 yamt tail = off; 1020 1.25.2.2 yamt *headp = head; 1021 1.25.2.2 yamt *tailp = tail; 1022 1.25.2.2 yamt } 1023 1.25.2.2 yamt 1024 1.25.2.4 yamt static inline void 1025 1.25.2.2 yamt wapbl_advance_tail(size_t size, size_t off, size_t delta, off_t *headp, 1026 1.25.2.2 yamt off_t *tailp) 1027 1.25.2.2 yamt { 1028 1.25.2.2 yamt off_t head = *headp; 1029 1.25.2.2 yamt off_t tail = *tailp; 1030 1.25.2.2 yamt 1031 1.25.2.2 yamt KASSERT(delta <= wapbl_space_used(size, head, tail)); 1032 1.25.2.2 yamt tail = wapbl_advance(size, off, tail, delta); 1033 1.25.2.2 yamt if (head == tail) { 1034 1.25.2.2 yamt head = tail = 0; 1035 1.25.2.2 yamt } 1036 1.25.2.2 yamt *headp = head; 1037 1.25.2.2 yamt *tailp = tail; 1038 1.25.2.2 yamt } 1039 1.25.2.2 yamt 1040 1.25.2.2 yamt #ifdef _KERNEL 1041 1.25.2.2 yamt 1042 1.25.2.2 yamt /****************************************************************/ 1043 1.25.2.2 yamt 1044 1.25.2.2 yamt /* 1045 1.25.2.2 yamt * Remove transactions whose buffers are completely flushed to disk. 1046 1.25.2.2 yamt * Will block until at least minfree space is available. 1047 1.25.2.2 yamt * only intended to be called from inside wapbl_flush and therefore 1048 1.25.2.2 yamt * does not protect against commit races with itself or with flush. 1049 1.25.2.2 yamt */ 1050 1.25.2.2 yamt static int 1051 1.25.2.2 yamt wapbl_truncate(struct wapbl *wl, size_t minfree, int waitonly) 1052 1.25.2.2 yamt { 1053 1.25.2.2 yamt size_t delta; 1054 1.25.2.2 yamt size_t avail; 1055 1.25.2.2 yamt off_t head; 1056 1.25.2.2 yamt off_t tail; 1057 1.25.2.2 yamt int error = 0; 1058 1.25.2.2 yamt 1059 1.25.2.2 yamt KASSERT(minfree <= (wl->wl_circ_size - wl->wl_reserved_bytes)); 1060 1.25.2.2 yamt KASSERT(rw_write_held(&wl->wl_rwlock)); 1061 1.25.2.2 yamt 1062 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1063 1.25.2.2 yamt 1064 1.25.2.2 yamt /* 1065 1.25.2.2 yamt * First check to see if we have to do a commit 1066 1.25.2.2 yamt * at all. 1067 1.25.2.2 yamt */ 1068 1.25.2.2 yamt avail = wapbl_space_free(wl->wl_circ_size, wl->wl_head, wl->wl_tail); 1069 1.25.2.2 yamt if (minfree < avail) { 1070 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1071 1.25.2.2 yamt return 0; 1072 1.25.2.2 yamt } 1073 1.25.2.2 yamt minfree -= avail; 1074 1.25.2.2 yamt while ((wl->wl_error_count == 0) && 1075 1.25.2.2 yamt (wl->wl_reclaimable_bytes < minfree)) { 1076 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_TRUNCATE, 1077 1.25.2.2 yamt ("wapbl_truncate: sleeping on %p wl=%p bytes=%zd " 1078 1.25.2.2 yamt "minfree=%zd\n", 1079 1.25.2.2 yamt &wl->wl_reclaimable_bytes, wl, wl->wl_reclaimable_bytes, 1080 1.25.2.2 yamt minfree)); 1081 1.25.2.2 yamt 1082 1.25.2.2 yamt cv_wait(&wl->wl_reclaimable_cv, &wl->wl_mtx); 1083 1.25.2.2 yamt } 1084 1.25.2.2 yamt if (wl->wl_reclaimable_bytes < minfree) { 1085 1.25.2.2 yamt KASSERT(wl->wl_error_count); 1086 1.25.2.2 yamt /* XXX maybe get actual error from buffer instead someday? */ 1087 1.25.2.2 yamt error = EIO; 1088 1.25.2.2 yamt } 1089 1.25.2.2 yamt head = wl->wl_head; 1090 1.25.2.2 yamt tail = wl->wl_tail; 1091 1.25.2.2 yamt delta = wl->wl_reclaimable_bytes; 1092 1.25.2.2 yamt 1093 1.25.2.2 yamt /* If all of of the entries are flushed, then be sure to keep 1094 1.25.2.2 yamt * the reserved bytes reserved. Watch out for discarded transactions, 1095 1.25.2.2 yamt * which could leave more bytes reserved than are reclaimable. 1096 1.25.2.2 yamt */ 1097 1.25.2.2 yamt if (SIMPLEQ_EMPTY(&wl->wl_entries) && 1098 1.25.2.2 yamt (delta >= wl->wl_reserved_bytes)) { 1099 1.25.2.2 yamt delta -= wl->wl_reserved_bytes; 1100 1.25.2.2 yamt } 1101 1.25.2.2 yamt wapbl_advance_tail(wl->wl_circ_size, wl->wl_circ_off, delta, &head, 1102 1.25.2.2 yamt &tail); 1103 1.25.2.2 yamt KDASSERT(wl->wl_reserved_bytes <= 1104 1.25.2.2 yamt wapbl_space_used(wl->wl_circ_size, head, tail)); 1105 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1106 1.25.2.2 yamt 1107 1.25.2.2 yamt if (error) 1108 1.25.2.2 yamt return error; 1109 1.25.2.2 yamt 1110 1.25.2.2 yamt if (waitonly) 1111 1.25.2.2 yamt return 0; 1112 1.25.2.2 yamt 1113 1.25.2.2 yamt /* 1114 1.25.2.2 yamt * This is where head, tail and delta are unprotected 1115 1.25.2.2 yamt * from races against itself or flush. This is ok since 1116 1.25.2.2 yamt * we only call this routine from inside flush itself. 1117 1.25.2.2 yamt * 1118 1.25.2.2 yamt * XXX: how can it race against itself when accessed only 1119 1.25.2.2 yamt * from behind the write-locked rwlock? 1120 1.25.2.2 yamt */ 1121 1.25.2.2 yamt error = wapbl_write_commit(wl, head, tail); 1122 1.25.2.2 yamt if (error) 1123 1.25.2.2 yamt return error; 1124 1.25.2.2 yamt 1125 1.25.2.2 yamt wl->wl_head = head; 1126 1.25.2.2 yamt wl->wl_tail = tail; 1127 1.25.2.2 yamt 1128 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1129 1.25.2.2 yamt KASSERT(wl->wl_reclaimable_bytes >= delta); 1130 1.25.2.2 yamt wl->wl_reclaimable_bytes -= delta; 1131 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1132 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_TRUNCATE, 1133 1.25.2.2 yamt ("wapbl_truncate thread %d.%d truncating %zu bytes\n", 1134 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid, delta)); 1135 1.25.2.2 yamt 1136 1.25.2.2 yamt return 0; 1137 1.25.2.2 yamt } 1138 1.25.2.2 yamt 1139 1.25.2.2 yamt /****************************************************************/ 1140 1.25.2.2 yamt 1141 1.25.2.2 yamt void 1142 1.25.2.2 yamt wapbl_biodone(struct buf *bp) 1143 1.25.2.2 yamt { 1144 1.25.2.2 yamt struct wapbl_entry *we = bp->b_private; 1145 1.25.2.2 yamt struct wapbl *wl = we->we_wapbl; 1146 1.25.2.2 yamt 1147 1.25.2.2 yamt /* 1148 1.25.2.2 yamt * Handle possible flushing of buffers after log has been 1149 1.25.2.2 yamt * decomissioned. 1150 1.25.2.2 yamt */ 1151 1.25.2.2 yamt if (!wl) { 1152 1.25.2.2 yamt KASSERT(we->we_bufcount > 0); 1153 1.25.2.2 yamt we->we_bufcount--; 1154 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1155 1.25.2.2 yamt KASSERT(we->we_unsynced_bufbytes >= bp->b_bufsize); 1156 1.25.2.2 yamt we->we_unsynced_bufbytes -= bp->b_bufsize; 1157 1.25.2.2 yamt #endif 1158 1.25.2.2 yamt 1159 1.25.2.2 yamt if (we->we_bufcount == 0) { 1160 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1161 1.25.2.2 yamt KASSERT(we->we_unsynced_bufbytes == 0); 1162 1.25.2.2 yamt #endif 1163 1.25.2.2 yamt wapbl_free(we, sizeof(*we)); 1164 1.25.2.2 yamt } 1165 1.25.2.2 yamt 1166 1.25.2.2 yamt brelse(bp, 0); 1167 1.25.2.2 yamt return; 1168 1.25.2.2 yamt } 1169 1.25.2.2 yamt 1170 1.25.2.2 yamt #ifdef ohbother 1171 1.25.2.2 yamt KDASSERT(bp->b_flags & B_DONE); 1172 1.25.2.2 yamt KDASSERT(!(bp->b_flags & B_DELWRI)); 1173 1.25.2.2 yamt KDASSERT(bp->b_flags & B_ASYNC); 1174 1.25.2.2 yamt KDASSERT(bp->b_flags & B_BUSY); 1175 1.25.2.2 yamt KDASSERT(!(bp->b_flags & B_LOCKED)); 1176 1.25.2.2 yamt KDASSERT(!(bp->b_flags & B_READ)); 1177 1.25.2.2 yamt KDASSERT(!(bp->b_flags & B_INVAL)); 1178 1.25.2.2 yamt KDASSERT(!(bp->b_flags & B_NOCACHE)); 1179 1.25.2.2 yamt #endif 1180 1.25.2.2 yamt 1181 1.25.2.2 yamt if (bp->b_error) { 1182 1.25.2.2 yamt #ifdef notyet /* Can't currently handle possible dirty buffer reuse */ 1183 1.25.2.3 yamt /* 1184 1.25.2.3 yamt * XXXpooka: interfaces not fully updated 1185 1.25.2.3 yamt * Note: this was not enabled in the original patch 1186 1.25.2.3 yamt * against netbsd4 either. I don't know if comment 1187 1.25.2.3 yamt * above is true or not. 1188 1.25.2.3 yamt */ 1189 1.25.2.2 yamt 1190 1.25.2.2 yamt /* 1191 1.25.2.2 yamt * If an error occurs, report the error and leave the 1192 1.25.2.2 yamt * buffer as a delayed write on the LRU queue. 1193 1.25.2.2 yamt * restarting the write would likely result in 1194 1.25.2.2 yamt * an error spinloop, so let it be done harmlessly 1195 1.25.2.2 yamt * by the syncer. 1196 1.25.2.2 yamt */ 1197 1.25.2.2 yamt bp->b_flags &= ~(B_DONE); 1198 1.25.2.2 yamt simple_unlock(&bp->b_interlock); 1199 1.25.2.2 yamt 1200 1.25.2.2 yamt if (we->we_error == 0) { 1201 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1202 1.25.2.2 yamt wl->wl_error_count++; 1203 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1204 1.25.2.2 yamt cv_broadcast(&wl->wl_reclaimable_cv); 1205 1.25.2.2 yamt } 1206 1.25.2.2 yamt we->we_error = bp->b_error; 1207 1.25.2.2 yamt bp->b_error = 0; 1208 1.25.2.2 yamt brelse(bp); 1209 1.25.2.2 yamt return; 1210 1.25.2.2 yamt #else 1211 1.25.2.2 yamt /* For now, just mark the log permanently errored out */ 1212 1.25.2.2 yamt 1213 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1214 1.25.2.2 yamt if (wl->wl_error_count == 0) { 1215 1.25.2.2 yamt wl->wl_error_count++; 1216 1.25.2.2 yamt cv_broadcast(&wl->wl_reclaimable_cv); 1217 1.25.2.2 yamt } 1218 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1219 1.25.2.2 yamt #endif 1220 1.25.2.2 yamt } 1221 1.25.2.2 yamt 1222 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1223 1.25.2.2 yamt 1224 1.25.2.2 yamt KASSERT(we->we_bufcount > 0); 1225 1.25.2.2 yamt we->we_bufcount--; 1226 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1227 1.25.2.2 yamt KASSERT(we->we_unsynced_bufbytes >= bp->b_bufsize); 1228 1.25.2.2 yamt we->we_unsynced_bufbytes -= bp->b_bufsize; 1229 1.25.2.2 yamt KASSERT(wl->wl_unsynced_bufbytes >= bp->b_bufsize); 1230 1.25.2.2 yamt wl->wl_unsynced_bufbytes -= bp->b_bufsize; 1231 1.25.2.2 yamt #endif 1232 1.25.2.2 yamt 1233 1.25.2.2 yamt /* 1234 1.25.2.2 yamt * If the current transaction can be reclaimed, start 1235 1.25.2.2 yamt * at the beginning and reclaim any consecutive reclaimable 1236 1.25.2.2 yamt * transactions. If we successfully reclaim anything, 1237 1.25.2.2 yamt * then wakeup anyone waiting for the reclaim. 1238 1.25.2.2 yamt */ 1239 1.25.2.2 yamt if (we->we_bufcount == 0) { 1240 1.25.2.2 yamt size_t delta = 0; 1241 1.25.2.2 yamt int errcnt = 0; 1242 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1243 1.25.2.2 yamt KDASSERT(we->we_unsynced_bufbytes == 0); 1244 1.25.2.2 yamt #endif 1245 1.25.2.2 yamt /* 1246 1.25.2.2 yamt * clear any posted error, since the buffer it came from 1247 1.25.2.2 yamt * has successfully flushed by now 1248 1.25.2.2 yamt */ 1249 1.25.2.2 yamt while ((we = SIMPLEQ_FIRST(&wl->wl_entries)) && 1250 1.25.2.2 yamt (we->we_bufcount == 0)) { 1251 1.25.2.2 yamt delta += we->we_reclaimable_bytes; 1252 1.25.2.2 yamt if (we->we_error) 1253 1.25.2.2 yamt errcnt++; 1254 1.25.2.2 yamt SIMPLEQ_REMOVE_HEAD(&wl->wl_entries, we_entries); 1255 1.25.2.2 yamt wapbl_free(we, sizeof(*we)); 1256 1.25.2.2 yamt } 1257 1.25.2.2 yamt 1258 1.25.2.2 yamt if (delta) { 1259 1.25.2.2 yamt wl->wl_reclaimable_bytes += delta; 1260 1.25.2.2 yamt KASSERT(wl->wl_error_count >= errcnt); 1261 1.25.2.2 yamt wl->wl_error_count -= errcnt; 1262 1.25.2.2 yamt cv_broadcast(&wl->wl_reclaimable_cv); 1263 1.25.2.2 yamt } 1264 1.25.2.2 yamt } 1265 1.25.2.2 yamt 1266 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1267 1.25.2.2 yamt brelse(bp, 0); 1268 1.25.2.2 yamt } 1269 1.25.2.2 yamt 1270 1.25.2.2 yamt /* 1271 1.25.2.2 yamt * Write transactions to disk + start I/O for contents 1272 1.25.2.2 yamt */ 1273 1.25.2.2 yamt int 1274 1.25.2.2 yamt wapbl_flush(struct wapbl *wl, int waitfor) 1275 1.25.2.2 yamt { 1276 1.25.2.2 yamt struct buf *bp; 1277 1.25.2.2 yamt struct wapbl_entry *we; 1278 1.25.2.2 yamt off_t off; 1279 1.25.2.2 yamt off_t head; 1280 1.25.2.2 yamt off_t tail; 1281 1.25.2.2 yamt size_t delta = 0; 1282 1.25.2.2 yamt size_t flushsize; 1283 1.25.2.2 yamt size_t reserved; 1284 1.25.2.2 yamt int error = 0; 1285 1.25.2.2 yamt 1286 1.25.2.2 yamt /* 1287 1.25.2.2 yamt * Do a quick check to see if a full flush can be skipped 1288 1.25.2.2 yamt * This assumes that the flush callback does not need to be called 1289 1.25.2.2 yamt * unless there are other outstanding bufs. 1290 1.25.2.2 yamt */ 1291 1.25.2.2 yamt if (!waitfor) { 1292 1.25.2.2 yamt size_t nbufs; 1293 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); /* XXX need mutex here to 1294 1.25.2.2 yamt protect the KASSERTS */ 1295 1.25.2.2 yamt nbufs = wl->wl_bufcount; 1296 1.25.2.2 yamt KASSERT((wl->wl_bufcount == 0) == (wl->wl_bufbytes == 0)); 1297 1.25.2.2 yamt KASSERT((wl->wl_bufcount == 0) == (wl->wl_bcount == 0)); 1298 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1299 1.25.2.2 yamt if (nbufs == 0) 1300 1.25.2.2 yamt return 0; 1301 1.25.2.2 yamt } 1302 1.25.2.2 yamt 1303 1.25.2.2 yamt /* 1304 1.25.2.2 yamt * XXX we may consider using LK_UPGRADE here 1305 1.25.2.2 yamt * if we want to call flush from inside a transaction 1306 1.25.2.2 yamt */ 1307 1.25.2.2 yamt rw_enter(&wl->wl_rwlock, RW_WRITER); 1308 1.25.2.2 yamt wl->wl_flush(wl->wl_mount, wl->wl_deallocblks, wl->wl_dealloclens, 1309 1.25.2.2 yamt wl->wl_dealloccnt); 1310 1.25.2.2 yamt 1311 1.25.2.2 yamt /* 1312 1.25.2.2 yamt * Now that we are fully locked and flushed, 1313 1.25.2.2 yamt * do another check for nothing to do. 1314 1.25.2.2 yamt */ 1315 1.25.2.2 yamt if (wl->wl_bufcount == 0) { 1316 1.25.2.2 yamt goto out; 1317 1.25.2.2 yamt } 1318 1.25.2.2 yamt 1319 1.25.2.2 yamt #if 0 1320 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_FLUSH, 1321 1.25.2.2 yamt ("wapbl_flush thread %d.%d flushing entries with " 1322 1.25.2.2 yamt "bufcount=%zu bufbytes=%zu\n", 1323 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid, wl->wl_bufcount, 1324 1.25.2.2 yamt wl->wl_bufbytes)); 1325 1.25.2.2 yamt #endif 1326 1.25.2.2 yamt 1327 1.25.2.2 yamt /* Calculate amount of space needed to flush */ 1328 1.25.2.2 yamt flushsize = wapbl_transaction_len(wl); 1329 1.25.2.2 yamt 1330 1.25.2.2 yamt if (flushsize > (wl->wl_circ_size - wl->wl_reserved_bytes)) { 1331 1.25.2.2 yamt /* 1332 1.25.2.2 yamt * XXX this could be handled more gracefully, perhaps place 1333 1.25.2.2 yamt * only a partial transaction in the log and allow the 1334 1.25.2.2 yamt * remaining to flush without the protection of the journal. 1335 1.25.2.2 yamt */ 1336 1.25.2.2 yamt panic("wapbl_flush: current transaction too big to flush\n"); 1337 1.25.2.2 yamt } 1338 1.25.2.2 yamt 1339 1.25.2.2 yamt error = wapbl_truncate(wl, flushsize, 0); 1340 1.25.2.2 yamt if (error) 1341 1.25.2.2 yamt goto out2; 1342 1.25.2.2 yamt 1343 1.25.2.2 yamt off = wl->wl_head; 1344 1.25.2.2 yamt KASSERT((off == 0) || ((off >= wl->wl_circ_off) && 1345 1.25.2.2 yamt (off < wl->wl_circ_off + wl->wl_circ_size))); 1346 1.25.2.2 yamt error = wapbl_write_blocks(wl, &off); 1347 1.25.2.2 yamt if (error) 1348 1.25.2.2 yamt goto out2; 1349 1.25.2.2 yamt error = wapbl_write_revocations(wl, &off); 1350 1.25.2.2 yamt if (error) 1351 1.25.2.2 yamt goto out2; 1352 1.25.2.2 yamt error = wapbl_write_inodes(wl, &off); 1353 1.25.2.2 yamt if (error) 1354 1.25.2.2 yamt goto out2; 1355 1.25.2.2 yamt 1356 1.25.2.2 yamt reserved = 0; 1357 1.25.2.2 yamt if (wl->wl_inohashcnt) 1358 1.25.2.2 yamt reserved = wapbl_transaction_inodes_len(wl); 1359 1.25.2.2 yamt 1360 1.25.2.2 yamt head = wl->wl_head; 1361 1.25.2.2 yamt tail = wl->wl_tail; 1362 1.25.2.2 yamt 1363 1.25.2.2 yamt wapbl_advance_head(wl->wl_circ_size, wl->wl_circ_off, flushsize, 1364 1.25.2.2 yamt &head, &tail); 1365 1.25.2.2 yamt #ifdef WAPBL_DEBUG 1366 1.25.2.2 yamt if (head != off) { 1367 1.25.2.2 yamt panic("lost head! head=%"PRIdMAX" tail=%" PRIdMAX 1368 1.25.2.2 yamt " off=%"PRIdMAX" flush=%zu\n", 1369 1.25.2.2 yamt (intmax_t)head, (intmax_t)tail, (intmax_t)off, 1370 1.25.2.2 yamt flushsize); 1371 1.25.2.2 yamt } 1372 1.25.2.2 yamt #else 1373 1.25.2.2 yamt KASSERT(head == off); 1374 1.25.2.2 yamt #endif 1375 1.25.2.2 yamt 1376 1.25.2.2 yamt /* Opportunistically move the tail forward if we can */ 1377 1.25.2.2 yamt if (!wapbl_lazy_truncate) { 1378 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1379 1.25.2.2 yamt delta = wl->wl_reclaimable_bytes; 1380 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1381 1.25.2.2 yamt wapbl_advance_tail(wl->wl_circ_size, wl->wl_circ_off, delta, 1382 1.25.2.2 yamt &head, &tail); 1383 1.25.2.2 yamt } 1384 1.25.2.2 yamt 1385 1.25.2.2 yamt error = wapbl_write_commit(wl, head, tail); 1386 1.25.2.2 yamt if (error) 1387 1.25.2.2 yamt goto out2; 1388 1.25.2.2 yamt 1389 1.25.2.2 yamt we = wapbl_calloc(1, sizeof(*we)); 1390 1.25.2.2 yamt 1391 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1392 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_FLUSH, 1393 1.25.2.2 yamt ("wapbl_flush: thread %d.%d head+=%zu tail+=%zu used=%zu" 1394 1.25.2.2 yamt " unsynced=%zu" 1395 1.25.2.2 yamt "\n\tbufcount=%zu bufbytes=%zu bcount=%zu deallocs=%d " 1396 1.25.2.2 yamt "inodes=%d\n", 1397 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid, flushsize, delta, 1398 1.25.2.2 yamt wapbl_space_used(wl->wl_circ_size, head, tail), 1399 1.25.2.2 yamt wl->wl_unsynced_bufbytes, wl->wl_bufcount, 1400 1.25.2.2 yamt wl->wl_bufbytes, wl->wl_bcount, wl->wl_dealloccnt, 1401 1.25.2.2 yamt wl->wl_inohashcnt)); 1402 1.25.2.2 yamt #else 1403 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_FLUSH, 1404 1.25.2.2 yamt ("wapbl_flush: thread %d.%d head+=%zu tail+=%zu used=%zu" 1405 1.25.2.2 yamt "\n\tbufcount=%zu bufbytes=%zu bcount=%zu deallocs=%d " 1406 1.25.2.2 yamt "inodes=%d\n", 1407 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid, flushsize, delta, 1408 1.25.2.2 yamt wapbl_space_used(wl->wl_circ_size, head, tail), 1409 1.25.2.2 yamt wl->wl_bufcount, wl->wl_bufbytes, wl->wl_bcount, 1410 1.25.2.2 yamt wl->wl_dealloccnt, wl->wl_inohashcnt)); 1411 1.25.2.2 yamt #endif 1412 1.25.2.2 yamt 1413 1.25.2.2 yamt 1414 1.25.2.2 yamt mutex_enter(&bufcache_lock); 1415 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1416 1.25.2.2 yamt 1417 1.25.2.2 yamt wl->wl_reserved_bytes = reserved; 1418 1.25.2.2 yamt wl->wl_head = head; 1419 1.25.2.2 yamt wl->wl_tail = tail; 1420 1.25.2.2 yamt KASSERT(wl->wl_reclaimable_bytes >= delta); 1421 1.25.2.2 yamt wl->wl_reclaimable_bytes -= delta; 1422 1.25.2.2 yamt wl->wl_dealloccnt = 0; 1423 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1424 1.25.2.2 yamt wl->wl_unsynced_bufbytes += wl->wl_bufbytes; 1425 1.25.2.2 yamt #endif 1426 1.25.2.2 yamt 1427 1.25.2.2 yamt we->we_wapbl = wl; 1428 1.25.2.2 yamt we->we_bufcount = wl->wl_bufcount; 1429 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1430 1.25.2.2 yamt we->we_unsynced_bufbytes = wl->wl_bufbytes; 1431 1.25.2.2 yamt #endif 1432 1.25.2.2 yamt we->we_reclaimable_bytes = flushsize; 1433 1.25.2.2 yamt we->we_error = 0; 1434 1.25.2.2 yamt SIMPLEQ_INSERT_TAIL(&wl->wl_entries, we, we_entries); 1435 1.25.2.2 yamt 1436 1.25.2.2 yamt /* 1437 1.25.2.2 yamt * this flushes bufs in reverse order than they were queued 1438 1.25.2.2 yamt * it shouldn't matter, but if we care we could use TAILQ instead. 1439 1.25.2.2 yamt * XXX Note they will get put on the lru queue when they flush 1440 1.25.2.2 yamt * so we might actually want to change this to preserve order. 1441 1.25.2.2 yamt */ 1442 1.25.2.2 yamt while ((bp = LIST_FIRST(&wl->wl_bufs)) != NULL) { 1443 1.25.2.2 yamt if (bbusy(bp, 0, 0, &wl->wl_mtx)) { 1444 1.25.2.2 yamt continue; 1445 1.25.2.2 yamt } 1446 1.25.2.2 yamt bp->b_iodone = wapbl_biodone; 1447 1.25.2.2 yamt bp->b_private = we; 1448 1.25.2.2 yamt bremfree(bp); 1449 1.25.2.2 yamt wapbl_remove_buf_locked(wl, bp); 1450 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1451 1.25.2.2 yamt mutex_exit(&bufcache_lock); 1452 1.25.2.2 yamt bawrite(bp); 1453 1.25.2.2 yamt mutex_enter(&bufcache_lock); 1454 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1455 1.25.2.2 yamt } 1456 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1457 1.25.2.2 yamt mutex_exit(&bufcache_lock); 1458 1.25.2.2 yamt 1459 1.25.2.2 yamt #if 0 1460 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_FLUSH, 1461 1.25.2.2 yamt ("wapbl_flush thread %d.%d done flushing entries...\n", 1462 1.25.2.2 yamt curproc->p_pid, curlwp->l_lid)); 1463 1.25.2.2 yamt #endif 1464 1.25.2.2 yamt 1465 1.25.2.2 yamt out: 1466 1.25.2.2 yamt 1467 1.25.2.2 yamt /* 1468 1.25.2.2 yamt * If the waitfor flag is set, don't return until everything is 1469 1.25.2.2 yamt * fully flushed and the on disk log is empty. 1470 1.25.2.2 yamt */ 1471 1.25.2.2 yamt if (waitfor) { 1472 1.25.2.2 yamt error = wapbl_truncate(wl, wl->wl_circ_size - 1473 1.25.2.2 yamt wl->wl_reserved_bytes, wapbl_lazy_truncate); 1474 1.25.2.2 yamt } 1475 1.25.2.2 yamt 1476 1.25.2.2 yamt out2: 1477 1.25.2.2 yamt if (error) { 1478 1.25.2.2 yamt wl->wl_flush_abort(wl->wl_mount, wl->wl_deallocblks, 1479 1.25.2.2 yamt wl->wl_dealloclens, wl->wl_dealloccnt); 1480 1.25.2.2 yamt } 1481 1.25.2.2 yamt 1482 1.25.2.2 yamt #ifdef WAPBL_DEBUG_PRINT 1483 1.25.2.2 yamt if (error) { 1484 1.25.2.2 yamt pid_t pid = -1; 1485 1.25.2.2 yamt lwpid_t lid = -1; 1486 1.25.2.2 yamt if (curproc) 1487 1.25.2.2 yamt pid = curproc->p_pid; 1488 1.25.2.2 yamt if (curlwp) 1489 1.25.2.2 yamt lid = curlwp->l_lid; 1490 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1491 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1492 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_ERROR, 1493 1.25.2.2 yamt ("wapbl_flush: thread %d.%d aborted flush: " 1494 1.25.2.2 yamt "error = %d\n" 1495 1.25.2.2 yamt "\tbufcount=%zu bufbytes=%zu bcount=%zu " 1496 1.25.2.2 yamt "deallocs=%d inodes=%d\n" 1497 1.25.2.2 yamt "\terrcnt = %d, reclaimable=%zu reserved=%zu " 1498 1.25.2.2 yamt "unsynced=%zu\n", 1499 1.25.2.2 yamt pid, lid, error, wl->wl_bufcount, 1500 1.25.2.2 yamt wl->wl_bufbytes, wl->wl_bcount, 1501 1.25.2.2 yamt wl->wl_dealloccnt, wl->wl_inohashcnt, 1502 1.25.2.2 yamt wl->wl_error_count, wl->wl_reclaimable_bytes, 1503 1.25.2.2 yamt wl->wl_reserved_bytes, wl->wl_unsynced_bufbytes)); 1504 1.25.2.2 yamt SIMPLEQ_FOREACH(we, &wl->wl_entries, we_entries) { 1505 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_ERROR, 1506 1.25.2.2 yamt ("\tentry: bufcount = %zu, reclaimable = %zu, " 1507 1.25.2.2 yamt "error = %d, unsynced = %zu\n", 1508 1.25.2.2 yamt we->we_bufcount, we->we_reclaimable_bytes, 1509 1.25.2.2 yamt we->we_error, we->we_unsynced_bufbytes)); 1510 1.25.2.2 yamt } 1511 1.25.2.2 yamt #else 1512 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_ERROR, 1513 1.25.2.2 yamt ("wapbl_flush: thread %d.%d aborted flush: " 1514 1.25.2.2 yamt "error = %d\n" 1515 1.25.2.2 yamt "\tbufcount=%zu bufbytes=%zu bcount=%zu " 1516 1.25.2.2 yamt "deallocs=%d inodes=%d\n" 1517 1.25.2.2 yamt "\terrcnt = %d, reclaimable=%zu reserved=%zu\n", 1518 1.25.2.2 yamt pid, lid, error, wl->wl_bufcount, 1519 1.25.2.2 yamt wl->wl_bufbytes, wl->wl_bcount, 1520 1.25.2.2 yamt wl->wl_dealloccnt, wl->wl_inohashcnt, 1521 1.25.2.2 yamt wl->wl_error_count, wl->wl_reclaimable_bytes, 1522 1.25.2.2 yamt wl->wl_reserved_bytes)); 1523 1.25.2.2 yamt SIMPLEQ_FOREACH(we, &wl->wl_entries, we_entries) { 1524 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_ERROR, 1525 1.25.2.2 yamt ("\tentry: bufcount = %zu, reclaimable = %zu, " 1526 1.25.2.2 yamt "error = %d\n", we->we_bufcount, 1527 1.25.2.2 yamt we->we_reclaimable_bytes, we->we_error)); 1528 1.25.2.2 yamt } 1529 1.25.2.2 yamt #endif 1530 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1531 1.25.2.2 yamt } 1532 1.25.2.2 yamt #endif 1533 1.25.2.2 yamt 1534 1.25.2.2 yamt rw_exit(&wl->wl_rwlock); 1535 1.25.2.2 yamt return error; 1536 1.25.2.2 yamt } 1537 1.25.2.2 yamt 1538 1.25.2.2 yamt /****************************************************************/ 1539 1.25.2.2 yamt 1540 1.25.2.2 yamt void 1541 1.25.2.2 yamt wapbl_jlock_assert(struct wapbl *wl) 1542 1.25.2.2 yamt { 1543 1.25.2.2 yamt 1544 1.25.2.2 yamt KASSERT(rw_lock_held(&wl->wl_rwlock)); 1545 1.25.2.2 yamt } 1546 1.25.2.2 yamt 1547 1.25.2.2 yamt void 1548 1.25.2.2 yamt wapbl_junlock_assert(struct wapbl *wl) 1549 1.25.2.2 yamt { 1550 1.25.2.2 yamt 1551 1.25.2.2 yamt KASSERT(!rw_write_held(&wl->wl_rwlock)); 1552 1.25.2.2 yamt } 1553 1.25.2.2 yamt 1554 1.25.2.2 yamt /****************************************************************/ 1555 1.25.2.2 yamt 1556 1.25.2.2 yamt /* locks missing */ 1557 1.25.2.2 yamt void 1558 1.25.2.2 yamt wapbl_print(struct wapbl *wl, 1559 1.25.2.2 yamt int full, 1560 1.25.2.2 yamt void (*pr)(const char *, ...)) 1561 1.25.2.2 yamt { 1562 1.25.2.2 yamt struct buf *bp; 1563 1.25.2.2 yamt struct wapbl_entry *we; 1564 1.25.2.2 yamt (*pr)("wapbl %p", wl); 1565 1.25.2.2 yamt (*pr)("\nlogvp = %p, devvp = %p, logpbn = %"PRId64"\n", 1566 1.25.2.2 yamt wl->wl_logvp, wl->wl_devvp, wl->wl_logpbn); 1567 1.25.2.2 yamt (*pr)("circ = %zu, header = %zu, head = %"PRIdMAX" tail = %"PRIdMAX"\n", 1568 1.25.2.2 yamt wl->wl_circ_size, wl->wl_circ_off, 1569 1.25.2.2 yamt (intmax_t)wl->wl_head, (intmax_t)wl->wl_tail); 1570 1.25.2.2 yamt (*pr)("fs_dev_bshift = %d, log_dev_bshift = %d\n", 1571 1.25.2.2 yamt wl->wl_log_dev_bshift, wl->wl_fs_dev_bshift); 1572 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1573 1.25.2.2 yamt (*pr)("bufcount = %zu, bufbytes = %zu bcount = %zu reclaimable = %zu " 1574 1.25.2.2 yamt "reserved = %zu errcnt = %d unsynced = %zu\n", 1575 1.25.2.2 yamt wl->wl_bufcount, wl->wl_bufbytes, wl->wl_bcount, 1576 1.25.2.2 yamt wl->wl_reclaimable_bytes, wl->wl_reserved_bytes, 1577 1.25.2.2 yamt wl->wl_error_count, wl->wl_unsynced_bufbytes); 1578 1.25.2.2 yamt #else 1579 1.25.2.2 yamt (*pr)("bufcount = %zu, bufbytes = %zu bcount = %zu reclaimable = %zu " 1580 1.25.2.2 yamt "reserved = %zu errcnt = %d\n", wl->wl_bufcount, wl->wl_bufbytes, 1581 1.25.2.2 yamt wl->wl_bcount, wl->wl_reclaimable_bytes, wl->wl_reserved_bytes, 1582 1.25.2.2 yamt wl->wl_error_count); 1583 1.25.2.2 yamt #endif 1584 1.25.2.2 yamt (*pr)("\tdealloccnt = %d, dealloclim = %d\n", 1585 1.25.2.2 yamt wl->wl_dealloccnt, wl->wl_dealloclim); 1586 1.25.2.2 yamt (*pr)("\tinohashcnt = %d, inohashmask = 0x%08x\n", 1587 1.25.2.2 yamt wl->wl_inohashcnt, wl->wl_inohashmask); 1588 1.25.2.2 yamt (*pr)("entries:\n"); 1589 1.25.2.2 yamt SIMPLEQ_FOREACH(we, &wl->wl_entries, we_entries) { 1590 1.25.2.2 yamt #ifdef WAPBL_DEBUG_BUFBYTES 1591 1.25.2.2 yamt (*pr)("\tbufcount = %zu, reclaimable = %zu, error = %d, " 1592 1.25.2.2 yamt "unsynced = %zu\n", 1593 1.25.2.2 yamt we->we_bufcount, we->we_reclaimable_bytes, 1594 1.25.2.2 yamt we->we_error, we->we_unsynced_bufbytes); 1595 1.25.2.2 yamt #else 1596 1.25.2.2 yamt (*pr)("\tbufcount = %zu, reclaimable = %zu, error = %d\n", 1597 1.25.2.2 yamt we->we_bufcount, we->we_reclaimable_bytes, we->we_error); 1598 1.25.2.2 yamt #endif 1599 1.25.2.2 yamt } 1600 1.25.2.2 yamt if (full) { 1601 1.25.2.2 yamt int cnt = 0; 1602 1.25.2.2 yamt (*pr)("bufs ="); 1603 1.25.2.2 yamt LIST_FOREACH(bp, &wl->wl_bufs, b_wapbllist) { 1604 1.25.2.2 yamt if (!LIST_NEXT(bp, b_wapbllist)) { 1605 1.25.2.2 yamt (*pr)(" %p", bp); 1606 1.25.2.2 yamt } else if ((++cnt % 6) == 0) { 1607 1.25.2.2 yamt (*pr)(" %p,\n\t", bp); 1608 1.25.2.2 yamt } else { 1609 1.25.2.2 yamt (*pr)(" %p,", bp); 1610 1.25.2.2 yamt } 1611 1.25.2.2 yamt } 1612 1.25.2.2 yamt (*pr)("\n"); 1613 1.25.2.2 yamt 1614 1.25.2.2 yamt (*pr)("dealloced blks = "); 1615 1.25.2.2 yamt { 1616 1.25.2.2 yamt int i; 1617 1.25.2.2 yamt cnt = 0; 1618 1.25.2.2 yamt for (i = 0; i < wl->wl_dealloccnt; i++) { 1619 1.25.2.2 yamt (*pr)(" %"PRId64":%d,", 1620 1.25.2.2 yamt wl->wl_deallocblks[i], 1621 1.25.2.2 yamt wl->wl_dealloclens[i]); 1622 1.25.2.2 yamt if ((++cnt % 4) == 0) { 1623 1.25.2.2 yamt (*pr)("\n\t"); 1624 1.25.2.2 yamt } 1625 1.25.2.2 yamt } 1626 1.25.2.2 yamt } 1627 1.25.2.2 yamt (*pr)("\n"); 1628 1.25.2.2 yamt 1629 1.25.2.2 yamt (*pr)("registered inodes = "); 1630 1.25.2.2 yamt { 1631 1.25.2.2 yamt int i; 1632 1.25.2.2 yamt cnt = 0; 1633 1.25.2.2 yamt for (i = 0; i <= wl->wl_inohashmask; i++) { 1634 1.25.2.2 yamt struct wapbl_ino_head *wih; 1635 1.25.2.2 yamt struct wapbl_ino *wi; 1636 1.25.2.2 yamt 1637 1.25.2.2 yamt wih = &wl->wl_inohash[i]; 1638 1.25.2.2 yamt LIST_FOREACH(wi, wih, wi_hash) { 1639 1.25.2.2 yamt if (wi->wi_ino == 0) 1640 1.25.2.2 yamt continue; 1641 1.25.2.2 yamt (*pr)(" %"PRId32"/0%06"PRIo32",", 1642 1.25.2.2 yamt wi->wi_ino, wi->wi_mode); 1643 1.25.2.2 yamt if ((++cnt % 4) == 0) { 1644 1.25.2.2 yamt (*pr)("\n\t"); 1645 1.25.2.2 yamt } 1646 1.25.2.2 yamt } 1647 1.25.2.2 yamt } 1648 1.25.2.2 yamt (*pr)("\n"); 1649 1.25.2.2 yamt } 1650 1.25.2.2 yamt } 1651 1.25.2.2 yamt } 1652 1.25.2.2 yamt 1653 1.25.2.2 yamt #if defined(WAPBL_DEBUG) || defined(DDB) 1654 1.25.2.2 yamt void 1655 1.25.2.2 yamt wapbl_dump(struct wapbl *wl) 1656 1.25.2.2 yamt { 1657 1.25.2.2 yamt #if defined(WAPBL_DEBUG) 1658 1.25.2.2 yamt if (!wl) 1659 1.25.2.2 yamt wl = wapbl_debug_wl; 1660 1.25.2.2 yamt #endif 1661 1.25.2.2 yamt if (!wl) 1662 1.25.2.2 yamt return; 1663 1.25.2.2 yamt wapbl_print(wl, 1, printf); 1664 1.25.2.2 yamt } 1665 1.25.2.2 yamt #endif 1666 1.25.2.2 yamt 1667 1.25.2.2 yamt /****************************************************************/ 1668 1.25.2.2 yamt 1669 1.25.2.2 yamt void 1670 1.25.2.2 yamt wapbl_register_deallocation(struct wapbl *wl, daddr_t blk, int len) 1671 1.25.2.2 yamt { 1672 1.25.2.2 yamt 1673 1.25.2.2 yamt wapbl_jlock_assert(wl); 1674 1.25.2.2 yamt 1675 1.25.2.2 yamt /* XXX should eventually instead tie this into resource estimation */ 1676 1.25.2.4 yamt /* 1677 1.25.2.4 yamt * XXX this panic needs locking/mutex analysis and the 1678 1.25.2.4 yamt * ability to cope with the failure. 1679 1.25.2.4 yamt */ 1680 1.25.2.4 yamt /* XXX this XXX doesn't have enough XXX */ 1681 1.25.2.4 yamt if (__predict_false(wl->wl_dealloccnt >= wl->wl_dealloclim)) 1682 1.25.2.4 yamt panic("wapbl_register_deallocation: out of resources"); 1683 1.25.2.4 yamt 1684 1.25.2.2 yamt wl->wl_deallocblks[wl->wl_dealloccnt] = blk; 1685 1.25.2.2 yamt wl->wl_dealloclens[wl->wl_dealloccnt] = len; 1686 1.25.2.2 yamt wl->wl_dealloccnt++; 1687 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_ALLOC, 1688 1.25.2.2 yamt ("wapbl_register_deallocation: blk=%"PRId64" len=%d\n", blk, len)); 1689 1.25.2.2 yamt } 1690 1.25.2.2 yamt 1691 1.25.2.2 yamt /****************************************************************/ 1692 1.25.2.2 yamt 1693 1.25.2.2 yamt static void 1694 1.25.2.2 yamt wapbl_inodetrk_init(struct wapbl *wl, u_int size) 1695 1.25.2.2 yamt { 1696 1.25.2.2 yamt 1697 1.25.2.2 yamt wl->wl_inohash = hashinit(size, HASH_LIST, true, &wl->wl_inohashmask); 1698 1.25.2.2 yamt if (atomic_inc_uint_nv(&wapbl_ino_pool_refcount) == 1) { 1699 1.25.2.2 yamt pool_init(&wapbl_ino_pool, sizeof(struct wapbl_ino), 0, 0, 0, 1700 1.25.2.2 yamt "wapblinopl", &pool_allocator_nointr, IPL_NONE); 1701 1.25.2.2 yamt } 1702 1.25.2.2 yamt } 1703 1.25.2.2 yamt 1704 1.25.2.2 yamt static void 1705 1.25.2.2 yamt wapbl_inodetrk_free(struct wapbl *wl) 1706 1.25.2.2 yamt { 1707 1.25.2.2 yamt 1708 1.25.2.2 yamt /* XXX this KASSERT needs locking/mutex analysis */ 1709 1.25.2.2 yamt KASSERT(wl->wl_inohashcnt == 0); 1710 1.25.2.2 yamt hashdone(wl->wl_inohash, HASH_LIST, wl->wl_inohashmask); 1711 1.25.2.2 yamt if (atomic_dec_uint_nv(&wapbl_ino_pool_refcount) == 0) { 1712 1.25.2.2 yamt pool_destroy(&wapbl_ino_pool); 1713 1.25.2.2 yamt } 1714 1.25.2.2 yamt } 1715 1.25.2.2 yamt 1716 1.25.2.2 yamt static struct wapbl_ino * 1717 1.25.2.2 yamt wapbl_inodetrk_get(struct wapbl *wl, ino_t ino) 1718 1.25.2.2 yamt { 1719 1.25.2.2 yamt struct wapbl_ino_head *wih; 1720 1.25.2.2 yamt struct wapbl_ino *wi; 1721 1.25.2.2 yamt 1722 1.25.2.2 yamt KASSERT(mutex_owned(&wl->wl_mtx)); 1723 1.25.2.2 yamt 1724 1.25.2.2 yamt wih = &wl->wl_inohash[ino & wl->wl_inohashmask]; 1725 1.25.2.2 yamt LIST_FOREACH(wi, wih, wi_hash) { 1726 1.25.2.2 yamt if (ino == wi->wi_ino) 1727 1.25.2.2 yamt return wi; 1728 1.25.2.2 yamt } 1729 1.25.2.2 yamt return 0; 1730 1.25.2.2 yamt } 1731 1.25.2.2 yamt 1732 1.25.2.2 yamt void 1733 1.25.2.2 yamt wapbl_register_inode(struct wapbl *wl, ino_t ino, mode_t mode) 1734 1.25.2.2 yamt { 1735 1.25.2.2 yamt struct wapbl_ino_head *wih; 1736 1.25.2.2 yamt struct wapbl_ino *wi; 1737 1.25.2.2 yamt 1738 1.25.2.2 yamt wi = pool_get(&wapbl_ino_pool, PR_WAITOK); 1739 1.25.2.2 yamt 1740 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1741 1.25.2.2 yamt if (wapbl_inodetrk_get(wl, ino) == NULL) { 1742 1.25.2.2 yamt wi->wi_ino = ino; 1743 1.25.2.2 yamt wi->wi_mode = mode; 1744 1.25.2.2 yamt wih = &wl->wl_inohash[ino & wl->wl_inohashmask]; 1745 1.25.2.2 yamt LIST_INSERT_HEAD(wih, wi, wi_hash); 1746 1.25.2.2 yamt wl->wl_inohashcnt++; 1747 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_INODE, 1748 1.25.2.2 yamt ("wapbl_register_inode: ino=%"PRId64"\n", ino)); 1749 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1750 1.25.2.2 yamt } else { 1751 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1752 1.25.2.2 yamt pool_put(&wapbl_ino_pool, wi); 1753 1.25.2.2 yamt } 1754 1.25.2.2 yamt } 1755 1.25.2.2 yamt 1756 1.25.2.2 yamt void 1757 1.25.2.2 yamt wapbl_unregister_inode(struct wapbl *wl, ino_t ino, mode_t mode) 1758 1.25.2.2 yamt { 1759 1.25.2.2 yamt struct wapbl_ino *wi; 1760 1.25.2.2 yamt 1761 1.25.2.2 yamt mutex_enter(&wl->wl_mtx); 1762 1.25.2.2 yamt wi = wapbl_inodetrk_get(wl, ino); 1763 1.25.2.2 yamt if (wi) { 1764 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_INODE, 1765 1.25.2.2 yamt ("wapbl_unregister_inode: ino=%"PRId64"\n", ino)); 1766 1.25.2.2 yamt KASSERT(wl->wl_inohashcnt > 0); 1767 1.25.2.2 yamt wl->wl_inohashcnt--; 1768 1.25.2.2 yamt LIST_REMOVE(wi, wi_hash); 1769 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1770 1.25.2.2 yamt 1771 1.25.2.2 yamt pool_put(&wapbl_ino_pool, wi); 1772 1.25.2.2 yamt } else { 1773 1.25.2.2 yamt mutex_exit(&wl->wl_mtx); 1774 1.25.2.2 yamt } 1775 1.25.2.2 yamt } 1776 1.25.2.2 yamt 1777 1.25.2.2 yamt /****************************************************************/ 1778 1.25.2.2 yamt 1779 1.25.2.4 yamt static inline size_t 1780 1.25.2.2 yamt wapbl_transaction_inodes_len(struct wapbl *wl) 1781 1.25.2.2 yamt { 1782 1.25.2.2 yamt int blocklen = 1<<wl->wl_log_dev_bshift; 1783 1.25.2.2 yamt int iph; 1784 1.25.2.2 yamt 1785 1.25.2.2 yamt /* Calculate number of inodes described in a inodelist header */ 1786 1.25.2.2 yamt iph = (blocklen - offsetof(struct wapbl_wc_inodelist, wc_inodes)) / 1787 1.25.2.2 yamt sizeof(((struct wapbl_wc_inodelist *)0)->wc_inodes[0]); 1788 1.25.2.2 yamt 1789 1.25.2.2 yamt KASSERT(iph > 0); 1790 1.25.2.2 yamt 1791 1.25.2.2 yamt return MAX(1, howmany(wl->wl_inohashcnt, iph))*blocklen; 1792 1.25.2.2 yamt } 1793 1.25.2.2 yamt 1794 1.25.2.2 yamt 1795 1.25.2.2 yamt /* Calculate amount of space a transaction will take on disk */ 1796 1.25.2.2 yamt static size_t 1797 1.25.2.2 yamt wapbl_transaction_len(struct wapbl *wl) 1798 1.25.2.2 yamt { 1799 1.25.2.2 yamt int blocklen = 1<<wl->wl_log_dev_bshift; 1800 1.25.2.2 yamt size_t len; 1801 1.25.2.2 yamt int bph; 1802 1.25.2.2 yamt 1803 1.25.2.2 yamt /* Calculate number of blocks described in a blocklist header */ 1804 1.25.2.2 yamt bph = (blocklen - offsetof(struct wapbl_wc_blocklist, wc_blocks)) / 1805 1.25.2.2 yamt sizeof(((struct wapbl_wc_blocklist *)0)->wc_blocks[0]); 1806 1.25.2.2 yamt 1807 1.25.2.2 yamt KASSERT(bph > 0); 1808 1.25.2.2 yamt 1809 1.25.2.2 yamt len = wl->wl_bcount; 1810 1.25.2.2 yamt len += howmany(wl->wl_bufcount, bph)*blocklen; 1811 1.25.2.2 yamt len += howmany(wl->wl_dealloccnt, bph)*blocklen; 1812 1.25.2.2 yamt len += wapbl_transaction_inodes_len(wl); 1813 1.25.2.2 yamt 1814 1.25.2.2 yamt return len; 1815 1.25.2.2 yamt } 1816 1.25.2.2 yamt 1817 1.25.2.2 yamt /* 1818 1.25.2.2 yamt * Perform commit operation 1819 1.25.2.2 yamt * 1820 1.25.2.2 yamt * Note that generation number incrementation needs to 1821 1.25.2.2 yamt * be protected against racing with other invocations 1822 1.25.2.2 yamt * of wapbl_commit. This is ok since this routine 1823 1.25.2.2 yamt * is only invoked from wapbl_flush 1824 1.25.2.2 yamt */ 1825 1.25.2.2 yamt static int 1826 1.25.2.2 yamt wapbl_write_commit(struct wapbl *wl, off_t head, off_t tail) 1827 1.25.2.2 yamt { 1828 1.25.2.2 yamt struct wapbl_wc_header *wc = wl->wl_wc_header; 1829 1.25.2.2 yamt struct timespec ts; 1830 1.25.2.2 yamt int error; 1831 1.25.2.2 yamt int force = 1; 1832 1.25.2.4 yamt daddr_t pbn; 1833 1.25.2.2 yamt 1834 1.25.2.2 yamt /* XXX Calc checksum here, instead we do this for now */ 1835 1.25.2.2 yamt error = VOP_IOCTL(wl->wl_devvp, DIOCCACHESYNC, &force, FWRITE, FSCRED); 1836 1.25.2.2 yamt if (error) { 1837 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_ERROR, 1838 1.25.2.4 yamt ("wapbl_write_commit: DIOCCACHESYNC on dev 0x%"PRIx64 1839 1.25.2.4 yamt " returned %d\n", wl->wl_devvp->v_rdev, error)); 1840 1.25.2.2 yamt } 1841 1.25.2.2 yamt 1842 1.25.2.2 yamt wc->wc_head = head; 1843 1.25.2.2 yamt wc->wc_tail = tail; 1844 1.25.2.2 yamt wc->wc_checksum = 0; 1845 1.25.2.2 yamt wc->wc_version = 1; 1846 1.25.2.2 yamt getnanotime(&ts); 1847 1.25.2.2 yamt wc->wc_time = ts.tv_sec; 1848 1.25.2.2 yamt wc->wc_timensec = ts.tv_nsec; 1849 1.25.2.2 yamt 1850 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_WRITE, 1851 1.25.2.2 yamt ("wapbl_write_commit: head = %"PRIdMAX "tail = %"PRIdMAX"\n", 1852 1.25.2.2 yamt (intmax_t)head, (intmax_t)tail)); 1853 1.25.2.2 yamt 1854 1.25.2.2 yamt /* 1855 1.25.2.2 yamt * XXX if generation will rollover, then first zero 1856 1.25.2.2 yamt * over second commit header before trying to write both headers. 1857 1.25.2.2 yamt */ 1858 1.25.2.2 yamt 1859 1.25.2.4 yamt pbn = wl->wl_logpbn + (wc->wc_generation % 2); 1860 1.25.2.4 yamt #ifdef _KERNEL 1861 1.25.2.4 yamt pbn = btodb(pbn << wc->wc_log_dev_bshift); 1862 1.25.2.4 yamt #endif 1863 1.25.2.4 yamt error = wapbl_write(wc, wc->wc_len, wl->wl_devvp, pbn); 1864 1.25.2.2 yamt if (error) 1865 1.25.2.2 yamt return error; 1866 1.25.2.2 yamt 1867 1.25.2.2 yamt error = VOP_IOCTL(wl->wl_devvp, DIOCCACHESYNC, &force, FWRITE, FSCRED); 1868 1.25.2.2 yamt if (error) { 1869 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_ERROR, 1870 1.25.2.4 yamt ("wapbl_write_commit: DIOCCACHESYNC on dev 0x%"PRIx64 1871 1.25.2.4 yamt " returned %d\n", wl->wl_devvp->v_rdev, error)); 1872 1.25.2.2 yamt } 1873 1.25.2.2 yamt 1874 1.25.2.2 yamt /* 1875 1.25.2.2 yamt * If the generation number was zero, write it out a second time. 1876 1.25.2.2 yamt * This handles initialization and generation number rollover 1877 1.25.2.2 yamt */ 1878 1.25.2.2 yamt if (wc->wc_generation++ == 0) { 1879 1.25.2.2 yamt error = wapbl_write_commit(wl, head, tail); 1880 1.25.2.2 yamt /* 1881 1.25.2.2 yamt * This panic should be able to be removed if we do the 1882 1.25.2.2 yamt * zero'ing mentioned above, and we are certain to roll 1883 1.25.2.2 yamt * back generation number on failure. 1884 1.25.2.2 yamt */ 1885 1.25.2.2 yamt if (error) 1886 1.25.2.2 yamt panic("wapbl_write_commit: error writing duplicate " 1887 1.25.2.2 yamt "log header: %d\n", error); 1888 1.25.2.2 yamt } 1889 1.25.2.2 yamt return 0; 1890 1.25.2.2 yamt } 1891 1.25.2.2 yamt 1892 1.25.2.2 yamt /* Returns new offset value */ 1893 1.25.2.2 yamt static int 1894 1.25.2.2 yamt wapbl_write_blocks(struct wapbl *wl, off_t *offp) 1895 1.25.2.2 yamt { 1896 1.25.2.2 yamt struct wapbl_wc_blocklist *wc = 1897 1.25.2.2 yamt (struct wapbl_wc_blocklist *)wl->wl_wc_scratch; 1898 1.25.2.2 yamt int blocklen = 1<<wl->wl_log_dev_bshift; 1899 1.25.2.2 yamt int bph; 1900 1.25.2.2 yamt struct buf *bp; 1901 1.25.2.2 yamt off_t off = *offp; 1902 1.25.2.2 yamt int error; 1903 1.25.2.2 yamt size_t padding; 1904 1.25.2.2 yamt 1905 1.25.2.2 yamt KASSERT(rw_write_held(&wl->wl_rwlock)); 1906 1.25.2.2 yamt 1907 1.25.2.2 yamt bph = (blocklen - offsetof(struct wapbl_wc_blocklist, wc_blocks)) / 1908 1.25.2.2 yamt sizeof(((struct wapbl_wc_blocklist *)0)->wc_blocks[0]); 1909 1.25.2.2 yamt 1910 1.25.2.2 yamt bp = LIST_FIRST(&wl->wl_bufs); 1911 1.25.2.2 yamt 1912 1.25.2.2 yamt while (bp) { 1913 1.25.2.2 yamt int cnt; 1914 1.25.2.2 yamt struct buf *obp = bp; 1915 1.25.2.2 yamt 1916 1.25.2.2 yamt KASSERT(bp->b_flags & B_LOCKED); 1917 1.25.2.2 yamt 1918 1.25.2.2 yamt wc->wc_type = WAPBL_WC_BLOCKS; 1919 1.25.2.2 yamt wc->wc_len = blocklen; 1920 1.25.2.2 yamt wc->wc_blkcount = 0; 1921 1.25.2.2 yamt while (bp && (wc->wc_blkcount < bph)) { 1922 1.25.2.2 yamt /* 1923 1.25.2.2 yamt * Make sure all the physical block numbers are up to 1924 1.25.2.2 yamt * date. If this is not always true on a given 1925 1.25.2.2 yamt * filesystem, then VOP_BMAP must be called. We 1926 1.25.2.2 yamt * could call VOP_BMAP here, or else in the filesystem 1927 1.25.2.2 yamt * specific flush callback, although neither of those 1928 1.25.2.2 yamt * solutions allow us to take the vnode lock. If a 1929 1.25.2.2 yamt * filesystem requires that we must take the vnode lock 1930 1.25.2.2 yamt * to call VOP_BMAP, then we can probably do it in 1931 1.25.2.2 yamt * bwrite when the vnode lock should already be held 1932 1.25.2.2 yamt * by the invoking code. 1933 1.25.2.2 yamt */ 1934 1.25.2.2 yamt KASSERT((bp->b_vp->v_type == VBLK) || 1935 1.25.2.2 yamt (bp->b_blkno != bp->b_lblkno)); 1936 1.25.2.2 yamt KASSERT(bp->b_blkno > 0); 1937 1.25.2.2 yamt 1938 1.25.2.2 yamt wc->wc_blocks[wc->wc_blkcount].wc_daddr = bp->b_blkno; 1939 1.25.2.2 yamt wc->wc_blocks[wc->wc_blkcount].wc_dlen = bp->b_bcount; 1940 1.25.2.2 yamt wc->wc_len += bp->b_bcount; 1941 1.25.2.2 yamt wc->wc_blkcount++; 1942 1.25.2.2 yamt bp = LIST_NEXT(bp, b_wapbllist); 1943 1.25.2.2 yamt } 1944 1.25.2.2 yamt if (wc->wc_len % blocklen != 0) { 1945 1.25.2.2 yamt padding = blocklen - wc->wc_len % blocklen; 1946 1.25.2.2 yamt wc->wc_len += padding; 1947 1.25.2.2 yamt } else { 1948 1.25.2.2 yamt padding = 0; 1949 1.25.2.2 yamt } 1950 1.25.2.2 yamt 1951 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_WRITE, 1952 1.25.2.2 yamt ("wapbl_write_blocks: len = %u (padding %zu) off = %"PRIdMAX"\n", 1953 1.25.2.2 yamt wc->wc_len, padding, (intmax_t)off)); 1954 1.25.2.2 yamt 1955 1.25.2.2 yamt error = wapbl_circ_write(wl, wc, blocklen, &off); 1956 1.25.2.2 yamt if (error) 1957 1.25.2.2 yamt return error; 1958 1.25.2.2 yamt bp = obp; 1959 1.25.2.2 yamt cnt = 0; 1960 1.25.2.2 yamt while (bp && (cnt++ < bph)) { 1961 1.25.2.2 yamt error = wapbl_circ_write(wl, bp->b_data, 1962 1.25.2.2 yamt bp->b_bcount, &off); 1963 1.25.2.2 yamt if (error) 1964 1.25.2.2 yamt return error; 1965 1.25.2.2 yamt bp = LIST_NEXT(bp, b_wapbllist); 1966 1.25.2.2 yamt } 1967 1.25.2.2 yamt if (padding) { 1968 1.25.2.2 yamt void *zero; 1969 1.25.2.2 yamt 1970 1.25.2.2 yamt zero = wapbl_malloc(padding); 1971 1.25.2.2 yamt memset(zero, 0, padding); 1972 1.25.2.2 yamt error = wapbl_circ_write(wl, zero, padding, &off); 1973 1.25.2.2 yamt wapbl_free(zero, padding); 1974 1.25.2.2 yamt if (error) 1975 1.25.2.2 yamt return error; 1976 1.25.2.2 yamt } 1977 1.25.2.2 yamt } 1978 1.25.2.2 yamt *offp = off; 1979 1.25.2.2 yamt return 0; 1980 1.25.2.2 yamt } 1981 1.25.2.2 yamt 1982 1.25.2.2 yamt static int 1983 1.25.2.2 yamt wapbl_write_revocations(struct wapbl *wl, off_t *offp) 1984 1.25.2.2 yamt { 1985 1.25.2.2 yamt struct wapbl_wc_blocklist *wc = 1986 1.25.2.2 yamt (struct wapbl_wc_blocklist *)wl->wl_wc_scratch; 1987 1.25.2.2 yamt int i; 1988 1.25.2.2 yamt int blocklen = 1<<wl->wl_log_dev_bshift; 1989 1.25.2.2 yamt int bph; 1990 1.25.2.2 yamt off_t off = *offp; 1991 1.25.2.2 yamt int error; 1992 1.25.2.2 yamt 1993 1.25.2.2 yamt if (wl->wl_dealloccnt == 0) 1994 1.25.2.2 yamt return 0; 1995 1.25.2.2 yamt 1996 1.25.2.2 yamt bph = (blocklen - offsetof(struct wapbl_wc_blocklist, wc_blocks)) / 1997 1.25.2.2 yamt sizeof(((struct wapbl_wc_blocklist *)0)->wc_blocks[0]); 1998 1.25.2.2 yamt 1999 1.25.2.2 yamt i = 0; 2000 1.25.2.2 yamt while (i < wl->wl_dealloccnt) { 2001 1.25.2.2 yamt wc->wc_type = WAPBL_WC_REVOCATIONS; 2002 1.25.2.2 yamt wc->wc_len = blocklen; 2003 1.25.2.2 yamt wc->wc_blkcount = 0; 2004 1.25.2.2 yamt while ((i < wl->wl_dealloccnt) && (wc->wc_blkcount < bph)) { 2005 1.25.2.2 yamt wc->wc_blocks[wc->wc_blkcount].wc_daddr = 2006 1.25.2.2 yamt wl->wl_deallocblks[i]; 2007 1.25.2.2 yamt wc->wc_blocks[wc->wc_blkcount].wc_dlen = 2008 1.25.2.2 yamt wl->wl_dealloclens[i]; 2009 1.25.2.2 yamt wc->wc_blkcount++; 2010 1.25.2.2 yamt i++; 2011 1.25.2.2 yamt } 2012 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_WRITE, 2013 1.25.2.2 yamt ("wapbl_write_revocations: len = %u off = %"PRIdMAX"\n", 2014 1.25.2.2 yamt wc->wc_len, (intmax_t)off)); 2015 1.25.2.2 yamt error = wapbl_circ_write(wl, wc, blocklen, &off); 2016 1.25.2.2 yamt if (error) 2017 1.25.2.2 yamt return error; 2018 1.25.2.2 yamt } 2019 1.25.2.2 yamt *offp = off; 2020 1.25.2.2 yamt return 0; 2021 1.25.2.2 yamt } 2022 1.25.2.2 yamt 2023 1.25.2.2 yamt static int 2024 1.25.2.2 yamt wapbl_write_inodes(struct wapbl *wl, off_t *offp) 2025 1.25.2.2 yamt { 2026 1.25.2.2 yamt struct wapbl_wc_inodelist *wc = 2027 1.25.2.2 yamt (struct wapbl_wc_inodelist *)wl->wl_wc_scratch; 2028 1.25.2.2 yamt int i; 2029 1.25.2.2 yamt int blocklen = 1 << wl->wl_log_dev_bshift; 2030 1.25.2.2 yamt off_t off = *offp; 2031 1.25.2.2 yamt int error; 2032 1.25.2.2 yamt 2033 1.25.2.2 yamt struct wapbl_ino_head *wih; 2034 1.25.2.2 yamt struct wapbl_ino *wi; 2035 1.25.2.2 yamt int iph; 2036 1.25.2.2 yamt 2037 1.25.2.2 yamt iph = (blocklen - offsetof(struct wapbl_wc_inodelist, wc_inodes)) / 2038 1.25.2.2 yamt sizeof(((struct wapbl_wc_inodelist *)0)->wc_inodes[0]); 2039 1.25.2.2 yamt 2040 1.25.2.2 yamt i = 0; 2041 1.25.2.2 yamt wih = &wl->wl_inohash[0]; 2042 1.25.2.2 yamt wi = 0; 2043 1.25.2.2 yamt do { 2044 1.25.2.2 yamt wc->wc_type = WAPBL_WC_INODES; 2045 1.25.2.2 yamt wc->wc_len = blocklen; 2046 1.25.2.2 yamt wc->wc_inocnt = 0; 2047 1.25.2.2 yamt wc->wc_clear = (i == 0); 2048 1.25.2.2 yamt while ((i < wl->wl_inohashcnt) && (wc->wc_inocnt < iph)) { 2049 1.25.2.2 yamt while (!wi) { 2050 1.25.2.2 yamt KASSERT((wih - &wl->wl_inohash[0]) 2051 1.25.2.2 yamt <= wl->wl_inohashmask); 2052 1.25.2.2 yamt wi = LIST_FIRST(wih++); 2053 1.25.2.2 yamt } 2054 1.25.2.2 yamt wc->wc_inodes[wc->wc_inocnt].wc_inumber = wi->wi_ino; 2055 1.25.2.2 yamt wc->wc_inodes[wc->wc_inocnt].wc_imode = wi->wi_mode; 2056 1.25.2.2 yamt wc->wc_inocnt++; 2057 1.25.2.2 yamt i++; 2058 1.25.2.2 yamt wi = LIST_NEXT(wi, wi_hash); 2059 1.25.2.2 yamt } 2060 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_WRITE, 2061 1.25.2.2 yamt ("wapbl_write_inodes: len = %u off = %"PRIdMAX"\n", 2062 1.25.2.2 yamt wc->wc_len, (intmax_t)off)); 2063 1.25.2.2 yamt error = wapbl_circ_write(wl, wc, blocklen, &off); 2064 1.25.2.2 yamt if (error) 2065 1.25.2.2 yamt return error; 2066 1.25.2.2 yamt } while (i < wl->wl_inohashcnt); 2067 1.25.2.2 yamt 2068 1.25.2.2 yamt *offp = off; 2069 1.25.2.2 yamt return 0; 2070 1.25.2.2 yamt } 2071 1.25.2.2 yamt 2072 1.25.2.2 yamt #endif /* _KERNEL */ 2073 1.25.2.2 yamt 2074 1.25.2.2 yamt /****************************************************************/ 2075 1.25.2.2 yamt 2076 1.25.2.2 yamt struct wapbl_blk { 2077 1.25.2.2 yamt LIST_ENTRY(wapbl_blk) wb_hash; 2078 1.25.2.2 yamt daddr_t wb_blk; 2079 1.25.2.2 yamt off_t wb_off; /* Offset of this block in the log */ 2080 1.25.2.2 yamt }; 2081 1.25.2.2 yamt #define WAPBL_BLKPOOL_MIN 83 2082 1.25.2.2 yamt 2083 1.25.2.2 yamt static void 2084 1.25.2.2 yamt wapbl_blkhash_init(struct wapbl_replay *wr, u_int size) 2085 1.25.2.2 yamt { 2086 1.25.2.2 yamt if (size < WAPBL_BLKPOOL_MIN) 2087 1.25.2.2 yamt size = WAPBL_BLKPOOL_MIN; 2088 1.25.2.2 yamt KASSERT(wr->wr_blkhash == 0); 2089 1.25.2.2 yamt #ifdef _KERNEL 2090 1.25.2.2 yamt wr->wr_blkhash = hashinit(size, HASH_LIST, true, &wr->wr_blkhashmask); 2091 1.25.2.2 yamt #else /* ! _KERNEL */ 2092 1.25.2.2 yamt /* Manually implement hashinit */ 2093 1.25.2.2 yamt { 2094 1.25.2.2 yamt unsigned long i, hashsize; 2095 1.25.2.2 yamt for (hashsize = 1; hashsize < size; hashsize <<= 1) 2096 1.25.2.2 yamt continue; 2097 1.25.2.2 yamt wr->wr_blkhash = wapbl_malloc(hashsize * sizeof(*wr->wr_blkhash)); 2098 1.25.2.2 yamt for (i = 0; i < wr->wr_blkhashmask; i++) 2099 1.25.2.2 yamt LIST_INIT(&wr->wr_blkhash[i]); 2100 1.25.2.2 yamt wr->wr_blkhashmask = hashsize - 1; 2101 1.25.2.2 yamt } 2102 1.25.2.2 yamt #endif /* ! _KERNEL */ 2103 1.25.2.2 yamt } 2104 1.25.2.2 yamt 2105 1.25.2.2 yamt static void 2106 1.25.2.2 yamt wapbl_blkhash_free(struct wapbl_replay *wr) 2107 1.25.2.2 yamt { 2108 1.25.2.2 yamt KASSERT(wr->wr_blkhashcnt == 0); 2109 1.25.2.2 yamt #ifdef _KERNEL 2110 1.25.2.2 yamt hashdone(wr->wr_blkhash, HASH_LIST, wr->wr_blkhashmask); 2111 1.25.2.2 yamt #else /* ! _KERNEL */ 2112 1.25.2.2 yamt wapbl_free(wr->wr_blkhash, 2113 1.25.2.2 yamt (wr->wr_blkhashmask + 1) * sizeof(*wr->wr_blkhash)); 2114 1.25.2.2 yamt #endif /* ! _KERNEL */ 2115 1.25.2.2 yamt } 2116 1.25.2.2 yamt 2117 1.25.2.2 yamt static struct wapbl_blk * 2118 1.25.2.2 yamt wapbl_blkhash_get(struct wapbl_replay *wr, daddr_t blk) 2119 1.25.2.2 yamt { 2120 1.25.2.2 yamt struct wapbl_blk_head *wbh; 2121 1.25.2.2 yamt struct wapbl_blk *wb; 2122 1.25.2.2 yamt wbh = &wr->wr_blkhash[blk & wr->wr_blkhashmask]; 2123 1.25.2.2 yamt LIST_FOREACH(wb, wbh, wb_hash) { 2124 1.25.2.2 yamt if (blk == wb->wb_blk) 2125 1.25.2.2 yamt return wb; 2126 1.25.2.2 yamt } 2127 1.25.2.2 yamt return 0; 2128 1.25.2.2 yamt } 2129 1.25.2.2 yamt 2130 1.25.2.2 yamt static void 2131 1.25.2.2 yamt wapbl_blkhash_ins(struct wapbl_replay *wr, daddr_t blk, off_t off) 2132 1.25.2.2 yamt { 2133 1.25.2.2 yamt struct wapbl_blk_head *wbh; 2134 1.25.2.2 yamt struct wapbl_blk *wb; 2135 1.25.2.2 yamt wb = wapbl_blkhash_get(wr, blk); 2136 1.25.2.2 yamt if (wb) { 2137 1.25.2.2 yamt KASSERT(wb->wb_blk == blk); 2138 1.25.2.2 yamt wb->wb_off = off; 2139 1.25.2.2 yamt } else { 2140 1.25.2.2 yamt wb = wapbl_malloc(sizeof(*wb)); 2141 1.25.2.2 yamt wb->wb_blk = blk; 2142 1.25.2.2 yamt wb->wb_off = off; 2143 1.25.2.2 yamt wbh = &wr->wr_blkhash[blk & wr->wr_blkhashmask]; 2144 1.25.2.2 yamt LIST_INSERT_HEAD(wbh, wb, wb_hash); 2145 1.25.2.2 yamt wr->wr_blkhashcnt++; 2146 1.25.2.2 yamt } 2147 1.25.2.2 yamt } 2148 1.25.2.2 yamt 2149 1.25.2.2 yamt static void 2150 1.25.2.2 yamt wapbl_blkhash_rem(struct wapbl_replay *wr, daddr_t blk) 2151 1.25.2.2 yamt { 2152 1.25.2.2 yamt struct wapbl_blk *wb = wapbl_blkhash_get(wr, blk); 2153 1.25.2.2 yamt if (wb) { 2154 1.25.2.2 yamt KASSERT(wr->wr_blkhashcnt > 0); 2155 1.25.2.2 yamt wr->wr_blkhashcnt--; 2156 1.25.2.2 yamt LIST_REMOVE(wb, wb_hash); 2157 1.25.2.2 yamt wapbl_free(wb, sizeof(*wb)); 2158 1.25.2.2 yamt } 2159 1.25.2.2 yamt } 2160 1.25.2.2 yamt 2161 1.25.2.2 yamt static void 2162 1.25.2.2 yamt wapbl_blkhash_clear(struct wapbl_replay *wr) 2163 1.25.2.2 yamt { 2164 1.25.2.2 yamt unsigned long i; 2165 1.25.2.2 yamt for (i = 0; i <= wr->wr_blkhashmask; i++) { 2166 1.25.2.2 yamt struct wapbl_blk *wb; 2167 1.25.2.2 yamt 2168 1.25.2.2 yamt while ((wb = LIST_FIRST(&wr->wr_blkhash[i]))) { 2169 1.25.2.2 yamt KASSERT(wr->wr_blkhashcnt > 0); 2170 1.25.2.2 yamt wr->wr_blkhashcnt--; 2171 1.25.2.2 yamt LIST_REMOVE(wb, wb_hash); 2172 1.25.2.2 yamt wapbl_free(wb, sizeof(*wb)); 2173 1.25.2.2 yamt } 2174 1.25.2.2 yamt } 2175 1.25.2.2 yamt KASSERT(wr->wr_blkhashcnt == 0); 2176 1.25.2.2 yamt } 2177 1.25.2.2 yamt 2178 1.25.2.2 yamt /****************************************************************/ 2179 1.25.2.2 yamt 2180 1.25.2.2 yamt static int 2181 1.25.2.2 yamt wapbl_circ_read(struct wapbl_replay *wr, void *data, size_t len, off_t *offp) 2182 1.25.2.2 yamt { 2183 1.25.2.2 yamt size_t slen; 2184 1.25.2.2 yamt off_t off = *offp; 2185 1.25.2.2 yamt int error; 2186 1.25.2.4 yamt daddr_t pbn; 2187 1.25.2.2 yamt 2188 1.25.2.2 yamt KASSERT(((len >> wr->wr_log_dev_bshift) << 2189 1.25.2.2 yamt wr->wr_log_dev_bshift) == len); 2190 1.25.2.4 yamt 2191 1.25.2.2 yamt if (off < wr->wr_circ_off) 2192 1.25.2.2 yamt off = wr->wr_circ_off; 2193 1.25.2.2 yamt slen = wr->wr_circ_off + wr->wr_circ_size - off; 2194 1.25.2.2 yamt if (slen < len) { 2195 1.25.2.4 yamt pbn = wr->wr_logpbn + (off >> wr->wr_log_dev_bshift); 2196 1.25.2.4 yamt #ifdef _KERNEL 2197 1.25.2.4 yamt pbn = btodb(pbn << wr->wr_log_dev_bshift); 2198 1.25.2.4 yamt #endif 2199 1.25.2.4 yamt error = wapbl_read(data, slen, wr->wr_devvp, pbn); 2200 1.25.2.2 yamt if (error) 2201 1.25.2.2 yamt return error; 2202 1.25.2.2 yamt data = (uint8_t *)data + slen; 2203 1.25.2.2 yamt len -= slen; 2204 1.25.2.2 yamt off = wr->wr_circ_off; 2205 1.25.2.2 yamt } 2206 1.25.2.4 yamt pbn = wr->wr_logpbn + (off >> wr->wr_log_dev_bshift); 2207 1.25.2.4 yamt #ifdef _KERNEL 2208 1.25.2.4 yamt pbn = btodb(pbn << wr->wr_log_dev_bshift); 2209 1.25.2.4 yamt #endif 2210 1.25.2.4 yamt error = wapbl_read(data, len, wr->wr_devvp, pbn); 2211 1.25.2.2 yamt if (error) 2212 1.25.2.2 yamt return error; 2213 1.25.2.2 yamt off += len; 2214 1.25.2.2 yamt if (off >= wr->wr_circ_off + wr->wr_circ_size) 2215 1.25.2.2 yamt off = wr->wr_circ_off; 2216 1.25.2.2 yamt *offp = off; 2217 1.25.2.2 yamt return 0; 2218 1.25.2.2 yamt } 2219 1.25.2.2 yamt 2220 1.25.2.2 yamt static void 2221 1.25.2.2 yamt wapbl_circ_advance(struct wapbl_replay *wr, size_t len, off_t *offp) 2222 1.25.2.2 yamt { 2223 1.25.2.2 yamt size_t slen; 2224 1.25.2.2 yamt off_t off = *offp; 2225 1.25.2.2 yamt 2226 1.25.2.2 yamt KASSERT(((len >> wr->wr_log_dev_bshift) << 2227 1.25.2.2 yamt wr->wr_log_dev_bshift) == len); 2228 1.25.2.2 yamt 2229 1.25.2.2 yamt if (off < wr->wr_circ_off) 2230 1.25.2.2 yamt off = wr->wr_circ_off; 2231 1.25.2.2 yamt slen = wr->wr_circ_off + wr->wr_circ_size - off; 2232 1.25.2.2 yamt if (slen < len) { 2233 1.25.2.2 yamt len -= slen; 2234 1.25.2.2 yamt off = wr->wr_circ_off; 2235 1.25.2.2 yamt } 2236 1.25.2.2 yamt off += len; 2237 1.25.2.2 yamt if (off >= wr->wr_circ_off + wr->wr_circ_size) 2238 1.25.2.2 yamt off = wr->wr_circ_off; 2239 1.25.2.2 yamt *offp = off; 2240 1.25.2.2 yamt } 2241 1.25.2.2 yamt 2242 1.25.2.2 yamt /****************************************************************/ 2243 1.25.2.2 yamt 2244 1.25.2.2 yamt int 2245 1.25.2.2 yamt wapbl_replay_start(struct wapbl_replay **wrp, struct vnode *vp, 2246 1.25.2.2 yamt daddr_t off, size_t count, size_t blksize) 2247 1.25.2.2 yamt { 2248 1.25.2.2 yamt struct wapbl_replay *wr; 2249 1.25.2.2 yamt int error; 2250 1.25.2.2 yamt struct vnode *devvp; 2251 1.25.2.2 yamt daddr_t logpbn; 2252 1.25.2.2 yamt uint8_t *scratch; 2253 1.25.2.2 yamt struct wapbl_wc_header *wch; 2254 1.25.2.2 yamt struct wapbl_wc_header *wch2; 2255 1.25.2.2 yamt /* Use this until we read the actual log header */ 2256 1.25.2.4 yamt int log_dev_bshift = ilog2(blksize); 2257 1.25.2.2 yamt size_t used; 2258 1.25.2.4 yamt daddr_t pbn; 2259 1.25.2.2 yamt 2260 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_REPLAY, 2261 1.25.2.2 yamt ("wapbl_replay_start: vp=%p off=%"PRId64 " count=%zu blksize=%zu\n", 2262 1.25.2.2 yamt vp, off, count, blksize)); 2263 1.25.2.2 yamt 2264 1.25.2.2 yamt if (off < 0) 2265 1.25.2.2 yamt return EINVAL; 2266 1.25.2.2 yamt 2267 1.25.2.2 yamt if (blksize < DEV_BSIZE) 2268 1.25.2.2 yamt return EINVAL; 2269 1.25.2.2 yamt if (blksize % DEV_BSIZE) 2270 1.25.2.2 yamt return EINVAL; 2271 1.25.2.2 yamt 2272 1.25.2.2 yamt #ifdef _KERNEL 2273 1.25.2.2 yamt #if 0 2274 1.25.2.2 yamt /* XXX vp->v_size isn't reliably set for VBLK devices, 2275 1.25.2.2 yamt * especially root. However, we might still want to verify 2276 1.25.2.2 yamt * that the full load is readable */ 2277 1.25.2.2 yamt if ((off + count) * blksize > vp->v_size) 2278 1.25.2.2 yamt return EINVAL; 2279 1.25.2.2 yamt #endif 2280 1.25.2.2 yamt if ((error = VOP_BMAP(vp, off, &devvp, &logpbn, 0)) != 0) { 2281 1.25.2.2 yamt return error; 2282 1.25.2.2 yamt } 2283 1.25.2.2 yamt #else /* ! _KERNEL */ 2284 1.25.2.2 yamt devvp = vp; 2285 1.25.2.2 yamt logpbn = off; 2286 1.25.2.2 yamt #endif /* ! _KERNEL */ 2287 1.25.2.2 yamt 2288 1.25.2.2 yamt scratch = wapbl_malloc(MAXBSIZE); 2289 1.25.2.2 yamt 2290 1.25.2.4 yamt pbn = logpbn; 2291 1.25.2.4 yamt #ifdef _KERNEL 2292 1.25.2.4 yamt pbn = btodb(pbn << log_dev_bshift); 2293 1.25.2.4 yamt #endif 2294 1.25.2.4 yamt error = wapbl_read(scratch, 2<<log_dev_bshift, devvp, pbn); 2295 1.25.2.2 yamt if (error) 2296 1.25.2.2 yamt goto errout; 2297 1.25.2.2 yamt 2298 1.25.2.2 yamt wch = (struct wapbl_wc_header *)scratch; 2299 1.25.2.2 yamt wch2 = 2300 1.25.2.2 yamt (struct wapbl_wc_header *)(scratch + (1<<log_dev_bshift)); 2301 1.25.2.2 yamt /* XXX verify checksums and magic numbers */ 2302 1.25.2.2 yamt if (wch->wc_type != WAPBL_WC_HEADER) { 2303 1.25.2.2 yamt printf("Unrecognized wapbl magic: 0x%08x\n", wch->wc_type); 2304 1.25.2.2 yamt error = EFTYPE; 2305 1.25.2.2 yamt goto errout; 2306 1.25.2.2 yamt } 2307 1.25.2.2 yamt 2308 1.25.2.2 yamt if (wch2->wc_generation > wch->wc_generation) 2309 1.25.2.2 yamt wch = wch2; 2310 1.25.2.2 yamt 2311 1.25.2.2 yamt wr = wapbl_calloc(1, sizeof(*wr)); 2312 1.25.2.2 yamt 2313 1.25.2.2 yamt wr->wr_logvp = vp; 2314 1.25.2.2 yamt wr->wr_devvp = devvp; 2315 1.25.2.2 yamt wr->wr_logpbn = logpbn; 2316 1.25.2.2 yamt 2317 1.25.2.2 yamt wr->wr_scratch = scratch; 2318 1.25.2.2 yamt 2319 1.25.2.2 yamt wr->wr_log_dev_bshift = wch->wc_log_dev_bshift; 2320 1.25.2.2 yamt wr->wr_fs_dev_bshift = wch->wc_fs_dev_bshift; 2321 1.25.2.2 yamt wr->wr_circ_off = wch->wc_circ_off; 2322 1.25.2.2 yamt wr->wr_circ_size = wch->wc_circ_size; 2323 1.25.2.2 yamt wr->wr_generation = wch->wc_generation; 2324 1.25.2.2 yamt 2325 1.25.2.2 yamt used = wapbl_space_used(wch->wc_circ_size, wch->wc_head, wch->wc_tail); 2326 1.25.2.2 yamt 2327 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_REPLAY, 2328 1.25.2.2 yamt ("wapbl_replay: head=%"PRId64" tail=%"PRId64" off=%"PRId64 2329 1.25.2.2 yamt " len=%"PRId64" used=%zu\n", 2330 1.25.2.2 yamt wch->wc_head, wch->wc_tail, wch->wc_circ_off, 2331 1.25.2.2 yamt wch->wc_circ_size, used)); 2332 1.25.2.2 yamt 2333 1.25.2.2 yamt wapbl_blkhash_init(wr, (used >> wch->wc_fs_dev_bshift)); 2334 1.25.2.2 yamt 2335 1.25.2.2 yamt error = wapbl_replay_process(wr, wch->wc_head, wch->wc_tail); 2336 1.25.2.2 yamt if (error) { 2337 1.25.2.2 yamt wapbl_replay_stop(wr); 2338 1.25.2.2 yamt wapbl_replay_free(wr); 2339 1.25.2.2 yamt return error; 2340 1.25.2.2 yamt } 2341 1.25.2.2 yamt 2342 1.25.2.2 yamt *wrp = wr; 2343 1.25.2.2 yamt return 0; 2344 1.25.2.2 yamt 2345 1.25.2.2 yamt errout: 2346 1.25.2.2 yamt wapbl_free(scratch, MAXBSIZE); 2347 1.25.2.2 yamt return error; 2348 1.25.2.2 yamt } 2349 1.25.2.2 yamt 2350 1.25.2.2 yamt void 2351 1.25.2.2 yamt wapbl_replay_stop(struct wapbl_replay *wr) 2352 1.25.2.2 yamt { 2353 1.25.2.2 yamt 2354 1.25.2.2 yamt if (!wapbl_replay_isopen(wr)) 2355 1.25.2.2 yamt return; 2356 1.25.2.2 yamt 2357 1.25.2.2 yamt WAPBL_PRINTF(WAPBL_PRINT_REPLAY, ("wapbl_replay_stop called\n")); 2358 1.25.2.2 yamt 2359 1.25.2.2 yamt wapbl_free(wr->wr_scratch, MAXBSIZE); 2360 1.25.2.2 yamt wr->wr_scratch = NULL; 2361 1.25.2.2 yamt 2362 1.25.2.2 yamt wr->wr_logvp = NULL; 2363 1.25.2.2 yamt 2364 1.25.2.2 yamt wapbl_blkhash_clear(wr); 2365 1.25.2.2 yamt wapbl_blkhash_free(wr); 2366 1.25.2.2 yamt } 2367 1.25.2.2 yamt 2368 1.25.2.2 yamt void 2369 1.25.2.2 yamt wapbl_replay_free(struct wapbl_replay *wr) 2370 1.25.2.2 yamt { 2371 1.25.2.2 yamt 2372 1.25.2.2 yamt KDASSERT(!wapbl_replay_isopen(wr)); 2373 1.25.2.2 yamt 2374 1.25.2.2 yamt if (wr->wr_inodes) 2375 1.25.2.2 yamt wapbl_free(wr->wr_inodes, 2376 1.25.2.2 yamt wr->wr_inodescnt * sizeof(wr->wr_inodes[0])); 2377 1.25.2.2 yamt wapbl_free(wr, sizeof(*wr)); 2378 1.25.2.2 yamt } 2379 1.25.2.2 yamt 2380 1.25.2.2 yamt #ifdef _KERNEL 2381 1.25.2.2 yamt int 2382 1.25.2.2 yamt wapbl_replay_isopen1(struct wapbl_replay *wr) 2383 1.25.2.2 yamt { 2384 1.25.2.2 yamt 2385 1.25.2.2 yamt return wapbl_replay_isopen(wr); 2386 1.25.2.2 yamt } 2387 1.25.2.2 yamt #endif 2388 1.25.2.2 yamt 2389 1.25.2.2 yamt static void 2390 1.25.2.2 yamt wapbl_replay_process_blocks(struct wapbl_replay *wr, off_t *offp) 2391 1.25.2.2 yamt { 2392 1.25.2.2 yamt struct wapbl_wc_blocklist *wc = 2393 1.25.2.2 yamt (struct wapbl_wc_blocklist *)wr->wr_scratch; 2394 1.25.2.2 yamt int fsblklen = 1 << wr->wr_fs_dev_bshift; 2395 1.25.2.2 yamt int i, j, n; 2396 1.25.2.2 yamt 2397 1.25.2.2 yamt for (i = 0; i < wc->wc_blkcount; i++) { 2398 1.25.2.2 yamt /* 2399 1.25.2.2 yamt * Enter each physical block into the hashtable independently. 2400 1.25.2.2 yamt */ 2401 1.25.2.2 yamt n = wc->wc_blocks[i].wc_dlen >> wr->wr_fs_dev_bshift; 2402 1.25.2.2 yamt for (j = 0; j < n; j++) { 2403 1.25.2.4 yamt wapbl_blkhash_ins(wr, wc->wc_blocks[i].wc_daddr + btodb(j * fsblklen), 2404 1.25.2.2 yamt *offp); 2405 1.25.2.2 yamt wapbl_circ_advance(wr, fsblklen, offp); 2406 1.25.2.2 yamt } 2407 1.25.2.2 yamt } 2408 1.25.2.2 yamt } 2409 1.25.2.2 yamt 2410 1.25.2.2 yamt static void 2411 1.25.2.2 yamt wapbl_replay_process_revocations(struct wapbl_replay *wr) 2412 1.25.2.2 yamt { 2413 1.25.2.2 yamt struct wapbl_wc_blocklist *wc = 2414 1.25.2.2 yamt (struct wapbl_wc_blocklist *)wr->wr_scratch; 2415 1.25.2.4 yamt int fsblklen = 1 << wr->wr_fs_dev_bshift; 2416 1.25.2.2 yamt int i, j, n; 2417 1.25.2.2 yamt 2418 1.25.2.2 yamt for (i = 0; i < wc->wc_blkcount; i++) { 2419 1.25.2.2 yamt /* 2420 1.25.2.2 yamt * Remove any blocks found from the hashtable. 2421 1.25.2.2 yamt */ 2422 1.25.2.2 yamt n = wc->wc_blocks[i].wc_dlen >> wr->wr_fs_dev_bshift; 2423 1.25.2.2 yamt for (j = 0; j < n; j++) 2424 1.25.2.4 yamt wapbl_blkhash_rem(wr, wc->wc_blocks[i].wc_daddr + btodb(j * fsblklen)); 2425 1.25.2.2 yamt } 2426 1.25.2.2 yamt } 2427 1.25.2.2 yamt 2428 1.25.2.2 yamt static void 2429 1.25.2.2 yamt wapbl_replay_process_inodes(struct wapbl_replay *wr, off_t oldoff, off_t newoff) 2430 1.25.2.2 yamt { 2431 1.25.2.2 yamt struct wapbl_wc_inodelist *wc = 2432 1.25.2.2 yamt (struct wapbl_wc_inodelist *)wr->wr_scratch; 2433 1.25.2.2 yamt void *new_inodes; 2434 1.25.2.2 yamt const size_t oldsize = wr->wr_inodescnt * sizeof(wr->wr_inodes[0]); 2435 1.25.2.2 yamt 2436 1.25.2.2 yamt KASSERT(sizeof(wr->wr_inodes[0]) == sizeof(wc->wc_inodes[0])); 2437 1.25.2.2 yamt 2438 1.25.2.2 yamt /* 2439 1.25.2.2 yamt * Keep track of where we found this so location won't be 2440 1.25.2.2 yamt * overwritten. 2441 1.25.2.2 yamt */ 2442 1.25.2.2 yamt if (wc->wc_clear) { 2443 1.25.2.2 yamt wr->wr_inodestail = oldoff; 2444 1.25.2.2 yamt wr->wr_inodescnt = 0; 2445 1.25.2.2 yamt if (wr->wr_inodes != NULL) { 2446 1.25.2.2 yamt wapbl_free(wr->wr_inodes, oldsize); 2447 1.25.2.2 yamt wr->wr_inodes = NULL; 2448 1.25.2.2 yamt } 2449 1.25.2.2 yamt } 2450 1.25.2.2 yamt wr->wr_inodeshead = newoff; 2451 1.25.2.2 yamt if (wc->wc_inocnt == 0) 2452 1.25.2.2 yamt return; 2453 1.25.2.2 yamt 2454 1.25.2.2 yamt new_inodes = wapbl_malloc((wr->wr_inodescnt + wc->wc_inocnt) * 2455 1.25.2.2 yamt sizeof(wr->wr_inodes[0])); 2456 1.25.2.2 yamt if (wr->wr_inodes != NULL) { 2457 1.25.2.2 yamt memcpy(new_inodes, wr->wr_inodes, oldsize); 2458 1.25.2.2 yamt wapbl_free(wr->wr_inodes, oldsize); 2459 1.25.2.2 yamt } 2460 1.25.2.2 yamt wr->wr_inodes = new_inodes; 2461 1.25.2.2 yamt memcpy(&wr->wr_inodes[wr->wr_inodescnt], wc->wc_inodes, 2462 1.25.2.2 yamt wc->wc_inocnt * sizeof(wr->wr_inodes[0])); 2463 1.25.2.2 yamt wr->wr_inodescnt += wc->wc_inocnt; 2464 1.25.2.2 yamt } 2465 1.25.2.2 yamt 2466 1.25.2.2 yamt static int 2467 1.25.2.2 yamt wapbl_replay_process(struct wapbl_replay *wr, off_t head, off_t tail) 2468 1.25.2.2 yamt { 2469 1.25.2.2 yamt off_t off; 2470 1.25.2.2 yamt int error; 2471 1.25.2.2 yamt 2472 1.25.2.2 yamt int logblklen = 1 << wr->wr_log_dev_bshift; 2473 1.25.2.2 yamt 2474 1.25.2.2 yamt wapbl_blkhash_clear(wr); 2475 1.25.2.2 yamt 2476 1.25.2.2 yamt off = tail; 2477 1.25.2.2 yamt while (off != head) { 2478 1.25.2.2 yamt struct wapbl_wc_null *wcn; 2479 1.25.2.2 yamt off_t saveoff = off; 2480 1.25.2.2 yamt error = wapbl_circ_read(wr, wr->wr_scratch, logblklen, &off); 2481 1.25.2.2 yamt if (error) 2482 1.25.2.2 yamt goto errout; 2483 1.25.2.2 yamt wcn = (struct wapbl_wc_null *)wr->wr_scratch; 2484 1.25.2.2 yamt switch (wcn->wc_type) { 2485 1.25.2.2 yamt case WAPBL_WC_BLOCKS: 2486 1.25.2.2 yamt wapbl_replay_process_blocks(wr, &off); 2487 1.25.2.2 yamt break; 2488 1.25.2.2 yamt 2489 1.25.2.2 yamt case WAPBL_WC_REVOCATIONS: 2490 1.25.2.2 yamt wapbl_replay_process_revocations(wr); 2491 1.25.2.2 yamt break; 2492 1.25.2.2 yamt 2493 1.25.2.2 yamt case WAPBL_WC_INODES: 2494 1.25.2.2 yamt wapbl_replay_process_inodes(wr, saveoff, off); 2495 1.25.2.2 yamt break; 2496 1.25.2.2 yamt 2497 1.25.2.2 yamt default: 2498 1.25.2.2 yamt printf("Unrecognized wapbl type: 0x%08x\n", 2499 1.25.2.2 yamt wcn->wc_type); 2500 1.25.2.2 yamt error = EFTYPE; 2501 1.25.2.2 yamt goto errout; 2502 1.25.2.2 yamt } 2503 1.25.2.2 yamt wapbl_circ_advance(wr, wcn->wc_len, &saveoff); 2504 1.25.2.2 yamt if (off != saveoff) { 2505 1.25.2.2 yamt printf("wapbl_replay: corrupted records\n"); 2506 1.25.2.2 yamt error = EFTYPE; 2507 1.25.2.2 yamt goto errout; 2508 1.25.2.2 yamt } 2509 1.25.2.2 yamt } 2510 1.25.2.2 yamt return 0; 2511 1.25.2.2 yamt 2512 1.25.2.2 yamt errout: 2513 1.25.2.2 yamt wapbl_blkhash_clear(wr); 2514 1.25.2.2 yamt return error; 2515 1.25.2.2 yamt } 2516 1.25.2.2 yamt 2517 1.25.2.2 yamt #if 0 2518 1.25.2.2 yamt int 2519 1.25.2.2 yamt wapbl_replay_verify(struct wapbl_replay *wr, struct vnode *fsdevvp) 2520 1.25.2.2 yamt { 2521 1.25.2.2 yamt off_t off; 2522 1.25.2.2 yamt int mismatchcnt = 0; 2523 1.25.2.2 yamt int logblklen = 1 << wr->wr_log_dev_bshift; 2524 1.25.2.2 yamt int fsblklen = 1 << wr->wr_fs_dev_bshift; 2525 1.25.2.2 yamt void *scratch1 = wapbl_malloc(MAXBSIZE); 2526 1.25.2.2 yamt void *scratch2 = wapbl_malloc(MAXBSIZE); 2527 1.25.2.2 yamt int error = 0; 2528 1.25.2.2 yamt 2529 1.25.2.2 yamt KDASSERT(wapbl_replay_isopen(wr)); 2530 1.25.2.2 yamt 2531 1.25.2.2 yamt off = wch->wc_tail; 2532 1.25.2.2 yamt while (off != wch->wc_head) { 2533 1.25.2.2 yamt struct wapbl_wc_null *wcn; 2534 1.25.2.2 yamt #ifdef DEBUG 2535 1.25.2.2 yamt off_t saveoff = off; 2536 1.25.2.2 yamt #endif 2537 1.25.2.2 yamt error = wapbl_circ_read(wr, wr->wr_scratch, logblklen, &off); 2538 1.25.2.2 yamt if (error) 2539 1.25.2.2 yamt goto out; 2540 1.25.2.2 yamt wcn = (struct wapbl_wc_null *)wr->wr_scratch; 2541 1.25.2.2 yamt switch (wcn->wc_type) { 2542 1.25.2.2 yamt case WAPBL_WC_BLOCKS: 2543 1.25.2.2 yamt { 2544 1.25.2.2 yamt struct wapbl_wc_blocklist *wc = 2545 1.25.2.2 yamt (struct wapbl_wc_blocklist *)wr->wr_scratch; 2546 1.25.2.2 yamt int i; 2547 1.25.2.2 yamt for (i = 0; i < wc->wc_blkcount; i++) { 2548 1.25.2.2 yamt int foundcnt = 0; 2549 1.25.2.2 yamt int dirtycnt = 0; 2550 1.25.2.2 yamt int j, n; 2551 1.25.2.2 yamt /* 2552 1.25.2.2 yamt * Check each physical block into the 2553 1.25.2.2 yamt * hashtable independently 2554 1.25.2.2 yamt */ 2555 1.25.2.2 yamt n = wc->wc_blocks[i].wc_dlen >> 2556 1.25.2.2 yamt wch->wc_fs_dev_bshift; 2557 1.25.2.2 yamt for (j = 0; j < n; j++) { 2558 1.25.2.2 yamt struct wapbl_blk *wb = 2559 1.25.2.2 yamt wapbl_blkhash_get(wr, 2560 1.25.2.4 yamt wc->wc_blocks[i].wc_daddr + btodb(j * fsblklen)); 2561 1.25.2.2 yamt if (wb && (wb->wb_off == off)) { 2562 1.25.2.2 yamt foundcnt++; 2563 1.25.2.2 yamt error = 2564 1.25.2.2 yamt wapbl_circ_read(wr, 2565 1.25.2.2 yamt scratch1, fsblklen, 2566 1.25.2.2 yamt &off); 2567 1.25.2.2 yamt if (error) 2568 1.25.2.2 yamt goto out; 2569 1.25.2.2 yamt error = 2570 1.25.2.2 yamt wapbl_read(scratch2, 2571 1.25.2.2 yamt fsblklen, fsdevvp, 2572 1.25.2.2 yamt wb->wb_blk); 2573 1.25.2.2 yamt if (error) 2574 1.25.2.2 yamt goto out; 2575 1.25.2.2 yamt if (memcmp(scratch1, 2576 1.25.2.2 yamt scratch2, 2577 1.25.2.2 yamt fsblklen)) { 2578 1.25.2.2 yamt printf( 2579 1.25.2.2 yamt "wapbl_verify: mismatch block %"PRId64" at off %"PRIdMAX"\n", 2580 1.25.2.2 yamt wb->wb_blk, (intmax_t)off); 2581 1.25.2.2 yamt dirtycnt++; 2582 1.25.2.2 yamt mismatchcnt++; 2583 1.25.2.2 yamt } 2584 1.25.2.2 yamt } else { 2585 1.25.2.2 yamt wapbl_circ_advance(wr, 2586 1.25.2.2 yamt fsblklen, &off); 2587 1.25.2.2 yamt } 2588 1.25.2.2 yamt } 2589 1.25.2.2 yamt #if 0 2590 1.25.2.2 yamt /* 2591 1.25.2.2 yamt * If all of the blocks in an entry 2592 1.25.2.2 yamt * are clean, then remove all of its 2593 1.25.2.2 yamt * blocks from the hashtable since they 2594 1.25.2.2 yamt * never will need replay. 2595 1.25.2.2 yamt */ 2596 1.25.2.2 yamt if ((foundcnt != 0) && 2597 1.25.2.2 yamt (dirtycnt == 0)) { 2598 1.25.2.2 yamt off = saveoff; 2599 1.25.2.2 yamt wapbl_circ_advance(wr, 2600 1.25.2.2 yamt logblklen, &off); 2601 1.25.2.2 yamt for (j = 0; j < n; j++) { 2602 1.25.2.2 yamt struct wapbl_blk *wb = 2603 1.25.2.2 yamt wapbl_blkhash_get(wr, 2604 1.25.2.4 yamt wc->wc_blocks[i].wc_daddr + btodb(j * fsblklen)); 2605 1.25.2.2 yamt if (wb && 2606 1.25.2.2 yamt (wb->wb_off == off)) { 2607 1.25.2.2 yamt wapbl_blkhash_rem(wr, wb->wb_blk); 2608 1.25.2.2 yamt } 2609 1.25.2.2 yamt wapbl_circ_advance(wr, 2610 1.25.2.2 yamt fsblklen, &off); 2611 1.25.2.2 yamt } 2612 1.25.2.2 yamt } 2613 1.25.2.2 yamt #endif 2614 1.25.2.2 yamt } 2615 1.25.2.2 yamt } 2616 1.25.2.2 yamt break; 2617 1.25.2.2 yamt case WAPBL_WC_REVOCATIONS: 2618 1.25.2.2 yamt case WAPBL_WC_INODES: 2619 1.25.2.2 yamt break; 2620 1.25.2.2 yamt default: 2621 1.25.2.2 yamt KASSERT(0); 2622 1.25.2.2 yamt } 2623 1.25.2.2 yamt #ifdef DEBUG 2624 1.25.2.2 yamt wapbl_circ_advance(wr, wcn->wc_len, &saveoff); 2625 1.25.2.2 yamt KASSERT(off == saveoff); 2626 1.25.2.2 yamt #endif 2627 1.25.2.2 yamt } 2628 1.25.2.2 yamt out: 2629 1.25.2.2 yamt wapbl_free(scratch1, MAXBSIZE); 2630 1.25.2.2 yamt wapbl_free(scratch2, MAXBSIZE); 2631 1.25.2.2 yamt if (!error && mismatchcnt) 2632 1.25.2.2 yamt error = EFTYPE; 2633 1.25.2.2 yamt return error; 2634 1.25.2.2 yamt } 2635 1.25.2.2 yamt #endif 2636 1.25.2.2 yamt 2637 1.25.2.2 yamt int 2638 1.25.2.2 yamt wapbl_replay_write(struct wapbl_replay *wr, struct vnode *fsdevvp) 2639 1.25.2.2 yamt { 2640 1.25.2.2 yamt struct wapbl_blk *wb; 2641 1.25.2.2 yamt size_t i; 2642 1.25.2.2 yamt off_t off; 2643 1.25.2.2 yamt void *scratch; 2644 1.25.2.2 yamt int error = 0; 2645 1.25.2.2 yamt int fsblklen = 1 << wr->wr_fs_dev_bshift; 2646 1.25.2.2 yamt 2647 1.25.2.2 yamt KDASSERT(wapbl_replay_isopen(wr)); 2648 1.25.2.2 yamt 2649 1.25.2.2 yamt scratch = wapbl_malloc(MAXBSIZE); 2650 1.25.2.2 yamt 2651 1.25.2.2 yamt for (i = 0; i < wr->wr_blkhashmask; ++i) { 2652 1.25.2.2 yamt LIST_FOREACH(wb, &wr->wr_blkhash[i], wb_hash) { 2653 1.25.2.2 yamt off = wb->wb_off; 2654 1.25.2.2 yamt error = wapbl_circ_read(wr, scratch, fsblklen, &off); 2655 1.25.2.2 yamt if (error) 2656 1.25.2.2 yamt break; 2657 1.25.2.2 yamt error = wapbl_write(scratch, fsblklen, fsdevvp, 2658 1.25.2.2 yamt wb->wb_blk); 2659 1.25.2.2 yamt if (error) 2660 1.25.2.2 yamt break; 2661 1.25.2.2 yamt } 2662 1.25.2.2 yamt } 2663 1.25.2.2 yamt 2664 1.25.2.2 yamt wapbl_free(scratch, MAXBSIZE); 2665 1.25.2.2 yamt return error; 2666 1.25.2.2 yamt } 2667 1.25.2.2 yamt 2668 1.25.2.2 yamt int 2669 1.25.2.2 yamt wapbl_replay_can_read(struct wapbl_replay *wr, daddr_t blk, long len) 2670 1.25.2.2 yamt { 2671 1.25.2.2 yamt int fsblklen = 1 << wr->wr_fs_dev_bshift; 2672 1.25.2.2 yamt 2673 1.25.2.2 yamt KDASSERT(wapbl_replay_isopen(wr)); 2674 1.25.2.2 yamt KASSERT((len % fsblklen) == 0); 2675 1.25.2.2 yamt 2676 1.25.2.2 yamt while (len != 0) { 2677 1.25.2.2 yamt struct wapbl_blk *wb = wapbl_blkhash_get(wr, blk); 2678 1.25.2.2 yamt if (wb) 2679 1.25.2.2 yamt return 1; 2680 1.25.2.2 yamt len -= fsblklen; 2681 1.25.2.2 yamt } 2682 1.25.2.2 yamt return 0; 2683 1.25.2.2 yamt } 2684 1.25.2.2 yamt 2685 1.25.2.2 yamt int 2686 1.25.2.2 yamt wapbl_replay_read(struct wapbl_replay *wr, void *data, daddr_t blk, long len) 2687 1.25.2.2 yamt { 2688 1.25.2.2 yamt int fsblklen = 1 << wr->wr_fs_dev_bshift; 2689 1.25.2.2 yamt 2690 1.25.2.2 yamt KDASSERT(wapbl_replay_isopen(wr)); 2691 1.25.2.2 yamt 2692 1.25.2.2 yamt KASSERT((len % fsblklen) == 0); 2693 1.25.2.2 yamt 2694 1.25.2.2 yamt while (len != 0) { 2695 1.25.2.2 yamt struct wapbl_blk *wb = wapbl_blkhash_get(wr, blk); 2696 1.25.2.2 yamt if (wb) { 2697 1.25.2.2 yamt off_t off = wb->wb_off; 2698 1.25.2.2 yamt int error; 2699 1.25.2.2 yamt error = wapbl_circ_read(wr, data, fsblklen, &off); 2700 1.25.2.2 yamt if (error) 2701 1.25.2.2 yamt return error; 2702 1.25.2.2 yamt } 2703 1.25.2.2 yamt data = (uint8_t *)data + fsblklen; 2704 1.25.2.2 yamt len -= fsblklen; 2705 1.25.2.2 yamt blk++; 2706 1.25.2.2 yamt } 2707 1.25.2.2 yamt return 0; 2708 1.25.2.2 yamt } 2709 1.25.2.5 yamt 2710 1.25.2.5 yamt #ifdef _KERNEL 2711 1.25.2.5 yamt /* 2712 1.25.2.5 yamt * This is not really a module now, but maybe on it's way to 2713 1.25.2.5 yamt * being one some day. 2714 1.25.2.5 yamt */ 2715 1.25.2.5 yamt MODULE(MODULE_CLASS_VFS, wapbl, NULL); 2716 1.25.2.5 yamt 2717 1.25.2.5 yamt static int 2718 1.25.2.5 yamt wapbl_modcmd(modcmd_t cmd, void *arg) 2719 1.25.2.5 yamt { 2720 1.25.2.5 yamt 2721 1.25.2.5 yamt switch (cmd) { 2722 1.25.2.5 yamt case MODULE_CMD_INIT: 2723 1.25.2.5 yamt malloc_type_attach(M_WAPBL); 2724 1.25.2.5 yamt return 0; 2725 1.25.2.5 yamt case MODULE_CMD_FINI: 2726 1.25.2.5 yamt return EOPNOTSUPP; 2727 1.25.2.5 yamt default: 2728 1.25.2.5 yamt return ENOTTY; 2729 1.25.2.5 yamt } 2730 1.25.2.5 yamt } 2731 1.25.2.5 yamt #endif /* _KERNEL */ 2732
Indexes created Thu Oct 02 14:10:14 GMT 2025