SegmentedAllocator::SegmentedAllocator(
SegmentProvider& sp,
- SegmentManager& sm,
- Journal& journal)
+ SegmentManager& sm)
: segment_provider(sp),
- segment_manager(sm),
- journal(journal)
+ segment_manager(sm)
{
std::generate_n(
std::back_inserter(writers),
[&] {
return Writer{
segment_provider,
- segment_manager,
- journal};
+ segment_manager};
});
}
segment_manager.get_block_size()));
bp.zero();
auto header =segment_header_t{
- journal.get_segment_seq(),
+ OOL_SEG_SEQ,
segment.get_segment_id(),
NO_DELTAS, 0, true};
logger().debug("SegmentedAllocator::Writer::init_segment: initting {}, {}",
#include "crimson/common/condition_variable.h"
#include "crimson/os/seastore/cached_extent.h"
-#include "crimson/os/seastore/journal.h"
#include "crimson/os/seastore/logging.h"
#include "crimson/os/seastore/segment_manager.h"
#include "crimson/os/seastore/transaction.h"
public:
Writer(
SegmentProvider& sp,
- SegmentManager& sm,
- Journal& journal)
+ SegmentManager& sm)
: segment_provider(sp),
- segment_manager(sm),
- journal(journal)
+ segment_manager(sm)
{}
Writer(Writer &&) = default;
open_segment_wrapper_ref current_segment;
std::list<open_segment_wrapper_ref> open_segments;
seastore_off_t allocated_to = 0;
- Journal& journal;
crimson::condition_variable segment_rotation_guard;
seastar::gate writer_guard;
bool rolling_segment = false;
public:
SegmentedAllocator(
SegmentProvider& sp,
- SegmentManager& sm,
- Journal& journal);
+ SegmentManager& sm);
Writer &get_writer(placement_hint_t hint) {
return writers[std::rand() % writers.size()];
SegmentProvider& segment_provider;
SegmentManager& segment_manager;
std::vector<Writer> writers;
- Journal& journal;
};
class ExtentPlacementManager {
* sequence number > the current journal segment seq. We can
* safetly skip these deltas because the extent must already
* have been rewritten.
- *
- * Note, this comparison exploits the fact that
- * SEGMENT_SEQ_NULL is a large number.
*/
- auto& seg_addr = delta.paddr.as_seg_paddr();
- if (delta.paddr != P_ADDR_NULL &&
- (segment_provider->get_seq(seg_addr.get_segment_id()) >
- locator.write_result.start_seq.segment_seq)) {
- return replay_ertr::now();
- } else {
- return handler(locator, delta);
+ if (delta.paddr != P_ADDR_NULL) {
+ auto& seg_addr = delta.paddr.as_seg_paddr();
+ auto delta_paddr_segment_seq = segment_provider->get_seq(seg_addr.get_segment_id());
+ auto locator_segment_seq = locator.write_result.start_seq.segment_seq;
+ if (delta_paddr_segment_seq == NULL_SEG_SEQ ||
+ (delta_paddr_segment_seq <= MAX_VALID_SEG_SEQ &&
+ delta_paddr_segment_seq > locator_segment_seq)) {
+ return replay_ertr::now();
+ }
}
+ return handler(locator, delta);
});
});
});
/* Monotonically increasing segment seq, uniquely identifies
* the incarnation of a segment */
using segment_seq_t = uint32_t;
-static constexpr segment_seq_t NULL_SEG_SEQ =
- std::numeric_limits<segment_seq_t>::max();
static constexpr segment_seq_t MAX_SEG_SEQ =
std::numeric_limits<segment_seq_t>::max();
+static constexpr segment_seq_t NULL_SEG_SEQ = MAX_SEG_SEQ;
+static constexpr segment_seq_t OOL_SEG_SEQ = MAX_SEG_SEQ - 1;
+static constexpr segment_seq_t MAX_VALID_SEG_SEQ = MAX_SEG_SEQ - 2;
// Offset of delta within a record
using record_delta_idx_t = uint32_t;
device_type_t::SEGMENTED,
std::make_unique<SegmentedAllocator>(
*segment_cleaner,
- *sm,
- *journal));
+ *sm));
}
~TransactionManager();
device_type_t::SEGMENTED,
std::make_unique<SegmentedAllocator>(
*segment_cleaner,
- *segment_manager,
- *journal));
+ *segment_manager));
journal->set_segment_provider(&*segment_cleaner);
device_type_t::SEGMENTED,
std::make_unique<SegmentedAllocator>(
*segment_cleaner,
- segment_manager,
- *journal));
+ segment_manager));
journal->set_segment_provider(&*segment_cleaner);