VDO_ASSERT_LOG_ONLY
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == get_acting_zone_thread_id(manager)),
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == manager->initiator_thread_id),
VDO_ASSERT_LOG_ONLY((page_completion->waiter.next_waiter == NULL),
VDO_ASSERT_LOG_ONLY((page_completion->waiter.next_waiter == NULL),
VDO_ASSERT_LOG_ONLY(false, "Info found in a usable state.");
VDO_ASSERT_LOG_ONLY(lock->locked,
VDO_ASSERT_LOG_ONLY((lock_holder == lock),
VDO_ASSERT_LOG_ONLY((thread_id == cache->zone->thread_id),
VDO_ASSERT_LOG_ONLY(!vdo_is_state_quiescent(&cache->zone->state),
VDO_ASSERT_LOG_ONLY(dirty_lists->next_period == 0, "current period not set");
VDO_ASSERT_LOG_ONLY((zone->active_lookups == 0),
VDO_ASSERT_LOG_ONLY(!is_in_flight(info),
VDO_ASSERT_LOG_ONLY(!completion->complete, "completion is not complete");
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == vdo->thread_config.cpu_thread),
VDO_ASSERT_LOG_ONLY((data_vio != lock_holder),
VDO_ASSERT_LOG_ONLY((data_vio == lock_holder),
VDO_ASSERT_LOG_ONLY(lock->locked, "lbn_lock with waiters is not locked");
VDO_ASSERT_LOG_ONLY((lock_holder == data_vio),
VDO_ASSERT_LOG_ONLY(data_vio->allocation.lock == NULL,
VDO_ASSERT_LOG_ONLY(data_vio->hash_lock == NULL,
VDO_ASSERT_LOG_ONLY((allocation->pbn == VDO_ZERO_BLOCK),
VDO_ASSERT_LOG_ONLY(!data_vio->is_duplicate, "compressing a non-duplicate block");
VDO_ASSERT_LOG_ONLY(data_vio->hash_lock != NULL,
VDO_ASSERT_LOG_ONLY(data_vio_has_allocation(data_vio),
VDO_ASSERT_LOG_ONLY(!data_vio->is_zero, "zero blocks should not be hashed");
VDO_ASSERT_LOG_ONLY(!data_vio->is_zero, "must not prepare to dedupe zero blocks");
VDO_ASSERT_LOG_ONLY((!vdo_uses_bio_ack_queue(vdo) ||
VDO_ASSERT_LOG_ONLY(data_vio_has_flush_generation_lock(data_vio),
VDO_ASSERT_LOG_ONLY((pool->discard_limiter.busy == 0),
VDO_ASSERT_LOG_ONLY((data_vio->remaining_discard <=
VDO_ASSERT_LOG_ONLY((limiter->release_count <= limiter->busy),
VDO_ASSERT_LOG_ONLY((discard_limit <= pool_size),
VDO_ASSERT_LOG_ONLY((pool->limiter.busy == 0),
VDO_ASSERT_LOG_ONLY((bio_list_empty(&pool->limiter.waiters) &&
VDO_ASSERT_LOG_ONLY((bio_list_empty(&pool->discard_limiter.waiters) &&
VDO_ASSERT_LOG_ONLY(!vdo_is_state_quiescent(&pool->state),
VDO_ASSERT_LOG_ONLY((vio->type == VIO_TYPE_DATA), "vio is a data_vio");
VDO_ASSERT_LOG_ONLY((expected == thread_id),
VDO_ASSERT_LOG_ONLY((expected == thread_id),
VDO_ASSERT_LOG_ONLY((expected == thread_id),
VDO_ASSERT_LOG_ONLY((expected == thread_id),
VDO_ASSERT_LOG_ONLY((expected == thread_id),
VDO_ASSERT_LOG_ONLY((expected == thread_id),
VDO_ASSERT_LOG_ONLY((journal_thread == thread_id),
VDO_ASSERT_LOG_ONLY((packer_thread == thread_id),
VDO_ASSERT_LOG_ONLY((cpu_thread == thread_id),
VDO_ASSERT_LOG_ONLY(!vdo_is_state_compressed(agent->new_mapped.state),
VDO_ASSERT_LOG_ONLY(agent_is_done,
VDO_ASSERT_LOG_ONLY(vdo_is_pbn_read_lock(lock->duplicate_lock),
VDO_ASSERT_LOG_ONLY(!lock->verified, "hash lock only verifies advice once");
VDO_ASSERT_LOG_ONLY(lock->duplicate_lock == NULL,
VDO_ASSERT_LOG_ONLY(lock->duplicate_lock != NULL,
VDO_ASSERT_LOG_ONLY(lock->duplicate_lock == NULL,
VDO_ASSERT_LOG_ONLY(false, "hash lock must not be in unimplemented state %s",
VDO_ASSERT_LOG_ONLY(data_vio == lock->agent,
VDO_ASSERT_LOG_ONLY(lock == removed,
VDO_ASSERT_LOG_ONLY(lock != vdo_int_map_get(zone->hash_lock_map, lock_key),
VDO_ASSERT_LOG_ONLY(!vdo_waitq_has_waiters(&lock->waiters),
VDO_ASSERT_LOG_ONLY((lock->duplicate_lock == NULL),
VDO_ASSERT_LOG_ONLY((lock->state == VDO_HASH_LOCK_BYPASSING),
VDO_ASSERT_LOG_ONLY(list_empty(&lock->pool_node),
VDO_ASSERT_LOG_ONLY(list_empty(&lock->duplicate_vios),
VDO_ASSERT_LOG_ONLY(data_vio->new_mapped.pbn == allocation->pbn,
VDO_ASSERT_LOG_ONLY(vdo_is_pbn_read_lock(allocation->lock),
VDO_ASSERT_LOG_ONLY(vdo_get_duplicate_lock(data_vio) == NULL,
VDO_ASSERT_LOG_ONLY(vdo_is_state_compressed(data_vio->new_mapped.state),
VDO_ASSERT_LOG_ONLY(claimed, "impossible to fail to claim an initial increment");
VDO_ASSERT_LOG_ONLY(false, "uds request was timed out (state %d)",
VDO_ASSERT_LOG_ONLY(READ_ONCE(zone->active) == 0, "all contexts inactive");
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == zone->thread_id),
VDO_ASSERT_LOG_ONLY(data_vio == data_vio->hash_lock->agent,
VDO_ASSERT_LOG_ONLY((hash_lock->duplicate_lock == NULL),
VDO_ASSERT_LOG_ONLY(data_vio->hash_zone != NULL,
VDO_ASSERT_LOG_ONLY(!list_empty(&data_vio->hash_lock_entry),
VDO_ASSERT_LOG_ONLY(old_lock->reference_count > 0,
VDO_ASSERT_LOG_ONLY(old_lock->reference_count > 1,
VDO_ASSERT_LOG_ONLY(lock->duplicate_lock == NULL,
VDO_ASSERT_LOG_ONLY(lock->duplicate_lock != NULL,
VDO_ASSERT_LOG_ONLY(lock->verified, "new advice should have been verified");
VDO_ASSERT_LOG_ONLY(lock->update_advice, "should only update advice if needed");
VDO_ASSERT_LOG_ONLY(lock->agent == NULL, "shouldn't have an agent in DEDUPING");
VDO_ASSERT_LOG_ONLY(!vdo_waitq_has_waiters(&lock->waiters),
VDO_ASSERT_LOG_ONLY(lock == replace_lock,
VDO_ASSERT_LOG_ONLY(replace_lock->registered,
VDO_ASSERT_LOG_ONLY(vdo_get_callback_thread_id() == get_thread_id_for_phase(vdo),
VDO_ASSERT_LOG_ONLY(false,
VDO_ASSERT_LOG_ONLY(false, "instance number %u must be allocated", instance);
VDO_ASSERT_LOG_ONLY((new_physical_blocks > current_physical_blocks),
VDO_ASSERT_LOG_ONLY((config->logical_blocks > logical_blocks),
VDO_ASSERT_LOG_ONLY(instances.count == 0,
VDO_ASSERT_LOG_ONLY(code->normal, "vdo should not receive bios while in state %s",
VDO_ASSERT_LOG_ONLY(result == VDO_SUCCESS, "layout has expected partition: %u", id);
VDO_ASSERT_LOG_ONLY(layout->num_partitions <= U8_MAX,
VDO_ASSERT_LOG_ONLY(sizeof(struct layout_3_0) == *offset - initial_offset,
VDO_ASSERT_LOG_ONLY(header.size == *offset - initial_offset,
VDO_ASSERT_LOG_ONLY(*offset == VDO_COMPONENT_DATA_OFFSET + VDO_COMPONENT_DATA_SIZE,
VDO_ASSERT_LOG_ONLY(*offset == VDO_COMPONENT_DATA_OFFSET + VDO_COMPONENT_DATA_SIZE,
VDO_ASSERT_LOG_ONLY(offset <= VDO_SECTOR_SIZE,
VDO_ASSERT_LOG_ONLY(VDO_BLOCK_MAP_HEADER_2_0.size == *offset - initial_offset,
VDO_ASSERT_LOG_ONLY(VDO_RECOVERY_JOURNAL_HEADER_7_0.size == *offset - initial_offset,
VDO_ASSERT_LOG_ONLY(VDO_SLAB_DEPOT_HEADER_2_0.size == *offset - initial_offset,
VDO_ASSERT_LOG_ONLY((flush->flush_generation ==
VDO_ASSERT_LOG_ONLY(!code->quiescent, "Flushing not allowed in state %s",
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == flusher->thread_id),
VDO_ASSERT_LOG_ONLY(completion->my_queue == NULL,
VDO_ASSERT_LOG_ONLY((type->max_priority <= VDO_WORK_Q_MAX_PRIORITY),
VDO_ASSERT_LOG_ONLY(offset == sizeof(nonce_data),
VDO_ASSERT_LOG_ONLY(false, "Bad load context state %u",
VDO_ASSERT_LOG_ONLY(false, "Bad load context state %u",
VDO_ASSERT_LOG_ONLY((result == UDS_SUCCESS), "barrier message allocation");
VDO_ASSERT_LOG_ONLY(false, "invalid index stage: %d", stage);
VDO_ASSERT_LOG_ONLY(search_pending(invalidate_counter),
VDO_ASSERT_LOG_ONLY(search_pending(invalidate_counter),
VDO_ASSERT_LOG_ONLY(result == VDO_SUCCESS, "bio map insertion succeeds");
VDO_ASSERT_LOG_ONLY(!code->quiescent, "I/O not allowed in state %s", code->name);
VDO_ASSERT_LOG_ONLY(!in_interrupt(), "not in interrupt context");
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == zone->thread_id),
VDO_ASSERT_LOG_ONLY((zone->flush_generation == expected_generation),
VDO_ASSERT_LOG_ONLY(vdo_is_state_normal(&zone->state), "vdo state is normal");
VDO_ASSERT_LOG_ONLY((zone->oldest_active_generation <= data_vio->flush_generation),
VDO_ASSERT_LOG_ONLY(memory_stats.kmalloc_bytes == 0,
VDO_ASSERT_LOG_ONLY(memory_stats.vmalloc_bytes == 0,
VDO_ASSERT_LOG_ONLY((bin != NULL), "data_vio in packer has a bin");
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == packer->thread_id),
VDO_ASSERT_LOG_ONLY(!lock->has_provisional_reference,
VDO_ASSERT_LOG_ONLY(pool->borrowed > 0, "shouldn't return more than borrowed");
VDO_ASSERT_LOG_ONLY(pool->borrowed == 0,
VDO_ASSERT_LOG_ONLY(false, "must always be able to borrow a PBN lock");
VDO_ASSERT_LOG_ONLY(allocation->lock == NULL,
VDO_ASSERT_LOG_ONLY(lock->holder_count > 0,
VDO_ASSERT_LOG_ONLY((lock == holder), "physical block lock mismatch for block %llu",
VDO_ASSERT_LOG_ONLY(!vdo_is_pbn_read_lock(lock),
VDO_ASSERT_LOG_ONLY(!has_lock_type(lock, VIO_BLOCK_MAP_WRITE_LOCK),
VDO_ASSERT_LOG_ONLY(lock->holder_count == 1,
VDO_ASSERT_LOG_ONLY((priority <= table->max_priority),
VDO_ASSERT_LOG_ONLY(vdo_before_journal_point(&journal->commit_point,
VDO_ASSERT_LOG_ONLY((decrements <= journal_value),
VDO_ASSERT_LOG_ONLY((block->sequence_number >= last_active_block->sequence_number),
VDO_ASSERT_LOG_ONLY(data_vio->recovery_sequence_number == 0,
VDO_ASSERT_LOG_ONLY((*current_value >= 1),
VDO_ASSERT_LOG_ONLY((zone_type != VDO_ZONE_TYPE_JOURNAL),
VDO_ASSERT_LOG_ONLY(*current_value < U16_MAX,
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == journal->thread_id),
VDO_ASSERT_LOG_ONLY(((result == VDO_READ_ONLY) ||
VDO_ASSERT_LOG_ONLY(list_empty(&journal->active_tail_blocks),
VDO_ASSERT_LOG_ONLY(list_empty(&journal->active_tail_blocks),
VDO_ASSERT_LOG_ONLY((*journal_value == atomic_read(decrement_counter)),
VDO_ASSERT_LOG_ONLY(first_sorted_entry == repair->current_entry,
VDO_ASSERT_LOG_ONLY(just_sorted_entry < current_entry,
VDO_ASSERT_LOG_ONLY(list_empty(&slab->allocq_entry),
VDO_ASSERT_LOG_ONLY(journal->recovery_lock == 0, "slab journal was clean");
VDO_ASSERT_LOG_ONLY((journal->head + journal->size) == journal->tail,
VDO_ASSERT_LOG_ONLY((journal->blocking_threshold >= journal->size),
VDO_ASSERT_LOG_ONLY((free_blocks < (1 << 23)), "free blocks must be less than 2^23");
VDO_ASSERT_LOG_ONLY(((journal->size < 16) ||
VDO_ASSERT_LOG_ONLY((slab->status != VDO_SLAB_REBUILT),
VDO_ASSERT_LOG_ONLY(list_empty(&slab->allocq_entry),
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == thread_id),
VDO_ASSERT_LOG_ONLY((slab->counters[free_index] == EMPTY_REFERENCE_COUNT),
VDO_ASSERT_LOG_ONLY((recovery_lock < journal->recovery_lock),
VDO_ASSERT_LOG_ONLY(depot->first_block == partition->offset,
VDO_ASSERT_LOG_ONLY(depot->new_slabs != NULL, "Must have new slabs to use");
VDO_ASSERT_LOG_ONLY(!is_vio_pool_busy(allocator->vio_pool),
VDO_ASSERT_LOG_ONLY((adjustment != 0), "adjustment must be non-zero");
VDO_ASSERT_LOG_ONLY((-adjustment <= lock->count),
VDO_ASSERT_LOG_ONLY(journal->tail_header.entry_count == 0,
VDO_ASSERT_LOG_ONLY((get_lock(journal, block)->count == 0),
VDO_ASSERT_LOG_ONLY(unused_entries >= 0, "vdo_slab journal block is not overfull");
VDO_ASSERT_LOG_ONLY(!found_it, "new thread not already in registry");
VDO_ASSERT_LOG_ONLY(found_it, "thread found in registry");
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == vdo->thread_config.admin_thread),
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() ==
VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() ==
VDO_ASSERT_LOG_ONLY(!vdo_waitq_has_waiters(&pool->waiting),
VDO_ASSERT_LOG_ONLY((pool->busy_count == 0),
VDO_ASSERT_LOG_ONLY(list_empty(&pool->busy),
VDO_ASSERT_LOG_ONLY(pool->size == 0,
VDO_ASSERT_LOG_ONLY((pool->thread_id == vdo_get_callback_thread_id()),
VDO_ASSERT_LOG_ONLY((pool->thread_id == vdo_get_callback_thread_id()),
VDO_ASSERT_LOG_ONLY(0, "Bio operation %d not a write, read, discard, or empty flush",
VDO_ASSERT_LOG_ONLY((expected == thread_id),