Skip to content

Commit 0d933fd

Browse files
alexvrualexvru
authored
Support shred orchestration in BSC (#13881)
1 parent 1ee80e5 commit 0d933fd

File tree

19 files changed

+892
-52
lines changed

19 files changed

+892
-52
lines changed

‎ydb/core/blobstorage/nodewarden/node_warden_impl.cpp

Lines changed: 96 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -100,6 +100,8 @@ STATEFN(TNodeWarden::StateOnline) {
100100
hFunc(TEvTabletPipe::TEvClientDestroyed, Handle);
101101

102102
hFunc(NPDisk::TEvSlayResult, Handle);
103+
hFunc(NPDisk::TEvShredPDiskResult, Handle);
104+
hFunc(NPDisk::TEvShredPDisk, Handle);
103105

104106
hFunc(TEvRegisterPDiskLoadActor, Handle);
105107

@@ -575,6 +577,50 @@ void TNodeWarden::Handle(NPDisk::TEvSlayResult::TPtr ev) {
575577
};
576578
}
577579

580+
void TNodeWarden::Handle(NPDisk::TEvShredPDiskResult::TPtr ev) {
581+
ProcessShredStatus(ev->Cookie, ev->Get()->ShredGeneration, ev->Get()->Status == NKikimrProto::OK ? std::nullopt :
582+
std::make_optional(TStringBuilder() << "failed to shred PDisk Status# " << NKikimrProto::EReplyStatus_Name(
583+
ev->Get()->Status)));
584+
}
585+
586+
void TNodeWarden::Handle(NPDisk::TEvShredPDisk::TPtr ev) {
587+
// the message has returned to sender -- PDisk was terminated before processing it; normally it must never happen,
588+
// because NodeWarden issues PoisonPill synchronously with removing PDisk from the LocalPDisks set
589+
ProcessShredStatus(ev->Cookie, ev->Get()->ShredGeneration, "PDisk has been terminated before it got shredded");
590+
Y_DEBUG_ABORT("unexpected case");
591+
}
592+
593+
void TNodeWarden::ProcessShredStatus(ui64 cookie, ui64 generation, std::optional<TString> error) {
594+
const auto it = ShredInFlight.find(cookie);
595+
const std::optional<TPDiskKey> key = it != ShredInFlight.end() ? std::make_optional(it->second) : std::nullopt;
596+
if (it != ShredInFlight.end()) {
597+
ShredInFlight.erase(it);
598+
}
599+
600+
const auto pdiskIt = key ? LocalPDisks.find(*key) : LocalPDisks.end();
601+
TPDiskRecord *pdisk = pdiskIt != LocalPDisks.end() ? &pdiskIt->second : nullptr;
602+
if (pdisk) {
603+
const size_t numErased = pdisk->ShredCookies.erase(cookie);
604+
Y_ABORT_UNLESS(numErased);
605+
}
606+
607+
STLOG(PRI_DEBUG, BS_SHRED, BSSN00, "processing shred result from PDisk",
608+
(Cookie, cookie),
609+
(PDiskId, key),
610+
(ShredGeneration, generation),
611+
(ErrorReason, error),
612+
(ShredGenerationIssued, pdisk ? pdisk->ShredGenerationIssued : std::nullopt));
613+
614+
if (pdisk && generation == pdisk->ShredGenerationIssued) {
615+
if (error) {
616+
pdisk->ShredState.emplace<TString>(std::move(*error));
617+
} else {
618+
pdisk->ShredState.emplace<ui64>(generation);
619+
}
620+
SendPDiskReport(key->PDiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_SHRED, pdisk->ShredState);
621+
}
622+
}
623+
578624
void TNodeWarden::Handle(TEvRegisterPDiskLoadActor::TPtr ev) {
579625
Send(ev.Get()->Sender, new TEvRegisterPDiskLoadActorResult(NextLocalPDiskInitOwnerRound()));
580626
}
@@ -609,6 +655,56 @@ void TNodeWarden::Handle(TEvBlobStorage::TEvControllerNodeServiceSetUpdate::TPtr
609655
ApplyGroupInfo(groupId, generation, nullptr, false, false);
610656
}
611657
}
658+
659+
if (record.HasShredRequest()) {
660+
const auto& request = record.GetShredRequest();
661+
const ui64 generation = request.GetShredGeneration();
662+
for (ui32 pdiskId : request.GetPDiskIds()) {
663+
const TPDiskKey key(LocalNodeId, pdiskId);
664+
if (const auto it = LocalPDisks.find(key); it != LocalPDisks.end()) {
665+
TPDiskRecord& pdisk = it->second;
666+
667+
auto issueShredRequestToPDisk = [&] {
668+
const ui64 cookie = ++LastShredCookie;
669+
ShredInFlight.emplace(cookie, key);
670+
pdisk.ShredCookies.insert(cookie);
671+
672+
const TActorId actorId = SelfId();
673+
auto ev = std::make_unique<NPDisk::TEvShredPDisk>(generation);
674+
TActivationContext::Send(new IEventHandle(MakeBlobStoragePDiskID(LocalNodeId, pdiskId), SelfId(),
675+
ev.release(), IEventHandle::FlagForwardOnNondelivery, cookie, &actorId));
676+
pdisk.ShredGenerationIssued.emplace(generation);
677+
678+
STLOG(PRI_DEBUG, BS_SHRED, BSSN01, "sending shred query to PDisk",
679+
(Cookie, cookie),
680+
(PDiskId, key),
681+
(ShredGeneration, generation));
682+
};
683+
684+
if (pdisk.ShredGenerationIssued == generation) {
685+
std::visit(TOverloaded{
686+
[&](std::monostate&) {
687+
// shredding is in progress, do nothing
688+
},
689+
[&](ui64& generation) {
690+
// shredding has already completed for this generation, report it
691+
SendPDiskReport(pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_SHRED, generation);
692+
},
693+
[&](TString& /*aborted*/) {
694+
// shredding finished with error last time, restart
695+
issueShredRequestToPDisk();
696+
}
697+
}, pdisk.ShredState);
698+
} else if (pdisk.ShredGenerationIssued < generation) {
699+
issueShredRequestToPDisk();
700+
} else {
701+
SendPDiskReport(pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_SHRED, "obsolete generation");
702+
}
703+
} else {
704+
SendPDiskReport(pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_SHRED, "PDisk not found");
705+
}
706+
}
707+
}
612708
}
613709

614710
void TNodeWarden::SendDropDonorQuery(ui32 nodeId, ui32 pdiskId, ui32 vslotId, const TVDiskID& vdiskId, TDuration backoff) {

‎ydb/core/blobstorage/nodewarden/node_warden_impl.h

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,10 @@ namespace NKikimr::NStorage {
6161
friend bool operator ==(const TPDiskKey& x, const TPDiskKey& y) {
6262
return x.NodeId == y.NodeId && x.PDiskId == y.PDiskId;
6363
}
64+
65+
TString ToString() const {
66+
return TStringBuilder() << '[' << NodeId << ':' << PDiskId << ']';
67+
}
6468
};
6569

6670
struct TUnreportedMetricTag {};
@@ -78,6 +82,10 @@ namespace NKikimr::NStorage {
7882
ui32 RefCount = 0;
7983
bool Temporary = false;
8084

85+
std::optional<ui64> ShredGenerationIssued;
86+
std::variant<std::monostate, ui64, TString> ShredState; // not issued, finished with generation, aborted
87+
THashSet<ui64> ShredCookies;
88+
8189
TPDiskRecord(NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk record)
8290
: Record(std::move(record))
8391
{}
@@ -113,6 +121,8 @@ namespace NKikimr::NStorage {
113121
std::map<TPDiskKey, TPDiskRecord> LocalPDisks;
114122
TIntrusiveList<TPDiskRecord, TUnreportedMetricTag> PDisksWithUnreportedMetrics;
115123
std::map<ui64, ui32> PDiskRestartRequests;
124+
ui64 LastShredCookie = 0;
125+
THashMap<ui64, TPDiskKey> ShredInFlight;
116126

117127
struct TPDiskByPathInfo {
118128
TPDiskKey RunningPDiskId; // currently running PDiskId
@@ -535,6 +545,9 @@ namespace NKikimr::NStorage {
535545
void Handle(TEvInterconnect::TEvNodeInfo::TPtr ev);
536546
void Handle(TEvInterconnect::TEvNodesInfo::TPtr ev);
537547
void Handle(NPDisk::TEvSlayResult::TPtr ev);
548+
void Handle(NPDisk::TEvShredPDiskResult::TPtr ev);
549+
void Handle(NPDisk::TEvShredPDisk::TPtr ev);
550+
void ProcessShredStatus(ui64 cookie, ui64 generation, std::optional<TString> error);
538551
void Handle(TEvRegisterPDiskLoadActor::TPtr ev);
539552
void Handle(TEvBlobStorage::TEvControllerNodeServiceSetUpdate::TPtr ev);
540553

@@ -543,7 +556,8 @@ namespace NKikimr::NStorage {
543556
void SendVDiskReport(TVSlotId vslotId, const TVDiskID& vdiskId,
544557
NKikimrBlobStorage::TEvControllerNodeReport::EVDiskPhase phase, TDuration backoff = {});
545558

546-
void SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase);
559+
void SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase,
560+
std::variant<std::monostate, ui64, TString> shredState = {});
547561

548562
void Handle(TEvBlobStorage::TEvControllerUpdateDiskStatus::TPtr ev);
549563
void Handle(TEvBlobStorage::TEvControllerGroupMetricsExchange::TPtr ev);

‎ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp

Lines changed: 16 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -224,6 +224,9 @@ namespace NKikimr::NStorage {
224224
Y_ABORT_UNLESS(jt != PDiskByPath.end() && jt->second.RunningPDiskId == it->first);
225225
pending = std::move(jt->second.Pending);
226226
PDiskByPath.erase(jt);
227+
for (ui64 cookie : it->second.ShredCookies) {
228+
ShredInFlight.erase(cookie);
229+
}
227230
LocalPDisks.erase(it);
228231
PDiskRestartInFlight.erase(pdiskId);
229232

@@ -250,14 +253,26 @@ namespace NKikimr::NStorage {
250253
}
251254
}
252255

253-
void TNodeWarden::SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase) {
256+
void TNodeWarden::SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase,
257+
std::variant<std::monostate, ui64, TString> shredState) {
254258
STLOG(PRI_DEBUG, BS_NODE, NW41, "SendPDiskReport", (PDiskId, pdiskId), (Phase, phase));
255259

256260
auto report = std::make_unique<TEvBlobStorage::TEvControllerNodeReport>(LocalNodeId);
257261
auto *pReport = report->Record.AddPDiskReports();
258262
pReport->SetPDiskId(pdiskId);
259263
pReport->SetPhase(phase);
260264

265+
const TPDiskKey key(LocalNodeId, pdiskId);
266+
if (const auto it = LocalPDisks.find(key); it != LocalPDisks.end() && it->second.Record.HasPDiskGuid()) {
267+
pReport->SetPDiskGuid(it->second.Record.GetPDiskGuid());
268+
}
269+
270+
std::visit(TOverloaded{
271+
[](std::monostate&) {},
272+
[pReport](ui64& generation) { pReport->SetShredGenerationFinished(generation); },
273+
[pReport](TString& aborted) { pReport->SetShredAborted(aborted); }
274+
}, shredState);
275+
261276
SendToController(std::move(report));
262277
}
263278

‎ydb/core/blobstorage/nodewarden/node_warden_pipe.cpp

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,21 @@ void TNodeWarden::SendRegisterNode() {
8383
FillInVDiskStatus(ev->Record.MutableVDiskStatus(), true);
8484
ev->Record.SetDeclarativePDiskManagement(true);
8585

86+
for (const auto& [key, pdisk] : LocalPDisks) {
87+
if (pdisk.ShredGenerationIssued) {
88+
auto *item = ev->Record.AddShredStatus();
89+
item->SetPDiskId(key.PDiskId);
90+
if (pdisk.Record.HasPDiskGuid()) {
91+
item->SetPDiskGuid(pdisk.Record.GetPDiskGuid());
92+
}
93+
std::visit(TOverloaded{
94+
[item](const std::monostate&) { item->SetShredInProgress(true); },
95+
[item](const ui64& generation) { item->SetShredGenerationFinished(generation); },
96+
[item](const TString& aborted) { item->SetShredAborted(aborted); }
97+
}, pdisk.ShredState);
98+
}
99+
}
100+
86101
SendToController(std::move(ev));
87102
}
88103

‎ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp

Lines changed: 56 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1083,7 +1083,7 @@ namespace NKikimr {
10831083

10841084
LOG_DEBUG_S(ctx, BS_VDISK_BLOCK, VCtx->VDiskLogPrefix
10851085
<< "TEvVBlock: tabletId# " << tabletId << " gen# " << gen
1086-
<< " Marker# BSVS14");
1086+
<< " Marker# BSVS00");
10871087

10881088
TLsnSeg seg;
10891089
ui32 actGen = 0;
@@ -1824,6 +1824,7 @@ namespace NKikimr {
18241824
}
18251825
UpdateReplState();
18261826
RunBalancing(ctx);
1827+
ProcessShredQ();
18271828
}
18281829

18291830
void SkeletonErrorState(const TActorContext &ctx,
@@ -2637,6 +2638,52 @@ namespace NKikimr {
26372638
}
26382639
}
26392640

2641+
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2642+
// Shredding support
2643+
2644+
std::deque<std::unique_ptr<IEventHandle>> ShredQ;
2645+
2646+
template<typename TEvent>
2647+
void HandleShredEnqueue(TAutoPtr<TEventHandle<TEvent>> ev) {
2648+
STLOG(PRI_DEBUG, BS_SHRED, BSSV00, VCtx->VDiskLogPrefix << "enqueued shred event", (Type, ev->GetTypeRewrite()));
2649+
ShredQ.emplace_back(ev.Release());
2650+
}
2651+
2652+
void ProcessShredQ() {
2653+
for (auto& ev : std::exchange(ShredQ, {})) {
2654+
TAutoPtr<IEventHandle> temp(ev.release());
2655+
Receive(temp);
2656+
}
2657+
}
2658+
2659+
void HandleShred(NPDisk::TEvPreShredCompactVDisk::TPtr ev) {
2660+
STLOG(PRI_DEBUG, BS_SHRED, BSSV01, VCtx->VDiskLogPrefix << "processing TEvPreShredCompactVDisk",
2661+
(ShredGeneration, ev->Get()->ShredGeneration));
2662+
Send(ev->Sender, new NPDisk::TEvPreShredCompactVDiskResult(PDiskCtx->Dsk->Owner, PDiskCtx->Dsk->OwnerRound,
2663+
ev->Get()->ShredGeneration, NKikimrProto::OK, TString()), 0, ev->Cookie);
2664+
}
2665+
2666+
void HandleShred(NPDisk::TEvShredVDisk::TPtr ev) {
2667+
STLOG(PRI_DEBUG, BS_SHRED, BSSV02, VCtx->VDiskLogPrefix << "processing TEvShredVDisk",
2668+
(ShredGeneration, ev->Get()->ShredGeneration));
2669+
Send(ev->Sender, new NPDisk::TEvShredVDiskResult(PDiskCtx->Dsk->Owner, PDiskCtx->Dsk->OwnerRound,
2670+
ev->Get()->ShredGeneration, NKikimrProto::OK, TString()), 0, ev->Cookie);
2671+
}
2672+
2673+
void HandleShredError(NPDisk::TEvPreShredCompactVDisk::TPtr ev) {
2674+
STLOG(PRI_DEBUG, BS_SHRED, BSSV03, VCtx->VDiskLogPrefix << "processing TEvPreShredCompactVDisk in error state",
2675+
(ShredGeneration, ev->Get()->ShredGeneration));
2676+
Send(ev->Sender, new NPDisk::TEvPreShredCompactVDiskResult(PDiskCtx->Dsk->Owner, PDiskCtx->Dsk->OwnerRound,
2677+
ev->Get()->ShredGeneration, NKikimrProto::ERROR, "VDisk is in error state"), 0, ev->Cookie);
2678+
}
2679+
2680+
void HandleShredError(NPDisk::TEvShredVDisk::TPtr ev) {
2681+
STLOG(PRI_DEBUG, BS_SHRED, BSSV04, VCtx->VDiskLogPrefix << "processing TEvShredVDisk in error state",
2682+
(ShredGeneration, ev->Get()->ShredGeneration));
2683+
Send(ev->Sender, new NPDisk::TEvShredVDiskResult(PDiskCtx->Dsk->Owner, PDiskCtx->Dsk->OwnerRound,
2684+
ev->Get()->ShredGeneration, NKikimrProto::ERROR, "VDisk is in error state"), 0, ev->Cookie);
2685+
}
2686+
26402687
// NOTES: we have 4 state functions, one of which is an error state (StateDatabaseError) and
26412688
// others are good: StateLocalRecovery, StateSyncGuidRecovery, StateNormal
26422689
// We switch between states in the following manner:
@@ -2696,6 +2743,8 @@ namespace NKikimr {
26962743
hFunc(NPDisk::TEvChunkForgetResult, Handle)
26972744
FFunc(TEvPrivate::EvCheckSnapshotExpiration, CheckSnapshotExpiration)
26982745
hFunc(TEvReplInvoke, HandleReplNotInProgress)
2746+
hFunc(NPDisk::TEvPreShredCompactVDisk, HandleShredEnqueue)
2747+
hFunc(NPDisk::TEvShredVDisk, HandleShredEnqueue)
26992748
)
27002749

27012750
COUNTED_STRICT_STFUNC(StateSyncGuidRecovery,
@@ -2749,6 +2798,8 @@ namespace NKikimr {
27492798
hFunc(NPDisk::TEvChunkForgetResult, Handle)
27502799
FFunc(TEvPrivate::EvCheckSnapshotExpiration, CheckSnapshotExpiration)
27512800
hFunc(TEvReplInvoke, HandleReplNotInProgress)
2801+
hFunc(NPDisk::TEvPreShredCompactVDisk, HandleShredEnqueue)
2802+
hFunc(NPDisk::TEvShredVDisk, HandleShredEnqueue)
27522803
)
27532804

27542805
COUNTED_STRICT_STFUNC(StateNormal,
@@ -2819,6 +2870,8 @@ namespace NKikimr {
28192870
FFunc(TEvPrivate::EvCheckSnapshotExpiration, CheckSnapshotExpiration)
28202871
hFunc(TEvReplInvoke, Handle)
28212872
CFunc(TEvStartBalancing::EventType, RunBalancing)
2873+
hFunc(NPDisk::TEvPreShredCompactVDisk, HandleShred)
2874+
hFunc(NPDisk::TEvShredVDisk, HandleShred)
28222875
)
28232876

28242877
COUNTED_STRICT_STFUNC(StateDatabaseError,
@@ -2846,6 +2899,8 @@ namespace NKikimr {
28462899
hFunc(NPDisk::TEvChunkForgetResult, Handle)
28472900
FFunc(TEvPrivate::EvCheckSnapshotExpiration, CheckSnapshotExpiration)
28482901
hFunc(TEvReplInvoke, HandleReplNotInProgress)
2902+
hFunc(NPDisk::TEvPreShredCompactVDisk, HandleShredError)
2903+
hFunc(NPDisk::TEvShredVDisk, HandleShredError)
28492904
)
28502905

28512906
PDISK_TERMINATE_STATE_FUNC_DEF;

‎ydb/core/blobstorage/vdisk/skeleton/skeleton_vmovedpatch_actor.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -104,7 +104,7 @@ namespace NKikimr {
104104
<< " OriginalBlobId# " << OriginalId
105105
<< " PatchedBlobId# " << PatchedId
106106
<< " ErrorReason# " << ErrorReason
107-
<< " Marker# BSVSP01");
107+
<< " Marker# BSVSP00");
108108
SendVDiskResponse(ctx, Event->Sender, vMovedPatchResult.release(), Event->Cookie, VCtx);
109109
PassAway();
110110
}

‎ydb/core/mind/bscontroller/bsc.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -438,6 +438,7 @@ STFUNC(TBlobStorageController::StateWork) {
438438
hFunc(TEvTabletPipe::TEvClientDestroyed, ConsoleInteraction->Handle);
439439
hFunc(TEvBlobStorage::TEvGetBlockResult, ConsoleInteraction->Handle);
440440
fFunc(TEvBlobStorage::EvControllerShredRequest, EnqueueIncomingEvent);
441+
cFunc(TEvPrivate::EvUpdateShredState, ShredState.HandleUpdateShredState);
441442
default:
442443
if (!HandleDefaultEvents(ev, SelfId())) {
443444
STLOG(PRI_ERROR, BS_CONTROLLER, BSC06, "StateWork unexpected event", (Type, type),

‎ydb/core/mind/bscontroller/config.cpp

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -93,7 +93,8 @@ namespace NKikimr::NBsController {
9393
const ui32 nodeId = fullPDiskId.NodeId;
9494
const ui32 pdiskId = fullPDiskId.PDiskId;
9595

96-
NKikimrBlobStorage::TNodeWardenServiceSet &service = *Services[nodeId].MutableServiceSet();
96+
auto& query = Services[nodeId];
97+
NKikimrBlobStorage::TNodeWardenServiceSet &service = *query.MutableServiceSet();
9798
NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk *pdisk = service.AddPDisks();
9899
pdisk->SetNodeID(nodeId);
99100
pdisk->SetPDiskID(pdiskId);
@@ -125,6 +126,14 @@ namespace NKikimr::NBsController {
125126
break;
126127
}
127128

129+
if (auto& shred = Self->ShredState; shred.ShouldShred(fullPDiskId, pdiskInfo)) {
130+
const auto& generation = shred.GetCurrentGeneration();
131+
Y_ABORT_UNLESS(generation);
132+
auto *m = query.MutableShredRequest();
133+
m->SetShredGeneration(*generation);
134+
m->AddPDiskIds(fullPDiskId.PDiskId);
135+
}
136+
128137
return pdisk;
129138
}
130139

@@ -505,6 +514,7 @@ namespace NKikimr::NBsController {
505514
CommitStoragePoolStatUpdates(state);
506515
CommitSysViewUpdates(state);
507516
CommitVirtualGroupUpdates(state);
517+
CommitShredUpdates(state);
508518

509519
// add updated and remove deleted vslots from VSlotReadyTimestampQ
510520
const TMonotonic now = TActivationContext::Monotonic();

‎ydb/core/mind/bscontroller/config_fit_pdisks.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -344,7 +344,8 @@ namespace NKikimr {
344344
/* nextVslotId */ 1000, disk.PDiskConfig, disk.BoxId, DefaultMaxSlots,
345345
NKikimrBlobStorage::EDriveStatus::ACTIVE, /* statusTimestamp */ TInstant::Zero(),
346346
NKikimrBlobStorage::EDecommitStatus::DECOMMIT_NONE, NBsController::TPDiskMood::Normal,
347-
disk.Serial, disk.LastSeenSerial, disk.LastSeenPath, staticSlotUsage);
347+
disk.Serial, disk.LastSeenSerial, disk.LastSeenPath, staticSlotUsage,
348+
true /* assume shred completed for this disk */);
348349

349350
// Set PDiskId and Guid in DrivesSerials
350351
if (auto info = state.DrivesSerials.FindForUpdate(disk.Serial)) {

0 commit comments

Comments
 (0)