42  *   flag is set to active when we create the checkpoint and remains active
45  *   references the state of the pool when we take the checkpoint. The entry
46  *   remains populated until we start discarding the checkpoint or we rewind
52  *   but we want to keep around in case we decide to rewind to the checkpoint.
56  *   checkpoint, with the only exception being the scenario when we free
66  * - To create a checkpoint, we first wait for the current TXG to be synced,
67  *   so we can use the most recently synced uberblock (spa_ubsync) as the
68  *   checkpointed uberblock. Then we use an early synctask to place that
71  *   to the TXG of the checkpointed uberblock. We use an early synctask for
76  * - When a checkpoint exists, we need to ensure that the blocks that
82  *   Whenever a block is freed and we find out that it is referenced by the
83  *   checkpoint (we find out by comparing its birth to spa_checkpoint_txg),
84  *   we place it in the ms_checkpointing tree instead of the ms_freeingtree.
85  *   This way, we divide the blocks that are being freed into checkpointed
88  *   In order to persist these frees, we write the extents from the
93  *   when we discard the checkpoint, we can find the entries that have
97  * - To discard the checkpoint we use an early synctask to delete the
100  *   We use an early synctask to ensure that the operation happens before any
103  *   Once the synctask is done and the discarding zthr is awake, we discard
113  * - To rewind to the checkpoint, we first use the current uberblock and
114  *   open the MOS so we can access the checkpointed uberblock from the MOS
115  *   config. After we retrieve the checkpointed uberblock, we use it as the
120  *   An important note on rewinding to the checkpoint has to do with how we
121  *   handle ZIL blocks. In the scenario of a rewind, we clear out any ZIL
122  *   blocks that have not been claimed by the time we took the checkpoint
128  * - In the hypothetical event that we take a checkpoint, remove a vdev,
131  *   and others of similar nature, we disallow the following operations that
219 	 * Since the space map is not condensed, we know that  in spa_checkpoint_discard_sync_callback()
225 	 * metaslab boundaries. So if needed we could add code  in spa_checkpoint_discard_sync_callback()
233 	 * At this point we should not be processing any  in spa_checkpoint_discard_sync_callback()
235 	 * unnecessary. We use the lock anyway though to  in spa_checkpoint_discard_sync_callback()
290 	 * number of non-debug entries, we want to ensure that we only  in spa_checkpoint_discard_thread_sync()
291 	 * read what we prefetched from open-context.  in spa_checkpoint_discard_thread_sync()
293 	 * Thus, we set the maximum entries that the space map callback  in spa_checkpoint_discard_thread_sync()
297 	 * Note that since this is a conservative estimate we also  in spa_checkpoint_discard_thread_sync()
310 	 * 1] We reached the beginning of the space map. At this point  in spa_checkpoint_discard_thread_sync()
317 	 * 2] We reached the memory limit (amount of memory used to hold  in spa_checkpoint_discard_thread_sync()
500 	 * (we use spa_ubsync), its txg must be equal to the txg number of  in spa_checkpoint_sync()
501 	 * the txg we are syncing, minus 1.  in spa_checkpoint_sync()
506 	 * Once the checkpoint is in place, we need to ensure that none of  in spa_checkpoint_sync()
508 	 * When there is a checkpoint and a block is freed, we compare its  in spa_checkpoint_sync()
510 	 * block is part of the checkpoint or not. Therefore, we have to set  in spa_checkpoint_sync()
526 	 * Note that the feature will be deactivated when we've  in spa_checkpoint_sync()
553 	 * uberblock (spa_ubsync) has all the changes that we expect  in spa_checkpoint()
554 	 * to see if we were to revert later to the checkpoint. In other  in spa_checkpoint()
555 	 * words we want the checkpointed uberblock to include/reference  in spa_checkpoint()
556 	 * all the changes that were pending at the time that we issued  in spa_checkpoint()
563 	 * txg (spa_ubsync) we want to ensure that are not freeing any of  in spa_checkpoint()
565 	 * run. Thus, we run it as an early synctask, so the dirty changes  in spa_checkpoint()
620 	 * Similarly to spa_checkpoint(), we want our synctask to run  in spa_checkpoint_discard()