}
};
+ class assert_failure {
+ const char* const msg = nullptr;
+ public:
+ template <std::size_t N>
+ assert_failure(const char (&msg)[N])
+ : msg(msg) {
+ }
+ assert_failure() = default;
+
+ void operator()(const unthrowable_wrapper&) {
+ if (msg) {
+ ceph_abort(msg);
+ } else {
+ ceph_abort();
+ }
+ }
+ };
private:
// can be used only to initialize the `instance` member
#else
auto result = epm.alloc_new_non_data_extent(t, T::TYPE, length, hint, gen);
#endif
- auto ret = CachedExtent::make_cached_extent_ref<T>(std::move(result.bp));
+ if (!result) {
+ return nullptr;
+ }
+ auto ret = CachedExtent::make_cached_extent_ref<T>(std::move(result->bp));
ret->init(CachedExtent::extent_state_t::INITIAL_WRITE_PENDING,
- result.paddr,
+ result->paddr,
hint,
- result.gen,
+ result->gen,
t.get_trans_id());
t.add_fresh_extent(ret);
SUBDEBUGT(seastore_cache,
"allocated {} {}B extent at {}, hint={}, gen={} -- {}",
- t, T::TYPE, length, result.paddr,
- hint, rewrite_gen_printer_t{result.gen}, *ret);
+ t, T::TYPE, length, result->paddr,
+ hint, rewrite_gen_printer_t{result->gen}, *ret);
return ret;
}
/**
}).si_then([] (auto) {
return create_iertr::make_ready_future<>();
});
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ create_iertr::pass_further{}
+ );
}
case CollectionNode::create_result_t::SUCCESS: {
return create_iertr::make_ready_future<>();
bufferptr bp;
rewrite_gen_t gen;
};
- alloc_result_t alloc_new_non_data_extent(
+ std::optional<alloc_result_t> alloc_new_non_data_extent(
Transaction& t,
extent_types_t type,
extent_len_t length,
data_category_t category = get_extent_category(type);
gen = adjust_generation(category, type, hint, gen);
- // XXX: bp might be extended to point to different memory (e.g. PMem)
- // according to the allocator.
- auto bp = ceph::bufferptr(
- buffer::create_page_aligned(length));
- bp.zero();
paddr_t addr;
#ifdef UNIT_TESTS_BUILT
if (unlikely(external_paddr.has_value())) {
generation_to_writer(gen)]->alloc_paddr(length);
}
assert(!(category == data_category_t::DATA));
- return {addr, std::move(bp), gen};
+
+ if (addr.is_null()) {
+ return std::nullopt;
+ }
+
+ // XXX: bp might be extended to point to different memory (e.g. PMem)
+ // according to the allocator.
+ auto bp = ceph::bufferptr(
+ buffer::create_page_aligned(length));
+ bp.zero();
+
+ return alloc_result_t{addr, std::move(bp), gen};
}
std::list<alloc_result_t> alloc_new_data_extents(
auto iter = region.bl->cbegin();
iter.copy(region.len, extent->get_bptr().c_str());
return ObjectDataHandler::write_iertr::now();
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ ObjectDataHandler::write_iertr::pass_further{}
+ );
} else if (region.is_zero()) {
DEBUGT("reserving: {}~{}",
ctx.t,
}
ceph_assert(pin->get_key() == region.addr);
return ObjectDataHandler::write_iertr::now();
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ ObjectDataHandler::write_iertr::pass_further{}
+ );
} else {
ceph_abort("impossible");
return ObjectDataHandler::write_iertr::now();
pin->get_key(),
pin->get_length());
return write_iertr::now();
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ write_iertr::pass_further{}
+ );
}
}
return TransactionManager::reserve_extent_iertr::now();
});
});
- },
+ }
+ ).handle_error_interruptible(
ObjectDataHandler::write_iertr::pass_further{},
crimson::ct_error::assert_all{
"object_data_handler::clone invalid error"
- }
- );
+ });
}
ObjectDataHandler::clone_ret ObjectDataHandler::clone(
t.get_omap_tree_stats().depth = 1u;
t.get_omap_tree_stats().extents_num_delta++;
return initialize_omap_iertr::make_ready_future<omap_root_t>(omap_root);
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ TransactionManager::alloc_extent_iertr::pass_further{}
+ );
}
BtreeOMapManager::get_root_ret
oc.t.get_omap_tree_stats().depth = omap_root.depth;
++(oc.t.get_omap_tree_stats().extents_num_delta);
return seastar::now();
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ TransactionManager::alloc_extent_iertr::pass_further{}
+ );
}
BtreeOMapManager::handle_root_merge_ret
return split_children_ret(
interruptible::ready_future_marker{},
std::make_tuple(left, right, split_into(*left, *right)));
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ split_children_iertr::pass_further{}
+ );
}
OMapInnerNode::full_merge_ret
return full_merge_ret(
interruptible::ready_future_marker{},
std::move(replacement));
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ full_merge_iertr::pass_further{}
+ );
}
OMapInnerNode::make_balanced_ret
std::make_tuple(replacement_left, replacement_right,
balance_into_new_nodes(*this, right,
*replacement_left, *replacement_right)));
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ make_balanced_iertr::pass_further{}
+ );
}
OMapInnerNode::merge_entry_ret
return split_children_ret(
interruptible::ready_future_marker{},
std::make_tuple(left, right, split_into(*left, *right)));
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ split_children_iertr::pass_further{}
+ );
}
OMapLeafNode::full_merge_ret
return full_merge_ret(
interruptible::ready_future_marker{},
std::move(replacement));
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ full_merge_iertr::pass_further{}
+ );
}
OMapLeafNode::make_balanced_ret
balance_into_new_nodes(
*this, right,
*replacement_left, *replacement_right)));
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ make_balanced_iertr::pass_further{}
+ );
}
assert(extent->get_length() == len);
std::ignore = len;
return NodeExtentRef(extent);
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ alloc_iertr::pass_further{}
+ );
}
retire_iertr::future<> retire_extent(
LOG_PREFIX(BlockRBManager::alloc_extent);
assert(allocator);
auto alloc = allocator->alloc_extent(size);
+ if (!alloc) {
+ return P_ADDR_NULL;
+ }
ceph_assert((*alloc).num_intervals() == 1);
auto extent = (*alloc).begin();
ceph_assert(size == extent.get_len());
* Allocates a new block of type T with the minimum lba range of size len
* greater than laddr_hint.
*/
- using alloc_extent_iertr = LBAManager::alloc_extent_iertr;
+ using alloc_extent_iertr = LBAManager::alloc_extent_iertr::extend<
+ crimson::ct_error::enospc>;
template <typename T>
using alloc_extent_ret = alloc_extent_iertr::future<TCachedExtentRef<T>>;
template <typename T>
len,
placement_hint,
INIT_GENERATION);
+ if (!ext) {
+ return crimson::ct_error::enospc::make();
+ }
return lba_manager->alloc_extent(
t,
laddr_hint,
len,
placement_hint,
INIT_GENERATION);
+ if (exts.empty()) {
+ return crimson::ct_error::enospc::make();
+ }
return seastar::do_with(
std::move(exts),
laddr_hint,
std::move(lpin), std::move(ext), std::move(rpin)));
});
});
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ crimson::ct_error::pass_further_all{}
+ );
});
} else if (new_offset == 0 && o_len != new_offset + new_len) {
return tm->remap_pin<TestBlock, 1>(
nullptr, std::move(ext), std::move(rpin)));
});
});
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ crimson::ct_error::pass_further_all{}
+ );
} else if (new_offset != 0 && o_len == new_offset + new_len) {
return tm->remap_pin<TestBlock, 1>(
t,
std::move(lpin), std::move(ext), nullptr));
});
});
- });
+ }).handle_error_interruptible(
+ crimson::ct_error::enospc::assert_failure{"unexpected enospc"},
+ crimson::ct_error::pass_further_all{}
+ );
} else {
ceph_abort("impossible");
return _overwrite_pin_iertr::make_ready_future<
projects / ceph.git / commitdiff