md/dm-vdo/slab-depot.c

250 	int result = (vdo_is_read_only(allocator->depot->vdo) ?
253 	vdo_waitq_notify_all_waiters(queue, NULL, &result);
297 	vdo_enter_read_only_mode(completion->vdo, completion->result);
367 	int result;
371 		result = VDO_READ_ONLY;
372 		waiter->callback(waiter, &result);
378 		result = VDO_INVALID_ADMIN_STATE;
379 		waiter->callback(waiter, &result);
430 	vdo_enter_read_only_mode(completion->vdo, completion->result);
552  * @context: The result code of the update.
563 	int result = *((int *) context);
565 	if (result != VDO_SUCCESS) {
566 		if (result != VDO_READ_ONLY) {
571 			vdo_log_error_strerror(result, "failed slab summary update %llu",
576 		vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);
695 	int result = completion->result;
703 	if (result != VDO_SUCCESS) {
705 		vdo_log_error_strerror(result, "cannot write slab journal block %llu",
707 		vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);
908 	int result;
910 	result = VDO_ASSERT(vdo_before_journal_point(&journal->tail_header.recovery_point,
917 	if (result != VDO_SUCCESS) {
918 		vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);
923 		result = VDO_ASSERT((journal->tail_header.entry_count <
926 		if (result != VDO_SUCCESS) {
928 						 result);
1018 	int result = *((int *) context);
1022 	if ((result != VDO_SUCCESS) && (result != VDO_READ_ONLY)) {
1023 		vdo_log_error_strerror(result, "failed to update slab summary");
1024 		vdo_enter_read_only_mode(slab->allocator->depot->vdo, result);
1168 	int result = completion->result;
1175 	vdo_enter_read_only_mode(slab->allocator->depot->vdo, result);
1323 	int result = slab_block_number_from_pbn(slab, pbn, &index);
1325 	if (result != VDO_SUCCESS)
1326 		return result;
1600 	int result;
1603 		result = decrement_for_data(slab, block, block_number, old_status,
1605 		if ((result == VDO_SUCCESS) && (old_status == RS_PROVISIONAL)) {
1611 		result = increment_for_data(slab, block, block_number, old_status,
1614 		result = increment_for_block_map(slab, block, block_number, old_status,
1619 	if (result != VDO_SUCCESS)
1620 		return result;
1633 	int result;
1640 	result = slab_block_number_from_pbn(slab, updater->zpbn.pbn, &block_number);
1641 	if (result != VDO_SUCCESS)
1642 		return result;
1645 	result = update_reference_count(slab, block, block_number, slab_journal_point,
1648 	if ((result != VDO_SUCCESS) || provisional_decrement)
1649 		return result;
1658 		result = VDO_ASSERT(is_valid_journal_point(slab_journal_point),
1660 		if (result != VDO_SUCCESS)
1661 			return result;
1691 	int result;
1733 		result = VDO_SUCCESS;
1736 		result = adjust_reference_count(journal->slab, updater,
1741 		continue_data_vio_with_error(data_vio, result);
1743 		vdo_continue_completion(&data_vio->decrement_completion, result);
1784 			 * outstanding, as it could result in reference count corruption.
1945 	int result;
1954 	result = slab_block_number_from_pbn(slab, pbn, &block_number);
1955 	if (result != VDO_SUCCESS)
1956 		return result;
1959 	result = update_reference_count(slab, block, block_number, NULL,
1961 	if (result != VDO_SUCCESS)
1962 		return result;
1983 	int result;
1997 	result = update_reference_count(slab, block, entry.sbn, entry_point,
1999 	if (result != VDO_SUCCESS)
2000 		return result;
2361 	int result;
2364 	result = VDO_ASSERT(slab->reference_blocks == NULL,
2367 	if (result != VDO_SUCCESS)
2368 		return result;
2370 	result = vdo_allocate(slab->reference_block_count, struct reference_block,
2372 	if (result != VDO_SUCCESS)
2373 		return result;
2380 	result = vdo_allocate(bytes, vdo_refcount_t, "ref counts array",
2382 	if (result != VDO_SUCCESS) {
2384 		return result;
2448 	int result = completion->result;
2454 	vdo_finish_loading_with_result(&journal->slab->state, result);
2548 	int result;
2557 	result = VDO_ASSERT((free_blocks <= allocator->depot->slab_config.data_blocks),
2561 	if (result != VDO_SUCCESS) {
2562 		vdo_enter_read_only_mode(allocator->depot->vdo, result);
2670 static void finish_scrubbing(struct slab_scrubber *scrubber, int result)
2682 		vdo_fail_completion(vdo_forget(scrubber->vio.completion.parent), result);
2746  * @result: The error.
2748 static void abort_scrubbing(struct slab_scrubber *scrubber, int result)
2750 	vdo_enter_read_only_mode(scrubber->vio.completion.vdo, result);
2751 	finish_scrubbing(scrubber, result);
2764 			completion->result);
2784 	int result;
2800 		result = replay_reference_count_change(slab, &entry_point, entry);
2801 		if (result != VDO_SUCCESS) {
2802 			vdo_log_error_strerror(result,
2808 			return result;
2824 	int result;
2866 		result = apply_block_entries(block, header.entry_count, sequence, slab);
2867 		if (result != VDO_SUCCESS) {
2868 			abort_scrubbing(scrubber, result);
2883 	result = VDO_ASSERT(!vdo_before_journal_point(&last_entry_applied,
2886 	if (result != VDO_SUCCESS) {
2887 		abort_scrubbing(scrubber, result);
3110 	int result;
3118 	result = slab_block_number_from_pbn(slab, pbn, &block_number);
3119 	if (result != VDO_SUCCESS)
3120 		return result;
3188 	int result;
3192 		result = allocate_slab_block(allocator->open_slab, block_number_ptr);
3193 		if ((result == VDO_SUCCESS) || (result != VDO_NO_SPACE))
3194 			return result;
3337 		vdo_set_completion_result(allocator->state.waiter, completion->result);
3403 	int result = (((read_err == 0) && (write_err == 0)) ? VDO_SUCCESS : -EIO);
3405 	if (result != VDO_SUCCESS) {
3406 		vdo_fail_completion(&allocator->completion, result);
3478 	vdo_finish_loading_with_result(&allocator->state, completion->result);
3484 	int result;
3488 	result = vdo_allocate(allocator->slab_count, struct slab_status, __func__,
3490 	if (result != VDO_SUCCESS)
3491 		return result;
3513 	int result;
3519 	result = get_slab_statuses(allocator, &slab_statuses);
3520 	if (result != VDO_SUCCESS)
3521 		return result;
3662 	int result;
3664 	result = vdo_allocate(slab_config->slab_journal_blocks, struct journal_lock,
3666 	if (result != VDO_SUCCESS)
3667 		return result;
3669 	result = vdo_allocate(VDO_BLOCK_SIZE, char, "struct packed_slab_journal_block",
3671 	if (result != VDO_SUCCESS)
3672 		return result;
3723 	int result;
3725 	result = vdo_allocate(1, struct vdo_slab, __func__, &slab);
3726 	if (result != VDO_SUCCESS)
3727 		return result;
3744 	result = initialize_slab_journal(slab);
3745 	if (result != VDO_SUCCESS) {
3747 		return result;
3752 		result = allocate_slab_counters(slab);
3753 		if (result != VDO_SUCCESS) {
3755 			return result;
3780 	int result;
3782 	result = vdo_allocate(slab_count, struct vdo_slab *,
3784 	if (result != VDO_SUCCESS)
3785 		return result;
3803 		result = make_slab(slab_origin, allocator, depot->new_slab_count,
3805 		if (result != VDO_SUCCESS)
3806 			return result;
3935 	int result;
3937 	result = vdo_allocate(VDO_BLOCK_SIZE * slab_journal_size,
3939 	if (result != VDO_SUCCESS)
3940 		return result;
3942 	result = allocate_vio_components(allocator->completion.vdo,
3947 	if (result != VDO_SUCCESS) {
3949 		return result;
3969 	int result;
3971 	result = vdo_allocate(VDO_BLOCK_SIZE, char, __func__, &block->outgoing_entries);
3972 	if (result != VDO_SUCCESS)
3973 		return result;
3975 	result = allocate_vio_components(allocator->depot->vdo, VIO_TYPE_SLAB_SUMMARY,
3978 	if (result != VDO_SUCCESS)
3979 		return result;
3990 	int result;
4006 	result = vdo_register_read_only_listener(vdo, allocator,
4009 	if (result != VDO_SUCCESS)
4010 		return result;
4013 	result = make_vio_pool(vdo, BLOCK_ALLOCATOR_VIO_POOL_SIZE, allocator->thread_id,
4016 	if (result != VDO_SUCCESS)
4017 		return result;
4019 	result = initialize_slab_scrubber(allocator);
4020 	if (result != VDO_SUCCESS)
4021 		return result;
4023 	result = vdo_make_priority_table(max_priority, &allocator->prioritized_slabs);
4024 	if (result != VDO_SUCCESS)
4025 		return result;
4027 	result = vdo_allocate(VDO_SLAB_SUMMARY_BLOCKS_PER_ZONE,
4030 	if (result != VDO_SUCCESS)
4031 		return result;
4039 		result = initialize_slab_summary_block(allocator, i);
4040 		if (result != VDO_SUCCESS)
4041 			return result;
4066 	int result;
4073 	result = vdo_make_action_manager(depot->zone_count, get_allocator_thread_id,
4077 	if (result != VDO_SUCCESS)
4078 		return result;
4087 	result = vdo_allocate(MAXIMUM_VDO_SLAB_SUMMARY_ENTRIES,
4090 	if (result != VDO_SUCCESS)
4091 		return result;
4120 		result = initialize_block_allocator(depot, zone);
4121 		if (result != VDO_SUCCESS)
4122 			return result;
4126 	result = allocate_slabs(depot, slab_count);
4127 	if (result != VDO_SUCCESS)
4128 		return result;
4161 	int result;
4175 	result = vdo_allocate_extended(struct slab_depot,
4178 	if (result != VDO_SUCCESS)
4179 		return result;
4189 	result = allocate_components(depot, summary_partition);
4190 	if (result != VDO_SUCCESS) {
4192 		return result;
4294 		int result = allocate_slab_counters(next_slab(&iterator));
4296 		if (result != VDO_SUCCESS)
4297 			return result;
4342 	int result;
4347 	result = get_slab_number(depot, pbn, &slab_number);
4348 	if (result != VDO_SUCCESS) {
4349 		vdo_enter_read_only_mode(depot->vdo, result);
4369 	int result;
4374 	result = get_reference_counter(slab, pbn, &counter_ptr);
4375 	if (result != VDO_SUCCESS)
4447 	int result = completion->result;
4451 	vdo_fail_completion(parent, result);
4543 	int result;
4549 	result = create_multi_block_metadata_vio(depot->vdo, VIO_TYPE_SLAB_SUMMARY,
4553 	if (result != VDO_SUCCESS) {
4554 		vdo_fail_completion(parent, result);
4607 	int result;
4609 	result = vdo_prepare_slabs_for_allocation(allocator);
4610 	if (result != VDO_SUCCESS) {
4611 		vdo_fail_completion(parent, result);
4661 	int result;
4670 	result = vdo_configure_slab_depot(partition, depot->slab_config,
4672 	if (result != VDO_SUCCESS)
4673 		return result;
4687 	result = allocate_slabs(depot, new_slab_count);
4688 	if (result != VDO_SUCCESS) {
4690 		return result;
4801 		vdo_finish_draining_with_result(&allocator->state, completion->result);
4858 	int result;
4866 	result = vdo_resume_if_quiescent(&scrubber->admin_state);
4867 	if (result != VDO_SUCCESS) {
4868 		vdo_fail_completion(&allocator->completion, result);
4898 		vdo_finish_resuming_with_result(&allocator->state, completion->result);