VDO_BLOCK_SIZE
memcpy(page, loaded, VDO_BLOCK_SIZE);
return &cache->pages[(info - cache->infos) * VDO_BLOCK_SIZE];
memcpy(vio->vio.data, tree_page->page_buffer, VDO_BLOCK_SIZE);
u64 size = cache->page_count * (u64) VDO_BLOCK_SIZE;
result = vdo_allocate_memory(size, VDO_BLOCK_SIZE, "cache pages", &cache->pages);
((VDO_BLOCK_SIZE - sizeof(struct block_map_page)) /
memset(get_page_buffer(info), 0, VDO_BLOCK_SIZE);
char page_buffer[VDO_BLOCK_SIZE];
VDO_SECTORS_PER_BLOCK = (VDO_BLOCK_SIZE >> SECTOR_SHIFT),
VDO_BLOCK_SIZE - data_vio->offset);
data_vio->is_partial = (data_vio->remaining_discard < VDO_BLOCK_SIZE);
fragment_size, VDO_BLOCK_SIZE);
if (size != VDO_BLOCK_SIZE) {
VDO_BLOCK_SIZE - data_vio->offset));
data_vio->is_zero = mem_is_zero(data, VDO_BLOCK_SIZE);
memset(data_vio->vio.data, 0, VDO_BLOCK_SIZE);
data_vio->compression.block->data, VDO_BLOCK_SIZE,
murmurhash3_128(data_vio->vio.data, VDO_BLOCK_SIZE, 0x62ea60be,
data_vio->remaining_discard > (u32) (VDO_BLOCK_SIZE - data_vio->offset)) {
if (data_vio->remaining_discard > (u32) (VDO_BLOCK_SIZE - data_vio->offset)) {
(u32) (VDO_BLOCK_SIZE - data_vio->offset)),
data_vio->is_partial = (bio->bi_iter.bi_size < VDO_BLOCK_SIZE) || (data_vio->offset != 0);
data_vio->is_zero = mem_is_zero(data_vio->vio.data, VDO_BLOCK_SIZE);
BUILD_BUG_ON(VDO_BLOCK_SIZE > PAGE_SIZE);
result = vdo_allocate_memory(VDO_BLOCK_SIZE, 0, "data_vio data",
result = vdo_allocate_memory(VDO_BLOCK_SIZE, 0, "compressed block",
result = vdo_allocate_memory(VDO_BLOCK_SIZE, 0, "vio scratch",
for (i = 0; i < VDO_BLOCK_SIZE; i += sizeof(u64)) {
geometry.bio_offset) * VDO_BLOCK_SIZE);
.size = (vdo_get_index_region_size(geometry) * VDO_BLOCK_SIZE),
limits->physical_block_size = VDO_BLOCK_SIZE;
limits->io_min = VDO_BLOCK_SIZE;
limits->io_opt = VDO_BLOCK_SIZE;
limits->discard_granularity = VDO_BLOCK_SIZE;
return bdev_nr_bytes(vdo_get_backing_device(vdo)) / VDO_BLOCK_SIZE;
u64 block_size = VDO_BLOCK_SIZE;
if (value > (UINT_MAX / VDO_BLOCK_SIZE)) {
UINT_MAX / VDO_BLOCK_SIZE);
if (logical_bytes > (MAXIMUM_VDO_LOGICAL_BLOCKS * VDO_BLOCK_SIZE)) {
if ((logical_bytes % VDO_BLOCK_SIZE) != 0) {
config->logical_blocks = logical_bytes / VDO_BLOCK_SIZE;
config->physical_blocks = device_size / VDO_BLOCK_SIZE;
*index_blocks_ptr = index_bytes / VDO_BLOCK_SIZE;
memset(buffer, 0, VDO_BLOCK_SIZE);
VDO_BLOCK_SIZE - sizeof(struct packed_slab_journal_block_header),
VDO_SLAB_SUMMARY_ENTRIES_PER_BLOCK = VDO_BLOCK_SIZE / sizeof(struct slab_summary_entry),
operation, vio->data, vio->block_count * VDO_BLOCK_SIZE);
write_block_count_t("physicalSize : ", config->physical_blocks * VDO_BLOCK_SIZE, ", ",
write_block_count_t("logicalSize : ", config->logical_blocks * VDO_BLOCK_SIZE, ", ",
VDO_COMPRESSED_BLOCK_DATA_SIZE = VDO_BLOCK_SIZE - sizeof(struct compressed_block_header),
((VDO_BLOCK_SIZE - sizeof(struct packed_journal_header)) /
result = vdo_allocate(VDO_BLOCK_SIZE, __func__, &data);
memset(block->vio.data, 0x0, VDO_BLOCK_SIZE);
char *header = &data[pbn * VDO_BLOCK_SIZE];
result = vdo_allocate(remaining * VDO_BLOCK_SIZE, __func__, &repair->journal_data);
ptr += (blocks * VDO_BLOCK_SIZE);
offset = ((vdo_get_recovery_journal_block_number(journal, sequence) * VDO_BLOCK_SIZE) +
slab->active_count -= vio->io_size / VDO_BLOCK_SIZE;
unsigned int block_count = vio->io_size / VDO_BLOCK_SIZE;
for (i = 0; i < block_count; i++, block++, data += VDO_BLOCK_SIZE) {
REQ_OP_READ, block_count * VDO_BLOCK_SIZE);
char *end_data = scrubber->vio.data + (end_index * VDO_BLOCK_SIZE);
char *block_data = scrubber->vio.data + (index * VDO_BLOCK_SIZE);
memcpy(block->outgoing_entries, block->entries, VDO_BLOCK_SIZE);
BUILD_BUG_ON(sizeof(*journal->block) != VDO_BLOCK_SIZE);
result = vdo_allocate(VDO_BLOCK_SIZE * slab_journal_size, __func__, &journal_data);
result = vdo_allocate(VDO_BLOCK_SIZE, __func__, &block->outgoing_entries);
BUILD_BUG_ON((VDO_BLOCK_SIZE % sizeof(struct slab_summary_entry)) != 0);
memcpy(pooled->vio.data, journal->block, VDO_BLOCK_SIZE);
return ((size_t) vdo->device_config->cache_size) * VDO_BLOCK_SIZE;
stats->block_size = VDO_BLOCK_SIZE;
result = vdo_allocate(VDO_BLOCK_SIZE, "encoded geometry block",
result = vdo_allocate(VDO_BLOCK_SIZE, "encoded super block",
(unsigned long long) necessary_size * VDO_BLOCK_SIZE);
if (mem_is_zero(vdo->geometry_block.vio.data, VDO_BLOCK_SIZE)) {
return vio_reset_bio_with_size(vio, data, vio->block_count * VDO_BLOCK_SIZE,
int vio_size = vio->block_count * VDO_BLOCK_SIZE;
size_t per_vio_size = VDO_BLOCK_SIZE * block_count;
MAX_BLOCKS_PER_VIO = (BIO_MAX_VECS << PAGE_SHIFT) / VDO_BLOCK_SIZE,