VDO_ASSERT
int result = VDO_ASSERT(!is_dirty(info), "cache must have no dirty pages");
result = VDO_ASSERT((in_cyclic_range(zone->oldest_generation, a, zone->generation, 1 << 8) &&
result = VDO_ASSERT((zone->dirty_page_counts[generation] > 0),
result = VDO_ASSERT((new_count != 0), "dirty page count overflow for generation %u",
result = VDO_ASSERT(!vdo_waiter_is_waiting(&page->waiter),
result = VDO_ASSERT(cache_size > 0, "block map cache size is specified");
result = VDO_ASSERT(state < ARRAY_SIZE(state_names),
int result = VDO_ASSERT((pbn == NO_PAGE) || (info->pbn == NO_PAGE),
result = VDO_ASSERT(info->busy == 0, "VDO Page must not be busy");
result = VDO_ASSERT(!vdo_waitq_has_waiters(&info->waiting),
result = VDO_ASSERT(completion->ready, "VDO Page completion not ready");
result = VDO_ASSERT(completion->info != NULL,
result = VDO_ASSERT(completion->info->pbn == completion->pbn,
result = VDO_ASSERT(is_valid(completion->info),
result = VDO_ASSERT(completion->writable,
result = VDO_ASSERT((info->busy == 0), "Page is not busy before loading.");
if (VDO_ASSERT(thread_id < vdo->thread_config.thread_count,
return VDO_ASSERT(expected == completion->type,
int result = VDO_ASSERT(data_vio->is_discard,
result = VDO_ASSERT(lock_holder->logical.locked, "logical block lock held");
result = VDO_ASSERT(data_vio->hash_lock == NULL,
result = VDO_ASSERT(list_empty(&data_vio->hash_lock_entry),
return VDO_ASSERT(data_vio->recovery_sequence_number == 0,
result = VDO_ASSERT(!list_empty(&zone->lock_pool),
result = VDO_ASSERT(instance < instances.bit_count,
result = VDO_ASSERT(sizeof(struct layout_3_0) == *offset - initial_offset,
result = VDO_ASSERT(config->slab_size > 0, "slab size unspecified");
result = VDO_ASSERT(is_power_of_2(config->slab_size),
result = VDO_ASSERT(config->slab_size <= MAX_VDO_SLAB_BLOCKS,
result = VDO_ASSERT(config->slab_journal_blocks <= config->slab_size,
result = VDO_ASSERT((slab_config.data_blocks >= 1),
result = VDO_ASSERT(config->physical_blocks > 0, "physical blocks unspecified");
result = VDO_ASSERT(config->physical_blocks <= MAXIMUM_VDO_PHYSICAL_BLOCKS,
result = VDO_ASSERT((config->logical_blocks > 0),
result = VDO_ASSERT(config->logical_blocks <= MAXIMUM_VDO_LOGICAL_BLOCKS,
result = VDO_ASSERT(config->recovery_journal_size > 0,
result = VDO_ASSERT(is_power_of_2(config->recovery_journal_size),
result = VDO_ASSERT(offset == VDO_SUPER_BLOCK_FIXED_SIZE + VDO_COMPONENT_DATA_SIZE,
result = VDO_ASSERT(header->size == offset + sizeof(u32),
result = VDO_ASSERT(header.size == offset + sizeof(u32),
result = VDO_ASSERT(flat_page_origin == VDO_BLOCK_MAP_FLAT_PAGE_ORIGIN,
result = VDO_ASSERT(flat_page_count == 0,
result = VDO_ASSERT(VDO_BLOCK_MAP_HEADER_2_0.size == *offset - initial_offset,
result = VDO_ASSERT(VDO_RECOVERY_JOURNAL_HEADER_7_0.size == *offset - initial_offset,
result = VDO_ASSERT(VDO_SLAB_DEPOT_HEADER_2_0.size == *offset - initial_offset,
result = VDO_ASSERT(first_error < next_free_error,
result = VDO_ASSERT(vdo_is_state_normal(&flusher->state),
if (VDO_ASSERT(completion->priority <= queue->common.type->max_priority,
if (VDO_ASSERT(completion->my_queue == &queue->common,
result = VDO_ASSERT(!(found && entry.is_collision),
result = VDO_ASSERT(page_number < record_pages,
result = VDO_ASSERT(offset == sizeof(struct uds_configuration_6_02),
result = VDO_ASSERT(offset == sizeof(struct uds_configuration_6_02),
result = VDO_ASSERT(offset == sizeof(struct delta_index_header),
int result = VDO_ASSERT(!delta_entry->at_end,
result = VDO_ASSERT((list_number < delta_index->list_count),
result = VDO_ASSERT((list_number < delta_zone->list_count),
result = VDO_ASSERT((delta_entry->offset == size),
result = VDO_ASSERT(!delta_entry->is_collision, "entry is not a collision");
result = VDO_ASSERT(delta_entry->is_collision,
int result = VDO_ASSERT((delta_entry->delta_list != &delta_entry->temp_delta_list),
result = VDO_ASSERT((value & value_mask) == value,
result = VDO_ASSERT((key == delta_entry->key),
result = VDO_ASSERT((key >= delta_entry->key), "key past end of list");
result = VDO_ASSERT((key < delta_entry->key),
result = VDO_ASSERT((key >= delta_entry->key - delta_entry->delta),
result = VDO_ASSERT(offset == sizeof(struct delta_index_header),
request->status = VDO_ASSERT(false, "unknown request type: %d",
result = VDO_ASSERT(offset == sizeof(struct sub_index_data),
result = VDO_ASSERT(offset == sizeof(struct volume_index_data),
result = VDO_ASSERT(offset == sizeof(buffer),
result = VDO_ASSERT(offset == sizeof(buffer),
result = VDO_ASSERT((cache->cache_slots <= VOLUME_CACHE_MAX_ENTRIES),
result = VDO_ASSERT((page->read_pending), "page to install has a pending read");
result = VDO_ASSERT((page->read_pending), "page to install has a pending read");
result = VDO_ASSERT(record_page_number < geometry->record_pages_per_chapter,
result = VDO_ASSERT((status.stage == DATA_VIO_COMPRESSING),
result = VDO_ASSERT(!list_empty(&pool->idle_list),
result = VDO_ASSERT(lock->holder_count > 0, "physical block %llu lock held",
result = VDO_ASSERT((repair->block_map_entry_count <= repair->entry_count),
result = VDO_ASSERT(is_valid_journal_point(slab_journal_point),
result = VDO_ASSERT(slab->reference_blocks == NULL,
result = VDO_ASSERT((free_blocks <= allocator->depot->slab_config.data_blocks),
result = VDO_ASSERT(!vdo_before_journal_point(&last_entry_applied,
result = VDO_ASSERT(vdo_before_journal_point(&journal->tail_header.recovery_point,
result = VDO_ASSERT((journal->tail_header.entry_count <
result = VDO_ASSERT(thread_id != vdo->thread_config.dedupe_thread,
result = VDO_ASSERT(slab != NULL, "vdo_get_slab must succeed on all valid PBNs");
return VDO_ASSERT(vdo_work_queue_type_is(thread->queue, type),
result = VDO_ASSERT(filter_vdos_locked(vdo_is_equal, vdo) == NULL,
if (VDO_ASSERT(size <= vio_size, "specified size %d is not greater than allocated %d",
result = VDO_ASSERT(block_count <= MAX_BLOCKS_PER_VIO,
result = VDO_ASSERT(((vio_type != VIO_TYPE_UNINITIALIZED) && (vio_type != VIO_TYPE_DATA)),