drivers/gpu/drm/mediatek/mtk_drm_drv.c

912

struct device_node *next = NULL, *prev, *vdo = dev->parent->of_node;

drivers/gpu/drm/mediatek/mtk_drm_drv.c

920

ret = mtk_drm_of_get_ddp_ep_cid(vdo, 0, cpath, &next, &temp_path[idx]);

drivers/md/dm-vdo/action-manager.c

106

vdo_action_scheduler_fn scheduler, struct vdo *vdo,

drivers/md/dm-vdo/action-manager.c

128

vdo_initialize_completion(&manager->completion, vdo, VDO_ACTION_COMPLETION);

drivers/md/dm-vdo/action-manager.h

83

struct vdo *vdo,

drivers/md/dm-vdo/block-map.c

1127

if (vdo_is_read_only(info->cache->vdo)) {

drivers/md/dm-vdo/block-map.c

1241

vdo_initialize_completion(completion, cache->vdo, VDO_PAGE_COMPLETION);

drivers/md/dm-vdo/block-map.c

1246

if (page_completion->writable && vdo_is_read_only(cache->vdo)) {

drivers/md/dm-vdo/block-map.c

1776

static bool __must_check is_invalid_tree_entry(const struct vdo *vdo,

drivers/md/dm-vdo/block-map.c

1789

return !vdo_is_physical_data_block(vdo->depot, mapping->pbn);

drivers/md/dm-vdo/block-map.c

193

result = create_metadata_vio(cache->vdo, VIO_TYPE_BLOCK_MAP,

drivers/md/dm-vdo/block-map.c

2177

vdo_add_recovery_journal_entry(completion->vdo->recovery_journal, data_vio);

drivers/md/dm-vdo/block-map.c

2743

struct vdo *vdo = map->vdo;

drivers/md/dm-vdo/block-map.c

2749

zone->thread_id = vdo->thread_config.logical_threads[zone_number];

drivers/md/dm-vdo/block-map.c

2769

result = make_vio_pool(vdo, BLOCK_MAP_VIO_POOL_SIZE, 1,

drivers/md/dm-vdo/block-map.c

2778

zone->page_cache.vdo = vdo;

drivers/md/dm-vdo/block-map.c

2877

struct vdo *vdo, struct recovery_journal *journal,

drivers/md/dm-vdo/block-map.c

2892

result = vdo_allocate_extended(vdo->thread_config.logical_zone_count,

drivers/md/dm-vdo/block-map.c

2897

map->vdo = vdo;

drivers/md/dm-vdo/block-map.c

2912

map->zone_count = vdo->thread_config.logical_zone_count;

drivers/md/dm-vdo/block-map.c

2923

map, schedule_era_advance, vdo,

drivers/md/dm-vdo/block-map.c

574

struct vdo *vdo = cache->vdo;

drivers/md/dm-vdo/block-map.c

576

if ((result != VDO_READ_ONLY) && !vdo_is_read_only(vdo)) {

drivers/md/dm-vdo/block-map.c

579

vdo_enter_read_only_mode(vdo, result);

drivers/md/dm-vdo/block-map.c

645

(vdo_is_read_only(zone->block_map->vdo) ?

drivers/md/dm-vdo/block-map.c

652

vdo_enter_read_only_mode(zone->block_map->vdo, result);

drivers/md/dm-vdo/block-map.c

687

vdo_enter_read_only_mode(cache->zone->block_map->vdo, result);

drivers/md/dm-vdo/block-map.h

255

struct vdo *vdo;

drivers/md/dm-vdo/block-map.h

334

block_count_t logical_blocks, struct vdo *vdo,

drivers/md/dm-vdo/block-map.h

51

struct vdo *vdo;

drivers/md/dm-vdo/completion.c

114

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/completion.c

117

if (VDO_ASSERT(thread_id < vdo->thread_config.thread_count,

drivers/md/dm-vdo/completion.c

120

vdo->thread_config.thread_count) != VDO_SUCCESS)

drivers/md/dm-vdo/completion.c

126

vdo_enqueue_work_queue(vdo->threads[thread_id].queue, completion);

drivers/md/dm-vdo/completion.c

52

struct vdo *vdo,

drivers/md/dm-vdo/completion.c

56

completion->vdo = vdo;

drivers/md/dm-vdo/completion.h

31

void vdo_initialize_completion(struct vdo_completion *completion, struct vdo *vdo,

drivers/md/dm-vdo/data-vio.c

1000

VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == vdo->thread_config.cpu_thread),

drivers/md/dm-vdo/data-vio.c

1011

assert_on_vdo_cpu_thread(completion->vdo, __func__);

drivers/md/dm-vdo/data-vio.c

1023

assert_on_vdo_cpu_thread(completion->vdo, __func__);

drivers/md/dm-vdo/data-vio.c

1262

struct data_vio_pool *pool = completion->vdo->data_vio_pool;

drivers/md/dm-vdo/data-vio.c

1282

struct vdo *vdo = vdo_from_data_vio(data_vio);

drivers/md/dm-vdo/data-vio.c

1302

(READ_ONCE(vdo->read_only_notifier.read_only_error) == VDO_SUCCESS) &&

drivers/md/dm-vdo/data-vio.c

1328

if (vdo_is_read_only(completion->vdo))

drivers/md/dm-vdo/data-vio.c

1343

vdo_enter_read_only_mode(completion->vdo, completion->result);

drivers/md/dm-vdo/data-vio.c

1692

vdo_add_recovery_journal_entry(completion->vdo->recovery_journal, data_vio);

drivers/md/dm-vdo/data-vio.c

1919

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/data-vio.c

1921

VDO_ASSERT_LOG_ONLY((!vdo_uses_bio_ack_queue(vdo) ||

drivers/md/dm-vdo/data-vio.c

1922

(vdo_get_callback_thread_id() == vdo->thread_config.bio_ack_thread)),

drivers/md/dm-vdo/data-vio.c

246

struct vdo *vdo = vdo_from_data_vio(data_vio);

drivers/md/dm-vdo/data-vio.c

254

lock->zone = &vdo->logical_zones->zones[zone_number];

drivers/md/dm-vdo/data-vio.c

261

struct vdo *vdo = vdo_from_data_vio(data_vio);

drivers/md/dm-vdo/data-vio.c

263

if (vdo_is_read_only(vdo)) {

drivers/md/dm-vdo/data-vio.c

275

struct vdo *vdo = vdo_from_data_vio(data_vio);

drivers/md/dm-vdo/data-vio.c

287

vdo_count_bios(&vdo->stats.bios_acknowledged, bio);

drivers/md/dm-vdo/data-vio.c

289

vdo_count_bios(&vdo->stats.bios_acknowledged_partial, bio);

drivers/md/dm-vdo/data-vio.c

426

struct vdo *vdo = vdo_from_data_vio(data_vio);

drivers/md/dm-vdo/data-vio.c

432

if (data_vio->logical.lbn >= vdo->states.vdo.config.logical_blocks) {

drivers/md/dm-vdo/data-vio.c

528

static void launch_bio(struct vdo *vdo, struct data_vio *data_vio, struct bio *bio)

drivers/md/dm-vdo/data-vio.c

552

vdo_count_bios(&vdo->stats.bios_in_partial, bio);

drivers/md/dm-vdo/data-vio.c

556

vdo_count_bios(&vdo->stats.bios_in_partial, bio);

drivers/md/dm-vdo/data-vio.c

575

lbn = (bio->bi_iter.bi_sector - vdo->starting_sector_offset) / VDO_SECTORS_PER_BLOCK;

drivers/md/dm-vdo/data-vio.c

583

launch_bio(limiter->pool->completion.vdo, data_vio, bio);

drivers/md/dm-vdo/data-vio.c

783

static int initialize_data_vio(struct data_vio *data_vio, struct vdo *vdo)

drivers/md/dm-vdo/data-vio.c

813

vdo_initialize_completion(&data_vio->decrement_completion, vdo,

drivers/md/dm-vdo/data-vio.c

815

initialize_vio(&data_vio->vio, bio, 1, VIO_TYPE_DATA, VIO_PRIORITY_DATA, vdo);

drivers/md/dm-vdo/data-vio.c

838

int make_data_vio_pool(struct vdo *vdo, data_vio_count_t pool_size,

drivers/md/dm-vdo/data-vio.c

859

vdo_initialize_completion(&pool->completion, vdo, VDO_DATA_VIO_POOL_COMPLETION);

drivers/md/dm-vdo/data-vio.c

861

process_release_callback, vdo->thread_config.cpu_thread,

drivers/md/dm-vdo/data-vio.c

873

result = initialize_data_vio(data_vio, vdo);

drivers/md/dm-vdo/data-vio.c

981

launch_bio(pool->completion.vdo, data_vio, bio);

drivers/md/dm-vdo/data-vio.c

998

static void assert_on_vdo_cpu_thread(const struct vdo *vdo, const char *name)

drivers/md/dm-vdo/data-vio.h

313

static inline struct vdo *vdo_from_data_vio(struct data_vio *data_vio)

drivers/md/dm-vdo/data-vio.h

315

return data_vio->vio.completion.vdo;

drivers/md/dm-vdo/data-vio.h

331

int make_data_vio_pool(struct vdo *vdo, data_vio_count_t pool_size,

drivers/md/dm-vdo/data-vio.h

637

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/data-vio.h

639

if (!vdo_uses_bio_ack_queue(vdo)) {

drivers/md/dm-vdo/data-vio.h

645

vdo->thread_config.bio_ack_thread);

drivers/md/dm-vdo/dedupe.c

1605

struct vdo *vdo = vdo_from_data_vio(data_vio);

drivers/md/dm-vdo/dedupe.c

1629

atomic64_inc(&vdo->stats.invalid_advice_pbn_count);

drivers/md/dm-vdo/dedupe.c

1633

result = vdo_get_physical_zone(vdo, advice->pbn, &advice->zone);

drivers/md/dm-vdo/dedupe.c

1638

atomic64_inc(&vdo->stats.invalid_advice_pbn_count);

drivers/md/dm-vdo/dedupe.c

2169

static int initialize_index(struct vdo *vdo, struct hash_zones *zones)

drivers/md/dm-vdo/dedupe.c

2173

struct volume_geometry geometry = vdo->geometry;

drivers/md/dm-vdo/dedupe.c

2194

.bdev = vdo->device_config->owned_device->bdev,

drivers/md/dm-vdo/dedupe.c

2206

result = vdo_make_thread(vdo, vdo->thread_config.dedupe_thread, &uds_queue_type,

drivers/md/dm-vdo/dedupe.c

2214

vdo_initialize_completion(&zones->completion, vdo, VDO_HASH_ZONES_COMPLETION);

drivers/md/dm-vdo/dedupe.c

2216

vdo->thread_config.dedupe_thread);

drivers/md/dm-vdo/dedupe.c

2335

report_dedupe_timeouts(completion->vdo->hash_zones, timed_out);

drivers/md/dm-vdo/dedupe.c

2349

static int __must_check initialize_zone(struct vdo *vdo, struct hash_zones *zones,

drivers/md/dm-vdo/dedupe.c

2362

zone->thread_id = vdo->thread_config.hash_zone_threads[zone_number];

drivers/md/dm-vdo/dedupe.c

2363

vdo_initialize_completion(&zone->completion, vdo, VDO_HASH_ZONE_COMPLETION);

drivers/md/dm-vdo/dedupe.c

2391

return vdo_make_default_thread(vdo, zone->thread_id);

drivers/md/dm-vdo/dedupe.c

2410

int vdo_make_hash_zones(struct vdo *vdo, struct hash_zones **zones_ptr)

drivers/md/dm-vdo/dedupe.c

2415

zone_count_t zone_count = vdo->thread_config.hash_zone_count;

drivers/md/dm-vdo/dedupe.c

2424

result = initialize_index(vdo, zones);

drivers/md/dm-vdo/dedupe.c

2434

result = initialize_zone(vdo, zones, z);

drivers/md/dm-vdo/dedupe.c

2442

vdo->thread_config.admin_thread, zones, NULL,

drivers/md/dm-vdo/dedupe.c

2443

vdo, &zones->manager);

drivers/md/dm-vdo/dedupe.c

2546

vdo_schedule_operation(zones->manager, parent->vdo->suspend_type, suspend_index,

drivers/md/dm-vdo/dedupe.c

2577

struct device_config *config = parent->vdo->device_config;

drivers/md/dm-vdo/dedupe.c

2617

if (vdo_is_read_only(parent->vdo)) {

drivers/md/dm-vdo/dedupe.c

2902

struct vdo *vdo = vdo_from_data_vio(data_vio);

drivers/md/dm-vdo/dedupe.c

2907

if (!READ_ONCE(vdo->hash_zones->dedupe_flag)) {

drivers/md/dm-vdo/dedupe.c

2914

atomic64_inc(&vdo->hash_zones->dedupe_context_busy);

drivers/md/dm-vdo/dedupe.h

81

int __must_check vdo_make_hash_zones(struct vdo *vdo, struct hash_zones **zones_ptr);

drivers/md/dm-vdo/dm-vdo-target.c

1002

vdo_count_bios(&vdo->stats.bios_in, bio);

drivers/md/dm-vdo/dm-vdo-target.c

1007

vdo_launch_flush(vdo, bio);

drivers/md/dm-vdo/dm-vdo-target.c

1014

(vdo == vdo_get_work_queue_owner(current_work_queue)->vdo));

drivers/md/dm-vdo/dm-vdo-target.c

1015

vdo_launch_bio(vdo->data_vio_pool, bio);

drivers/md/dm-vdo/dm-vdo-target.c

1021

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

1023

limits->logical_block_size = vdo->device_config->logical_block_size;

drivers/md/dm-vdo/dm-vdo-target.c

1045

(vdo->device_config->max_discard_blocks * VDO_SECTORS_PER_BLOCK);

drivers/md/dm-vdo/dm-vdo-target.c

1072

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

1081

mutex_lock(&vdo->stats_mutex);

drivers/md/dm-vdo/dm-vdo-target.c

1082

vdo_fetch_statistics(vdo, &vdo->stats_buffer);

drivers/md/dm-vdo/dm-vdo-target.c

1083

stats = &vdo->stats_buffer;

drivers/md/dm-vdo/dm-vdo-target.c

1086

vdo_get_backing_device(vdo), stats->mode,

drivers/md/dm-vdo/dm-vdo-target.c

1088

vdo_get_dedupe_index_state_name(vdo->hash_zones),

drivers/md/dm-vdo/dm-vdo-target.c

1089

vdo_get_compressing(vdo) ? "online" : "offline",

drivers/md/dm-vdo/dm-vdo-target.c

1092

mutex_unlock(&vdo->stats_mutex);

drivers/md/dm-vdo/dm-vdo-target.c

1108

static block_count_t __must_check get_underlying_device_block_count(const struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

1110

return bdev_nr_bytes(vdo_get_backing_device(vdo)) / VDO_BLOCK_SIZE;

drivers/md/dm-vdo/dm-vdo-target.c

1113

static int __must_check process_vdo_message_locked(struct vdo *vdo, unsigned int argc,

drivers/md/dm-vdo/dm-vdo-target.c

1118

vdo_set_compressing(vdo, true);

drivers/md/dm-vdo/dm-vdo-target.c

1123

vdo_set_compressing(vdo, false);

drivers/md/dm-vdo/dm-vdo-target.c

1141

static int __must_check process_vdo_message(struct vdo *vdo, unsigned int argc,

drivers/md/dm-vdo/dm-vdo-target.c

1154

return vdo_dump(vdo, argc, argv, "dmsetup message");

drivers/md/dm-vdo/dm-vdo-target.c

1158

vdo->dump_on_shutdown = true;

drivers/md/dm-vdo/dm-vdo-target.c

1167

return vdo_message_dedupe_index(vdo->hash_zones, argv[0]);

drivers/md/dm-vdo/dm-vdo-target.c

1170

if (atomic_cmpxchg(&vdo->processing_message, 0, 1) != 0)

drivers/md/dm-vdo/dm-vdo-target.c

1173

result = process_vdo_message_locked(vdo, argc, argv);

drivers/md/dm-vdo/dm-vdo-target.c

1177

atomic_set(&vdo->processing_message, 0);

drivers/md/dm-vdo/dm-vdo-target.c

1185

struct vdo *vdo;

drivers/md/dm-vdo/dm-vdo-target.c

1193

vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

1195

vdo_register_thread_device_id(&instance_thread, &vdo->instance);

drivers/md/dm-vdo/dm-vdo-target.c

1202

vdo_write_stats(vdo, result_buffer, maxlen);

drivers/md/dm-vdo/dm-vdo-target.c

1205

vdo_write_config(vdo, &result_buffer, &maxlen);

drivers/md/dm-vdo/dm-vdo-target.c

1208

result = vdo_status_to_errno(process_vdo_message(vdo, argc, argv));

drivers/md/dm-vdo/dm-vdo-target.c

1233

static bool vdo_uses_device(struct vdo *vdo, const void *context)

drivers/md/dm-vdo/dm-vdo-target.c

1237

return vdo_get_backing_device(vdo)->bd_dev == config->owned_device->bdev->bd_dev;

drivers/md/dm-vdo/dm-vdo-target.c

1245

static thread_id_t __must_check get_thread_id_for_phase(struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

1247

switch (vdo->admin.phase) {

drivers/md/dm-vdo/dm-vdo-target.c

1252

return vdo->thread_config.packer_thread;

drivers/md/dm-vdo/dm-vdo-target.c

1256

return vdo->thread_config.cpu_thread;

drivers/md/dm-vdo/dm-vdo-target.c

1261

return vdo->thread_config.journal_thread;

drivers/md/dm-vdo/dm-vdo-target.c

1264

return vdo->thread_config.admin_thread;

drivers/md/dm-vdo/dm-vdo-target.c

1268

static struct vdo_completion *prepare_admin_completion(struct vdo *vdo,

drivers/md/dm-vdo/dm-vdo-target.c

1272

struct vdo_completion *completion = &vdo->admin.completion;

drivers/md/dm-vdo/dm-vdo-target.c

1280

completion->callback_thread_id = get_thread_id_for_phase(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

1292

static u32 advance_phase(struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

1294

u32 phase = vdo->admin.phase++;

drivers/md/dm-vdo/dm-vdo-target.c

1296

vdo->admin.completion.callback_thread_id = get_thread_id_for_phase(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

1297

vdo->admin.completion.requeue = true;

drivers/md/dm-vdo/dm-vdo-target.c

1305

static int perform_admin_operation(struct vdo *vdo, u32 starting_phase,

drivers/md/dm-vdo/dm-vdo-target.c

1310

struct vdo_administrator *admin = &vdo->admin;

drivers/md/dm-vdo/dm-vdo-target.c

1321

vdo_launch_completion(prepare_admin_completion(vdo, callback, error_handler));

drivers/md/dm-vdo/dm-vdo-target.c

1340

static void assert_admin_phase_thread(struct vdo *vdo, const char *what)

drivers/md/dm-vdo/dm-vdo-target.c

1342

VDO_ASSERT_LOG_ONLY(vdo_get_callback_thread_id() == get_thread_id_for_phase(vdo),

drivers/md/dm-vdo/dm-vdo-target.c

1344

ADMIN_PHASE_NAMES[vdo->admin.phase]);

drivers/md/dm-vdo/dm-vdo-target.c

1353

struct vdo_administrator *admin = &completion->vdo->admin;

drivers/md/dm-vdo/dm-vdo-target.c

1369

static int __must_check decode_from_super_block(struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

1371

const struct device_config *config = vdo->device_config;

drivers/md/dm-vdo/dm-vdo-target.c

1374

result = vdo_decode_component_states(vdo->super_block.buffer, &vdo->geometry,

drivers/md/dm-vdo/dm-vdo-target.c

1375

&vdo->states);

drivers/md/dm-vdo/dm-vdo-target.c

1379

vdo_set_state(vdo, vdo->states.vdo.state);

drivers/md/dm-vdo/dm-vdo-target.c

1380

vdo->load_state = vdo->states.vdo.state;

drivers/md/dm-vdo/dm-vdo-target.c

1386

if (vdo->states.vdo.config.logical_blocks < config->logical_blocks) {

drivers/md/dm-vdo/dm-vdo-target.c

1389

(unsigned long long) vdo->states.vdo.config.logical_blocks);

drivers/md/dm-vdo/dm-vdo-target.c

1390

vdo->states.vdo.config.logical_blocks = config->logical_blocks;

drivers/md/dm-vdo/dm-vdo-target.c

1393

result = vdo_validate_component_states(&vdo->states, vdo->geometry.nonce,

drivers/md/dm-vdo/dm-vdo-target.c

1399

vdo->layout = vdo->states.layout;

drivers/md/dm-vdo/dm-vdo-target.c

1414

static int __must_check decode_vdo(struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

1420

result = decode_from_super_block(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

1422

vdo_destroy_component_states(&vdo->states);

drivers/md/dm-vdo/dm-vdo-target.c

1426

maximum_age = vdo_convert_maximum_age(vdo->device_config->block_map_maximum_age);

drivers/md/dm-vdo/dm-vdo-target.c

1428

vdo_get_recovery_journal_length(vdo->states.vdo.config.recovery_journal_size);

drivers/md/dm-vdo/dm-vdo-target.c

1441

result = vdo_enable_read_only_entry(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

1445

partition = vdo_get_known_partition(&vdo->layout,

drivers/md/dm-vdo/dm-vdo-target.c

1447

result = vdo_decode_recovery_journal(vdo->states.recovery_journal,

drivers/md/dm-vdo/dm-vdo-target.c

1448

vdo->states.vdo.nonce, vdo, partition,

drivers/md/dm-vdo/dm-vdo-target.c

1449

vdo->states.vdo.complete_recoveries,

drivers/md/dm-vdo/dm-vdo-target.c

1450

vdo->states.vdo.config.recovery_journal_size,

drivers/md/dm-vdo/dm-vdo-target.c

1451

&vdo->recovery_journal);

drivers/md/dm-vdo/dm-vdo-target.c

1455

partition = vdo_get_known_partition(&vdo->layout, VDO_SLAB_SUMMARY_PARTITION);

drivers/md/dm-vdo/dm-vdo-target.c

1456

result = vdo_decode_slab_depot(vdo->states.slab_depot, vdo, partition,

drivers/md/dm-vdo/dm-vdo-target.c

1457

&vdo->depot);

drivers/md/dm-vdo/dm-vdo-target.c

1461

result = vdo_decode_block_map(vdo->states.block_map,

drivers/md/dm-vdo/dm-vdo-target.c

1462

vdo->states.vdo.config.logical_blocks, vdo,

drivers/md/dm-vdo/dm-vdo-target.c

1463

vdo->recovery_journal, vdo->states.vdo.nonce,

drivers/md/dm-vdo/dm-vdo-target.c

1464

vdo->device_config->cache_size, maximum_age,

drivers/md/dm-vdo/dm-vdo-target.c

1465

&vdo->block_map);

drivers/md/dm-vdo/dm-vdo-target.c

1469

result = vdo_make_physical_zones(vdo, &vdo->physical_zones);

drivers/md/dm-vdo/dm-vdo-target.c

1474

result = vdo_make_logical_zones(vdo, &vdo->logical_zones);

drivers/md/dm-vdo/dm-vdo-target.c

1478

return vdo_make_hash_zones(vdo, &vdo->hash_zones);

drivers/md/dm-vdo/dm-vdo-target.c

1487

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

1490

assert_admin_phase_thread(vdo, __func__);

drivers/md/dm-vdo/dm-vdo-target.c

1492

switch (advance_phase(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

1494

result = vdo_start_operation(&vdo->admin.state,

drivers/md/dm-vdo/dm-vdo-target.c

1500

if (vdo->needs_formatting)

drivers/md/dm-vdo/dm-vdo-target.c

1501

vdo->admin.phase = PRE_LOAD_PHASE_FORMAT_START;

drivers/md/dm-vdo/dm-vdo-target.c

1503

vdo->admin.phase = PRE_LOAD_PHASE_LOAD_SUPER;

drivers/md/dm-vdo/dm-vdo-target.c

1509

vdo_continue_completion(completion, vdo_clear_layout(vdo));

drivers/md/dm-vdo/dm-vdo-target.c

1513

vdo_save_super_block(vdo, completion);

drivers/md/dm-vdo/dm-vdo-target.c

1517

vdo_save_geometry_block(vdo, completion);

drivers/md/dm-vdo/dm-vdo-target.c

1522

vdo_uninitialize_layout(&vdo->states.layout);

drivers/md/dm-vdo/dm-vdo-target.c

1527

vdo_load_super_block(vdo, completion);

drivers/md/dm-vdo/dm-vdo-target.c

1531

vdo_continue_completion(completion, decode_vdo(vdo));

drivers/md/dm-vdo/dm-vdo-target.c

1560

static void set_device_config(struct dm_target *ti, struct vdo *vdo,

drivers/md/dm-vdo/dm-vdo-target.c

1564

list_add_tail(&config->config_list, &vdo->device_config_list);

drivers/md/dm-vdo/dm-vdo-target.c

1565

config->vdo = vdo;

drivers/md/dm-vdo/dm-vdo-target.c

1573

struct vdo *vdo;

drivers/md/dm-vdo/dm-vdo-target.c

1592

vdo = vdo_find_matching(vdo_uses_device, config);

drivers/md/dm-vdo/dm-vdo-target.c

1593

if (vdo != NULL) {

drivers/md/dm-vdo/dm-vdo-target.c

1595

vdo->device_config->parent_device_name);

drivers/md/dm-vdo/dm-vdo-target.c

1600

result = vdo_make(instance, config, &ti->error, &vdo);

drivers/md/dm-vdo/dm-vdo-target.c

1604

vdo_destroy(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

1608

result = perform_admin_operation(vdo, PRE_LOAD_PHASE_START, pre_load_callback,

drivers/md/dm-vdo/dm-vdo-target.c

1616

vdo_destroy(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

1620

set_device_config(ti, vdo, config);

drivers/md/dm-vdo/dm-vdo-target.c

1621

vdo->device_config = config;

drivers/md/dm-vdo/dm-vdo-target.c

1626

static bool __must_check vdo_is_named(struct vdo *vdo, const void *context)

drivers/md/dm-vdo/dm-vdo-target.c

1628

struct dm_target *ti = vdo->device_config->owning_target;

drivers/md/dm-vdo/dm-vdo-target.c

1766

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

1768

assert_admin_phase_thread(vdo, __func__);

drivers/md/dm-vdo/dm-vdo-target.c

1771

if (vdo_is_read_only(vdo))

drivers/md/dm-vdo/dm-vdo-target.c

1774

if (vdo_in_recovery_mode(vdo))

drivers/md/dm-vdo/dm-vdo-target.c

1793

static int grow_layout(struct vdo *vdo, block_count_t old_size, block_count_t new_size)

drivers/md/dm-vdo/dm-vdo-target.c

1798

if (vdo->next_layout.size == new_size) {

drivers/md/dm-vdo/dm-vdo-target.c

1804

if (vdo->partition_copier == NULL) {

drivers/md/dm-vdo/dm-vdo-target.c

1805

vdo->partition_copier = dm_kcopyd_client_create(NULL);

drivers/md/dm-vdo/dm-vdo-target.c

1806

if (IS_ERR(vdo->partition_copier)) {

drivers/md/dm-vdo/dm-vdo-target.c

1807

result = PTR_ERR(vdo->partition_copier);

drivers/md/dm-vdo/dm-vdo-target.c

1808

vdo->partition_copier = NULL;

drivers/md/dm-vdo/dm-vdo-target.c

1814

vdo_uninitialize_layout(&vdo->next_layout);

drivers/md/dm-vdo/dm-vdo-target.c

1820

result = vdo_initialize_layout(new_size, vdo->layout.start,

drivers/md/dm-vdo/dm-vdo-target.c

1821

get_partition_size(&vdo->layout,

drivers/md/dm-vdo/dm-vdo-target.c

1823

get_partition_size(&vdo->layout,

drivers/md/dm-vdo/dm-vdo-target.c

1825

get_partition_size(&vdo->layout,

drivers/md/dm-vdo/dm-vdo-target.c

1827

&vdo->next_layout);

drivers/md/dm-vdo/dm-vdo-target.c

1829

dm_kcopyd_client_destroy(vdo_forget(vdo->partition_copier));

drivers/md/dm-vdo/dm-vdo-target.c

1835

get_partition_size(&vdo->next_layout,

drivers/md/dm-vdo/dm-vdo-target.c

1837

get_partition_size(&vdo->next_layout,

drivers/md/dm-vdo/dm-vdo-target.c

1841

vdo_uninitialize_layout(&vdo->next_layout);

drivers/md/dm-vdo/dm-vdo-target.c

1842

dm_kcopyd_client_destroy(vdo_forget(vdo->partition_copier));

drivers/md/dm-vdo/dm-vdo-target.c

1849

static int prepare_to_grow_physical(struct vdo *vdo, block_count_t new_physical_blocks)

drivers/md/dm-vdo/dm-vdo-target.c

1852

block_count_t current_physical_blocks = vdo->states.vdo.config.physical_blocks;

drivers/md/dm-vdo/dm-vdo-target.c

1858

result = perform_admin_operation(vdo, PREPARE_GROW_PHYSICAL_PHASE_START,

drivers/md/dm-vdo/dm-vdo-target.c

1865

result = grow_layout(vdo, current_physical_blocks, new_physical_blocks);

drivers/md/dm-vdo/dm-vdo-target.c

1869

result = vdo_prepare_to_grow_slab_depot(vdo->depot,

drivers/md/dm-vdo/dm-vdo-target.c

1870

vdo_get_known_partition(&vdo->next_layout,

drivers/md/dm-vdo/dm-vdo-target.c

1873

vdo_uninitialize_layout(&vdo->next_layout);

drivers/md/dm-vdo/dm-vdo-target.c

1941

struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

1944

bool may_grow = (vdo_get_admin_state(vdo) != VDO_ADMIN_STATE_PRE_LOADED);

drivers/md/dm-vdo/dm-vdo-target.c

1946

result = validate_new_device_config(config, vdo->device_config, may_grow,

drivers/md/dm-vdo/dm-vdo-target.c

1951

if (config->logical_blocks > vdo->device_config->logical_blocks) {

drivers/md/dm-vdo/dm-vdo-target.c

1952

block_count_t logical_blocks = vdo->states.vdo.config.logical_blocks;

drivers/md/dm-vdo/dm-vdo-target.c

1959

result = vdo_prepare_to_grow_block_map(vdo->block_map,

drivers/md/dm-vdo/dm-vdo-target.c

1969

if (config->physical_blocks > vdo->device_config->physical_blocks) {

drivers/md/dm-vdo/dm-vdo-target.c

1970

result = prepare_to_grow_physical(vdo, config->physical_blocks);

drivers/md/dm-vdo/dm-vdo-target.c

1989

if (strcmp(config->parent_device_name, vdo->device_config->parent_device_name) != 0) {

drivers/md/dm-vdo/dm-vdo-target.c

1993

vdo->device_config->parent_device_name,

drivers/md/dm-vdo/dm-vdo-target.c

2001

unsigned int argc, char **argv, struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

2011

result = prepare_to_modify(ti, config, vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2017

set_device_config(ti, vdo, config);

drivers/md/dm-vdo/dm-vdo-target.c

2026

struct vdo *vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2030

vdo = vdo_find_matching(vdo_is_named, device_name);

drivers/md/dm-vdo/dm-vdo-target.c

2031

if (vdo == NULL) {

drivers/md/dm-vdo/dm-vdo-target.c

2034

vdo_register_thread_device_id(&instance_thread, &vdo->instance);

drivers/md/dm-vdo/dm-vdo-target.c

2035

result = update_existing_vdo(device_name, ti, argc, argv, vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2046

struct vdo *vdo = vdo_forget(config->vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2049

if (list_empty(&vdo->device_config_list)) {

drivers/md/dm-vdo/dm-vdo-target.c

2053

unsigned int instance = vdo->instance;

drivers/md/dm-vdo/dm-vdo-target.c

2061

if (vdo->dump_on_shutdown)

drivers/md/dm-vdo/dm-vdo-target.c

2062

vdo_dump_all(vdo, "device shutdown");

drivers/md/dm-vdo/dm-vdo-target.c

2064

vdo_destroy(vdo_forget(vdo));

drivers/md/dm-vdo/dm-vdo-target.c

2069

} else if (config == vdo->device_config) {

drivers/md/dm-vdo/dm-vdo-target.c

2074

vdo->device_config = list_first_entry(&vdo->device_config_list,

drivers/md/dm-vdo/dm-vdo-target.c

2094

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2096

switch (vdo_get_state(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2099

vdo_set_state(vdo, VDO_CLEAN);

drivers/md/dm-vdo/dm-vdo-target.c

2115

vdo_save_components(vdo, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2124

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2125

struct admin_state *state = &vdo->admin.state;

drivers/md/dm-vdo/dm-vdo-target.c

2128

assert_admin_phase_thread(vdo, __func__);

drivers/md/dm-vdo/dm-vdo-target.c

2130

switch (advance_phase(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2138

vdo_start_operation(state, vdo->suspend_type));

drivers/md/dm-vdo/dm-vdo-target.c

2148

if (vdo_in_read_only_mode(vdo))

drivers/md/dm-vdo/dm-vdo-target.c

2151

vdo_drain_packer(vdo->packer, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2155

drain_data_vio_pool(vdo->data_vio_pool, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2159

vdo_drain_hash_zones(vdo->hash_zones, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2163

vdo_drain_flusher(vdo->flusher, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2172

result = vdo_synchronous_flush(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2174

vdo_enter_read_only_mode(vdo, result);

drivers/md/dm-vdo/dm-vdo-target.c

2176

vdo_drain_logical_zones(vdo->logical_zones,

drivers/md/dm-vdo/dm-vdo-target.c

2181

vdo_drain_block_map(vdo->block_map, vdo_get_admin_state_code(state),

drivers/md/dm-vdo/dm-vdo-target.c

2186

vdo_drain_recovery_journal(vdo->recovery_journal,

drivers/md/dm-vdo/dm-vdo-target.c

2191

vdo_drain_slab_depot(vdo->depot, vdo_get_admin_state_code(state),

drivers/md/dm-vdo/dm-vdo-target.c

2220

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

2225

vdo_register_thread_device_id(&instance_thread, &vdo->instance);

drivers/md/dm-vdo/dm-vdo-target.c

2226

device_name = vdo_get_device_name(vdo->device_config->owning_target);

drivers/md/dm-vdo/dm-vdo-target.c

2233

result = perform_admin_operation(vdo, SUSPEND_PHASE_START, suspend_callback,

drivers/md/dm-vdo/dm-vdo-target.c

2244

vdo_get_admin_state(vdo)->name);

drivers/md/dm-vdo/dm-vdo-target.c

2259

static bool was_new(const struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

2261

return (vdo->load_state == VDO_NEW);

drivers/md/dm-vdo/dm-vdo-target.c

2270

static bool __must_check requires_repair(const struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

2272

switch (vdo_get_state(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2290

static enum slab_depot_load_type get_load_type(struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

2292

if (vdo_state_requires_read_only_rebuild(vdo->load_state))

drivers/md/dm-vdo/dm-vdo-target.c

2295

if (vdo_state_requires_recovery(vdo->load_state))

drivers/md/dm-vdo/dm-vdo-target.c

2307

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2310

assert_admin_phase_thread(vdo, __func__);

drivers/md/dm-vdo/dm-vdo-target.c

2312

switch (advance_phase(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2314

result = vdo_start_operation(&vdo->admin.state, VDO_ADMIN_STATE_LOADING);

drivers/md/dm-vdo/dm-vdo-target.c

2321

vdo_open_recovery_journal(vdo->recovery_journal, vdo->depot,

drivers/md/dm-vdo/dm-vdo-target.c

2322

vdo->block_map);

drivers/md/dm-vdo/dm-vdo-target.c

2327

vdo_set_dedupe_state_normal(vdo->hash_zones);

drivers/md/dm-vdo/dm-vdo-target.c

2328

if (vdo_is_read_only(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2337

if (requires_repair(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2342

vdo_load_slab_depot(vdo->depot,

drivers/md/dm-vdo/dm-vdo-target.c

2343

(was_new(vdo) ? VDO_ADMIN_STATE_FORMATTING :

drivers/md/dm-vdo/dm-vdo-target.c

2349

vdo_set_state(vdo, VDO_DIRTY);

drivers/md/dm-vdo/dm-vdo-target.c

2350

vdo_save_components(vdo, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2354

vdo_initialize_block_map_from_journal(vdo->block_map,

drivers/md/dm-vdo/dm-vdo-target.c

2355

vdo->recovery_journal);

drivers/md/dm-vdo/dm-vdo-target.c

2356

vdo_prepare_slab_depot_to_allocate(vdo->depot, get_load_type(vdo),

drivers/md/dm-vdo/dm-vdo-target.c

2361

if (vdo_state_requires_recovery(vdo->load_state))

drivers/md/dm-vdo/dm-vdo-target.c

2362

vdo_enter_recovery_mode(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2364

vdo_scrub_all_unrecovered_slabs(vdo->depot, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2368

WRITE_ONCE(vdo->compressing, vdo->device_config->compression);

drivers/md/dm-vdo/dm-vdo-target.c

2369

if (vdo->device_config->deduplication) {

drivers/md/dm-vdo/dm-vdo-target.c

2374

vdo_start_dedupe_index(vdo->hash_zones, was_new(vdo));

drivers/md/dm-vdo/dm-vdo-target.c

2377

vdo->allocations_allowed = false;

drivers/md/dm-vdo/dm-vdo-target.c

2384

vdo_drain_recovery_journal(vdo->recovery_journal, VDO_ADMIN_STATE_SAVING,

drivers/md/dm-vdo/dm-vdo-target.c

2391

vdo->admin.phase = LOAD_PHASE_FINISHED;

drivers/md/dm-vdo/dm-vdo-target.c

2411

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2414

vdo->thread_config.admin_thread))

drivers/md/dm-vdo/dm-vdo-target.c

2417

if (vdo_state_requires_read_only_rebuild(vdo->load_state) &&

drivers/md/dm-vdo/dm-vdo-target.c

2418

(vdo->admin.phase == LOAD_PHASE_MAKE_DIRTY)) {

drivers/md/dm-vdo/dm-vdo-target.c

2420

vdo->admin.phase = LOAD_PHASE_DRAIN_JOURNAL;

drivers/md/dm-vdo/dm-vdo-target.c

2426

(vdo->admin.phase == LOAD_PHASE_MAKE_DIRTY)) {

drivers/md/dm-vdo/dm-vdo-target.c

2428

vdo->admin.phase = LOAD_PHASE_FINISHED;

drivers/md/dm-vdo/dm-vdo-target.c

2435

vdo->admin.phase = LOAD_PHASE_WAIT_FOR_READ_ONLY;

drivers/md/dm-vdo/dm-vdo-target.c

2436

vdo_enter_read_only_mode(vdo, completion->result);

drivers/md/dm-vdo/dm-vdo-target.c

2447

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2449

switch (vdo_get_state(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2452

vdo_set_state(vdo, VDO_DIRTY);

drivers/md/dm-vdo/dm-vdo-target.c

2453

vdo_save_components(vdo, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2477

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2480

assert_admin_phase_thread(vdo, __func__);

drivers/md/dm-vdo/dm-vdo-target.c

2482

switch (advance_phase(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2484

result = vdo_start_operation(&vdo->admin.state,

drivers/md/dm-vdo/dm-vdo-target.c

2499

vdo_resume_hash_zones(vdo->hash_zones, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2503

vdo_resume_slab_depot(vdo->depot, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2507

vdo_resume_recovery_journal(vdo->recovery_journal, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2511

vdo_resume_block_map(vdo->block_map, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2515

vdo_resume_logical_zones(vdo->logical_zones, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2520

bool was_enabled = vdo_get_compressing(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2521

bool enable = vdo->device_config->compression;

drivers/md/dm-vdo/dm-vdo-target.c

2524

WRITE_ONCE(vdo->compressing, enable);

drivers/md/dm-vdo/dm-vdo-target.c

2527

vdo_resume_packer(vdo->packer, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2532

vdo_resume_flusher(vdo->flusher, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2536

resume_data_vio_pool(vdo->data_vio_pool, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2557

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2560

assert_admin_phase_thread(vdo, __func__);

drivers/md/dm-vdo/dm-vdo-target.c

2562

switch (advance_phase(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2564

if (vdo_is_read_only(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2571

result = vdo_start_operation(&vdo->admin.state,

drivers/md/dm-vdo/dm-vdo-target.c

2578

vdo->states.vdo.config.logical_blocks = vdo->block_map->next_entry_count;

drivers/md/dm-vdo/dm-vdo-target.c

2579

vdo_save_components(vdo, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2583

vdo_grow_block_map(vdo->block_map, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2590

vdo_enter_read_only_mode(vdo, completion->result);

drivers/md/dm-vdo/dm-vdo-target.c

2606

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2608

if (vdo->admin.phase == GROW_LOGICAL_PHASE_GROW_BLOCK_MAP) {

drivers/md/dm-vdo/dm-vdo-target.c

2613

vdo->states.vdo.config.logical_blocks = vdo->block_map->entry_count;

drivers/md/dm-vdo/dm-vdo-target.c

2614

vdo_abandon_block_map_growth(vdo->block_map);

drivers/md/dm-vdo/dm-vdo-target.c

2617

vdo->admin.phase = GROW_LOGICAL_PHASE_ERROR;

drivers/md/dm-vdo/dm-vdo-target.c

2631

static int perform_grow_logical(struct vdo *vdo, block_count_t new_logical_blocks)

drivers/md/dm-vdo/dm-vdo-target.c

2635

if (vdo->device_config->logical_blocks == new_logical_blocks) {

drivers/md/dm-vdo/dm-vdo-target.c

2640

vdo_abandon_block_map_growth(vdo->block_map);

drivers/md/dm-vdo/dm-vdo-target.c

2646

if (vdo->block_map->next_entry_count != new_logical_blocks)

drivers/md/dm-vdo/dm-vdo-target.c

2649

result = perform_admin_operation(vdo, GROW_LOGICAL_PHASE_START,

drivers/md/dm-vdo/dm-vdo-target.c

2667

static void partition_to_region(struct partition *partition, struct vdo *vdo,

drivers/md/dm-vdo/dm-vdo-target.c

2670

physical_block_number_t pbn = partition->offset - vdo->geometry.bio_offset;

drivers/md/dm-vdo/dm-vdo-target.c

2673

.bdev = vdo_get_backing_device(vdo),

drivers/md/dm-vdo/dm-vdo-target.c

2686

static void copy_partition(struct vdo *vdo, enum partition_id id,

drivers/md/dm-vdo/dm-vdo-target.c

2690

struct partition *from = vdo_get_known_partition(&vdo->layout, id);

drivers/md/dm-vdo/dm-vdo-target.c

2691

struct partition *to = vdo_get_known_partition(&vdo->next_layout, id);

drivers/md/dm-vdo/dm-vdo-target.c

2693

partition_to_region(from, vdo, &read_region);

drivers/md/dm-vdo/dm-vdo-target.c

2694

partition_to_region(to, vdo, &write_regions[0]);

drivers/md/dm-vdo/dm-vdo-target.c

2695

dm_kcopyd_copy(vdo->partition_copier, &read_region, 1, write_regions, 0,

drivers/md/dm-vdo/dm-vdo-target.c

2707

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

2710

assert_admin_phase_thread(vdo, __func__);

drivers/md/dm-vdo/dm-vdo-target.c

2712

switch (advance_phase(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2714

if (vdo_is_read_only(vdo)) {

drivers/md/dm-vdo/dm-vdo-target.c

2721

result = vdo_start_operation(&vdo->admin.state,

drivers/md/dm-vdo/dm-vdo-target.c

2729

copy_partition(vdo, VDO_RECOVERY_JOURNAL_PARTITION, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2733

copy_partition(vdo, VDO_SLAB_SUMMARY_PARTITION, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2737

vdo_uninitialize_layout(&vdo->layout);

drivers/md/dm-vdo/dm-vdo-target.c

2738

vdo->layout = vdo->next_layout;

drivers/md/dm-vdo/dm-vdo-target.c

2739

vdo_forget(vdo->next_layout.head);

drivers/md/dm-vdo/dm-vdo-target.c

2740

vdo->states.vdo.config.physical_blocks = vdo->layout.size;

drivers/md/dm-vdo/dm-vdo-target.c

2741

vdo_update_slab_depot_size(vdo->depot);

drivers/md/dm-vdo/dm-vdo-target.c

2742

vdo_save_components(vdo, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2746

vdo_use_new_slabs(vdo->depot, completion);

drivers/md/dm-vdo/dm-vdo-target.c

2750

vdo->depot->summary_origin =

drivers/md/dm-vdo/dm-vdo-target.c

2751

vdo_get_known_partition(&vdo->layout,

drivers/md/dm-vdo/dm-vdo-target.c

2753

vdo->recovery_journal->origin =

drivers/md/dm-vdo/dm-vdo-target.c

2754

vdo_get_known_partition(&vdo->layout,

drivers/md/dm-vdo/dm-vdo-target.c

2759

vdo_enter_read_only_mode(vdo, completion->result);

drivers/md/dm-vdo/dm-vdo-target.c

2766

vdo_uninitialize_layout(&vdo->next_layout);

drivers/md/dm-vdo/dm-vdo-target.c

2776

completion->vdo->admin.phase = GROW_PHYSICAL_PHASE_ERROR;

drivers/md/dm-vdo/dm-vdo-target.c

2790

static int perform_grow_physical(struct vdo *vdo, block_count_t new_physical_blocks)

drivers/md/dm-vdo/dm-vdo-target.c

2794

block_count_t old_physical_blocks = vdo->states.vdo.config.physical_blocks;

drivers/md/dm-vdo/dm-vdo-target.c

2800

if (new_physical_blocks != vdo->next_layout.size) {

drivers/md/dm-vdo/dm-vdo-target.c

2806

vdo_uninitialize_layout(&vdo->next_layout);

drivers/md/dm-vdo/dm-vdo-target.c

2807

vdo_abandon_new_slabs(vdo->depot);

drivers/md/dm-vdo/dm-vdo-target.c

2813

vdo_get_known_partition(&vdo->next_layout, VDO_SLAB_DEPOT_PARTITION)->count;

drivers/md/dm-vdo/dm-vdo-target.c

2814

prepared_depot_size = (vdo->depot->new_slabs == NULL) ? 0 : vdo->depot->new_size;

drivers/md/dm-vdo/dm-vdo-target.c

2818

result = perform_admin_operation(vdo, GROW_PHYSICAL_PHASE_START,

drivers/md/dm-vdo/dm-vdo-target.c

2839

static int __must_check apply_new_vdo_configuration(struct vdo *vdo,

drivers/md/dm-vdo/dm-vdo-target.c

2844

result = perform_grow_logical(vdo, config->logical_blocks);

drivers/md/dm-vdo/dm-vdo-target.c

2850

result = perform_grow_physical(vdo, config->physical_blocks);

drivers/md/dm-vdo/dm-vdo-target.c

2857

static int vdo_preresume_registered(struct dm_target *ti, struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

2864

backing_blocks = get_underlying_device_block_count(vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2873

if (vdo_get_admin_state(vdo) == VDO_ADMIN_STATE_PRE_LOADED) {

drivers/md/dm-vdo/dm-vdo-target.c

2875

result = perform_admin_operation(vdo, LOAD_PHASE_START, load_callback,

drivers/md/dm-vdo/dm-vdo-target.c

2883

vdo->suspend_type = VDO_ADMIN_STATE_SUSPENDING;

drivers/md/dm-vdo/dm-vdo-target.c

2884

perform_admin_operation(vdo, SUSPEND_PHASE_START,

drivers/md/dm-vdo/dm-vdo-target.c

2897

vdo->suspend_type = VDO_ADMIN_STATE_STOPPING;

drivers/md/dm-vdo/dm-vdo-target.c

2898

perform_admin_operation(vdo, SUSPEND_PHASE_START,

drivers/md/dm-vdo/dm-vdo-target.c

2911

result = apply_new_vdo_configuration(vdo, config);

drivers/md/dm-vdo/dm-vdo-target.c

2918

vdo->device_config = config;

drivers/md/dm-vdo/dm-vdo-target.c

2929

vdo_enter_read_only_mode(vdo, result);

drivers/md/dm-vdo/dm-vdo-target.c

2933

if (vdo_get_admin_state(vdo)->normal) {

drivers/md/dm-vdo/dm-vdo-target.c

2938

result = perform_admin_operation(vdo, RESUME_PHASE_START, resume_callback,

drivers/md/dm-vdo/dm-vdo-target.c

2956

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

2959

vdo_register_thread_device_id(&instance_thread, &vdo->instance);

drivers/md/dm-vdo/dm-vdo-target.c

2960

result = vdo_preresume_registered(ti, vdo);

drivers/md/dm-vdo/dm-vdo-target.c

986

static struct vdo *get_vdo_for_target(struct dm_target *ti)

drivers/md/dm-vdo/dm-vdo-target.c

988

return ((struct device_config *) ti->private)->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

994

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

996

const struct admin_state_code *code = vdo_get_admin_state_code(&vdo->admin.state);

drivers/md/dm-vdo/dump.c

130

int vdo_dump(struct vdo *vdo, unsigned int argc, char *const *argv, const char *why)

drivers/md/dm-vdo/dump.c

138

do_dump(vdo, dump_options_requested, why);

drivers/md/dm-vdo/dump.c

143

void vdo_dump_all(struct vdo *vdo, const char *why)

drivers/md/dm-vdo/dump.c

145

do_dump(vdo, ~0, why);

drivers/md/dm-vdo/dump.c

55

static void do_dump(struct vdo *vdo, unsigned int dump_options_requested,

drivers/md/dm-vdo/dump.c

62

active = get_data_vio_pool_active_requests(vdo->data_vio_pool);

drivers/md/dm-vdo/dump.c

63

maximum = get_data_vio_pool_maximum_requests(vdo->data_vio_pool);

drivers/md/dm-vdo/dump.c

64

outstanding = (atomic64_read(&vdo->stats.bios_submitted) -

drivers/md/dm-vdo/dump.c

65

atomic64_read(&vdo->stats.bios_completed));

drivers/md/dm-vdo/dump.c

68

vdo_get_device_name(vdo->device_config->owning_target));

drivers/md/dm-vdo/dump.c

69

if (((dump_options_requested & FLAG_SHOW_QUEUES) != 0) && (vdo->threads != NULL)) {

drivers/md/dm-vdo/dump.c

72

for (id = 0; id < vdo->thread_config.thread_count; id++)

drivers/md/dm-vdo/dump.c

73

vdo_dump_work_queue(vdo->threads[id].queue);

drivers/md/dm-vdo/dump.c

76

vdo_dump_hash_zones(vdo->hash_zones);

drivers/md/dm-vdo/dump.c

77

dump_data_vio_pool(vdo->data_vio_pool,

drivers/md/dm-vdo/dump.c

80

vdo_dump_status(vdo);

drivers/md/dm-vdo/dump.h

11

int vdo_dump(struct vdo *vdo, unsigned int argc, char *const *argv, const char *why);

drivers/md/dm-vdo/dump.h

13

void vdo_dump_all(struct vdo *vdo, const char *why);

drivers/md/dm-vdo/encodings.c

1372

decode_vdo_component(buffer, offset, &states->vdo);

drivers/md/dm-vdo/encodings.c

1375

states->vdo.config.physical_blocks, &states->layout);

drivers/md/dm-vdo/encodings.c

1442

if (geometry_nonce != states->vdo.nonce) {

drivers/md/dm-vdo/encodings.c

1446

(unsigned long long) states->vdo.nonce);

drivers/md/dm-vdo/encodings.c

1449

return vdo_validate_config(&states->vdo.config, physical_size, logical_size);

drivers/md/dm-vdo/encodings.c

1464

encode_vdo_component(buffer, offset, states->vdo);

drivers/md/dm-vdo/encodings.c

1559

states->vdo.config = *vdo_config;

drivers/md/dm-vdo/encodings.c

1560

states->vdo.nonce = nonce;

drivers/md/dm-vdo/encodings.c

1618

states->vdo.state = VDO_NEW;

drivers/md/dm-vdo/encodings.h

693

struct vdo_component vdo;

drivers/md/dm-vdo/flush.c

117

vdo_initialize_completion(&flush->completion, flusher->vdo,

drivers/md/dm-vdo/flush.c

135

int vdo_make_flusher(struct vdo *vdo)

drivers/md/dm-vdo/flush.c

137

int result = vdo_allocate(1, __func__, &vdo->flusher);

drivers/md/dm-vdo/flush.c

142

vdo->flusher->vdo = vdo;

drivers/md/dm-vdo/flush.c

143

vdo->flusher->thread_id = vdo->thread_config.packer_thread;

drivers/md/dm-vdo/flush.c

144

vdo_set_admin_state_code(&vdo->flusher->state, VDO_ADMIN_STATE_NORMAL_OPERATION);

drivers/md/dm-vdo/flush.c

145

vdo_initialize_completion(&vdo->flusher->completion, vdo,

drivers/md/dm-vdo/flush.c

148

spin_lock_init(&vdo->flusher->lock);

drivers/md/dm-vdo/flush.c

149

bio_list_init(&vdo->flusher->waiting_flush_bios);

drivers/md/dm-vdo/flush.c

150

vdo->flusher->flush_pool = mempool_create(1, allocate_flush, free_flush,

drivers/md/dm-vdo/flush.c

151

vdo->flusher);

drivers/md/dm-vdo/flush.c

152

return ((vdo->flusher->flush_pool == NULL) ? -ENOMEM : VDO_SUCCESS);

drivers/md/dm-vdo/flush.c

216

vdo_increment_packer_flush_generation(flusher->vdo->packer);

drivers/md/dm-vdo/flush.c

255

flusher->logical_zone_to_notify = &flusher->vdo->logical_zones->zones[0];

drivers/md/dm-vdo/flush.c

26

struct vdo *vdo;

drivers/md/dm-vdo/flush.c

270

struct flusher *flusher = completion->vdo->flusher;

drivers/md/dm-vdo/flush.c

278

vdo_enter_read_only_mode(flusher->vdo, result);

drivers/md/dm-vdo/flush.c

321

for (zone = &flusher->vdo->logical_zones->zones[0]; zone != NULL; zone = zone->next)

drivers/md/dm-vdo/flush.c

369

static void initialize_flush(struct vdo_flush *flush, struct vdo *vdo)

drivers/md/dm-vdo/flush.c

372

bio_list_merge_init(&flush->bios, &vdo->flusher->waiting_flush_bios);

drivers/md/dm-vdo/flush.c

380

completion->vdo->thread_config.packer_thread, NULL);

drivers/md/dm-vdo/flush.c

392

void vdo_launch_flush(struct vdo *vdo, struct bio *bio)

drivers/md/dm-vdo/flush.c

398

struct vdo_flush *flush = mempool_alloc(vdo->flusher->flush_pool, GFP_NOWAIT);

drivers/md/dm-vdo/flush.c

399

struct flusher *flusher = vdo->flusher;

drivers/md/dm-vdo/flush.c

416

initialize_flush(flush, vdo);

drivers/md/dm-vdo/flush.c

434

struct flusher *flusher = flush->completion.vdo->flusher;

drivers/md/dm-vdo/flush.c

441

initialize_flush(flush, flusher->vdo);

drivers/md/dm-vdo/flush.c

463

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/flush.c

471

vdo_count_bios(&vdo->stats.bios_acknowledged, bio);

drivers/md/dm-vdo/flush.c

474

bio_set_dev(bio, vdo_get_backing_device(vdo));

drivers/md/dm-vdo/flush.c

475

atomic64_inc(&vdo->stats.flush_out);

drivers/md/dm-vdo/flush.c

493

struct vdo *vdo = flusher->vdo;

drivers/md/dm-vdo/flush.c

494

zone_count_t bio_threads = flusher->vdo->thread_config.bio_thread_count;

drivers/md/dm-vdo/flush.c

498

return vdo->thread_config.bio_threads[0];

drivers/md/dm-vdo/flush.c

500

interval = vdo->device_config->thread_counts.bio_rotation_interval;

drivers/md/dm-vdo/flush.c

508

return vdo->thread_config.bio_threads[flusher->bio_queue_rotor];

drivers/md/dm-vdo/flush.c

521

select_bio_queue(completion->vdo->flusher), NULL);

drivers/md/dm-vdo/flush.h

28

int __must_check vdo_make_flusher(struct vdo *vdo);

drivers/md/dm-vdo/flush.h

38

void vdo_launch_flush(struct vdo *vdo, struct bio *bio);

drivers/md/dm-vdo/io-submitter.c

109

struct vdo *vdo = vio->completion.vdo;

drivers/md/dm-vdo/io-submitter.c

112

atomic64_inc(&vdo->stats.bios_submitted);

drivers/md/dm-vdo/io-submitter.c

114

bio_set_dev(bio, vdo_get_backing_device(vdo));

drivers/md/dm-vdo/io-submitter.c

142

struct io_submitter *submitter = vio->completion.vdo->io_submitter;

drivers/md/dm-vdo/io-submitter.c

275

struct vdo *vdo = vio->completion.vdo;

drivers/md/dm-vdo/io-submitter.c

277

&vdo->io_submitter->bio_queue_data[vio->bio_zone];

drivers/md/dm-vdo/io-submitter.c

348

const struct admin_state_code *code = vdo_get_admin_state(completion->vdo);

drivers/md/dm-vdo/io-submitter.c

389

bio_set_dev(vio->bio, vdo_get_backing_device(vio->completion.vdo));

drivers/md/dm-vdo/io-submitter.c

406

unsigned int max_requests_active, struct vdo *vdo,

drivers/md/dm-vdo/io-submitter.c

447

result = vdo_make_thread(vdo, vdo->thread_config.bio_threads[i],

drivers/md/dm-vdo/io-submitter.c

461

bio_queue_data->queue = vdo->threads[vdo->thread_config.bio_threads[i]].queue;

drivers/md/dm-vdo/io-submitter.c

76

struct atomic_statistics *stats = &vio->completion.vdo->stats;

drivers/md/dm-vdo/io-submitter.h

17

unsigned int max_requests_active, struct vdo *vdo,

drivers/md/dm-vdo/logical-zone.c

101

zones->vdo = vdo;

drivers/md/dm-vdo/logical-zone.c

112

vdo->thread_config.admin_thread, zones, NULL,

drivers/md/dm-vdo/logical-zone.c

113

vdo, &zones->manager);

drivers/md/dm-vdo/logical-zone.c

276

vdo_complete_flushes(zone->zones->vdo->flusher);

drivers/md/dm-vdo/logical-zone.c

301

vdo_get_flusher_thread_id(zone->zones->vdo->flusher));

drivers/md/dm-vdo/logical-zone.c

54

struct vdo *vdo = zones->vdo;

drivers/md/dm-vdo/logical-zone.c

62

if (zone_number < vdo->thread_config.logical_zone_count - 1)

drivers/md/dm-vdo/logical-zone.c

65

vdo_initialize_completion(&zone->completion, vdo,

drivers/md/dm-vdo/logical-zone.c

69

zone->thread_id = vdo->thread_config.logical_threads[zone_number];

drivers/md/dm-vdo/logical-zone.c

70

zone->block_map_zone = &vdo->block_map->zones[zone_number];

drivers/md/dm-vdo/logical-zone.c

74

allocation_zone_number = zone->thread_id % vdo->thread_config.physical_zone_count;

drivers/md/dm-vdo/logical-zone.c

75

zone->allocation_zone = &vdo->physical_zones->zones[allocation_zone_number];

drivers/md/dm-vdo/logical-zone.c

77

return vdo_make_default_thread(vdo, zone->thread_id);

drivers/md/dm-vdo/logical-zone.c

87

int vdo_make_logical_zones(struct vdo *vdo, struct logical_zones **zones_ptr)

drivers/md/dm-vdo/logical-zone.c

92

zone_count_t zone_count = vdo->thread_config.logical_zone_count;

drivers/md/dm-vdo/logical-zone.h

57

struct vdo *vdo;

drivers/md/dm-vdo/logical-zone.h

66

int __must_check vdo_make_logical_zones(struct vdo *vdo,

drivers/md/dm-vdo/message-stats.c

418

int vdo_write_stats(struct vdo *vdo, char *buf, unsigned int maxlen)

drivers/md/dm-vdo/message-stats.c

429

vdo_fetch_statistics(vdo, stats);

drivers/md/dm-vdo/message-stats.c

461

int vdo_write_config(struct vdo *vdo, char **buf, unsigned int *maxlen)

drivers/md/dm-vdo/message-stats.c

463

struct vdo_config *config = &vdo->states.vdo.config;

drivers/md/dm-vdo/message-stats.c

477

write_index_config(&vdo->geometry.index_config, buf, maxlen);

drivers/md/dm-vdo/message-stats.h

11

int vdo_write_config(struct vdo *vdo, char **buf, unsigned int *maxlen);

drivers/md/dm-vdo/message-stats.h

12

int vdo_write_stats(struct vdo *vdo, char *buf, unsigned int maxlen);

drivers/md/dm-vdo/packer.c

142

int vdo_make_packer(struct vdo *vdo, block_count_t bin_count, struct packer **packer_ptr)

drivers/md/dm-vdo/packer.c

152

packer->thread_id = vdo->thread_config.packer_thread;

drivers/md/dm-vdo/packer.c

177

result = vdo_make_default_thread(vdo, packer->thread_id);

drivers/md/dm-vdo/packer.h

101

int __must_check vdo_make_packer(struct vdo *vdo, block_count_t bin_count,

drivers/md/dm-vdo/physical-zone.c

325

static int initialize_zone(struct vdo *vdo, struct physical_zones *zones)

drivers/md/dm-vdo/physical-zone.c

342

zone->thread_id = vdo->thread_config.physical_threads[zone_number];

drivers/md/dm-vdo/physical-zone.c

343

zone->allocator = &vdo->depot->allocators[zone_number];

drivers/md/dm-vdo/physical-zone.c

344

zone->next = &zones->zones[(zone_number + 1) % vdo->thread_config.physical_zone_count];

drivers/md/dm-vdo/physical-zone.c

345

result = vdo_make_default_thread(vdo, zone->thread_id);

drivers/md/dm-vdo/physical-zone.c

361

int vdo_make_physical_zones(struct vdo *vdo, struct physical_zones **zones_ptr)

drivers/md/dm-vdo/physical-zone.c

365

zone_count_t zone_count = vdo->thread_config.physical_zone_count;

drivers/md/dm-vdo/physical-zone.c

375

result = initialize_zone(vdo, zones);

drivers/md/dm-vdo/physical-zone.h

94

int __must_check vdo_make_physical_zones(struct vdo *vdo,

drivers/md/dm-vdo/recovery-journal.c

323

return vdo_is_read_only(journal->flush_vio->completion.vdo);

drivers/md/dm-vdo/recovery-journal.c

397

vdo_enter_read_only_mode(journal->flush_vio->completion.vdo, error_code);

drivers/md/dm-vdo/recovery-journal.c

590

struct vdo *vdo)

drivers/md/dm-vdo/recovery-journal.c

593

struct thread_config *config = &vdo->thread_config;

drivers/md/dm-vdo/recovery-journal.c

622

vdo_initialize_completion(&counter->completion, vdo,

drivers/md/dm-vdo/recovery-journal.c

655

static int initialize_recovery_block(struct vdo *vdo, struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

676

result = allocate_vio_components(vdo, VIO_TYPE_RECOVERY_JOURNAL,

drivers/md/dm-vdo/recovery-journal.c

703

struct vdo *vdo, struct partition *partition,

drivers/md/dm-vdo/recovery-journal.c

720

journal->thread_id = vdo->thread_config.journal_thread;

drivers/md/dm-vdo/recovery-journal.c

737

result = initialize_recovery_block(vdo, journal, block);

drivers/md/dm-vdo/recovery-journal.c

744

result = initialize_lock_counter(journal, vdo);

drivers/md/dm-vdo/recovery-journal.c

750

result = create_metadata_vio(vdo, VIO_TYPE_RECOVERY_JOURNAL, VIO_PRIORITY_HIGH,

drivers/md/dm-vdo/recovery-journal.c

757

result = vdo_register_read_only_listener(vdo, journal,

drivers/md/dm-vdo/recovery-journal.c

765

result = vdo_make_default_thread(vdo, journal->thread_id);

drivers/md/dm-vdo/recovery-journal.h

255

nonce_t nonce, struct vdo *vdo,

drivers/md/dm-vdo/repair.c

1041

&repair->completion.vdo->block_map->zones[0], pbn, true,

drivers/md/dm-vdo/repair.c

1099

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/repair.c

1103

vdo_assert_on_logical_zone_thread(vdo, 0, __func__);

drivers/md/dm-vdo/repair.c

1106

vdo->block_map->zones[0].page_cache.rebuilding =

drivers/md/dm-vdo/repair.c

1107

vdo_state_requires_read_only_rebuild(vdo->load_state);

drivers/md/dm-vdo/repair.c

1224

struct recovery_journal *journal = repair->completion.vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1275

static bool unpack_entry(struct vdo *vdo, char *packed, enum vdo_metadata_type format,

drivers/md/dm-vdo/repair.c

1309

return (validate_recovery_journal_entry(vdo, entry) == VDO_SUCCESS);

drivers/md/dm-vdo/repair.c

1326

struct vdo *vdo = repair->completion.vdo;

drivers/md/dm-vdo/repair.c

1334

if (!unpack_entry(vdo, entries, format, &entry))

drivers/md/dm-vdo/repair.c

1406

struct vdo *vdo = repair->completion.vdo;

drivers/md/dm-vdo/repair.c

1407

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1455

struct vdo *vdo = repair->completion.vdo;

drivers/md/dm-vdo/repair.c

1474

result = validate_recovery_journal_entry(vdo, &entry);

drivers/md/dm-vdo/repair.c

1476

vdo_enter_read_only_mode(vdo, result);

drivers/md/dm-vdo/repair.c

1493

vdo_enter_read_only_mode(vdo, result);

drivers/md/dm-vdo/repair.c

1515

struct vdo *vdo = repair->completion.vdo;

drivers/md/dm-vdo/repair.c

1516

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1529

result = validate_recovery_journal_entry(vdo, &entry);

drivers/md/dm-vdo/repair.c

1531

vdo_enter_read_only_mode(vdo, result);

drivers/md/dm-vdo/repair.c

1555

struct recovery_journal *journal = repair->completion.vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1581

vdo_enter_read_only_mode(repair->completion.vdo, VDO_CORRUPT_JOURNAL);

drivers/md/dm-vdo/repair.c

1651

return (vdo_state_requires_read_only_rebuild(repair->completion.vdo->load_state) ?

drivers/md/dm-vdo/repair.c

1682

struct vdo *vdo = vio->completion.vdo;

drivers/md/dm-vdo/repair.c

1684

continue_vio_after_io(vio, finish_journal_load, vdo->thread_config.admin_thread);

drivers/md/dm-vdo/repair.c

1696

struct vdo *vdo = parent->vdo;

drivers/md/dm-vdo/repair.c

1697

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1702

vdo->device_config->cache_size >> 1,

drivers/md/dm-vdo/repair.c

1705

vdo_assert_on_admin_thread(vdo, __func__);

drivers/md/dm-vdo/repair.c

1707

if (vdo->load_state == VDO_FORCE_REBUILD) {

drivers/md/dm-vdo/repair.c

1709

vdo->states.vdo.read_only_recoveries++;

drivers/md/dm-vdo/repair.c

1710

} else if (vdo->load_state == VDO_REBUILD_FOR_UPGRADE) {

drivers/md/dm-vdo/repair.c

1722

vdo_initialize_completion(&repair->completion, vdo, VDO_REPAIR_COMPLETION);

drivers/md/dm-vdo/repair.c

1741

result = allocate_vio_components(vdo, VIO_TYPE_RECOVERY_JOURNAL,

drivers/md/dm-vdo/repair.c

207

const struct thread_config *thread_config = &completion->vdo->thread_config;

drivers/md/dm-vdo/repair.c

242

repair->completion.vdo->block_map->zones[0].page_cache.rebuilding = false;

drivers/md/dm-vdo/repair.c

253

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/repair.c

256

vdo_assert_on_admin_thread(vdo, __func__);

drivers/md/dm-vdo/repair.c

258

if (vdo->load_state != VDO_REBUILD_FOR_UPGRADE)

drivers/md/dm-vdo/repair.c

259

vdo->states.vdo.complete_recoveries++;

drivers/md/dm-vdo/repair.c

261

vdo_initialize_recovery_journal_post_repair(vdo->recovery_journal,

drivers/md/dm-vdo/repair.c

262

vdo->states.vdo.complete_recoveries,

drivers/md/dm-vdo/repair.c

268

if (vdo_state_requires_read_only_rebuild(vdo->load_state)) {

drivers/md/dm-vdo/repair.c

281

vdo_continue_completion(parent, vdo_allocate_reference_counters(vdo->depot));

drivers/md/dm-vdo/repair.c

294

if (vdo_state_requires_read_only_rebuild(completion->vdo->load_state))

drivers/md/dm-vdo/repair.c

326

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/repair.c

330

vdo_assert_on_admin_thread(vdo, __func__);

drivers/md/dm-vdo/repair.c

333

if (vdo_state_requires_read_only_rebuild(vdo->load_state)) {

drivers/md/dm-vdo/repair.c

342

vdo_drain_slab_depot(vdo->depot, operation, completion);

drivers/md/dm-vdo/repair.c

353

vdo_assert_on_admin_thread(completion->vdo, __func__);

drivers/md/dm-vdo/repair.c

358

vdo_drain_block_map(completion->vdo->block_map, VDO_ADMIN_STATE_RECOVERING,

drivers/md/dm-vdo/repair.c

423

struct slab_depot *depot = completion->vdo->depot;

drivers/md/dm-vdo/repair.c

527

if (vdo_is_physical_data_block(repair->completion.vdo->depot, pbn))

drivers/md/dm-vdo/repair.c

545

struct block_map *block_map = repair->completion.vdo->block_map;

drivers/md/dm-vdo/repair.c

577

struct block_map *map = completion->vdo->block_map;

drivers/md/dm-vdo/repair.c

616

struct slab_depot *depot = completion->vdo->depot;

drivers/md/dm-vdo/repair.c

640

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/repair.c

641

struct vdo_page_cache *cache = &vdo->block_map->zones[0].page_cache;

drivers/md/dm-vdo/repair.c

644

if (abort_on_error(vdo_allocate_reference_counters(vdo->depot), repair))

drivers/md/dm-vdo/repair.c

655

vdo_traverse_forest(vdo->block_map, process_entry, completion);

drivers/md/dm-vdo/repair.c

738

sector = get_sector(repair->completion.vdo->recovery_journal,

drivers/md/dm-vdo/repair.c

751

static int validate_recovery_journal_entry(const struct vdo *vdo,

drivers/md/dm-vdo/repair.c

754

if ((entry->slot.pbn >= vdo->states.vdo.config.physical_blocks) ||

drivers/md/dm-vdo/repair.c

758

!vdo_is_physical_data_block(vdo->depot, entry->mapping.pbn) ||

drivers/md/dm-vdo/repair.c

759

!vdo_is_physical_data_block(vdo->depot, entry->unmapping.pbn)) {

drivers/md/dm-vdo/repair.c

797

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/repair.c

798

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

815

result = validate_recovery_journal_entry(vdo, &entry);

drivers/md/dm-vdo/repair.c

817

vdo_enter_read_only_mode(vdo, result);

drivers/md/dm-vdo/repair.c

830

slab = vdo_get_slab(vdo->depot, pbn);

drivers/md/dm-vdo/repair.c

855

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/repair.c

857

vdo_assert_on_physical_zone_thread(vdo, allocator->zone_number, __func__);

drivers/md/dm-vdo/repair.c

860

repair->logical_blocks_used = vdo->recovery_journal->logical_blocks_used;

drivers/md/dm-vdo/repair.c

861

repair->block_map_data_blocks = vdo->recovery_journal->block_map_data_blocks;

drivers/md/dm-vdo/repair.c

888

vdo_assert_on_admin_thread(completion->vdo, __func__);

drivers/md/dm-vdo/repair.c

890

if (vdo_state_requires_read_only_rebuild(completion->vdo->load_state)) {

drivers/md/dm-vdo/repair.c

899

vdo_load_slab_depot(completion->vdo->depot, operation, completion, repair);

drivers/md/dm-vdo/repair.c

907

vdo_assert_on_admin_thread(completion->vdo, __func__);

drivers/md/dm-vdo/repair.c

911

operation = (vdo_state_requires_read_only_rebuild(completion->vdo->load_state) ?

drivers/md/dm-vdo/repair.c

914

vdo_drain_block_map(completion->vdo->block_map, operation, completion);

drivers/md/dm-vdo/slab-depot.c

1024

vdo_enter_read_only_mode(slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

1045

if (vdo_is_read_only(slab->allocator->depot->vdo))

drivers/md/dm-vdo/slab-depot.c

1087

if (vdo_is_read_only(completion->vdo)) {

drivers/md/dm-vdo/slab-depot.c

1175

vdo_enter_read_only_mode(slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

187

read_only = vdo_is_read_only(slab->allocator->depot->vdo);

drivers/md/dm-vdo/slab-depot.c

240

(vdo_is_read_only(allocator->depot->vdo) ?

drivers/md/dm-vdo/slab-depot.c

252

int result = (vdo_is_read_only(allocator->depot->vdo) ?

drivers/md/dm-vdo/slab-depot.c

2638

if (vdo_is_read_only(allocator->depot->vdo))

drivers/md/dm-vdo/slab-depot.c

2647

vdo_enter_read_only_mode(allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

2670

if (allocator->depot->vdo->suspend_type == VDO_ADMIN_STATE_SAVING)

drivers/md/dm-vdo/slab-depot.c

2768

atomic_cmpxchg(&allocator->depot->vdo->state, VDO_RECOVERING,

drivers/md/dm-vdo/slab-depot.c

2833

vdo_enter_read_only_mode(scrubber->vio.completion.vdo, result);

drivers/md/dm-vdo/slab-depot.c

299

vdo_enter_read_only_mode(completion->vdo, completion->result);

drivers/md/dm-vdo/slab-depot.c

3028

if (vdo_is_read_only(completion->vdo)) {

drivers/md/dm-vdo/slab-depot.c

330

if (vdo_is_read_only(depot->vdo)) {

drivers/md/dm-vdo/slab-depot.c

3307

if (vdo_is_read_only(allocator->depot->vdo))

drivers/md/dm-vdo/slab-depot.c

3326

struct vdo_slab *slab = vdo_get_slab(completion->vdo->depot, updater->zpbn.pbn);

drivers/md/dm-vdo/slab-depot.c

3333

if (vdo_is_read_only(completion->vdo)) {

drivers/md/dm-vdo/slab-depot.c

3504

pbn = slab->journal_origin - depot->vdo->geometry.bio_offset;

drivers/md/dm-vdo/slab-depot.c

3506

.bdev = vdo_get_backing_device(depot->vdo),

drivers/md/dm-vdo/slab-depot.c

372

if (vdo_is_read_only(block->vio.completion.vdo)) {

drivers/md/dm-vdo/slab-depot.c

3756

journal->recovery_journal = slab->allocator->depot->vdo->recovery_journal;

drivers/md/dm-vdo/slab-depot.c

3928

vdo_is_read_only(journal->slab->allocator->depot->vdo))

drivers/md/dm-vdo/slab-depot.c

4013

result = allocate_vio_components(allocator->completion.vdo,

drivers/md/dm-vdo/slab-depot.c

4046

result = allocate_vio_components(allocator->depot->vdo, VIO_TYPE_SLAB_SUMMARY,

drivers/md/dm-vdo/slab-depot.c

4064

struct vdo *vdo = depot->vdo;

drivers/md/dm-vdo/slab-depot.c

4072

.thread_id = vdo->thread_config.physical_threads[zone],

drivers/md/dm-vdo/slab-depot.c

4073

.nonce = vdo->states.vdo.nonce,

drivers/md/dm-vdo/slab-depot.c

4078

result = vdo_register_read_only_listener(vdo, allocator,

drivers/md/dm-vdo/slab-depot.c

4084

vdo_initialize_completion(&allocator->completion, vdo, VDO_BLOCK_ALLOCATOR_COMPLETION);

drivers/md/dm-vdo/slab-depot.c

4085

result = make_vio_pool(vdo, BLOCK_ALLOCATOR_VIO_POOL_SIZE, 1, allocator->thread_id,

drivers/md/dm-vdo/slab-depot.c

4096

result = make_vio_pool(vdo, BLOCK_ALLOCATOR_REFCOUNT_VIO_POOL_SIZE,

drivers/md/dm-vdo/slab-depot.c

4154

const struct thread_config *thread_config = &depot->vdo->thread_config;

drivers/md/dm-vdo/slab-depot.c

4159

depot->vdo, &depot->action_manager);

drivers/md/dm-vdo/slab-depot.c

4237

int vdo_decode_slab_depot(struct slab_depot_state_2_0 state, struct vdo *vdo,

drivers/md/dm-vdo/slab-depot.c

4261

result = vdo_allocate_extended(vdo->thread_config.physical_zone_count,

drivers/md/dm-vdo/slab-depot.c

4266

depot->vdo = vdo;

drivers/md/dm-vdo/slab-depot.c

4268

depot->zone_count = vdo->thread_config.physical_zone_count;

drivers/md/dm-vdo/slab-depot.c

431

vdo_enter_read_only_mode(completion->vdo, completion->result);

drivers/md/dm-vdo/slab-depot.c

4436

vdo_enter_read_only_mode(depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

4550

struct vdo *vdo = vio->completion.vdo;

drivers/md/dm-vdo/slab-depot.c

4553

vdo->thread_config.admin_thread);

drivers/md/dm-vdo/slab-depot.c

4603

struct slab_depot *depot = completion->vdo->depot;

drivers/md/dm-vdo/slab-depot.c

4617

struct vdo *vdo = vio->completion.vdo;

drivers/md/dm-vdo/slab-depot.c

4620

vdo->thread_config.admin_thread);

drivers/md/dm-vdo/slab-depot.c

4638

result = create_multi_block_metadata_vio(depot->vdo, VIO_TYPE_SLAB_SUMMARY,

drivers/md/dm-vdo/slab-depot.c

476

vdo_is_read_only(journal->slab->allocator->depot->vdo)) {

drivers/md/dm-vdo/slab-depot.c

5023

if (vdo_is_read_only(depot->vdo)) {

drivers/md/dm-vdo/slab-depot.c

577

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

629

vdo_is_read_only(journal->slab->allocator->depot->vdo) ||

drivers/md/dm-vdo/slab-depot.c

709

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

793

(vdo_is_read_only(journal->slab->allocator->depot->vdo) ?

drivers/md/dm-vdo/slab-depot.c

815

if (vdo_is_read_only(journal->slab->allocator->depot->vdo) ||

drivers/md/dm-vdo/slab-depot.c

918

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

927

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo,

drivers/md/dm-vdo/slab-depot.h

464

struct vdo *vdo;

drivers/md/dm-vdo/slab-depot.h

555

struct vdo *vdo,

drivers/md/dm-vdo/types.h

211

struct vdo *vdo;

drivers/md/dm-vdo/types.h

317

struct vdo *vdo;

drivers/md/dm-vdo/types.h

336

struct vdo;

drivers/md/dm-vdo/vdo.c

1030

void vdo_save_geometry_block(struct vdo *vdo, struct vdo_completion *parent)

drivers/md/dm-vdo/vdo.c

1032

struct vdo_geometry_block *geometry_block = &vdo->geometry_block;

drivers/md/dm-vdo/vdo.c

1034

vdo_encode_volume_geometry(geometry_block->buffer, &vdo->geometry,

drivers/md/dm-vdo/vdo.c

104

static struct vdo * __must_check filter_vdos_locked(vdo_filter_fn filter,

drivers/md/dm-vdo/vdo.c

107

struct vdo *vdo;

drivers/md/dm-vdo/vdo.c

1074

void vdo_save_super_block(struct vdo *vdo, struct vdo_completion *parent)

drivers/md/dm-vdo/vdo.c

1076

struct vdo_super_block *super_block = &vdo->super_block;

drivers/md/dm-vdo/vdo.c

1078

vdo_encode_super_block(super_block->buffer, &vdo->states);

drivers/md/dm-vdo/vdo.c

1082

vdo_get_data_region_start(vdo->geometry),

drivers/md/dm-vdo/vdo.c

109

list_for_each_entry(vdo, &registry.links, registration) {

drivers/md/dm-vdo/vdo.c

1093

void vdo_save_components(struct vdo *vdo, struct vdo_completion *parent)

drivers/md/dm-vdo/vdo.c

1095

struct vdo_super_block *super_block = &vdo->super_block;

drivers/md/dm-vdo/vdo.c

110

if (filter(vdo, context))

drivers/md/dm-vdo/vdo.c

1107

record_vdo(vdo);

drivers/md/dm-vdo/vdo.c

1108

vdo_save_super_block(vdo, parent);

drivers/md/dm-vdo/vdo.c

111

return vdo;

drivers/md/dm-vdo/vdo.c

1121

int vdo_register_read_only_listener(struct vdo *vdo, void *listener,

drivers/md/dm-vdo/vdo.c

1125

struct vdo_thread *thread = &vdo->threads[thread_id];

drivers/md/dm-vdo/vdo.c

1129

result = VDO_ASSERT(thread_id != vdo->thread_config.dedupe_thread,

drivers/md/dm-vdo/vdo.c

1159

struct vdo *vdo = listener;

drivers/md/dm-vdo/vdo.c

1161

if (vdo_in_read_only_mode(vdo))

drivers/md/dm-vdo/vdo.c

1164

vdo_set_state(vdo, VDO_READ_ONLY_MODE);

drivers/md/dm-vdo/vdo.c

1165

vdo_save_components(vdo, parent);

drivers/md/dm-vdo/vdo.c

1174

int vdo_enable_read_only_entry(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1177

bool is_read_only = vdo_in_read_only_mode(vdo);

drivers/md/dm-vdo/vdo.c

1178

struct read_only_notifier *notifier = &vdo->read_only_notifier;

drivers/md/dm-vdo/vdo.c

1188

vdo_initialize_completion(&notifier->completion, vdo,

drivers/md/dm-vdo/vdo.c

1191

for (id = 0; id < vdo->thread_config.thread_count; id++)

drivers/md/dm-vdo/vdo.c

1192

vdo->threads[id].is_read_only = is_read_only;

drivers/md/dm-vdo/vdo.c

1194

return vdo_register_read_only_listener(vdo, vdo, notify_vdo_of_read_only_mode,

drivers/md/dm-vdo/vdo.c

1195

vdo->thread_config.admin_thread);

drivers/md/dm-vdo/vdo.c

1208

struct vdo *vdo = parent->vdo;

drivers/md/dm-vdo/vdo.c

1209

struct read_only_notifier *notifier = &vdo->read_only_notifier;

drivers/md/dm-vdo/vdo.c

1211

vdo_assert_on_admin_thread(vdo, __func__);

drivers/md/dm-vdo/vdo.c

122

struct vdo *vdo_find_matching(vdo_filter_fn filter, const void *context)

drivers/md/dm-vdo/vdo.c

124

struct vdo *vdo;

drivers/md/dm-vdo/vdo.c

1255

vdo_assert_on_admin_thread(completion->vdo, __func__);

drivers/md/dm-vdo/vdo.c

127

vdo = filter_vdos_locked(filter, context);

drivers/md/dm-vdo/vdo.c

1272

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/vdo.c

1279

struct vdo_thread *thread = &vdo->threads[thread_id];

drivers/md/dm-vdo/vdo.c

130

return vdo;

drivers/md/dm-vdo/vdo.c

1301

if (++thread_id == vdo->thread_config.dedupe_thread) {

drivers/md/dm-vdo/vdo.c

1309

if (thread_id >= vdo->thread_config.thread_count) {

drivers/md/dm-vdo/vdo.c

1313

vdo->thread_config.admin_thread, NULL);

drivers/md/dm-vdo/vdo.c

1336

struct vdo *vdo = parent->vdo;

drivers/md/dm-vdo/vdo.c

1337

struct read_only_notifier *notifier = &vdo->read_only_notifier;

drivers/md/dm-vdo/vdo.c

1339

vdo_assert_on_admin_thread(vdo, __func__);

drivers/md/dm-vdo/vdo.c

1375

void vdo_enter_read_only_mode(struct vdo *vdo, int error_code)

drivers/md/dm-vdo/vdo.c

1379

struct read_only_notifier *notifier = &vdo->read_only_notifier;

drivers/md/dm-vdo/vdo.c

138

&thread->vdo->allocations_allowed);

drivers/md/dm-vdo/vdo.c

1383

thread = &vdo->threads[thread_id];

drivers/md/dm-vdo/vdo.c

1421

bool vdo_is_read_only(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1423

return vdo->threads[vdo_get_callback_thread_id()].is_read_only;

drivers/md/dm-vdo/vdo.c

1432

bool vdo_in_read_only_mode(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1434

return (vdo_get_state(vdo) == VDO_READ_ONLY_MODE);

drivers/md/dm-vdo/vdo.c

1443

bool vdo_in_recovery_mode(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1445

return (vdo_get_state(vdo) == VDO_RECOVERING);

drivers/md/dm-vdo/vdo.c

1452

void vdo_enter_recovery_mode(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1454

vdo_assert_on_admin_thread(vdo, __func__);

drivers/md/dm-vdo/vdo.c

1456

if (vdo_in_read_only_mode(vdo))

drivers/md/dm-vdo/vdo.c

1460

vdo_set_state(vdo, VDO_RECOVERING);

drivers/md/dm-vdo/vdo.c

1481

static int perform_synchronous_action(struct vdo *vdo, vdo_action_fn action,

drivers/md/dm-vdo/vdo.c

1486

vdo_initialize_completion(&sync.vdo_completion, vdo, VDO_SYNC_COMPLETION);

drivers/md/dm-vdo/vdo.c

1500

struct vdo *vdo = completion->vdo;

drivers/md/dm-vdo/vdo.c

1502

bool was_enabled = vdo_get_compressing(vdo);

drivers/md/dm-vdo/vdo.c

1505

WRITE_ONCE(vdo->compressing, *enable);

drivers/md/dm-vdo/vdo.c

1508

vdo_flush_packer(vdo->packer);

drivers/md/dm-vdo/vdo.c

1524

bool vdo_set_compressing(struct vdo *vdo, bool enable)

drivers/md/dm-vdo/vdo.c

1526

perform_synchronous_action(vdo, set_compression_callback,

drivers/md/dm-vdo/vdo.c

1527

vdo->thread_config.packer_thread,

drivers/md/dm-vdo/vdo.c

1538

bool vdo_get_compressing(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1540

return READ_ONCE(vdo->compressing);

drivers/md/dm-vdo/vdo.c

1543

static size_t get_block_map_cache_size(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1545

return ((size_t) vdo->device_config->cache_size) * VDO_BLOCK_SIZE;

drivers/md/dm-vdo/vdo.c

1548

static struct error_statistics __must_check get_vdo_error_statistics(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1555

const struct atomic_statistics *atoms = &vdo->stats;

drivers/md/dm-vdo/vdo.c

1593

static block_count_t __must_check vdo_get_physical_blocks_allocated(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1595

return (vdo_get_slab_depot_allocated_blocks(vdo->depot) -

drivers/md/dm-vdo/vdo.c

1596

vdo_get_journal_block_map_data_blocks_used(vdo->recovery_journal));

drivers/md/dm-vdo/vdo.c

1605

static block_count_t __must_check vdo_get_physical_blocks_overhead(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1612

return (vdo->states.vdo.config.physical_blocks -

drivers/md/dm-vdo/vdo.c

1613

vdo_get_slab_depot_data_blocks(vdo->depot) +

drivers/md/dm-vdo/vdo.c

1614

vdo_get_journal_block_map_data_blocks_used(vdo->recovery_journal));

drivers/md/dm-vdo/vdo.c

1637

static void get_vdo_statistics(const struct vdo *vdo, struct vdo_statistics *stats)

drivers/md/dm-vdo/vdo.c

1639

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/vdo.c

1640

enum vdo_state state = vdo_get_state(vdo);

drivers/md/dm-vdo/vdo.c

1642

vdo_assert_on_admin_thread(vdo, __func__);

drivers/md/dm-vdo/vdo.c

1652

stats->logical_blocks = vdo->states.vdo.config.logical_blocks;

drivers/md/dm-vdo/vdo.c

1658

stats->physical_blocks = vdo->states.vdo.config.physical_blocks;

drivers/md/dm-vdo/vdo.c

1660

stats->complete_recoveries = vdo->states.vdo.complete_recoveries;

drivers/md/dm-vdo/vdo.c

1661

stats->read_only_recoveries = vdo->states.vdo.read_only_recoveries;

drivers/md/dm-vdo/vdo.c

1662

stats->block_map_cache_size = get_block_map_cache_size(vdo);

drivers/md/dm-vdo/vdo.c

1665

stats->data_blocks_used = vdo_get_physical_blocks_allocated(vdo);

drivers/md/dm-vdo/vdo.c

1666

stats->overhead_blocks_used = vdo_get_physical_blocks_overhead(vdo);

drivers/md/dm-vdo/vdo.c

1668

vdo_get_slab_depot_statistics(vdo->depot, stats);

drivers/md/dm-vdo/vdo.c

1670

stats->packer = vdo_get_packer_statistics(vdo->packer);

drivers/md/dm-vdo/vdo.c

1671

stats->block_map = vdo_get_block_map_statistics(vdo->block_map);

drivers/md/dm-vdo/vdo.c

1672

vdo_get_dedupe_statistics(vdo->hash_zones, stats);

drivers/md/dm-vdo/vdo.c

1673

stats->errors = get_vdo_error_statistics(vdo);

drivers/md/dm-vdo/vdo.c

1677

stats->instance = vdo->instance;

drivers/md/dm-vdo/vdo.c

1678

stats->current_vios_in_progress = get_data_vio_pool_active_requests(vdo->data_vio_pool);

drivers/md/dm-vdo/vdo.c

1679

stats->max_vios = get_data_vio_pool_maximum_requests(vdo->data_vio_pool);

drivers/md/dm-vdo/vdo.c

1681

stats->flush_out = atomic64_read(&vdo->stats.flush_out);

drivers/md/dm-vdo/vdo.c

1682

stats->logical_block_size = vdo->device_config->logical_block_size;

drivers/md/dm-vdo/vdo.c

1683

copy_bio_stat(&stats->bios_in, &vdo->stats.bios_in);

drivers/md/dm-vdo/vdo.c

1684

copy_bio_stat(&stats->bios_in_partial, &vdo->stats.bios_in_partial);

drivers/md/dm-vdo/vdo.c

1685

copy_bio_stat(&stats->bios_out, &vdo->stats.bios_out);

drivers/md/dm-vdo/vdo.c

1686

copy_bio_stat(&stats->bios_meta, &vdo->stats.bios_meta);

drivers/md/dm-vdo/vdo.c

1687

copy_bio_stat(&stats->bios_journal, &vdo->stats.bios_journal);

drivers/md/dm-vdo/vdo.c

1688

copy_bio_stat(&stats->bios_page_cache, &vdo->stats.bios_page_cache);

drivers/md/dm-vdo/vdo.c

1689

copy_bio_stat(&stats->bios_out_completed, &vdo->stats.bios_out_completed);

drivers/md/dm-vdo/vdo.c

1690

copy_bio_stat(&stats->bios_meta_completed, &vdo->stats.bios_meta_completed);

drivers/md/dm-vdo/vdo.c

1692

&vdo->stats.bios_journal_completed);

drivers/md/dm-vdo/vdo.c

1694

&vdo->stats.bios_page_cache_completed);

drivers/md/dm-vdo/vdo.c

1695

copy_bio_stat(&stats->bios_acknowledged, &vdo->stats.bios_acknowledged);

drivers/md/dm-vdo/vdo.c

1696

copy_bio_stat(&stats->bios_acknowledged_partial, &vdo->stats.bios_acknowledged_partial);

drivers/md/dm-vdo/vdo.c

1712

get_vdo_statistics(completion->vdo, completion->parent);

drivers/md/dm-vdo/vdo.c

1721

void vdo_fetch_statistics(struct vdo *vdo, struct vdo_statistics *stats)

drivers/md/dm-vdo/vdo.c

1723

perform_synchronous_action(vdo, vdo_fetch_statistics_callback,

drivers/md/dm-vdo/vdo.c

1724

vdo->thread_config.admin_thread, stats);

drivers/md/dm-vdo/vdo.c

1746

BUG_ON(thread_id >= thread->vdo->thread_config.thread_count);

drivers/md/dm-vdo/vdo.c

1747

BUG_ON(thread != &thread->vdo->threads[thread_id]);

drivers/md/dm-vdo/vdo.c

1757

void vdo_dump_status(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

1761

vdo_dump_flusher(vdo->flusher);

drivers/md/dm-vdo/vdo.c

1762

vdo_dump_recovery_journal_statistics(vdo->recovery_journal);

drivers/md/dm-vdo/vdo.c

1763

vdo_dump_packer(vdo->packer);

drivers/md/dm-vdo/vdo.c

1764

vdo_dump_slab_depot(vdo->depot);

drivers/md/dm-vdo/vdo.c

1766

for (zone = 0; zone < vdo->thread_config.logical_zone_count; zone++)

drivers/md/dm-vdo/vdo.c

1767

vdo_dump_logical_zone(&vdo->logical_zones->zones[zone]);

drivers/md/dm-vdo/vdo.c

1769

for (zone = 0; zone < vdo->thread_config.physical_zone_count; zone++)

drivers/md/dm-vdo/vdo.c

1770

vdo_dump_physical_zone(&vdo->physical_zones->zones[zone]);

drivers/md/dm-vdo/vdo.c

1772

vdo_dump_hash_zones(vdo->hash_zones);

drivers/md/dm-vdo/vdo.c

1780

void vdo_assert_on_admin_thread(const struct vdo *vdo, const char *name)

drivers/md/dm-vdo/vdo.c

1782

VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == vdo->thread_config.admin_thread),

drivers/md/dm-vdo/vdo.c

1793

void vdo_assert_on_logical_zone_thread(const struct vdo *vdo, zone_count_t logical_zone,

drivers/md/dm-vdo/vdo.c

1797

vdo->thread_config.logical_threads[logical_zone]),

drivers/md/dm-vdo/vdo.c

1808

void vdo_assert_on_physical_zone_thread(const struct vdo *vdo,

drivers/md/dm-vdo/vdo.c

1812

vdo->thread_config.physical_threads[physical_zone]),

drivers/md/dm-vdo/vdo.c

1831

int vdo_get_physical_zone(const struct vdo *vdo, physical_block_number_t pbn,

drivers/md/dm-vdo/vdo.c

1846

if (!vdo_is_physical_data_block(vdo->depot, pbn))

drivers/md/dm-vdo/vdo.c

1850

slab = vdo_get_slab(vdo->depot, pbn);

drivers/md/dm-vdo/vdo.c

1855

*zone_ptr = &vdo->physical_zones->zones[slab->allocator->zone_number];

drivers/md/dm-vdo/vdo.c

261

static int initialize_geometry_block(struct vdo *vdo,

drivers/md/dm-vdo/vdo.c

267

(char **) &vdo->geometry_block.buffer);

drivers/md/dm-vdo/vdo.c

271

return allocate_vio_components(vdo, VIO_TYPE_GEOMETRY,

drivers/md/dm-vdo/vdo.c

274

&vdo->geometry_block.vio);

drivers/md/dm-vdo/vdo.c

277

static int initialize_super_block(struct vdo *vdo, struct vdo_super_block *super_block)

drivers/md/dm-vdo/vdo.c

282

(char **) &vdo->super_block.buffer);

drivers/md/dm-vdo/vdo.c

286

return allocate_vio_components(vdo, VIO_TYPE_SUPER_BLOCK,

drivers/md/dm-vdo/vdo.c

289

&vdo->super_block.vio);

drivers/md/dm-vdo/vdo.c

391

int vdo_make_thread(struct vdo *vdo, thread_id_t thread_id,

drivers/md/dm-vdo/vdo.c

395

struct vdo_thread *thread = &vdo->threads[thread_id];

drivers/md/dm-vdo/vdo.c

407

thread->vdo = vdo;

drivers/md/dm-vdo/vdo.c

409

get_thread_name(&vdo->thread_config, thread_id, queue_name, sizeof(queue_name));

drivers/md/dm-vdo/vdo.c

410

return vdo_make_work_queue(vdo->thread_name_prefix, queue_name, thread,

drivers/md/dm-vdo/vdo.c

420

static int register_vdo(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

425

result = VDO_ASSERT(filter_vdos_locked(vdo_is_equal, vdo) == NULL,

drivers/md/dm-vdo/vdo.c

428

INIT_LIST_HEAD(&vdo->registration);

drivers/md/dm-vdo/vdo.c

429

list_add_tail(&vdo->registration, &registry.links);

drivers/md/dm-vdo/vdo.c

447

static int __must_check vdo_format(struct vdo *vdo, char **error_ptr)

drivers/md/dm-vdo/vdo.c

452

struct device_config *config = vdo->device_config;

drivers/md/dm-vdo/vdo.c

468

result = vdo_initialize_volume_geometry(nonce, &uuid, &index_config, &vdo->geometry);

drivers/md/dm-vdo/vdo.c

474

result = vdo_initialize_component_states(&vdo_config, &vdo->geometry, nonce, &vdo->states);

drivers/md/dm-vdo/vdo.c

479

vdo->geometry.regions[VDO_DATA_REGION].start_block +

drivers/md/dm-vdo/vdo.c

494

vdo->needs_formatting = true;

drivers/md/dm-vdo/vdo.c

507

static int initialize_vdo(struct vdo *vdo, struct device_config *config,

drivers/md/dm-vdo/vdo.c

513

vdo->device_config = config;

drivers/md/dm-vdo/vdo.c

514

vdo->starting_sector_offset = config->owning_target->begin;

drivers/md/dm-vdo/vdo.c

515

vdo->instance = instance;

drivers/md/dm-vdo/vdo.c

516

vdo->allocations_allowed = true;

drivers/md/dm-vdo/vdo.c

517

vdo_set_admin_state_code(&vdo->admin.state, VDO_ADMIN_STATE_NEW);

drivers/md/dm-vdo/vdo.c

518

INIT_LIST_HEAD(&vdo->device_config_list);

drivers/md/dm-vdo/vdo.c

519

vdo_initialize_completion(&vdo->admin.completion, vdo, VDO_ADMIN_COMPLETION);

drivers/md/dm-vdo/vdo.c

520

init_completion(&vdo->admin.callback_sync);

drivers/md/dm-vdo/vdo.c

521

mutex_init(&vdo->stats_mutex);

drivers/md/dm-vdo/vdo.c

523

result = initialize_geometry_block(vdo, &vdo->geometry_block);

drivers/md/dm-vdo/vdo.c

529

result = initialize_super_block(vdo, &vdo->super_block);

drivers/md/dm-vdo/vdo.c

535

result = vdo_submit_metadata_vio_wait(&vdo->geometry_block.vio,

drivers/md/dm-vdo/vdo.c

542

if (mem_is_zero(vdo->geometry_block.vio.data, VDO_BLOCK_SIZE)) {

drivers/md/dm-vdo/vdo.c

543

result = vdo_format(vdo, reason);

drivers/md/dm-vdo/vdo.c

547

result = vdo_parse_geometry_block(vdo->geometry_block.buffer,

drivers/md/dm-vdo/vdo.c

548

&vdo->geometry);

drivers/md/dm-vdo/vdo.c

555

result = initialize_thread_config(config->thread_counts, &vdo->thread_config);

drivers/md/dm-vdo/vdo.c

564

config->thread_counts.hash_zones, vdo->thread_config.thread_count);

drivers/md/dm-vdo/vdo.c

568

&vdo->compression_context);

drivers/md/dm-vdo/vdo.c

576

&vdo->compression_context[i]);

drivers/md/dm-vdo/vdo.c

583

result = register_vdo(vdo);

drivers/md/dm-vdo/vdo.c

589

vdo_set_admin_state_code(&vdo->admin.state, VDO_ADMIN_STATE_INITIALIZED);

drivers/md/dm-vdo/vdo.c

603

struct vdo **vdo_ptr)

drivers/md/dm-vdo/vdo.c

606

struct vdo *vdo;

drivers/md/dm-vdo/vdo.c

611

result = vdo_allocate(1, __func__, &vdo);

drivers/md/dm-vdo/vdo.c

617

result = initialize_vdo(vdo, config, instance, reason);

drivers/md/dm-vdo/vdo.c

619

vdo_destroy(vdo);

drivers/md/dm-vdo/vdo.c

624

*vdo_ptr = vdo;

drivers/md/dm-vdo/vdo.c

626

snprintf(vdo->thread_name_prefix, sizeof(vdo->thread_name_prefix),

drivers/md/dm-vdo/vdo.c

628

result = vdo_allocate(vdo->thread_config.thread_count, __func__, &vdo->threads);

drivers/md/dm-vdo/vdo.c

634

result = vdo_make_thread(vdo, vdo->thread_config.admin_thread,

drivers/md/dm-vdo/vdo.c

641

result = vdo_make_flusher(vdo);

drivers/md/dm-vdo/vdo.c

647

result = vdo_make_packer(vdo, DEFAULT_PACKER_BINS, &vdo->packer);

drivers/md/dm-vdo/vdo.c

653

BUG_ON(vdo->device_config->logical_block_size <= 0);

drivers/md/dm-vdo/vdo.c

654

BUG_ON(vdo->device_config->owned_device == NULL);

drivers/md/dm-vdo/vdo.c

655

result = make_data_vio_pool(vdo, MAXIMUM_VDO_USER_VIOS,

drivers/md/dm-vdo/vdo.c

657

&vdo->data_vio_pool);

drivers/md/dm-vdo/vdo.c

665

get_data_vio_pool_request_limit(vdo->data_vio_pool),

drivers/md/dm-vdo/vdo.c

666

vdo, &vdo->io_submitter);

drivers/md/dm-vdo/vdo.c

672

if (vdo_uses_bio_ack_queue(vdo)) {

drivers/md/dm-vdo/vdo.c

673

result = vdo_make_thread(vdo, vdo->thread_config.bio_ack_thread,

drivers/md/dm-vdo/vdo.c

682

result = vdo_make_thread(vdo, vdo->thread_config.cpu_thread, &cpu_q_type,

drivers/md/dm-vdo/vdo.c

684

(void **) vdo->compression_context);

drivers/md/dm-vdo/vdo.c

693

static void finish_vdo(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

697

if (vdo->threads == NULL)

drivers/md/dm-vdo/vdo.c

700

vdo_cleanup_io_submitter(vdo->io_submitter);

drivers/md/dm-vdo/vdo.c

701

vdo_finish_dedupe_index(vdo->hash_zones);

drivers/md/dm-vdo/vdo.c

703

for (i = 0; i < vdo->thread_config.thread_count; i++)

drivers/md/dm-vdo/vdo.c

704

vdo_finish_work_queue(vdo->threads[i].queue);

drivers/md/dm-vdo/vdo.c

737

static void unregister_vdo(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

740

if (filter_vdos_locked(vdo_is_equal, vdo) == vdo)

drivers/md/dm-vdo/vdo.c

741

list_del_init(&vdo->registration);

drivers/md/dm-vdo/vdo.c

750

void vdo_destroy(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

754

if (vdo == NULL)

drivers/md/dm-vdo/vdo.c

758

BUG_ON(vdo_get_admin_state(vdo)->normal);

drivers/md/dm-vdo/vdo.c

760

vdo->allocations_allowed = true;

drivers/md/dm-vdo/vdo.c

762

finish_vdo(vdo);

drivers/md/dm-vdo/vdo.c

763

unregister_vdo(vdo);

drivers/md/dm-vdo/vdo.c

764

free_data_vio_pool(vdo->data_vio_pool);

drivers/md/dm-vdo/vdo.c

765

vdo_free_io_submitter(vdo_forget(vdo->io_submitter));

drivers/md/dm-vdo/vdo.c

766

vdo_free_flusher(vdo_forget(vdo->flusher));

drivers/md/dm-vdo/vdo.c

767

vdo_free_packer(vdo_forget(vdo->packer));

drivers/md/dm-vdo/vdo.c

768

vdo_free_recovery_journal(vdo_forget(vdo->recovery_journal));

drivers/md/dm-vdo/vdo.c

769

vdo_free_slab_depot(vdo_forget(vdo->depot));

drivers/md/dm-vdo/vdo.c

770

vdo_uninitialize_layout(&vdo->layout);

drivers/md/dm-vdo/vdo.c

771

vdo_uninitialize_layout(&vdo->next_layout);

drivers/md/dm-vdo/vdo.c

772

if (vdo->partition_copier)

drivers/md/dm-vdo/vdo.c

773

dm_kcopyd_client_destroy(vdo_forget(vdo->partition_copier));

drivers/md/dm-vdo/vdo.c

774

uninitialize_geometry_block(&vdo->geometry_block);

drivers/md/dm-vdo/vdo.c

775

uninitialize_super_block(&vdo->super_block);

drivers/md/dm-vdo/vdo.c

776

vdo_free_block_map(vdo_forget(vdo->block_map));

drivers/md/dm-vdo/vdo.c

777

vdo_free_hash_zones(vdo_forget(vdo->hash_zones));

drivers/md/dm-vdo/vdo.c

778

vdo_free_physical_zones(vdo_forget(vdo->physical_zones));

drivers/md/dm-vdo/vdo.c

779

vdo_free_logical_zones(vdo_forget(vdo->logical_zones));

drivers/md/dm-vdo/vdo.c

781

if (vdo->threads != NULL) {

drivers/md/dm-vdo/vdo.c

782

for (i = 0; i < vdo->thread_config.thread_count; i++) {

drivers/md/dm-vdo/vdo.c

783

free_listeners(&vdo->threads[i]);

drivers/md/dm-vdo/vdo.c

784

vdo_free_work_queue(vdo_forget(vdo->threads[i].queue));

drivers/md/dm-vdo/vdo.c

786

vdo_free(vdo_forget(vdo->threads));

drivers/md/dm-vdo/vdo.c

789

uninitialize_thread_config(&vdo->thread_config);

drivers/md/dm-vdo/vdo.c

791

if (vdo->compression_context != NULL) {

drivers/md/dm-vdo/vdo.c

792

for (i = 0; i < vdo->device_config->thread_counts.cpu_threads; i++)

drivers/md/dm-vdo/vdo.c

793

vdo_free(vdo_forget(vdo->compression_context[i]));

drivers/md/dm-vdo/vdo.c

795

vdo_free(vdo_forget(vdo->compression_context));

drivers/md/dm-vdo/vdo.c

797

vdo_free(vdo);

drivers/md/dm-vdo/vdo.c

841

void vdo_load_super_block(struct vdo *vdo, struct vdo_completion *parent)

drivers/md/dm-vdo/vdo.c

843

vdo->super_block.vio.completion.parent = parent;

drivers/md/dm-vdo/vdo.c

844

vdo_submit_metadata_vio(&vdo->super_block.vio,

drivers/md/dm-vdo/vdo.c

845

vdo_get_data_region_start(vdo->geometry),

drivers/md/dm-vdo/vdo.c

857

struct block_device *vdo_get_backing_device(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

859

return vdo->device_config->owned_device->bdev;

drivers/md/dm-vdo/vdo.c

879

int vdo_synchronous_flush(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

884

bio_init(&bio, vdo_get_backing_device(vdo), NULL, 0,

drivers/md/dm-vdo/vdo.c

889

atomic64_inc(&vdo->stats.flush_out);

drivers/md/dm-vdo/vdo.c

90

static bool vdo_is_equal(struct vdo *vdo, const void *context)

drivers/md/dm-vdo/vdo.c

907

enum vdo_state vdo_get_state(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

909

enum vdo_state state = atomic_read(&vdo->state);

drivers/md/dm-vdo/vdo.c

92

return (vdo == context);

drivers/md/dm-vdo/vdo.c

923

void vdo_set_state(struct vdo *vdo, enum vdo_state state)

drivers/md/dm-vdo/vdo.c

927

atomic_set(&vdo->state, state);

drivers/md/dm-vdo/vdo.c

936

const struct admin_state_code *vdo_get_admin_state(const struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

938

return vdo_get_admin_state_code(&vdo->admin.state);

drivers/md/dm-vdo/vdo.c

945

static void record_vdo(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

948

vdo->states.unused = vdo->geometry.unused;

drivers/md/dm-vdo/vdo.c

949

vdo->states.vdo.state = vdo_get_state(vdo);

drivers/md/dm-vdo/vdo.c

950

vdo->states.block_map = vdo_record_block_map(vdo->block_map);

drivers/md/dm-vdo/vdo.c

951

vdo->states.recovery_journal = vdo_record_recovery_journal(vdo->recovery_journal);

drivers/md/dm-vdo/vdo.c

952

vdo->states.slab_depot = vdo_record_slab_depot(vdo->depot);

drivers/md/dm-vdo/vdo.c

953

vdo->states.layout = vdo->layout;

drivers/md/dm-vdo/vdo.c

956

static int __must_check clear_partition(struct vdo *vdo, enum partition_id id)

drivers/md/dm-vdo/vdo.c

961

result = vdo_get_partition(&vdo->states.layout, id, &partition);

drivers/md/dm-vdo/vdo.c

965

return blkdev_issue_zeroout(vdo_get_backing_device(vdo),

drivers/md/dm-vdo/vdo.c

971

int vdo_clear_layout(struct vdo *vdo)

drivers/md/dm-vdo/vdo.c

976

result = blkdev_issue_zeroout(vdo_get_backing_device(vdo),

drivers/md/dm-vdo/vdo.c

983

result = clear_partition(vdo, VDO_BLOCK_MAP_PARTITION);

drivers/md/dm-vdo/vdo.c

987

return clear_partition(vdo, VDO_RECOVERY_JOURNAL_PARTITION);

drivers/md/dm-vdo/vdo.h

286

static inline bool vdo_uses_bio_ack_queue(struct vdo *vdo)

drivers/md/dm-vdo/vdo.h

288

return vdo->device_config->thread_counts.bio_ack_threads > 0;

drivers/md/dm-vdo/vdo.h

298

typedef bool (*vdo_filter_fn)(struct vdo *vdo, const void *context);

drivers/md/dm-vdo/vdo.h

301

struct vdo * __must_check vdo_find_matching(vdo_filter_fn filter, const void *context);

drivers/md/dm-vdo/vdo.h

303

int __must_check vdo_make_thread(struct vdo *vdo, thread_id_t thread_id,

drivers/md/dm-vdo/vdo.h

307

static inline int __must_check vdo_make_default_thread(struct vdo *vdo,

drivers/md/dm-vdo/vdo.h

310

return vdo_make_thread(vdo, thread_id, NULL, 1, NULL);

drivers/md/dm-vdo/vdo.h

314

char **reason, struct vdo **vdo_ptr);

drivers/md/dm-vdo/vdo.h

316

void vdo_destroy(struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

318

int __must_check vdo_format_components(struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

320

void vdo_format_super_block(struct vdo *vdo, struct vdo_completion *parent);

drivers/md/dm-vdo/vdo.h

322

void vdo_load_super_block(struct vdo *vdo, struct vdo_completion *parent);

drivers/md/dm-vdo/vdo.h

324

struct block_device * __must_check vdo_get_backing_device(const struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

328

int __must_check vdo_synchronous_flush(struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

330

const struct admin_state_code * __must_check vdo_get_admin_state(const struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

332

bool vdo_set_compressing(struct vdo *vdo, bool enable);

drivers/md/dm-vdo/vdo.h

334

bool vdo_get_compressing(struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

336

void vdo_fetch_statistics(struct vdo *vdo, struct vdo_statistics *stats);

drivers/md/dm-vdo/vdo.h

340

enum vdo_state __must_check vdo_get_state(const struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

342

void vdo_set_state(struct vdo *vdo, enum vdo_state state);

drivers/md/dm-vdo/vdo.h

344

int vdo_clear_layout(struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

345

void vdo_save_geometry_block(struct vdo *vdo, struct vdo_completion *parent);

drivers/md/dm-vdo/vdo.h

346

void vdo_save_super_block(struct vdo *vdo, struct vdo_completion *parent);

drivers/md/dm-vdo/vdo.h

348

void vdo_save_components(struct vdo *vdo, struct vdo_completion *parent);

drivers/md/dm-vdo/vdo.h

350

int vdo_register_read_only_listener(struct vdo *vdo, void *listener,

drivers/md/dm-vdo/vdo.h

354

int vdo_enable_read_only_entry(struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

360

void vdo_enter_read_only_mode(struct vdo *vdo, int error_code);

drivers/md/dm-vdo/vdo.h

362

bool __must_check vdo_is_read_only(struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

364

bool __must_check vdo_in_read_only_mode(const struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

366

bool __must_check vdo_in_recovery_mode(const struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

368

void vdo_enter_recovery_mode(struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

370

void vdo_assert_on_admin_thread(const struct vdo *vdo, const char *name);

drivers/md/dm-vdo/vdo.h

372

void vdo_assert_on_logical_zone_thread(const struct vdo *vdo, zone_count_t logical_zone,

drivers/md/dm-vdo/vdo.h

375

void vdo_assert_on_physical_zone_thread(const struct vdo *vdo, zone_count_t physical_zone,

drivers/md/dm-vdo/vdo.h

378

int __must_check vdo_get_physical_zone(const struct vdo *vdo, physical_block_number_t pbn,

drivers/md/dm-vdo/vdo.h

381

void vdo_dump_status(const struct vdo *vdo);

drivers/md/dm-vdo/vdo.h

57

struct vdo *vdo;

drivers/md/dm-vdo/vio.c

100

initialize_vio(vio, bio, block_count, vio_type, priority, vdo);

drivers/md/dm-vdo/vio.c

118

int create_multi_block_metadata_vio(struct vdo *vdo, enum vio_type vio_type,

drivers/md/dm-vdo/vio.c

138

result = allocate_vio_components(vdo, vio_type, priority, parent, block_count,

drivers/md/dm-vdo/vio.c

176

struct vdo *vdo = vio->completion.vdo;

drivers/md/dm-vdo/vio.c

177

struct device_config *config = vdo->device_config;

drivers/md/dm-vdo/vio.c

179

pbn -= vdo->geometry.bio_offset;

drivers/md/dm-vdo/vio.c

261

struct vdo *vdo = vio->completion.vdo;

drivers/md/dm-vdo/vio.c

265

atomic64_inc(&vdo->stats.read_only_error_count);

drivers/md/dm-vdo/vio.c

269

atomic64_inc(&vdo->stats.no_space_error_count);

drivers/md/dm-vdo/vio.c

321

int make_vio_pool(struct vdo *vdo, size_t pool_size, size_t block_count, thread_id_t thread_id,

drivers/md/dm-vdo/vio.c

348

result = allocate_vio_components(vdo, vio_type, priority, NULL, block_count, ptr,

drivers/md/dm-vdo/vio.c

44

struct vdo *vdo = vio->completion.vdo;

drivers/md/dm-vdo/vio.c

47

return ((pbn == VDO_GEOMETRY_BLOCK_LOCATION) ? pbn : pbn + vdo->geometry.bio_offset);

drivers/md/dm-vdo/vio.c

492

struct atomic_statistics *stats = &vio->completion.vdo->stats;

drivers/md/dm-vdo/vio.c

510

atomic64_inc(&vio->completion.vdo->stats.bios_completed);

drivers/md/dm-vdo/vio.c

78

int allocate_vio_components(struct vdo *vdo, enum vio_type vio_type,

drivers/md/dm-vdo/vio.h

111

enum vio_priority priority, struct vdo *vdo)

drivers/md/dm-vdo/vio.h

120

vdo_initialize_completion(&vio->completion, vdo, VIO_COMPLETION);

drivers/md/dm-vdo/vio.h

197

int __must_check make_vio_pool(struct vdo *vdo, size_t pool_size, size_t block_count,

drivers/md/dm-vdo/vio.h

58

return vio->completion.vdo->thread_config.bio_threads[vio->bio_zone];

drivers/md/dm-vdo/vio.h

80

int allocate_vio_components(struct vdo *vdo, enum vio_type vio_type,

drivers/md/dm-vdo/vio.h

83

int __must_check create_multi_block_metadata_vio(struct vdo *vdo, enum vio_type vio_type,

drivers/md/dm-vdo/vio.h

88

static inline int __must_check create_metadata_vio(struct vdo *vdo, enum vio_type vio_type,

drivers/md/dm-vdo/vio.h

93

return create_multi_block_metadata_vio(vdo, vio_type, priority, parent, 1, data,

drivers/platform/chrome/cros_ec_typec.c

407

desc.vdo = DP_PORT_VDO;

drivers/platform/chrome/cros_ec_typec.c

561

return node->amode->vdo;

drivers/platform/chrome/cros_ec_typec.c

688

dp_data.conf |= VDO_TYPEC_CABLE_SPEED(port->c_identity.vdo[0]) <<

drivers/platform/chrome/cros_ec_typec.c

902

desc.vdo = sop_disc->svids[i].mode_vdo[j];

drivers/platform/chrome/cros_ec_typec.c

969

id->vdo[i - 3] = disc->discovery_vdo[i];

drivers/platform/chrome/cros_ec_typec.c

997

cable_plug_type = VDO_TYPEC_CABLE_TYPE(port->c_identity.vdo[0]);

drivers/platform/chrome/cros_typec_altmode.c

58

static int cros_typec_altmode_enter(struct typec_altmode *alt, u32 *vdo)

drivers/platform/chrome/cros_typec_vdm.c

121

const u32 *vdo, int cnt)

drivers/platform/chrome/cros_typec_vdm.c

134

vdm_req.vdm_data[i] = vdo[i-1];

drivers/platform/chrome/cros_typec_vdm.c

95

static int cros_typec_port_amode_enter(struct typec_altmode *amode, u32 *vdo)

drivers/usb/typec/altmodes/displayport.c

106

signal = DP_CAP_DP_SIGNALLING(dp->port->vdo) & DP_CAP_DP_SIGNALLING(dp->alt->vdo);

drivers/usb/typec/altmodes/displayport.c

108

signal &= DP_CAP_DP_SIGNALLING(dp->plug_prime->vdo);

drivers/usb/typec/altmodes/displayport.c

117

pin_assign = DP_CAP_UFP_D_PIN_ASSIGN(dp->alt->vdo) &

drivers/usb/typec/altmodes/displayport.c

118

DP_CAP_DFP_D_PIN_ASSIGN(dp->port->vdo);

drivers/usb/typec/altmodes/displayport.c

121

pin_assign &= DP_CAP_DFP_D_PIN_ASSIGN(dp->plug_prime->vdo);

drivers/usb/typec/altmodes/displayport.c

126

pin_assign = DP_CAP_PIN_ASSIGN_UFP_D(dp->alt->vdo) &

drivers/usb/typec/altmodes/displayport.c

127

DP_CAP_PIN_ASSIGN_DFP_D(dp->port->vdo);

drivers/usb/typec/altmodes/displayport.c

130

pin_assign &= DP_CAP_UFP_D_PIN_ASSIGN(dp->plug_prime->vdo);

drivers/usb/typec/altmodes/displayport.c

270

u32 vdo;

drivers/usb/typec/altmodes/displayport.c

299

vdo = 1;

drivers/usb/typec/altmodes/displayport.c

300

ret = typec_altmode_vdm(dp->alt, header, &vdo, 2);

drivers/usb/typec/altmodes/displayport.c

346

static void dp_altmode_attention(struct typec_altmode *alt, const u32 vdo)

drivers/usb/typec/altmodes/displayport.c

354

dp->data.status = vdo;

drivers/usb/typec/altmodes/displayport.c

373

const u32 hdr, const u32 *vdo, int count)

drivers/usb/typec/altmodes/displayport.c

410

dp->data.status = *vdo;

drivers/usb/typec/altmodes/displayport.c

446

const u32 hdr, const u32 *vdo, int count)

drivers/usb/typec/altmodes/displayport.c

562

cap = DP_CAP_CAPABILITY(dp->alt->vdo);

drivers/usb/typec/altmodes/displayport.c

598

cap = DP_CAP_CAPABILITY(dp->alt->vdo);

drivers/usb/typec/altmodes/displayport.c

634

return DP_CAP_PIN_ASSIGN_DFP_D(dp->alt->vdo);

drivers/usb/typec/altmodes/displayport.c

636

return DP_CAP_PIN_ASSIGN_UFP_D(dp->alt->vdo);

drivers/usb/typec/altmodes/displayport.c

773

if (!(DP_CAP_PIN_ASSIGN_DFP_D(port->vdo) &

drivers/usb/typec/altmodes/displayport.c

774

DP_CAP_PIN_ASSIGN_UFP_D(alt->vdo)) &&

drivers/usb/typec/altmodes/displayport.c

775

!(DP_CAP_PIN_ASSIGN_UFP_D(port->vdo) &

drivers/usb/typec/altmodes/displayport.c

776

DP_CAP_PIN_ASSIGN_DFP_D(alt->vdo))) {

drivers/usb/typec/altmodes/thunderbolt.c

141

const u32 *vdo, int count)

drivers/usb/typec/altmodes/thunderbolt.c

190

const u32 hdr, const u32 *vdo, int count)

drivers/usb/typec/altmodes/thunderbolt.c

211

data.device_mode = tbt->alt->vdo;

drivers/usb/typec/altmodes/thunderbolt.c

214

data.cable_mode = tbt->plug[TYPEC_PLUG_SOP_P]->vdo;

drivers/usb/typec/altmodes/thunderbolt.c

319

u32 vdo;

drivers/usb/typec/altmodes/thunderbolt.c

347

vdo = tbt->alt->vdo & (TBT_VENDOR_SPECIFIC_B0 | TBT_VENDOR_SPECIFIC_B1);

drivers/usb/typec/altmodes/thunderbolt.c

348

vdo |= tbt->alt->vdo & TBT_INTEL_SPECIFIC_B0;

drivers/usb/typec/altmodes/thunderbolt.c

349

vdo |= TBT_MODE;

drivers/usb/typec/altmodes/thunderbolt.c

354

vdo |= TBT_ENTER_MODE_ACTIVE_CABLE;

drivers/usb/typec/altmodes/thunderbolt.c

356

vdo |= TBT_ENTER_MODE_CABLE_SPEED(TBT_CABLE_SPEED(plug->vdo));

drivers/usb/typec/altmodes/thunderbolt.c

357

vdo |= plug->vdo & TBT_CABLE_ROUNDED;

drivers/usb/typec/altmodes/thunderbolt.c

358

vdo |= plug->vdo & TBT_CABLE_OPTICAL;

drivers/usb/typec/altmodes/thunderbolt.c

359

vdo |= plug->vdo & TBT_CABLE_RETIMER;

drivers/usb/typec/altmodes/thunderbolt.c

360

vdo |= plug->vdo & TBT_CABLE_LINK_TRAINING;

drivers/usb/typec/altmodes/thunderbolt.c

362

vdo |= TBT_ENTER_MODE_CABLE_SPEED(TBT_CABLE_USB3_PASSIVE);

drivers/usb/typec/altmodes/thunderbolt.c

365

tbt->enter_vdo = vdo;

drivers/usb/typec/anx7411.c

552

int svid, int vdo)

drivers/usb/typec/anx7411.c

560

desc.vdo = vdo;

drivers/usb/typec/bus.c

126

int typec_altmode_enter(struct typec_altmode *adev, u32 *vdo)

drivers/usb/typec/bus.c

147

return pdev->ops->enter(pdev, vdo);

drivers/usb/typec/bus.c

186

int typec_altmode_attention(struct typec_altmode *adev, u32 vdo)

drivers/usb/typec/bus.c

197

pdev->ops->attention(pdev, vdo);

drivers/usb/typec/bus.c

215

const u32 header, const u32 *vdo, int count)

drivers/usb/typec/bus.c

233

return pdev->ops->vdm(pdev, header, vdo, count);

drivers/usb/typec/bus.c

259

int typec_cable_altmode_enter(struct typec_altmode *adev, enum typec_plug_index sop, u32 *vdo)

drivers/usb/typec/bus.c

278

return pdev->cable_ops->enter(pdev, sop, vdo);

drivers/usb/typec/bus.c

322

const u32 header, const u32 *vdo, int count)

drivers/usb/typec/bus.c

345

return pdev->cable_ops->vdm(pdev, sop, header, vdo, count);

drivers/usb/typec/class.c

133

return sysfs_emit(buf, "0x%08x\n", id->vdo[0]);

drivers/usb/typec/class.c

142

return sysfs_emit(buf, "0x%08x\n", id->vdo[1]);

drivers/usb/typec/class.c

151

return sysfs_emit(buf, "0x%08x\n", id->vdo[2]);

drivers/usb/typec/class.c

2620

u32 vdo;

drivers/usb/typec/class.c

2637

ret = fwnode_property_read_u32(child, "vdo", &vdo);

drivers/usb/typec/class.c

2651

desc.vdo = vdo;

drivers/usb/typec/class.c

347

return sprintf(buf, "0x%08x\n", alt->vdo);

drivers/usb/typec/class.c

349

static DEVICE_ATTR_RO(vdo);

drivers/usb/typec/class.c

657

alt->adev.vdo = desc->vdo;

drivers/usb/typec/class.c

933

u32 devcap = PD_VDO_UFP_DEVCAP(id->vdo[0]);

drivers/usb/typec/class.c

942

usb_capability = PD_VDO_DFP_HOSTCAP(id->vdo[0]);

drivers/usb/typec/tcpm/tcpm.c

1855

u32 vdo = p[VDO_INDEX_IDH];

drivers/usb/typec/tcpm/tcpm.c

1863

port->partner_ident.id_header = vdo;

drivers/usb/typec/tcpm/tcpm.c

1871

PD_IDH_VID(vdo),

drivers/usb/typec/tcpm/tcpm.c

1897

port->cable_ident.vdo[0] = p[VDO_INDEX_CABLE_1];

drivers/usb/typec/tcpm/tcpm.c

1908

port->cable_ident.vdo[1] = p[VDO_INDEX_CABLE_2];

drivers/usb/typec/tcpm/tcpm.c

2018

paltmode->vdo = p[i];

drivers/usb/typec/tcpm/tcpm.c

2022

paltmode->mode, paltmode->vdo);

drivers/usb/typec/tcpm/tcpm.c

3086

static int tcpm_altmode_enter(struct typec_altmode *altmode, u32 *vdo)

drivers/usb/typec/tcpm/tcpm.c

3099

return tcpm_queue_vdm_unlocked(port, header, vdo, vdo ? 1 : 0, TCPC_TX_SOP);

drivers/usb/typec/tcpm/tcpm.c

3134

u32 *vdo)

drivers/usb/typec/tcpm/tcpm.c

3147

return tcpm_queue_vdm_unlocked(port, header, vdo, vdo ? 1 : 0, TCPC_TX_SOP_PRIME);

drivers/usb/typec/tcpm/tcpm.c

7823

u32 *vdo;

drivers/usb/typec/tcpm/tcpm.c

7827

vdo = port->snk_vdo;

drivers/usb/typec/tcpm/tcpm.c

7829

vdo = port->snk_vdo_v1;

drivers/usb/typec/tcpm/tcpm.c

7833

pd_ident->vid = PD_IDH_VID(vdo[0]);

drivers/usb/typec/tcpm/tcpm.c

7834

pd_ident->pid = PD_PRODUCT_PID(vdo[2]);

drivers/usb/typec/tcpm/tcpm.c

7835

pd_ident->xid = PD_CSTAT_XID(vdo[1]);

drivers/usb/typec/tipd/core.c

1248

desc.vdo = DP_CONF_SET_PIN_ASSIGN(BIT(DP_PIN_ASSIGN_C) | BIT(DP_PIN_ASSIGN_D));

drivers/usb/typec/tipd/core.c

1249

desc.vdo |= DP_CAP_DFP_D;

drivers/usb/typec/ucsi/displayport.c

160

u32 cap = dp->alt->vdo;

drivers/usb/typec/ucsi/displayport.c

322

desc->vdo |= DP_CAP_DP_SIGNALLING(0) | DP_CAP_RECEPTACLE;

drivers/usb/typec/ucsi/displayport.c

325

desc->vdo |= all_assignments << 8;

drivers/usb/typec/ucsi/displayport.c

326

desc->vdo |= all_assignments << 16;

drivers/usb/typec/ucsi/displayport.c

48

static int ucsi_displayport_enter(struct typec_altmode *alt, u32 *vdo)

drivers/usb/typec/ucsi/thunderbolt.c

108

ret = ucsi_thunderbolt_set_altmode(tbt, true, *vdo);

drivers/usb/typec/ucsi/thunderbolt.c

47

bool enter, u32 vdo)

drivers/usb/typec/ucsi/thunderbolt.c

55

((u64)vdo << 32);

drivers/usb/typec/ucsi/thunderbolt.c

81

static int ucsi_thunderbolt_enter(struct typec_altmode *alt, u32 *vdo)

drivers/usb/typec/ucsi/trace.h

101

__entry->mode, __entry->vdo)

drivers/usb/typec/ucsi/trace.h

91

__field(u32, vdo)

drivers/usb/typec/ucsi/trace.h

97

__entry->vdo = alt->vdo;

drivers/usb/typec/ucsi/ucsi.c

1003

con->cable_identity = *(struct usb_pd_identity *)&vdo[1];

drivers/usb/typec/ucsi/ucsi.c

453

if (desc->vdo == USB_TYPEC_NVIDIA_VLINK_DBG_VDO)

drivers/usb/typec/ucsi/ucsi.c

597

u16 svid, u32 vdo, int offset)

drivers/usb/typec/ucsi/ucsi.c

605

if (alt_batch[k].svid == svid && alt_batch[k].mid == vdo) {

drivers/usb/typec/ucsi/ucsi.c

607

vdo, vdo, offset);

drivers/usb/typec/ucsi/ucsi.c

624

con->partner_altmode[partner_count - 1]->vdo,

drivers/usb/typec/ucsi/ucsi.c

625

vdo, offset);

drivers/usb/typec/ucsi/ucsi.c

644

if (altmodes[k]->svid != svid || altmodes[k]->vdo != vdo)

drivers/usb/typec/ucsi/ucsi.c

648

altmodes[k]->vdo, vdo, offset);

drivers/usb/typec/ucsi/ucsi.c

725

desc.vdo = altmode_array[i].mid;

drivers/usb/typec/ucsi/ucsi.c

795

desc.vdo = alt[j].mid;

drivers/usb/typec/ucsi/ucsi.c

836

adev[i]->vdo != USB_TYPEC_NVIDIA_VLINK_DBG_VDO))

drivers/usb/typec/ucsi/ucsi.c

975

u32 vdo[7] = {};

drivers/usb/typec/ucsi/ucsi.c

978

ret = ucsi_get_pd_message(con, UCSI_RECIPIENT_SOP, sizeof(vdo), vdo,

drivers/usb/typec/ucsi/ucsi.c

984

con->partner_identity = *(struct usb_pd_identity *)&vdo[1];

drivers/usb/typec/ucsi/ucsi.c

995

u32 vdo[7] = {};

drivers/usb/typec/ucsi/ucsi.c

998

ret = ucsi_get_pd_message(con, UCSI_RECIPIENT_SOP_P, sizeof(vdo), vdo,

drivers/usb/typec/ucsi/ucsi_ccg.c

517

(pin & DP_CONF_GET_PIN_ASSIGN(alt->vdo))) {

include/dt-bindings/usb/pd.h

449

#define PD_VDO_AMA_VCONN_REQ(vdo) (((vdo) >> 4) & 1)

include/dt-bindings/usb/pd.h

450

#define PD_VDO_AMA_VBUS_REQ(vdo) (((vdo) >> 3) & 1)

include/linux/platform_data/cros_ec_commands.h

5455

uint32_t vdo[6]; /* Mode VDOs */

include/linux/usb/pd_vdo.h

154

#define PD_IDH_PTYPE(vdo) (((vdo) >> 27) & 0x7)

include/linux/usb/pd_vdo.h

155

#define PD_IDH_VID(vdo) ((vdo) & 0xffff)

include/linux/usb/pd_vdo.h

156

#define PD_IDH_MODAL_SUPP(vdo) ((vdo) & (1 << 26))

include/linux/usb/pd_vdo.h

157

#define PD_IDH_DFP_PTYPE(vdo) (((vdo) >> 23) & 0x7)

include/linux/usb/pd_vdo.h

158

#define PD_IDH_CONN_TYPE(vdo) (((vdo) >> 21) & 0x3)

include/linux/usb/pd_vdo.h

159

#define PD_IDH_HOST_SUPP(vdo) ((vdo) & (1 << 31))

include/linux/usb/pd_vdo.h

166

#define PD_CSTAT_XID(vdo) (vdo)

include/linux/usb/pd_vdo.h

176

#define PD_PRODUCT_PID(vdo) (((vdo) >> 16) & 0xffff)

include/linux/usb/pd_vdo.h

192

#define PD_VDO_UFP_DEVCAP(vdo) FIELD_GET(GENMASK(27, 24), vdo)

include/linux/usb/pd_vdo.h

251

#define PD_VDO_DFP_HOSTCAP(vdo) FIELD_GET(GENMASK(26, 24), vdo)

include/linux/usb/pd_vdo.h

386

#define VDO_TYPEC_CABLE_SPEED(vdo) ((vdo) & 0x7)

include/linux/usb/pd_vdo.h

387

#define VDO_TYPEC_CABLE_TYPE(vdo) (((vdo) >> 18) & 0x3)

include/linux/usb/pd_vdo.h

464

#define PD_VDO_AMA_VCONN_REQ(vdo) (((vdo) >> 4) & 1)

include/linux/usb/pd_vdo.h

465

#define PD_VDO_AMA_VBUS_REQ(vdo) (((vdo) >> 3) & 1)

include/linux/usb/pd_vdo.h

510

#define PD_VDO_SVID_SVID0(vdo) ((vdo) >> 16)

include/linux/usb/pd_vdo.h

511

#define PD_VDO_SVID_SVID1(vdo) ((vdo) & 0xffff)

include/linux/usb/pd_vdo.h

78

#define PD_VDO_VID(vdo) ((vdo) >> 16)

include/linux/usb/pd_vdo.h

79

#define PD_VDO_SVDM(vdo) (((vdo) >> 15) & 1)

include/linux/usb/pd_vdo.h

80

#define PD_VDO_SVDM_VER(vdo) (((vdo) >> 13) & 0x3)

include/linux/usb/pd_vdo.h

81

#define PD_VDO_OPOS(vdo) (((vdo) >> 8) & 0x7)

include/linux/usb/pd_vdo.h

82

#define PD_VDO_CMD(vdo) ((vdo) & 0x1f)

include/linux/usb/pd_vdo.h

83

#define PD_VDO_CMDT(vdo) (((vdo) >> 6) & 0x3)

include/linux/usb/typec.h

134

u32 vdo[3];

include/linux/usb/typec.h

154

u32 vdo;

include/linux/usb/typec_altmode.h

100

int (*enter)(struct typec_altmode *altmode, enum typec_plug_index sop, u32 *vdo);

include/linux/usb/typec_altmode.h

103

const u32 hdr, const u32 *vdo, int cnt);

include/linux/usb/typec_altmode.h

106

int typec_cable_altmode_enter(struct typec_altmode *altmode, enum typec_plug_index sop, u32 *vdo);

include/linux/usb/typec_altmode.h

109

const u32 header, const u32 *vdo, int count);

include/linux/usb/typec_altmode.h

40

u32 vdo;

include/linux/usb/typec_altmode.h

73

int (*enter)(struct typec_altmode *altmode, u32 *vdo);

include/linux/usb/typec_altmode.h

75

void (*attention)(struct typec_altmode *altmode, u32 vdo);

include/linux/usb/typec_altmode.h

77

const u32 *vdo, int cnt);

include/linux/usb/typec_altmode.h

83

int typec_altmode_enter(struct typec_altmode *altmode, u32 *vdo);

include/linux/usb/typec_altmode.h

85

int typec_altmode_attention(struct typec_altmode *altmode, u32 vdo);

include/linux/usb/typec_altmode.h

87

const u32 header, const u32 *vdo, int count);

scripts/dtc/include-prefixes/dt-bindings/usb/pd.h

449

#define PD_VDO_AMA_VCONN_REQ(vdo) (((vdo) >> 4) & 1)

scripts/dtc/include-prefixes/dt-bindings/usb/pd.h

450

#define PD_VDO_AMA_VBUS_REQ(vdo) (((vdo) >> 3) & 1)