Lines Matching defs:wr
454 wapbl_start_flush_inodes(struct wapbl *wl, struct wapbl_replay *wr)
459 ("wapbl_start: reusing log with %d inodes\n", wr->wr_inodescnt));
465 KDASSERT(!wapbl_replay_isopen(wr));
467 KASSERT(wr->wr_devvp->v_type == VBLK);
468 KASSERT(wl->wl_devvp->v_rdev == wr->wr_devvp->v_rdev);
469 KASSERT(wl->wl_logpbn == wr->wr_logpbn);
470 KASSERT(wl->wl_circ_size == wr->wr_circ_size);
471 KASSERT(wl->wl_circ_off == wr->wr_circ_off);
472 KASSERT(wl->wl_log_dev_bshift == wr->wr_log_dev_bshift);
473 KASSERT(wl->wl_fs_dev_bshift == wr->wr_fs_dev_bshift);
475 wl->wl_wc_header->wc_generation = wr->wr_generation + 1;
477 for (i = 0; i < wr->wr_inodescnt; i++)
478 wapbl_register_inode(wl, wr->wr_inodes[i].wr_inumber,
479 wr->wr_inodes[i].wr_imode);
483 wapbl_space_free(wl->wl_circ_size, wr->wr_inodeshead,
484 wr->wr_inodestail));
486 wl->wl_head = wl->wl_tail = wr->wr_inodeshead;
502 daddr_t off, size_t count, size_t blksize, struct wapbl_replay *wr,
665 if (wr && wr->wr_inodescnt) {
666 error = wapbl_start_flush_inodes(wl, wr);
2767 wapbl_blkhash_init(struct wapbl_replay *wr, u_int size)
2772 KASSERT(wr->wr_blkhash == 0);
2774 wr->wr_blkhash = hashinit(size, HASH_LIST, true, &wr->wr_blkhashmask);
2782 wr->wr_blkhash = wapbl_alloc(hashsize *
2783 sizeof(*wr->wr_blkhash));
2785 LIST_INIT(&wr->wr_blkhash[i]);
2786 wr->wr_blkhashmask = hashsize - 1;
2792 wapbl_blkhash_free(struct wapbl_replay *wr)
2795 KASSERT(wr->wr_blkhashcnt == 0);
2797 hashdone(wr->wr_blkhash, HASH_LIST, wr->wr_blkhashmask);
2799 wapbl_free(wr->wr_blkhash,
2800 (wr->wr_blkhashmask + 1) * sizeof(*wr->wr_blkhash));
2805 wapbl_blkhash_get(struct wapbl_replay *wr, daddr_t blk)
2810 wbh = &wr->wr_blkhash[blk & wr->wr_blkhashmask];
2819 wapbl_blkhash_ins(struct wapbl_replay *wr, daddr_t blk, off_t off)
2824 wb = wapbl_blkhash_get(wr, blk);
2832 wbh = &wr->wr_blkhash[blk & wr->wr_blkhashmask];
2834 wr->wr_blkhashcnt++;
2839 wapbl_blkhash_rem(struct wapbl_replay *wr, daddr_t blk)
2841 struct wapbl_blk *wb = wapbl_blkhash_get(wr, blk);
2844 KASSERT(wr->wr_blkhashcnt > 0);
2845 wr->wr_blkhashcnt--;
2852 wapbl_blkhash_clear(struct wapbl_replay *wr)
2856 for (i = 0; i <= wr->wr_blkhashmask; i++) {
2859 while ((wb = LIST_FIRST(&wr->wr_blkhash[i]))) {
2860 KASSERT(wr->wr_blkhashcnt > 0);
2861 wr->wr_blkhashcnt--;
2866 KASSERT(wr->wr_blkhashcnt == 0);
2872 * wapbl_circ_read(wr, data, len, offp)
2874 * Read len bytes into data from the circular queue of wr,
2878 * If the starting linear byte offset precedes wr->wr_circ_off,
2879 * the read instead begins at wr->wr_circ_off. XXX WTF? This
2883 wapbl_circ_read(struct wapbl_replay *wr, void *data, size_t len, off_t *offp)
2890 KASSERT(((len >> wr->wr_log_dev_bshift) << wr->wr_log_dev_bshift) ==
2893 if (off < wr->wr_circ_off)
2894 off = wr->wr_circ_off;
2895 slen = wr->wr_circ_off + wr->wr_circ_size - off;
2897 pbn = wr->wr_logpbn + (off >> wr->wr_log_dev_bshift);
2899 pbn = btodb(pbn << wr->wr_log_dev_bshift);
2901 error = wapbl_read(data, slen, wr->wr_devvp, pbn);
2906 off = wr->wr_circ_off;
2908 pbn = wr->wr_logpbn + (off >> wr->wr_log_dev_bshift);
2910 pbn = btodb(pbn << wr->wr_log_dev_bshift);
2912 error = wapbl_read(data, len, wr->wr_devvp, pbn);
2916 if (off >= wr->wr_circ_off + wr->wr_circ_size)
2917 off = wr->wr_circ_off;
2923 * wapbl_circ_advance(wr, len, offp)
2925 * Compute the linear byte offset of the circular queue of wr that
2931 * If the starting linear byte offset precedes wr->wr_circ_off, it
2932 * is taken to be wr->wr_circ_off instead. XXX WTF? This should
2936 wapbl_circ_advance(struct wapbl_replay *wr, size_t len, off_t *offp)
2941 KASSERT(((len >> wr->wr_log_dev_bshift) << wr->wr_log_dev_bshift) ==
2944 if (off < wr->wr_circ_off)
2945 off = wr->wr_circ_off;
2946 slen = wr->wr_circ_off + wr->wr_circ_size - off;
2949 off = wr->wr_circ_off;
2952 if (off >= wr->wr_circ_off + wr->wr_circ_size)
2953 off = wr->wr_circ_off;
2963 struct wapbl_replay *wr;
3026 wr = wapbl_calloc(1, sizeof(*wr));
3028 wr->wr_logvp = vp;
3029 wr->wr_devvp = devvp;
3030 wr->wr_logpbn = logpbn;
3032 wr->wr_scratch = scratch;
3034 wr->wr_log_dev_bshift = wch->wc_log_dev_bshift;
3035 wr->wr_fs_dev_bshift = wch->wc_fs_dev_bshift;
3036 wr->wr_circ_off = wch->wc_circ_off;
3037 wr->wr_circ_size = wch->wc_circ_size;
3038 wr->wr_generation = wch->wc_generation;
3048 wapbl_blkhash_init(wr, (used >> wch->wc_fs_dev_bshift));
3050 error = wapbl_replay_process(wr, wch->wc_head, wch->wc_tail);
3052 wapbl_replay_stop(wr);
3053 wapbl_replay_free(wr);
3057 *wrp = wr;
3066 wapbl_replay_stop(struct wapbl_replay *wr)
3069 if (!wapbl_replay_isopen(wr))
3074 wapbl_free(wr->wr_scratch, MAXBSIZE);
3075 wr->wr_scratch = NULL;
3077 wr->wr_logvp = NULL;
3079 wapbl_blkhash_clear(wr);
3080 wapbl_blkhash_free(wr);
3084 wapbl_replay_free(struct wapbl_replay *wr)
3087 KDASSERT(!wapbl_replay_isopen(wr));
3089 if (wr->wr_inodes) {
3090 wapbl_free(wr->wr_inodes,
3091 wr->wr_inodescnt * sizeof(wr->wr_inodes[0]));
3093 wapbl_free(wr, sizeof(*wr));
3098 wapbl_replay_isopen1(struct wapbl_replay *wr)
3101 return wapbl_replay_isopen(wr);
3132 wapbl_replay_process_blocks(struct wapbl_replay *wr, off_t *offp)
3135 (struct wapbl_wc_blocklist *)wr->wr_scratch;
3136 int fsblklen = 1 << wr->wr_fs_dev_bshift;
3143 n = wc->wc_blocks[i].wc_dlen >> wr->wr_fs_dev_bshift;
3145 wapbl_blkhash_ins(wr,
3148 wapbl_circ_advance(wr, fsblklen, offp);
3154 wapbl_replay_process_revocations(struct wapbl_replay *wr)
3157 (struct wapbl_wc_blocklist *)wr->wr_scratch;
3158 int fsblklen = 1 << wr->wr_fs_dev_bshift;
3165 n = wc->wc_blocks[i].wc_dlen >> wr->wr_fs_dev_bshift;
3167 wapbl_blkhash_rem(wr, wapbl_block_daddr(wc, i, j,
3174 wapbl_replay_process_inodes(struct wapbl_replay *wr, off_t oldoff,
3178 (struct wapbl_wc_inodelist *)wr->wr_scratch;
3180 const size_t oldsize = wr->wr_inodescnt * sizeof(wr->wr_inodes[0]);
3182 KASSERT(sizeof(wr->wr_inodes[0]) == sizeof(wc->wc_inodes[0]));
3189 wr->wr_inodestail = oldoff;
3190 wr->wr_inodescnt = 0;
3191 if (wr->wr_inodes != NULL) {
3192 wapbl_free(wr->wr_inodes, oldsize);
3193 wr->wr_inodes = NULL;
3196 wr->wr_inodeshead = newoff;
3200 new_inodes = wapbl_alloc((wr->wr_inodescnt + wc->wc_inocnt) *
3201 sizeof(wr->wr_inodes[0]));
3202 if (wr->wr_inodes != NULL) {
3203 memcpy(new_inodes, wr->wr_inodes, oldsize);
3204 wapbl_free(wr->wr_inodes, oldsize);
3206 wr->wr_inodes = new_inodes;
3207 memcpy(&wr->wr_inodes[wr->wr_inodescnt], wc->wc_inodes,
3208 wc->wc_inocnt * sizeof(wr->wr_inodes[0]));
3209 wr->wr_inodescnt += wc->wc_inocnt;
3213 wapbl_replay_process(struct wapbl_replay *wr, off_t head, off_t tail)
3218 int logblklen = 1 << wr->wr_log_dev_bshift;
3220 wapbl_blkhash_clear(wr);
3226 error = wapbl_circ_read(wr, wr->wr_scratch, logblklen, &off);
3229 wcn = (struct wapbl_wc_null *)wr->wr_scratch;
3232 wapbl_replay_process_blocks(wr, &off);
3236 wapbl_replay_process_revocations(wr);
3240 wapbl_replay_process_inodes(wr, saveoff, off);
3249 wapbl_circ_advance(wr, wcn->wc_len, &saveoff);
3259 wapbl_blkhash_clear(wr);
3265 wapbl_replay_verify(struct wapbl_replay *wr, struct vnode *fsdevvp)
3269 int logblklen = 1 << wr->wr_log_dev_bshift;
3270 int fsblklen = 1 << wr->wr_fs_dev_bshift;
3275 KDASSERT(wapbl_replay_isopen(wr));
3283 error = wapbl_circ_read(wr, wr->wr_scratch, logblklen, &off);
3286 wcn = (struct wapbl_wc_null *)wr->wr_scratch;
3290 (struct wapbl_wc_blocklist *)wr->wr_scratch;
3304 wapbl_blkhash_get(wr,
3310 wapbl_circ_read(wr,
3335 wapbl_circ_advance(wr,
3348 wapbl_circ_advance(wr, logblklen,
3352 wapbl_blkhash_get(wr,
3357 wapbl_blkhash_rem(wr,
3360 wapbl_circ_advance(wr,
3375 wapbl_circ_advance(wr, wcn->wc_len, &saveoff);
3389 wapbl_replay_write(struct wapbl_replay *wr, struct vnode *fsdevvp)
3396 int fsblklen = 1 << wr->wr_fs_dev_bshift;
3398 KDASSERT(wapbl_replay_isopen(wr));
3402 for (i = 0; i <= wr->wr_blkhashmask; ++i) {
3403 LIST_FOREACH(wb, &wr->wr_blkhash[i], wb_hash) {
3405 error = wapbl_circ_read(wr, scratch, fsblklen, &off);
3420 wapbl_replay_can_read(struct wapbl_replay *wr, daddr_t blk, long len)
3422 int fsblklen = 1 << wr->wr_fs_dev_bshift;
3424 KDASSERT(wapbl_replay_isopen(wr));
3428 struct wapbl_blk *wb = wapbl_blkhash_get(wr, blk);
3437 wapbl_replay_read(struct wapbl_replay *wr, void *data, daddr_t blk, long len)
3439 int fsblklen = 1 << wr->wr_fs_dev_bshift;
3441 KDASSERT(wapbl_replay_isopen(wr));
3446 struct wapbl_blk *wb = wapbl_blkhash_get(wr, blk);
3450 error = wapbl_circ_read(wr, data, fsblklen, &off);
Indexes created Thu Oct 02 07:10:07 GMT 2025