1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5fa9e4066Sahrens * Common Development and Distribution License, Version 1.0 only 6fa9e4066Sahrens * (the "License"). You may not use this file except in compliance 7fa9e4066Sahrens * with the License. 8fa9e4066Sahrens * 9fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 11fa9e4066Sahrens * See the License for the specific language governing permissions 12fa9e4066Sahrens * and limitations under the License. 13fa9e4066Sahrens * 14fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 15fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 17fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 18fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 19fa9e4066Sahrens * 20fa9e4066Sahrens * CDDL HEADER END 21fa9e4066Sahrens */ 22fa9e4066Sahrens /* 23*13f5297eSperrin * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 24fa9e4066Sahrens * Use is subject to license terms. 25fa9e4066Sahrens */ 26fa9e4066Sahrens 27fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 28fa9e4066Sahrens 29fa9e4066Sahrens #include <sys/zfs_context.h> 30fa9e4066Sahrens #include <sys/spa.h> 31fa9e4066Sahrens #include <sys/dmu.h> 32fa9e4066Sahrens #include <sys/zap.h> 33fa9e4066Sahrens #include <sys/arc.h> 34fa9e4066Sahrens #include <sys/stat.h> 35fa9e4066Sahrens #include <sys/resource.h> 36fa9e4066Sahrens #include <sys/zil.h> 37fa9e4066Sahrens #include <sys/zil_impl.h> 38fa9e4066Sahrens #include <sys/dsl_dataset.h> 39fa9e4066Sahrens #include <sys/vdev.h> 40fa9e4066Sahrens 41fa9e4066Sahrens /* 42fa9e4066Sahrens * The zfs intent log (ZIL) saves transaction records of system calls 43fa9e4066Sahrens * that change the file system in memory with enough information 44fa9e4066Sahrens * to be able to replay them. These are stored in memory until 45fa9e4066Sahrens * either the DMU transaction group (txg) commits them to the stable pool 46fa9e4066Sahrens * and they can be discarded, or they are flushed to the stable log 47fa9e4066Sahrens * (also in the pool) due to a fsync, O_DSYNC or other synchronous 48fa9e4066Sahrens * requirement. In the event of a panic or power fail then those log 49fa9e4066Sahrens * records (transactions) are replayed. 50fa9e4066Sahrens * 51fa9e4066Sahrens * There is one ZIL per file system. Its on-disk (pool) format consists 52fa9e4066Sahrens * of 3 parts: 53fa9e4066Sahrens * 54fa9e4066Sahrens * - ZIL header 55fa9e4066Sahrens * - ZIL blocks 56fa9e4066Sahrens * - ZIL records 57fa9e4066Sahrens * 58fa9e4066Sahrens * A log record holds a system call transaction. Log blocks can 59fa9e4066Sahrens * hold many log records and the blocks are chained together. 60fa9e4066Sahrens * Each ZIL block contains a block pointer (blkptr_t) to the next 61fa9e4066Sahrens * ZIL block in the chain. The ZIL header points to the first 62fa9e4066Sahrens * block in the chain. Note there is not a fixed place in the pool 63fa9e4066Sahrens * to hold blocks. They are dynamically allocated and freed as 64fa9e4066Sahrens * needed from the blocks available. Figure X shows the ZIL structure: 65fa9e4066Sahrens */ 66fa9e4066Sahrens 67fa9e4066Sahrens /* 68fa9e4066Sahrens * These global ZIL switches affect all pools 69fa9e4066Sahrens */ 70fa9e4066Sahrens int zil_disable = 0; /* disable intent logging */ 71fa9e4066Sahrens int zil_always = 0; /* make every transaction synchronous */ 72fa9e4066Sahrens int zil_purge = 0; /* at pool open, just throw everything away */ 73fa9e4066Sahrens int zil_noflush = 0; /* don't flush write cache buffers on disks */ 74fa9e4066Sahrens 75fa9e4066Sahrens static kmem_cache_t *zil_lwb_cache; 76fa9e4066Sahrens 77fa9e4066Sahrens static int 78fa9e4066Sahrens zil_dva_compare(const void *x1, const void *x2) 79fa9e4066Sahrens { 80fa9e4066Sahrens const dva_t *dva1 = x1; 81fa9e4066Sahrens const dva_t *dva2 = x2; 82fa9e4066Sahrens 83fa9e4066Sahrens if (DVA_GET_VDEV(dva1) < DVA_GET_VDEV(dva2)) 84fa9e4066Sahrens return (-1); 85fa9e4066Sahrens if (DVA_GET_VDEV(dva1) > DVA_GET_VDEV(dva2)) 86fa9e4066Sahrens return (1); 87fa9e4066Sahrens 88fa9e4066Sahrens if (DVA_GET_OFFSET(dva1) < DVA_GET_OFFSET(dva2)) 89fa9e4066Sahrens return (-1); 90fa9e4066Sahrens if (DVA_GET_OFFSET(dva1) > DVA_GET_OFFSET(dva2)) 91fa9e4066Sahrens return (1); 92fa9e4066Sahrens 93fa9e4066Sahrens return (0); 94fa9e4066Sahrens } 95fa9e4066Sahrens 96fa9e4066Sahrens static void 97fa9e4066Sahrens zil_dva_tree_init(avl_tree_t *t) 98fa9e4066Sahrens { 99fa9e4066Sahrens avl_create(t, zil_dva_compare, sizeof (zil_dva_node_t), 100fa9e4066Sahrens offsetof(zil_dva_node_t, zn_node)); 101fa9e4066Sahrens } 102fa9e4066Sahrens 103fa9e4066Sahrens static void 104fa9e4066Sahrens zil_dva_tree_fini(avl_tree_t *t) 105fa9e4066Sahrens { 106fa9e4066Sahrens zil_dva_node_t *zn; 107fa9e4066Sahrens void *cookie = NULL; 108fa9e4066Sahrens 109fa9e4066Sahrens while ((zn = avl_destroy_nodes(t, &cookie)) != NULL) 110fa9e4066Sahrens kmem_free(zn, sizeof (zil_dva_node_t)); 111fa9e4066Sahrens 112fa9e4066Sahrens avl_destroy(t); 113fa9e4066Sahrens } 114fa9e4066Sahrens 115fa9e4066Sahrens static int 116fa9e4066Sahrens zil_dva_tree_add(avl_tree_t *t, dva_t *dva) 117fa9e4066Sahrens { 118fa9e4066Sahrens zil_dva_node_t *zn; 119fa9e4066Sahrens avl_index_t where; 120fa9e4066Sahrens 121fa9e4066Sahrens if (avl_find(t, dva, &where) != NULL) 122fa9e4066Sahrens return (EEXIST); 123fa9e4066Sahrens 124fa9e4066Sahrens zn = kmem_alloc(sizeof (zil_dva_node_t), KM_SLEEP); 125fa9e4066Sahrens zn->zn_dva = *dva; 126fa9e4066Sahrens avl_insert(t, zn, where); 127fa9e4066Sahrens 128fa9e4066Sahrens return (0); 129fa9e4066Sahrens } 130fa9e4066Sahrens 131fa9e4066Sahrens /* 132fa9e4066Sahrens * Read a log block, make sure it's valid, and byteswap it if necessary. 133fa9e4066Sahrens */ 134fa9e4066Sahrens static int 135fa9e4066Sahrens zil_read_log_block(zilog_t *zilog, blkptr_t *bp, char *buf) 136fa9e4066Sahrens { 137fa9e4066Sahrens uint64_t blksz = BP_GET_LSIZE(bp); 138fa9e4066Sahrens zil_trailer_t *ztp = (zil_trailer_t *)(buf + blksz) - 1; 139fa9e4066Sahrens zio_cksum_t cksum; 140fa9e4066Sahrens int error; 141fa9e4066Sahrens 142fa9e4066Sahrens error = zio_wait(zio_read(NULL, zilog->zl_spa, bp, buf, blksz, 143fa9e4066Sahrens NULL, NULL, ZIO_PRIORITY_SYNC_READ, 144fa9e4066Sahrens ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE)); 145fa9e4066Sahrens if (error) { 146fa9e4066Sahrens dprintf_bp(bp, "zilog %p bp %p read failed, error %d: ", 147fa9e4066Sahrens zilog, bp, error); 148fa9e4066Sahrens return (error); 149fa9e4066Sahrens } 150fa9e4066Sahrens 151fa9e4066Sahrens if (BP_SHOULD_BYTESWAP(bp)) 152fa9e4066Sahrens byteswap_uint64_array(buf, blksz); 153fa9e4066Sahrens 154fa9e4066Sahrens /* 155fa9e4066Sahrens * Sequence numbers should be... sequential. The checksum verifier for 156fa9e4066Sahrens * the next block should be: <logid[0], logid[1], objset id, seq + 1>. 157fa9e4066Sahrens */ 158fa9e4066Sahrens cksum = bp->blk_cksum; 159fa9e4066Sahrens cksum.zc_word[3]++; 160fa9e4066Sahrens if (bcmp(&cksum, &ztp->zit_next_blk.blk_cksum, sizeof (cksum)) != 0) { 161fa9e4066Sahrens dprintf_bp(bp, "zilog %p bp %p stale pointer: ", zilog, bp); 162fa9e4066Sahrens return (ESTALE); 163fa9e4066Sahrens } 164fa9e4066Sahrens 165fa9e4066Sahrens if (BP_IS_HOLE(&ztp->zit_next_blk)) { 166fa9e4066Sahrens dprintf_bp(bp, "zilog %p bp %p hole: ", zilog, bp); 167fa9e4066Sahrens return (ENOENT); 168fa9e4066Sahrens } 169fa9e4066Sahrens 170fa9e4066Sahrens if (ztp->zit_nused > (blksz - sizeof (zil_trailer_t))) { 171fa9e4066Sahrens dprintf("zilog %p bp %p nused exceeds blksz\n", zilog, bp); 172fa9e4066Sahrens return (EOVERFLOW); 173fa9e4066Sahrens } 174fa9e4066Sahrens 175fa9e4066Sahrens dprintf_bp(bp, "zilog %p bp %p good block: ", zilog, bp); 176fa9e4066Sahrens 177fa9e4066Sahrens return (0); 178fa9e4066Sahrens } 179fa9e4066Sahrens 180fa9e4066Sahrens /* 181fa9e4066Sahrens * Parse the intent log, and call parse_func for each valid record within. 182fa9e4066Sahrens */ 183fa9e4066Sahrens void 184fa9e4066Sahrens zil_parse(zilog_t *zilog, zil_parse_blk_func_t *parse_blk_func, 185fa9e4066Sahrens zil_parse_lr_func_t *parse_lr_func, void *arg, uint64_t txg) 186fa9e4066Sahrens { 187fa9e4066Sahrens blkptr_t blk; 188fa9e4066Sahrens char *lrbuf, *lrp; 189fa9e4066Sahrens zil_trailer_t *ztp; 190fa9e4066Sahrens int reclen, error; 191fa9e4066Sahrens 192fa9e4066Sahrens blk = zilog->zl_header->zh_log; 193fa9e4066Sahrens if (BP_IS_HOLE(&blk)) 194fa9e4066Sahrens return; 195fa9e4066Sahrens 196fa9e4066Sahrens /* 197fa9e4066Sahrens * Starting at the block pointed to by zh_log we read the log chain. 198fa9e4066Sahrens * For each block in the chain we strongly check that block to 199fa9e4066Sahrens * ensure its validity. We stop when an invalid block is found. 200fa9e4066Sahrens * For each block pointer in the chain we call parse_blk_func(). 201fa9e4066Sahrens * For each record in each valid block we call parse_lr_func(). 202fa9e4066Sahrens */ 203fa9e4066Sahrens zil_dva_tree_init(&zilog->zl_dva_tree); 204fa9e4066Sahrens lrbuf = zio_buf_alloc(SPA_MAXBLOCKSIZE); 205fa9e4066Sahrens for (;;) { 206fa9e4066Sahrens error = zil_read_log_block(zilog, &blk, lrbuf); 207fa9e4066Sahrens 208fa9e4066Sahrens if (parse_blk_func != NULL) 209fa9e4066Sahrens parse_blk_func(zilog, &blk, arg, txg); 210fa9e4066Sahrens 211fa9e4066Sahrens if (error) 212fa9e4066Sahrens break; 213fa9e4066Sahrens 214fa9e4066Sahrens ztp = (zil_trailer_t *)(lrbuf + BP_GET_LSIZE(&blk)) - 1; 215fa9e4066Sahrens blk = ztp->zit_next_blk; 216fa9e4066Sahrens 217fa9e4066Sahrens if (parse_lr_func == NULL) 218fa9e4066Sahrens continue; 219fa9e4066Sahrens 220fa9e4066Sahrens for (lrp = lrbuf; lrp < lrbuf + ztp->zit_nused; lrp += reclen) { 221fa9e4066Sahrens lr_t *lr = (lr_t *)lrp; 222fa9e4066Sahrens reclen = lr->lrc_reclen; 223fa9e4066Sahrens ASSERT3U(reclen, >=, sizeof (lr_t)); 224fa9e4066Sahrens parse_lr_func(zilog, lr, arg, txg); 225fa9e4066Sahrens } 226fa9e4066Sahrens } 227fa9e4066Sahrens zio_buf_free(lrbuf, SPA_MAXBLOCKSIZE); 228fa9e4066Sahrens zil_dva_tree_fini(&zilog->zl_dva_tree); 229fa9e4066Sahrens } 230fa9e4066Sahrens 231fa9e4066Sahrens /* ARGSUSED */ 232fa9e4066Sahrens static void 233fa9e4066Sahrens zil_claim_log_block(zilog_t *zilog, blkptr_t *bp, void *tx, uint64_t first_txg) 234fa9e4066Sahrens { 235fa9e4066Sahrens spa_t *spa = zilog->zl_spa; 236fa9e4066Sahrens int err; 237fa9e4066Sahrens 238fa9e4066Sahrens dprintf_bp(bp, "first_txg %llu: ", first_txg); 239fa9e4066Sahrens 240fa9e4066Sahrens /* 241fa9e4066Sahrens * Claim log block if not already committed and not already claimed. 242fa9e4066Sahrens */ 243fa9e4066Sahrens if (bp->blk_birth >= first_txg && 244fa9e4066Sahrens zil_dva_tree_add(&zilog->zl_dva_tree, BP_IDENTITY(bp)) == 0) { 245fa9e4066Sahrens err = zio_wait(zio_claim(NULL, spa, first_txg, bp, NULL, NULL)); 246fa9e4066Sahrens ASSERT(err == 0); 247fa9e4066Sahrens } 248fa9e4066Sahrens } 249fa9e4066Sahrens 250fa9e4066Sahrens static void 251fa9e4066Sahrens zil_claim_log_record(zilog_t *zilog, lr_t *lrc, void *tx, uint64_t first_txg) 252fa9e4066Sahrens { 253fa9e4066Sahrens if (lrc->lrc_txtype == TX_WRITE) { 254fa9e4066Sahrens lr_write_t *lr = (lr_write_t *)lrc; 255fa9e4066Sahrens zil_claim_log_block(zilog, &lr->lr_blkptr, tx, first_txg); 256fa9e4066Sahrens } 257fa9e4066Sahrens } 258fa9e4066Sahrens 259fa9e4066Sahrens /* ARGSUSED */ 260fa9e4066Sahrens static void 261fa9e4066Sahrens zil_free_log_block(zilog_t *zilog, blkptr_t *bp, void *tx, uint64_t claim_txg) 262fa9e4066Sahrens { 263fa9e4066Sahrens zio_free_blk(zilog->zl_spa, bp, dmu_tx_get_txg(tx)); 264fa9e4066Sahrens } 265fa9e4066Sahrens 266fa9e4066Sahrens static void 267fa9e4066Sahrens zil_free_log_record(zilog_t *zilog, lr_t *lrc, void *tx, uint64_t claim_txg) 268fa9e4066Sahrens { 269fa9e4066Sahrens /* 270fa9e4066Sahrens * If we previously claimed it, we need to free it. 271fa9e4066Sahrens */ 272fa9e4066Sahrens if (claim_txg != 0 && lrc->lrc_txtype == TX_WRITE) { 273fa9e4066Sahrens lr_write_t *lr = (lr_write_t *)lrc; 274fa9e4066Sahrens blkptr_t *bp = &lr->lr_blkptr; 275fa9e4066Sahrens if (bp->blk_birth >= claim_txg && 276fa9e4066Sahrens !zil_dva_tree_add(&zilog->zl_dva_tree, BP_IDENTITY(bp))) { 277fa9e4066Sahrens (void) arc_free(NULL, zilog->zl_spa, 278fa9e4066Sahrens dmu_tx_get_txg(tx), bp, NULL, NULL, ARC_WAIT); 279fa9e4066Sahrens } 280fa9e4066Sahrens } 281fa9e4066Sahrens } 282fa9e4066Sahrens 283fa9e4066Sahrens /* 284fa9e4066Sahrens * Create an on-disk intent log. 285fa9e4066Sahrens */ 286fa9e4066Sahrens static void 287fa9e4066Sahrens zil_create(zilog_t *zilog) 288fa9e4066Sahrens { 289fa9e4066Sahrens lwb_t *lwb; 290fa9e4066Sahrens uint64_t txg; 291fa9e4066Sahrens dmu_tx_t *tx; 292fa9e4066Sahrens blkptr_t blk; 293fa9e4066Sahrens int error; 294*13f5297eSperrin int no_blk; 295fa9e4066Sahrens 296fa9e4066Sahrens ASSERT(zilog->zl_header->zh_claim_txg == 0); 297fa9e4066Sahrens ASSERT(zilog->zl_header->zh_replay_seq == 0); 298fa9e4066Sahrens 299fa9e4066Sahrens /* 300fa9e4066Sahrens * Initialize the log header block. 301fa9e4066Sahrens */ 302fa9e4066Sahrens tx = dmu_tx_create(zilog->zl_os); 303fa9e4066Sahrens (void) dmu_tx_assign(tx, TXG_WAIT); 304fa9e4066Sahrens dsl_dataset_dirty(dmu_objset_ds(zilog->zl_os), tx); 305fa9e4066Sahrens txg = dmu_tx_get_txg(tx); 306fa9e4066Sahrens 307fa9e4066Sahrens /* 308*13f5297eSperrin * If we don't have a log block already then 309*13f5297eSperrin * allocate the first log block and assign its checksum verifier. 310fa9e4066Sahrens */ 311*13f5297eSperrin no_blk = BP_IS_HOLE(&zilog->zl_header->zh_log); 312*13f5297eSperrin if (no_blk) { 313*13f5297eSperrin error = zio_alloc_blk(zilog->zl_spa, ZIO_CHECKSUM_ZILOG, 314*13f5297eSperrin ZIL_MIN_BLKSZ, &blk, txg); 315*13f5297eSperrin } else { 316*13f5297eSperrin blk = zilog->zl_header->zh_log; 317*13f5297eSperrin error = 0; 318*13f5297eSperrin } 319fa9e4066Sahrens if (error == 0) { 320fa9e4066Sahrens ZIO_SET_CHECKSUM(&blk.blk_cksum, 321fa9e4066Sahrens spa_get_random(-1ULL), spa_get_random(-1ULL), 322fa9e4066Sahrens dmu_objset_id(zilog->zl_os), 1ULL); 323fa9e4066Sahrens 324fa9e4066Sahrens /* 325fa9e4066Sahrens * Allocate a log write buffer (lwb) for the first log block. 326fa9e4066Sahrens */ 327fa9e4066Sahrens lwb = kmem_cache_alloc(zil_lwb_cache, KM_SLEEP); 328fa9e4066Sahrens lwb->lwb_zilog = zilog; 329fa9e4066Sahrens lwb->lwb_blk = blk; 330fa9e4066Sahrens lwb->lwb_nused = 0; 331fa9e4066Sahrens lwb->lwb_sz = BP_GET_LSIZE(&lwb->lwb_blk); 332fa9e4066Sahrens lwb->lwb_buf = zio_buf_alloc(lwb->lwb_sz); 333fa9e4066Sahrens lwb->lwb_max_txg = txg; 334fa9e4066Sahrens lwb->lwb_seq = 0; 335fa9e4066Sahrens lwb->lwb_state = UNWRITTEN; 336fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 337fa9e4066Sahrens list_insert_tail(&zilog->zl_lwb_list, lwb); 338fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 339fa9e4066Sahrens } 340fa9e4066Sahrens 341fa9e4066Sahrens dmu_tx_commit(tx); 342*13f5297eSperrin if (no_blk) 343*13f5297eSperrin txg_wait_synced(zilog->zl_dmu_pool, txg); 344fa9e4066Sahrens } 345fa9e4066Sahrens 346fa9e4066Sahrens /* 347fa9e4066Sahrens * In one tx, free all log blocks and clear the log header. 348fa9e4066Sahrens */ 349fa9e4066Sahrens void 350fa9e4066Sahrens zil_destroy(zilog_t *zilog) 351fa9e4066Sahrens { 352fa9e4066Sahrens dmu_tx_t *tx; 353fa9e4066Sahrens uint64_t txg; 354fa9e4066Sahrens 355fa9e4066Sahrens mutex_enter(&zilog->zl_destroy_lock); 356fa9e4066Sahrens 357fa9e4066Sahrens if (BP_IS_HOLE(&zilog->zl_header->zh_log)) { 358fa9e4066Sahrens mutex_exit(&zilog->zl_destroy_lock); 359fa9e4066Sahrens return; 360fa9e4066Sahrens } 361fa9e4066Sahrens 362fa9e4066Sahrens tx = dmu_tx_create(zilog->zl_os); 363fa9e4066Sahrens (void) dmu_tx_assign(tx, TXG_WAIT); 364fa9e4066Sahrens dsl_dataset_dirty(dmu_objset_ds(zilog->zl_os), tx); 365fa9e4066Sahrens txg = dmu_tx_get_txg(tx); 366fa9e4066Sahrens 367fa9e4066Sahrens zil_parse(zilog, zil_free_log_block, zil_free_log_record, tx, 368fa9e4066Sahrens zilog->zl_header->zh_claim_txg); 369*13f5297eSperrin /* 370*13f5297eSperrin * zil_sync clears the zil header as soon as the zl_destroy_txg commits 371*13f5297eSperrin */ 372fa9e4066Sahrens zilog->zl_destroy_txg = txg; 373fa9e4066Sahrens 374fa9e4066Sahrens dmu_tx_commit(tx); 375fa9e4066Sahrens txg_wait_synced(zilog->zl_dmu_pool, txg); 376fa9e4066Sahrens 377fa9e4066Sahrens mutex_exit(&zilog->zl_destroy_lock); 378fa9e4066Sahrens } 379fa9e4066Sahrens 380fa9e4066Sahrens void 381fa9e4066Sahrens zil_claim(char *osname, void *txarg) 382fa9e4066Sahrens { 383fa9e4066Sahrens dmu_tx_t *tx = txarg; 384fa9e4066Sahrens uint64_t first_txg = dmu_tx_get_txg(tx); 385fa9e4066Sahrens zilog_t *zilog; 386fa9e4066Sahrens zil_header_t *zh; 387fa9e4066Sahrens objset_t *os; 388fa9e4066Sahrens int error; 389fa9e4066Sahrens 390fa9e4066Sahrens error = dmu_objset_open(osname, DMU_OST_ANY, DS_MODE_STANDARD, &os); 391fa9e4066Sahrens if (error) { 392fa9e4066Sahrens cmn_err(CE_WARN, "can't process intent log for %s", osname); 393fa9e4066Sahrens return; 394fa9e4066Sahrens } 395fa9e4066Sahrens 396fa9e4066Sahrens zilog = dmu_objset_zil(os); 397fa9e4066Sahrens zh = zilog->zl_header; 398fa9e4066Sahrens 399fa9e4066Sahrens /* 400fa9e4066Sahrens * Claim all log blocks if we haven't already done so. 401fa9e4066Sahrens */ 402fa9e4066Sahrens ASSERT3U(zh->zh_claim_txg, <=, first_txg); 403fa9e4066Sahrens if (zh->zh_claim_txg == 0 && !BP_IS_HOLE(&zh->zh_log)) { 404fa9e4066Sahrens zh->zh_claim_txg = first_txg; 405fa9e4066Sahrens zil_parse(zilog, zil_claim_log_block, zil_claim_log_record, 406fa9e4066Sahrens tx, first_txg); 407fa9e4066Sahrens dsl_dataset_dirty(dmu_objset_ds(os), tx); 408fa9e4066Sahrens } 409fa9e4066Sahrens ASSERT3U(first_txg, ==, (spa_last_synced_txg(zilog->zl_spa) + 1)); 410fa9e4066Sahrens dmu_objset_close(os); 411fa9e4066Sahrens } 412fa9e4066Sahrens 413fa9e4066Sahrens void 414fa9e4066Sahrens zil_add_vdev(zilog_t *zilog, uint64_t vdev, uint64_t seq) 415fa9e4066Sahrens { 416fa9e4066Sahrens zil_vdev_t *zv; 417fa9e4066Sahrens 418fa9e4066Sahrens if (zil_noflush) 419fa9e4066Sahrens return; 420fa9e4066Sahrens 421fa9e4066Sahrens ASSERT(MUTEX_HELD(&zilog->zl_lock)); 422fa9e4066Sahrens zv = kmem_alloc(sizeof (zil_vdev_t), KM_SLEEP); 423fa9e4066Sahrens zv->vdev = vdev; 424fa9e4066Sahrens zv->seq = seq; 425fa9e4066Sahrens list_insert_tail(&zilog->zl_vdev_list, zv); 426fa9e4066Sahrens } 427fa9e4066Sahrens 428fa9e4066Sahrens void 429fa9e4066Sahrens zil_flush_vdevs(zilog_t *zilog, uint64_t seq) 430fa9e4066Sahrens { 431fa9e4066Sahrens vdev_t *vd; 432fa9e4066Sahrens zil_vdev_t *zv, *zv2; 433fa9e4066Sahrens zio_t *zio; 434fa9e4066Sahrens spa_t *spa; 435fa9e4066Sahrens uint64_t vdev; 436fa9e4066Sahrens 437fa9e4066Sahrens if (zil_noflush) 438fa9e4066Sahrens return; 439fa9e4066Sahrens 440fa9e4066Sahrens ASSERT(MUTEX_HELD(&zilog->zl_lock)); 441fa9e4066Sahrens 442fa9e4066Sahrens spa = zilog->zl_spa; 443fa9e4066Sahrens zio = NULL; 444fa9e4066Sahrens 445fa9e4066Sahrens while ((zv = list_head(&zilog->zl_vdev_list)) != NULL && 446fa9e4066Sahrens zv->seq <= seq) { 447fa9e4066Sahrens vdev = zv->vdev; 448fa9e4066Sahrens list_remove(&zilog->zl_vdev_list, zv); 449fa9e4066Sahrens kmem_free(zv, sizeof (zil_vdev_t)); 450fa9e4066Sahrens 451fa9e4066Sahrens /* 452fa9e4066Sahrens * remove all chained entries <= seq with same vdev 453fa9e4066Sahrens */ 454fa9e4066Sahrens zv = list_head(&zilog->zl_vdev_list); 455fa9e4066Sahrens while (zv && zv->seq <= seq) { 456fa9e4066Sahrens zv2 = list_next(&zilog->zl_vdev_list, zv); 457fa9e4066Sahrens if (zv->vdev == vdev) { 458fa9e4066Sahrens list_remove(&zilog->zl_vdev_list, zv); 459fa9e4066Sahrens kmem_free(zv, sizeof (zil_vdev_t)); 460fa9e4066Sahrens } 461fa9e4066Sahrens zv = zv2; 462fa9e4066Sahrens } 463fa9e4066Sahrens 464fa9e4066Sahrens /* flush the write cache for this vdev */ 465fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 466fa9e4066Sahrens if (zio == NULL) 467fa9e4066Sahrens zio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL); 468fa9e4066Sahrens vd = vdev_lookup_top(spa, vdev); 469fa9e4066Sahrens ASSERT(vd); 470fa9e4066Sahrens (void) zio_nowait(zio_ioctl(zio, spa, vd, DKIOCFLUSHWRITECACHE, 471fa9e4066Sahrens NULL, NULL, ZIO_PRIORITY_NOW, 472fa9e4066Sahrens ZIO_FLAG_CANFAIL | ZIO_FLAG_DONT_RETRY)); 473fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 474fa9e4066Sahrens } 475fa9e4066Sahrens 476fa9e4066Sahrens /* 477fa9e4066Sahrens * Wait for all the flushes to complete. Not all devices actually 478fa9e4066Sahrens * support the DKIOCFLUSHWRITECACHE ioctl, so it's OK if it fails. 479fa9e4066Sahrens */ 48022ac5be4Sperrin if (zio != NULL) { 48122ac5be4Sperrin mutex_exit(&zilog->zl_lock); 482fa9e4066Sahrens (void) zio_wait(zio); 48322ac5be4Sperrin mutex_enter(&zilog->zl_lock); 48422ac5be4Sperrin } 485fa9e4066Sahrens } 486fa9e4066Sahrens 487fa9e4066Sahrens /* 488fa9e4066Sahrens * Function called when a log block write completes 489fa9e4066Sahrens */ 490fa9e4066Sahrens static void 491fa9e4066Sahrens zil_lwb_write_done(zio_t *zio) 492fa9e4066Sahrens { 493fa9e4066Sahrens lwb_t *prev; 494fa9e4066Sahrens lwb_t *lwb = zio->io_private; 495fa9e4066Sahrens zilog_t *zilog = lwb->lwb_zilog; 496fa9e4066Sahrens uint64_t max_seq; 497fa9e4066Sahrens 498fa9e4066Sahrens /* 499fa9e4066Sahrens * Now that we've written this log block, we have a stable pointer 500fa9e4066Sahrens * to the next block in the chain, so it's OK to let the txg in 501fa9e4066Sahrens * which we allocated the next block sync. 502fa9e4066Sahrens */ 503fa9e4066Sahrens txg_rele_to_sync(&lwb->lwb_txgh); 504fa9e4066Sahrens 505fa9e4066Sahrens zio_buf_free(lwb->lwb_buf, lwb->lwb_sz); 506fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 507fa9e4066Sahrens lwb->lwb_buf = NULL; 508fa9e4066Sahrens if (zio->io_error) { 509fa9e4066Sahrens zilog->zl_log_error = B_TRUE; 510fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 511fa9e4066Sahrens cv_broadcast(&zilog->zl_cv_seq); 512fa9e4066Sahrens return; 513fa9e4066Sahrens } 514fa9e4066Sahrens 515fa9e4066Sahrens prev = list_prev(&zilog->zl_lwb_list, lwb); 516fa9e4066Sahrens if (prev && prev->lwb_state != SEQ_COMPLETE) { 517fa9e4066Sahrens /* There's an unwritten buffer in the chain before this one */ 518fa9e4066Sahrens lwb->lwb_state = SEQ_INCOMPLETE; 519fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 520fa9e4066Sahrens return; 521fa9e4066Sahrens } 522fa9e4066Sahrens 523fa9e4066Sahrens max_seq = lwb->lwb_seq; 524fa9e4066Sahrens lwb->lwb_state = SEQ_COMPLETE; 525fa9e4066Sahrens /* 526fa9e4066Sahrens * We must also follow up the chain for already written buffers 527fa9e4066Sahrens * to see if we can set zl_ss_seq even higher. 528fa9e4066Sahrens */ 529fa9e4066Sahrens while (lwb = list_next(&zilog->zl_lwb_list, lwb)) { 530fa9e4066Sahrens if (lwb->lwb_state != SEQ_INCOMPLETE) 531fa9e4066Sahrens break; 532fa9e4066Sahrens lwb->lwb_state = SEQ_COMPLETE; 533fa9e4066Sahrens /* lwb_seq will be zero if we've written an empty buffer */ 534fa9e4066Sahrens if (lwb->lwb_seq) { 535fa9e4066Sahrens ASSERT3U(max_seq, <, lwb->lwb_seq); 536fa9e4066Sahrens max_seq = lwb->lwb_seq; 537fa9e4066Sahrens } 538fa9e4066Sahrens } 539fa9e4066Sahrens zilog->zl_ss_seq = MAX(max_seq, zilog->zl_ss_seq); 540fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 541fa9e4066Sahrens cv_broadcast(&zilog->zl_cv_seq); 542fa9e4066Sahrens } 543fa9e4066Sahrens 544fa9e4066Sahrens /* 545fa9e4066Sahrens * Start a log block write and advance to the next log block. 546fa9e4066Sahrens * Calls are serialized. 547fa9e4066Sahrens */ 548fa9e4066Sahrens static lwb_t * 549fa9e4066Sahrens zil_lwb_write_start(zilog_t *zilog, lwb_t *lwb) 550fa9e4066Sahrens { 551fa9e4066Sahrens lwb_t *nlwb; 552fa9e4066Sahrens zil_trailer_t *ztp = (zil_trailer_t *)(lwb->lwb_buf + lwb->lwb_sz) - 1; 553fa9e4066Sahrens uint64_t txg; 554fa9e4066Sahrens uint64_t zil_blksz; 555fa9e4066Sahrens int error; 556fa9e4066Sahrens 557fa9e4066Sahrens ASSERT(lwb->lwb_nused <= ZIL_BLK_DATA_SZ(lwb)); 558fa9e4066Sahrens 559fa9e4066Sahrens /* 560fa9e4066Sahrens * Allocate the next block and save its address in this block 561fa9e4066Sahrens * before writing it in order to establish the log chain. 562fa9e4066Sahrens * Note that if the allocation of nlwb synced before we wrote 563fa9e4066Sahrens * the block that points at it (lwb), we'd leak it if we crashed. 564fa9e4066Sahrens * Therefore, we don't do txg_rele_to_sync() until zil_lwb_write_done(). 565fa9e4066Sahrens */ 566fa9e4066Sahrens txg = txg_hold_open(zilog->zl_dmu_pool, &lwb->lwb_txgh); 567fa9e4066Sahrens txg_rele_to_quiesce(&lwb->lwb_txgh); 568fa9e4066Sahrens 569fa9e4066Sahrens /* 57022ac5be4Sperrin * Pick a ZIL blocksize. We request a size that is the 57122ac5be4Sperrin * maximum of the previous used size, the current used size and 57222ac5be4Sperrin * the amount waiting in the queue. 573fa9e4066Sahrens */ 57422ac5be4Sperrin zil_blksz = MAX(zilog->zl_cur_used, zilog->zl_prev_used); 57522ac5be4Sperrin zil_blksz = MAX(zil_blksz, zilog->zl_itx_list_sz + sizeof (*ztp)); 57622ac5be4Sperrin zil_blksz = P2ROUNDUP(zil_blksz, ZIL_MIN_BLKSZ); 57722ac5be4Sperrin if (zil_blksz > ZIL_MAX_BLKSZ) 57822ac5be4Sperrin zil_blksz = ZIL_MAX_BLKSZ; 579fa9e4066Sahrens 580fa9e4066Sahrens error = zio_alloc_blk(zilog->zl_spa, ZIO_CHECKSUM_ZILOG, 581fa9e4066Sahrens zil_blksz, &ztp->zit_next_blk, txg); 582fa9e4066Sahrens if (error) { 583fa9e4066Sahrens txg_rele_to_sync(&lwb->lwb_txgh); 584fa9e4066Sahrens return (NULL); 585fa9e4066Sahrens } 586fa9e4066Sahrens 587fa9e4066Sahrens ASSERT3U(ztp->zit_next_blk.blk_birth, ==, txg); 588fa9e4066Sahrens ztp->zit_nused = lwb->lwb_nused; 589fa9e4066Sahrens ztp->zit_bt.zbt_cksum = lwb->lwb_blk.blk_cksum; 590fa9e4066Sahrens ztp->zit_next_blk.blk_cksum = lwb->lwb_blk.blk_cksum; 591fa9e4066Sahrens ztp->zit_next_blk.blk_cksum.zc_word[3]++; 592fa9e4066Sahrens 593fa9e4066Sahrens /* 594fa9e4066Sahrens * Allocate a new log write buffer (lwb). 595fa9e4066Sahrens */ 596fa9e4066Sahrens nlwb = kmem_cache_alloc(zil_lwb_cache, KM_SLEEP); 597fa9e4066Sahrens 598fa9e4066Sahrens nlwb->lwb_zilog = zilog; 599fa9e4066Sahrens nlwb->lwb_blk = ztp->zit_next_blk; 600fa9e4066Sahrens nlwb->lwb_nused = 0; 601fa9e4066Sahrens nlwb->lwb_sz = BP_GET_LSIZE(&nlwb->lwb_blk); 602fa9e4066Sahrens nlwb->lwb_buf = zio_buf_alloc(nlwb->lwb_sz); 603fa9e4066Sahrens nlwb->lwb_max_txg = txg; 604fa9e4066Sahrens nlwb->lwb_seq = 0; 605fa9e4066Sahrens nlwb->lwb_state = UNWRITTEN; 606fa9e4066Sahrens 607fa9e4066Sahrens /* 608fa9e4066Sahrens * Put new lwb at the end of the log chain, 609fa9e4066Sahrens * and record the vdev for later flushing 610fa9e4066Sahrens */ 611fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 612fa9e4066Sahrens list_insert_tail(&zilog->zl_lwb_list, nlwb); 613fa9e4066Sahrens zil_add_vdev(zilog, DVA_GET_VDEV(BP_IDENTITY(&(lwb->lwb_blk))), 614fa9e4066Sahrens lwb->lwb_seq); 615fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 616fa9e4066Sahrens 617fa9e4066Sahrens /* 618fa9e4066Sahrens * write the old log block 619fa9e4066Sahrens */ 620fa9e4066Sahrens dprintf_bp(&lwb->lwb_blk, "lwb %p txg %llu: ", lwb, txg); 621fa9e4066Sahrens zio_nowait(zio_rewrite(NULL, zilog->zl_spa, ZIO_CHECKSUM_ZILOG, 0, 622fa9e4066Sahrens &lwb->lwb_blk, lwb->lwb_buf, lwb->lwb_sz, zil_lwb_write_done, lwb, 623fa9e4066Sahrens ZIO_PRIORITY_LOG_WRITE, ZIO_FLAG_MUSTSUCCEED)); 624fa9e4066Sahrens 625fa9e4066Sahrens return (nlwb); 626fa9e4066Sahrens } 627fa9e4066Sahrens 628fa9e4066Sahrens static lwb_t * 629fa9e4066Sahrens zil_lwb_commit(zilog_t *zilog, itx_t *itx, lwb_t *lwb) 630fa9e4066Sahrens { 631fa9e4066Sahrens lr_t *lrc = &itx->itx_lr; /* common log record */ 632fa9e4066Sahrens uint64_t seq = lrc->lrc_seq; 633fa9e4066Sahrens uint64_t txg = lrc->lrc_txg; 634fa9e4066Sahrens uint64_t reclen = lrc->lrc_reclen; 635fa9e4066Sahrens int error; 636fa9e4066Sahrens 637fa9e4066Sahrens if (lwb == NULL) 638fa9e4066Sahrens return (NULL); 639fa9e4066Sahrens ASSERT(lwb->lwb_buf != NULL); 640fa9e4066Sahrens 641fa9e4066Sahrens /* 642fa9e4066Sahrens * If it's a write, fetch the data or get its blkptr as appropriate. 643fa9e4066Sahrens */ 644fa9e4066Sahrens if (lrc->lrc_txtype == TX_WRITE) { 645fa9e4066Sahrens lr_write_t *lr = (lr_write_t *)lrc; 646fa9e4066Sahrens if (txg > spa_freeze_txg(zilog->zl_spa)) 647fa9e4066Sahrens txg_wait_synced(zilog->zl_dmu_pool, txg); 648fa9e4066Sahrens 649fa9e4066Sahrens if (!itx->itx_data_copied && 650fa9e4066Sahrens (error = zilog->zl_get_data(itx->itx_private, lr)) != 0) { 651fa9e4066Sahrens if (error != ENOENT && error != EALREADY) { 652fa9e4066Sahrens txg_wait_synced(zilog->zl_dmu_pool, txg); 653fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 654fa9e4066Sahrens zilog->zl_ss_seq = MAX(seq, zilog->zl_ss_seq); 655fa9e4066Sahrens zil_add_vdev(zilog, 656fa9e4066Sahrens DVA_GET_VDEV(BP_IDENTITY(&(lr->lr_blkptr))), 657fa9e4066Sahrens seq); 658fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 659fa9e4066Sahrens return (lwb); 660fa9e4066Sahrens } 661fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 662fa9e4066Sahrens zil_add_vdev(zilog, 663fa9e4066Sahrens DVA_GET_VDEV(BP_IDENTITY(&(lr->lr_blkptr))), seq); 664fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 665fa9e4066Sahrens return (lwb); 666fa9e4066Sahrens } 667fa9e4066Sahrens } 668fa9e4066Sahrens 66922ac5be4Sperrin zilog->zl_cur_used += reclen; 67022ac5be4Sperrin 671fa9e4066Sahrens /* 672fa9e4066Sahrens * If this record won't fit in the current log block, start a new one. 673fa9e4066Sahrens */ 674fa9e4066Sahrens if (lwb->lwb_nused + reclen > ZIL_BLK_DATA_SZ(lwb)) { 675fa9e4066Sahrens lwb = zil_lwb_write_start(zilog, lwb); 676fa9e4066Sahrens if (lwb == NULL) 677fa9e4066Sahrens return (NULL); 678fa9e4066Sahrens if (lwb->lwb_nused + reclen > ZIL_BLK_DATA_SZ(lwb)) { 679fa9e4066Sahrens txg_wait_synced(zilog->zl_dmu_pool, txg); 680fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 681fa9e4066Sahrens zilog->zl_ss_seq = MAX(seq, zilog->zl_ss_seq); 682fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 683fa9e4066Sahrens return (lwb); 684fa9e4066Sahrens } 685fa9e4066Sahrens } 686fa9e4066Sahrens 687fa9e4066Sahrens bcopy(lrc, lwb->lwb_buf + lwb->lwb_nused, reclen); 688fa9e4066Sahrens lwb->lwb_nused += reclen; 689fa9e4066Sahrens lwb->lwb_max_txg = MAX(lwb->lwb_max_txg, txg); 690fa9e4066Sahrens ASSERT3U(lwb->lwb_seq, <, seq); 691fa9e4066Sahrens lwb->lwb_seq = seq; 692fa9e4066Sahrens ASSERT3U(lwb->lwb_nused, <=, ZIL_BLK_DATA_SZ(lwb)); 693fa9e4066Sahrens ASSERT3U(P2PHASE(lwb->lwb_nused, sizeof (uint64_t)), ==, 0); 694fa9e4066Sahrens 695fa9e4066Sahrens return (lwb); 696fa9e4066Sahrens } 697fa9e4066Sahrens 698fa9e4066Sahrens itx_t * 699fa9e4066Sahrens zil_itx_create(int txtype, size_t lrsize) 700fa9e4066Sahrens { 701fa9e4066Sahrens itx_t *itx; 702fa9e4066Sahrens 703fa9e4066Sahrens lrsize = P2ROUNDUP(lrsize, sizeof (uint64_t)); 704fa9e4066Sahrens 705fa9e4066Sahrens itx = kmem_alloc(offsetof(itx_t, itx_lr) + lrsize, KM_SLEEP); 706fa9e4066Sahrens itx->itx_lr.lrc_txtype = txtype; 707fa9e4066Sahrens itx->itx_lr.lrc_reclen = lrsize; 708fa9e4066Sahrens itx->itx_lr.lrc_seq = 0; /* defensive */ 709fa9e4066Sahrens 710fa9e4066Sahrens return (itx); 711fa9e4066Sahrens } 712fa9e4066Sahrens 713fa9e4066Sahrens uint64_t 714fa9e4066Sahrens zil_itx_assign(zilog_t *zilog, itx_t *itx, dmu_tx_t *tx) 715fa9e4066Sahrens { 716fa9e4066Sahrens uint64_t seq; 717fa9e4066Sahrens 718fa9e4066Sahrens ASSERT(itx->itx_lr.lrc_seq == 0); 719fa9e4066Sahrens 720fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 721fa9e4066Sahrens list_insert_tail(&zilog->zl_itx_list, itx); 722fa9e4066Sahrens zilog->zl_itx_list_sz += itx->itx_lr.lrc_reclen; 723fa9e4066Sahrens itx->itx_lr.lrc_txg = dmu_tx_get_txg(tx); 724fa9e4066Sahrens itx->itx_lr.lrc_seq = seq = ++zilog->zl_itx_seq; 725fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 726fa9e4066Sahrens 727fa9e4066Sahrens return (seq); 728fa9e4066Sahrens } 729fa9e4066Sahrens 730fa9e4066Sahrens /* 731fa9e4066Sahrens * Free up all in-memory intent log transactions that have now been synced. 732fa9e4066Sahrens */ 733fa9e4066Sahrens static void 734fa9e4066Sahrens zil_itx_clean(zilog_t *zilog) 735fa9e4066Sahrens { 736fa9e4066Sahrens uint64_t synced_txg = spa_last_synced_txg(zilog->zl_spa); 737fa9e4066Sahrens uint64_t freeze_txg = spa_freeze_txg(zilog->zl_spa); 738fa9e4066Sahrens uint64_t max_seq = 0; 739fa9e4066Sahrens itx_t *itx; 740fa9e4066Sahrens 741fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 742fa9e4066Sahrens while ((itx = list_head(&zilog->zl_itx_list)) != NULL && 743fa9e4066Sahrens itx->itx_lr.lrc_txg <= MIN(synced_txg, freeze_txg)) { 744fa9e4066Sahrens list_remove(&zilog->zl_itx_list, itx); 745fa9e4066Sahrens zilog->zl_itx_list_sz -= itx->itx_lr.lrc_reclen; 746fa9e4066Sahrens ASSERT3U(max_seq, <, itx->itx_lr.lrc_seq); 747fa9e4066Sahrens max_seq = itx->itx_lr.lrc_seq; 748fa9e4066Sahrens kmem_free(itx, offsetof(itx_t, itx_lr) 749fa9e4066Sahrens + itx->itx_lr.lrc_reclen); 750fa9e4066Sahrens } 751fa9e4066Sahrens if (max_seq > zilog->zl_ss_seq) { 752fa9e4066Sahrens zilog->zl_ss_seq = max_seq; 753fa9e4066Sahrens cv_broadcast(&zilog->zl_cv_seq); 754fa9e4066Sahrens } 755fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 756fa9e4066Sahrens } 757fa9e4066Sahrens 758fa9e4066Sahrens void 759fa9e4066Sahrens zil_clean(zilog_t *zilog) 760fa9e4066Sahrens { 761fa9e4066Sahrens /* 762fa9e4066Sahrens * Check for any log blocks that can be freed. 763fa9e4066Sahrens * Log blocks are only freed when the log block allocation and 764fa9e4066Sahrens * log records contained within are both known to be committed. 765fa9e4066Sahrens */ 766fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 767fa9e4066Sahrens if (list_head(&zilog->zl_itx_list) != NULL) 768fa9e4066Sahrens (void) taskq_dispatch(zilog->zl_clean_taskq, 769fa9e4066Sahrens (void (*)(void *))zil_itx_clean, zilog, TQ_NOSLEEP); 770fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 771fa9e4066Sahrens } 772fa9e4066Sahrens 773fa9e4066Sahrens /* 774fa9e4066Sahrens * Push zfs transactions to stable storage up to the supplied sequence number. 775fa9e4066Sahrens */ 776fa9e4066Sahrens void 777fa9e4066Sahrens zil_commit(zilog_t *zilog, uint64_t seq, int ioflag) 778fa9e4066Sahrens { 779fa9e4066Sahrens uint64_t txg; 780fa9e4066Sahrens uint64_t max_seq; 781fa9e4066Sahrens uint64_t reclen; 782fa9e4066Sahrens itx_t *itx; 783fa9e4066Sahrens lwb_t *lwb; 784fa9e4066Sahrens spa_t *spa; 785fa9e4066Sahrens 786fa9e4066Sahrens if (zilog == NULL || seq == 0 || 787fa9e4066Sahrens ((ioflag & (FSYNC | FDSYNC | FRSYNC)) == 0 && !zil_always)) 788fa9e4066Sahrens return; 789fa9e4066Sahrens 790fa9e4066Sahrens spa = zilog->zl_spa; 791fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 792fa9e4066Sahrens 793fa9e4066Sahrens seq = MIN(seq, zilog->zl_itx_seq); /* cap seq at largest itx seq */ 794fa9e4066Sahrens 795fa9e4066Sahrens for (;;) { 796fa9e4066Sahrens if (zilog->zl_ss_seq >= seq) { /* already on stable storage */ 797fa9e4066Sahrens cv_signal(&zilog->zl_cv_write); 798fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 799fa9e4066Sahrens return; 800fa9e4066Sahrens } 801fa9e4066Sahrens 802fa9e4066Sahrens if (zilog->zl_writer == B_FALSE) /* no one writing, do it */ 803fa9e4066Sahrens break; 804fa9e4066Sahrens 805fa9e4066Sahrens cv_wait(&zilog->zl_cv_write, &zilog->zl_lock); 806fa9e4066Sahrens } 807fa9e4066Sahrens 808fa9e4066Sahrens zilog->zl_writer = B_TRUE; 809fa9e4066Sahrens max_seq = 0; 810fa9e4066Sahrens 811fa9e4066Sahrens if (zilog->zl_suspend) { 812fa9e4066Sahrens lwb = NULL; 813fa9e4066Sahrens } else { 814fa9e4066Sahrens lwb = list_tail(&zilog->zl_lwb_list); 815fa9e4066Sahrens if (lwb == NULL) { 816fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 817fa9e4066Sahrens zil_create(zilog); 818fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 819fa9e4066Sahrens lwb = list_tail(&zilog->zl_lwb_list); 820fa9e4066Sahrens } 821fa9e4066Sahrens } 822fa9e4066Sahrens 823fa9e4066Sahrens /* 824fa9e4066Sahrens * Loop through in-memory log transactions filling log blocks, 825fa9e4066Sahrens * until we reach the given sequence number and there's no more 826fa9e4066Sahrens * room in the write buffer. 827fa9e4066Sahrens */ 828fa9e4066Sahrens for (;;) { 829fa9e4066Sahrens itx = list_head(&zilog->zl_itx_list); 830fa9e4066Sahrens if (itx == NULL) 831fa9e4066Sahrens break; 832fa9e4066Sahrens 833fa9e4066Sahrens reclen = itx->itx_lr.lrc_reclen; 834fa9e4066Sahrens if ((itx->itx_lr.lrc_seq > seq) && 835fa9e4066Sahrens ((lwb == NULL) || (lwb->lwb_nused + reclen > 836fa9e4066Sahrens ZIL_BLK_DATA_SZ(lwb)))) 837fa9e4066Sahrens break; 838fa9e4066Sahrens 839fa9e4066Sahrens list_remove(&zilog->zl_itx_list, itx); 840fa9e4066Sahrens txg = itx->itx_lr.lrc_txg; 841fa9e4066Sahrens ASSERT(txg); 842fa9e4066Sahrens 843fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 844fa9e4066Sahrens if (txg > spa_last_synced_txg(spa) || 845fa9e4066Sahrens txg > spa_freeze_txg(spa)) 846fa9e4066Sahrens lwb = zil_lwb_commit(zilog, itx, lwb); 847fa9e4066Sahrens else 848fa9e4066Sahrens max_seq = itx->itx_lr.lrc_seq; 849fa9e4066Sahrens kmem_free(itx, offsetof(itx_t, itx_lr) 850fa9e4066Sahrens + itx->itx_lr.lrc_reclen); 851fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 852fa9e4066Sahrens zilog->zl_itx_list_sz -= reclen; 853fa9e4066Sahrens } 854fa9e4066Sahrens 855fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 856fa9e4066Sahrens 857fa9e4066Sahrens /* write the last block out */ 858fa9e4066Sahrens if (lwb != NULL && lwb->lwb_nused != 0) 859fa9e4066Sahrens lwb = zil_lwb_write_start(zilog, lwb); 860fa9e4066Sahrens 86122ac5be4Sperrin zilog->zl_prev_used = zilog->zl_cur_used; 86222ac5be4Sperrin zilog->zl_cur_used = 0; 863fa9e4066Sahrens 86422ac5be4Sperrin mutex_enter(&zilog->zl_lock); 865fa9e4066Sahrens if (max_seq > zilog->zl_ss_seq) { 866fa9e4066Sahrens zilog->zl_ss_seq = max_seq; 867fa9e4066Sahrens cv_broadcast(&zilog->zl_cv_seq); 868fa9e4066Sahrens } 869fa9e4066Sahrens /* 870fa9e4066Sahrens * Wait if necessary for our seq to be committed. 871fa9e4066Sahrens */ 872fa9e4066Sahrens if (lwb) { 873fa9e4066Sahrens while (zilog->zl_ss_seq < seq && zilog->zl_log_error == 0) 874fa9e4066Sahrens cv_wait(&zilog->zl_cv_seq, &zilog->zl_lock); 875fa9e4066Sahrens zil_flush_vdevs(zilog, seq); 876fa9e4066Sahrens } 87722ac5be4Sperrin 878fa9e4066Sahrens if (zilog->zl_log_error || lwb == NULL) { 879fa9e4066Sahrens zilog->zl_log_error = 0; 880fa9e4066Sahrens max_seq = zilog->zl_itx_seq; 881fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 882fa9e4066Sahrens txg_wait_synced(zilog->zl_dmu_pool, 0); 883fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 884fa9e4066Sahrens zilog->zl_ss_seq = MAX(max_seq, zilog->zl_ss_seq); 885fa9e4066Sahrens cv_broadcast(&zilog->zl_cv_seq); 886fa9e4066Sahrens } 88722ac5be4Sperrin /* wake up others waiting to start a write */ 88822ac5be4Sperrin zilog->zl_writer = B_FALSE; 889fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 89022ac5be4Sperrin cv_signal(&zilog->zl_cv_write); 891fa9e4066Sahrens } 892fa9e4066Sahrens 893fa9e4066Sahrens /* 894fa9e4066Sahrens * Called in syncing context to free committed log blocks and update log header. 895fa9e4066Sahrens */ 896fa9e4066Sahrens void 897fa9e4066Sahrens zil_sync(zilog_t *zilog, dmu_tx_t *tx) 898fa9e4066Sahrens { 899fa9e4066Sahrens uint64_t txg = dmu_tx_get_txg(tx); 900fa9e4066Sahrens spa_t *spa = zilog->zl_spa; 901fa9e4066Sahrens lwb_t *lwb; 902fa9e4066Sahrens 903fa9e4066Sahrens ASSERT(zilog->zl_stop_sync == 0); 904fa9e4066Sahrens 905fa9e4066Sahrens zilog->zl_header->zh_replay_seq = zilog->zl_replay_seq[txg & TXG_MASK]; 906fa9e4066Sahrens 907fa9e4066Sahrens if (zilog->zl_destroy_txg == txg) { 908fa9e4066Sahrens bzero(zilog->zl_header, sizeof (zil_header_t)); 909fa9e4066Sahrens bzero(zilog->zl_replay_seq, sizeof (zilog->zl_replay_seq)); 910fa9e4066Sahrens zilog->zl_destroy_txg = 0; 911fa9e4066Sahrens } 912fa9e4066Sahrens 913fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 914fa9e4066Sahrens for (;;) { 915fa9e4066Sahrens lwb = list_head(&zilog->zl_lwb_list); 916fa9e4066Sahrens if (lwb == NULL) { 917fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 918fa9e4066Sahrens return; 919fa9e4066Sahrens } 920fa9e4066Sahrens if (lwb->lwb_buf != NULL || lwb->lwb_max_txg > txg) 921fa9e4066Sahrens break; 922fa9e4066Sahrens list_remove(&zilog->zl_lwb_list, lwb); 923fa9e4066Sahrens zio_free_blk(spa, &lwb->lwb_blk, txg); 924fa9e4066Sahrens kmem_cache_free(zil_lwb_cache, lwb); 925fa9e4066Sahrens } 926fa9e4066Sahrens zilog->zl_header->zh_log = lwb->lwb_blk; 927fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 928fa9e4066Sahrens } 929fa9e4066Sahrens 930fa9e4066Sahrens void 931fa9e4066Sahrens zil_init(void) 932fa9e4066Sahrens { 933fa9e4066Sahrens zil_lwb_cache = kmem_cache_create("zil_lwb_cache", 934fa9e4066Sahrens sizeof (struct lwb), NULL, NULL, NULL, NULL, NULL, NULL, 0); 935fa9e4066Sahrens } 936fa9e4066Sahrens 937fa9e4066Sahrens void 938fa9e4066Sahrens zil_fini(void) 939fa9e4066Sahrens { 940fa9e4066Sahrens kmem_cache_destroy(zil_lwb_cache); 941fa9e4066Sahrens } 942fa9e4066Sahrens 943fa9e4066Sahrens zilog_t * 944fa9e4066Sahrens zil_alloc(objset_t *os, zil_header_t *zh_phys) 945fa9e4066Sahrens { 946fa9e4066Sahrens zilog_t *zilog; 947fa9e4066Sahrens 948fa9e4066Sahrens zilog = kmem_zalloc(sizeof (zilog_t), KM_SLEEP); 949fa9e4066Sahrens 950fa9e4066Sahrens zilog->zl_header = zh_phys; 951fa9e4066Sahrens zilog->zl_os = os; 952fa9e4066Sahrens zilog->zl_spa = dmu_objset_spa(os); 953fa9e4066Sahrens zilog->zl_dmu_pool = dmu_objset_pool(os); 954fa9e4066Sahrens 955fa9e4066Sahrens list_create(&zilog->zl_itx_list, sizeof (itx_t), 956fa9e4066Sahrens offsetof(itx_t, itx_node)); 957fa9e4066Sahrens 958fa9e4066Sahrens list_create(&zilog->zl_lwb_list, sizeof (lwb_t), 959fa9e4066Sahrens offsetof(lwb_t, lwb_node)); 960fa9e4066Sahrens 961fa9e4066Sahrens list_create(&zilog->zl_vdev_list, sizeof (zil_vdev_t), 962fa9e4066Sahrens offsetof(zil_vdev_t, vdev_seq_node)); 963fa9e4066Sahrens 964fa9e4066Sahrens return (zilog); 965fa9e4066Sahrens } 966fa9e4066Sahrens 967fa9e4066Sahrens void 968fa9e4066Sahrens zil_free(zilog_t *zilog) 969fa9e4066Sahrens { 970fa9e4066Sahrens lwb_t *lwb; 971fa9e4066Sahrens zil_vdev_t *zv; 972fa9e4066Sahrens 973fa9e4066Sahrens zilog->zl_stop_sync = 1; 974fa9e4066Sahrens 975fa9e4066Sahrens while ((lwb = list_head(&zilog->zl_lwb_list)) != NULL) { 976fa9e4066Sahrens list_remove(&zilog->zl_lwb_list, lwb); 977fa9e4066Sahrens if (lwb->lwb_buf != NULL) 978fa9e4066Sahrens zio_buf_free(lwb->lwb_buf, lwb->lwb_sz); 979fa9e4066Sahrens kmem_cache_free(zil_lwb_cache, lwb); 980fa9e4066Sahrens } 981fa9e4066Sahrens list_destroy(&zilog->zl_lwb_list); 982fa9e4066Sahrens 983fa9e4066Sahrens while ((zv = list_head(&zilog->zl_vdev_list)) != NULL) { 984fa9e4066Sahrens list_remove(&zilog->zl_vdev_list, zv); 985fa9e4066Sahrens kmem_free(zv, sizeof (zil_vdev_t)); 986fa9e4066Sahrens } 987fa9e4066Sahrens list_destroy(&zilog->zl_vdev_list); 988fa9e4066Sahrens 989fa9e4066Sahrens ASSERT(list_head(&zilog->zl_itx_list) == NULL); 990fa9e4066Sahrens list_destroy(&zilog->zl_itx_list); 991fa9e4066Sahrens 992fa9e4066Sahrens kmem_free(zilog, sizeof (zilog_t)); 993fa9e4066Sahrens } 994fa9e4066Sahrens 995*13f5297eSperrin /* 996*13f5297eSperrin * return true if there is a valid initial zil log block 997*13f5297eSperrin */ 998*13f5297eSperrin static int 999*13f5297eSperrin zil_empty(zilog_t *zilog) 1000*13f5297eSperrin { 1001*13f5297eSperrin blkptr_t blk; 1002*13f5297eSperrin char *lrbuf; 1003*13f5297eSperrin int error; 1004*13f5297eSperrin 1005*13f5297eSperrin blk = zilog->zl_header->zh_log; 1006*13f5297eSperrin if (BP_IS_HOLE(&blk)) 1007*13f5297eSperrin return (1); 1008*13f5297eSperrin 1009*13f5297eSperrin lrbuf = zio_buf_alloc(SPA_MAXBLOCKSIZE); 1010*13f5297eSperrin error = zil_read_log_block(zilog, &blk, lrbuf); 1011*13f5297eSperrin zio_buf_free(lrbuf, SPA_MAXBLOCKSIZE); 1012*13f5297eSperrin return (error ? 1 : 0); 1013*13f5297eSperrin } 1014*13f5297eSperrin 1015fa9e4066Sahrens /* 1016fa9e4066Sahrens * Open an intent log. 1017fa9e4066Sahrens */ 1018fa9e4066Sahrens zilog_t * 1019fa9e4066Sahrens zil_open(objset_t *os, zil_get_data_t *get_data) 1020fa9e4066Sahrens { 1021fa9e4066Sahrens zilog_t *zilog = dmu_objset_zil(os); 1022fa9e4066Sahrens 1023fa9e4066Sahrens zilog->zl_get_data = get_data; 1024fa9e4066Sahrens zilog->zl_clean_taskq = taskq_create("zil_clean", 1, minclsyspri, 1025fa9e4066Sahrens 2, 2, TASKQ_PREPOPULATE); 1026fa9e4066Sahrens 1027fa9e4066Sahrens return (zilog); 1028fa9e4066Sahrens } 1029fa9e4066Sahrens 1030fa9e4066Sahrens /* 1031fa9e4066Sahrens * Close an intent log. 1032fa9e4066Sahrens */ 1033fa9e4066Sahrens void 1034fa9e4066Sahrens zil_close(zilog_t *zilog) 1035fa9e4066Sahrens { 1036*13f5297eSperrin if (!zil_empty(zilog)) 1037*13f5297eSperrin txg_wait_synced(zilog->zl_dmu_pool, 0); 1038fa9e4066Sahrens taskq_destroy(zilog->zl_clean_taskq); 1039fa9e4066Sahrens zilog->zl_clean_taskq = NULL; 1040fa9e4066Sahrens zilog->zl_get_data = NULL; 1041fa9e4066Sahrens 1042fa9e4066Sahrens zil_itx_clean(zilog); 1043fa9e4066Sahrens ASSERT(list_head(&zilog->zl_itx_list) == NULL); 1044fa9e4066Sahrens } 1045fa9e4066Sahrens 1046fa9e4066Sahrens /* 1047fa9e4066Sahrens * Suspend an intent log. While in suspended mode, we still honor 1048fa9e4066Sahrens * synchronous semantics, but we rely on txg_wait_synced() to do it. 1049fa9e4066Sahrens * We suspend the log briefly when taking a snapshot so that the snapshot 1050fa9e4066Sahrens * contains all the data it's supposed to, and has an empty intent log. 1051fa9e4066Sahrens */ 1052fa9e4066Sahrens int 1053fa9e4066Sahrens zil_suspend(zilog_t *zilog) 1054fa9e4066Sahrens { 1055fa9e4066Sahrens lwb_t *lwb; 1056fa9e4066Sahrens 1057fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 1058fa9e4066Sahrens if (zilog->zl_header->zh_claim_txg != 0) { /* unplayed log */ 1059fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 1060fa9e4066Sahrens return (EBUSY); 1061fa9e4066Sahrens } 1062fa9e4066Sahrens zilog->zl_suspend++; 1063fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 1064fa9e4066Sahrens 1065fa9e4066Sahrens zil_commit(zilog, UINT64_MAX, FSYNC); 1066fa9e4066Sahrens 1067fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 1068fa9e4066Sahrens while ((lwb = list_head(&zilog->zl_lwb_list)) != NULL) { 1069fa9e4066Sahrens if (lwb->lwb_buf != NULL) { 1070fa9e4066Sahrens /* 1071fa9e4066Sahrens * Wait for the buffer if it's in the process of 1072fa9e4066Sahrens * being written. 1073fa9e4066Sahrens */ 1074fa9e4066Sahrens if ((lwb->lwb_seq != 0) && 1075fa9e4066Sahrens (lwb->lwb_state != SEQ_COMPLETE)) { 1076fa9e4066Sahrens cv_wait(&zilog->zl_cv_seq, &zilog->zl_lock); 1077fa9e4066Sahrens continue; 1078fa9e4066Sahrens } 1079fa9e4066Sahrens zio_buf_free(lwb->lwb_buf, lwb->lwb_sz); 1080fa9e4066Sahrens } 1081fa9e4066Sahrens list_remove(&zilog->zl_lwb_list, lwb); 1082fa9e4066Sahrens kmem_cache_free(zil_lwb_cache, lwb); 1083fa9e4066Sahrens } 1084fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 1085fa9e4066Sahrens 1086fa9e4066Sahrens zil_destroy(zilog); 1087fa9e4066Sahrens 1088fa9e4066Sahrens return (0); 1089fa9e4066Sahrens } 1090fa9e4066Sahrens 1091fa9e4066Sahrens void 1092fa9e4066Sahrens zil_resume(zilog_t *zilog) 1093fa9e4066Sahrens { 1094fa9e4066Sahrens mutex_enter(&zilog->zl_lock); 1095fa9e4066Sahrens ASSERT(zilog->zl_suspend != 0); 1096fa9e4066Sahrens zilog->zl_suspend--; 1097fa9e4066Sahrens mutex_exit(&zilog->zl_lock); 1098fa9e4066Sahrens } 1099fa9e4066Sahrens 1100fa9e4066Sahrens typedef struct zil_replay_arg { 1101fa9e4066Sahrens objset_t *zr_os; 1102fa9e4066Sahrens zil_replay_func_t **zr_replay; 1103fa9e4066Sahrens void *zr_arg; 1104fa9e4066Sahrens void (*zr_rm_sync)(void *arg); 1105fa9e4066Sahrens uint64_t *zr_txgp; 1106fa9e4066Sahrens boolean_t zr_byteswap; 1107fa9e4066Sahrens char *zr_lrbuf; 1108fa9e4066Sahrens } zil_replay_arg_t; 1109fa9e4066Sahrens 1110fa9e4066Sahrens static void 1111fa9e4066Sahrens zil_replay_log_record(zilog_t *zilog, lr_t *lr, void *zra, uint64_t claim_txg) 1112fa9e4066Sahrens { 1113fa9e4066Sahrens zil_replay_arg_t *zr = zra; 1114fa9e4066Sahrens zil_header_t *zh = zilog->zl_header; 1115fa9e4066Sahrens uint64_t reclen = lr->lrc_reclen; 1116fa9e4066Sahrens uint64_t txtype = lr->lrc_txtype; 1117fa9e4066Sahrens int pass, error; 1118fa9e4066Sahrens 1119fa9e4066Sahrens if (zilog->zl_stop_replay) 1120fa9e4066Sahrens return; 1121fa9e4066Sahrens 1122fa9e4066Sahrens if (lr->lrc_txg < claim_txg) /* already committed */ 1123fa9e4066Sahrens return; 1124fa9e4066Sahrens 1125fa9e4066Sahrens if (lr->lrc_seq <= zh->zh_replay_seq) /* already replayed */ 1126fa9e4066Sahrens return; 1127fa9e4066Sahrens 1128fa9e4066Sahrens /* 1129fa9e4066Sahrens * Make a copy of the data so we can revise and extend it. 1130fa9e4066Sahrens */ 1131fa9e4066Sahrens bcopy(lr, zr->zr_lrbuf, reclen); 1132fa9e4066Sahrens 1133fa9e4066Sahrens /* 1134fa9e4066Sahrens * The log block containing this lr may have been byteswapped 1135fa9e4066Sahrens * so that we can easily examine common fields like lrc_txtype. 1136fa9e4066Sahrens * However, the log is a mix of different data types, and only the 1137fa9e4066Sahrens * replay vectors know how to byteswap their records. Therefore, if 1138fa9e4066Sahrens * the lr was byteswapped, undo it before invoking the replay vector. 1139fa9e4066Sahrens */ 1140fa9e4066Sahrens if (zr->zr_byteswap) 1141fa9e4066Sahrens byteswap_uint64_array(zr->zr_lrbuf, reclen); 1142fa9e4066Sahrens 1143fa9e4066Sahrens /* 1144fa9e4066Sahrens * If this is a TX_WRITE with a blkptr, suck in the data. 1145fa9e4066Sahrens */ 1146fa9e4066Sahrens if (txtype == TX_WRITE && reclen == sizeof (lr_write_t)) { 1147fa9e4066Sahrens lr_write_t *lrw = (lr_write_t *)lr; 1148fa9e4066Sahrens blkptr_t *wbp = &lrw->lr_blkptr; 1149fa9e4066Sahrens uint64_t wlen = lrw->lr_length; 1150fa9e4066Sahrens char *wbuf = zr->zr_lrbuf + reclen; 1151fa9e4066Sahrens 1152fa9e4066Sahrens if (BP_IS_HOLE(wbp)) { /* compressed to a hole */ 1153fa9e4066Sahrens bzero(wbuf, wlen); 1154fa9e4066Sahrens } else { 1155fa9e4066Sahrens /* 1156fa9e4066Sahrens * A subsequent write may have overwritten this block, 1157fa9e4066Sahrens * in which case wbp may have been been freed and 1158fa9e4066Sahrens * reallocated, and our read of wbp may fail with a 1159fa9e4066Sahrens * checksum error. We can safely ignore this because 1160fa9e4066Sahrens * the later write will provide the correct data. 1161fa9e4066Sahrens */ 1162fa9e4066Sahrens (void) zio_wait(zio_read(NULL, zilog->zl_spa, 1163fa9e4066Sahrens wbp, wbuf, BP_GET_LSIZE(wbp), NULL, NULL, 1164fa9e4066Sahrens ZIO_PRIORITY_SYNC_READ, 1165fa9e4066Sahrens ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE)); 1166fa9e4066Sahrens (void) memmove(wbuf, wbuf + lrw->lr_blkoff, wlen); 1167fa9e4066Sahrens } 1168fa9e4066Sahrens } 1169fa9e4066Sahrens 1170fa9e4066Sahrens /* 1171fa9e4066Sahrens * We must now do two things atomically: replay this log record, 1172fa9e4066Sahrens * and update the log header to reflect the fact that we did so. 1173fa9e4066Sahrens * We use the DMU's ability to assign into a specific txg to do this. 1174fa9e4066Sahrens */ 1175fa9e4066Sahrens for (pass = 1; /* CONSTANTCONDITION */; pass++) { 1176fa9e4066Sahrens uint64_t replay_txg; 1177fa9e4066Sahrens dmu_tx_t *replay_tx; 1178fa9e4066Sahrens 1179fa9e4066Sahrens replay_tx = dmu_tx_create(zr->zr_os); 1180fa9e4066Sahrens error = dmu_tx_assign(replay_tx, TXG_WAIT); 1181fa9e4066Sahrens if (error) { 1182fa9e4066Sahrens dmu_tx_abort(replay_tx); 1183fa9e4066Sahrens break; 1184fa9e4066Sahrens } 1185fa9e4066Sahrens 1186fa9e4066Sahrens replay_txg = dmu_tx_get_txg(replay_tx); 1187fa9e4066Sahrens 1188fa9e4066Sahrens if (txtype == 0 || txtype >= TX_MAX_TYPE) { 1189fa9e4066Sahrens error = EINVAL; 1190fa9e4066Sahrens } else { 1191fa9e4066Sahrens /* 1192fa9e4066Sahrens * On the first pass, arrange for the replay vector 1193fa9e4066Sahrens * to fail its dmu_tx_assign(). That's the only way 1194fa9e4066Sahrens * to ensure that those code paths remain well tested. 1195fa9e4066Sahrens */ 1196fa9e4066Sahrens *zr->zr_txgp = replay_txg - (pass == 1); 1197fa9e4066Sahrens error = zr->zr_replay[txtype](zr->zr_arg, zr->zr_lrbuf, 1198fa9e4066Sahrens zr->zr_byteswap); 1199fa9e4066Sahrens *zr->zr_txgp = TXG_NOWAIT; 1200fa9e4066Sahrens } 1201fa9e4066Sahrens 1202fa9e4066Sahrens if (error == 0) { 1203fa9e4066Sahrens dsl_dataset_dirty(dmu_objset_ds(zr->zr_os), replay_tx); 1204fa9e4066Sahrens zilog->zl_replay_seq[replay_txg & TXG_MASK] = 1205fa9e4066Sahrens lr->lrc_seq; 1206fa9e4066Sahrens } 1207fa9e4066Sahrens 1208fa9e4066Sahrens dmu_tx_commit(replay_tx); 1209fa9e4066Sahrens 1210fa9e4066Sahrens if (error != ERESTART) 1211fa9e4066Sahrens break; 1212fa9e4066Sahrens 1213fa9e4066Sahrens if (pass != 1) 1214fa9e4066Sahrens txg_wait_open(spa_get_dsl(zilog->zl_spa), 1215fa9e4066Sahrens replay_txg + 1); 1216fa9e4066Sahrens 1217fa9e4066Sahrens dprintf("pass %d, retrying\n", pass); 1218fa9e4066Sahrens } 1219fa9e4066Sahrens 1220fa9e4066Sahrens if (error) { 1221fa9e4066Sahrens char *name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1222fa9e4066Sahrens dmu_objset_name(zr->zr_os, name); 1223fa9e4066Sahrens cmn_err(CE_WARN, "ZFS replay transaction error %d, " 1224fa9e4066Sahrens "dataset %s, seq 0x%llx, txtype %llu\n", 1225fa9e4066Sahrens error, name, 1226fa9e4066Sahrens (u_longlong_t)lr->lrc_seq, (u_longlong_t)txtype); 1227fa9e4066Sahrens zilog->zl_stop_replay = 1; 1228fa9e4066Sahrens kmem_free(name, MAXNAMELEN); 1229fa9e4066Sahrens } 1230fa9e4066Sahrens 1231fa9e4066Sahrens /* 1232fa9e4066Sahrens * The DMU's dnode layer doesn't see removes until the txg commits, 1233fa9e4066Sahrens * so a subsequent claim can spuriously fail with EEXIST. 1234fa9e4066Sahrens * To prevent this, if we might have removed an object, 1235fa9e4066Sahrens * wait for the delete thread to delete it, and then 1236fa9e4066Sahrens * wait for the transaction group to sync. 1237fa9e4066Sahrens */ 1238fa9e4066Sahrens if (txtype == TX_REMOVE || txtype == TX_RMDIR || txtype == TX_RENAME) { 1239fa9e4066Sahrens if (zr->zr_rm_sync != NULL) 1240fa9e4066Sahrens zr->zr_rm_sync(zr->zr_arg); 1241fa9e4066Sahrens txg_wait_synced(spa_get_dsl(zilog->zl_spa), 0); 1242fa9e4066Sahrens } 1243fa9e4066Sahrens } 1244fa9e4066Sahrens 1245fa9e4066Sahrens /* 1246*13f5297eSperrin * If this dataset has a non-empty intent log, replay it and destroy it. 1247fa9e4066Sahrens */ 1248fa9e4066Sahrens void 1249fa9e4066Sahrens zil_replay(objset_t *os, void *arg, uint64_t *txgp, 1250fa9e4066Sahrens zil_replay_func_t *replay_func[TX_MAX_TYPE], void (*rm_sync)(void *arg)) 1251fa9e4066Sahrens { 1252fa9e4066Sahrens zilog_t *zilog = dmu_objset_zil(os); 1253*13f5297eSperrin zil_replay_arg_t zr; 1254*13f5297eSperrin 1255*13f5297eSperrin if (zil_empty(zilog)) { 1256*13f5297eSperrin /* 1257*13f5297eSperrin * Initialise the log header but don't free the log block 1258*13f5297eSperrin * which will get reused. 1259*13f5297eSperrin */ 1260*13f5297eSperrin zilog->zl_header->zh_claim_txg = 0; 1261*13f5297eSperrin zilog->zl_header->zh_replay_seq = 0; 1262*13f5297eSperrin return; 1263*13f5297eSperrin } 1264fa9e4066Sahrens 1265fa9e4066Sahrens zr.zr_os = os; 1266fa9e4066Sahrens zr.zr_replay = replay_func; 1267fa9e4066Sahrens zr.zr_arg = arg; 1268fa9e4066Sahrens zr.zr_rm_sync = rm_sync; 1269fa9e4066Sahrens zr.zr_txgp = txgp; 1270fa9e4066Sahrens zr.zr_byteswap = BP_SHOULD_BYTESWAP(&zilog->zl_header->zh_log); 1271fa9e4066Sahrens zr.zr_lrbuf = kmem_alloc(2 * SPA_MAXBLOCKSIZE, KM_SLEEP); 1272fa9e4066Sahrens 1273fa9e4066Sahrens /* 1274fa9e4066Sahrens * Wait for in-progress removes to sync before starting replay. 1275fa9e4066Sahrens */ 1276fa9e4066Sahrens if (rm_sync != NULL) 1277fa9e4066Sahrens rm_sync(arg); 1278fa9e4066Sahrens txg_wait_synced(zilog->zl_dmu_pool, 0); 1279fa9e4066Sahrens 1280fa9e4066Sahrens zilog->zl_stop_replay = 0; 1281fa9e4066Sahrens zil_parse(zilog, NULL, zil_replay_log_record, &zr, 1282fa9e4066Sahrens zilog->zl_header->zh_claim_txg); 1283fa9e4066Sahrens kmem_free(zr.zr_lrbuf, 2 * SPA_MAXBLOCKSIZE); 1284fa9e4066Sahrens 1285fa9e4066Sahrens zil_destroy(zilog); 1286fa9e4066Sahrens } 1287