aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--executor/executor_runner.h6
-rw-r--r--pkg/flatrpc/flatrpc.fbs10
-rw-r--r--pkg/flatrpc/flatrpc.go72
-rw-r--r--pkg/flatrpc/flatrpc.h110
-rw-r--r--pkg/flatrpc/helpers.go2
-rw-r--r--pkg/rpcserver/rpcserver.go4
-rw-r--r--pkg/rpcserver/runner.go6
7 files changed, 105 insertions, 105 deletions
diff --git a/executor/executor_runner.h b/executor/executor_runner.h
index 766669dda..3bffcaeb2 100644
--- a/executor/executor_runner.h
+++ b/executor/executor_runner.h
@@ -508,7 +508,7 @@ private:
Handle(*msg);
else if (auto* msg = raw.msg.AsSignalUpdate())
Handle(*msg);
- else if (auto* msg = raw.msg.AsStartLeakChecks())
+ else if (auto* msg = raw.msg.AsCorpusTriaged())
Handle(*msg);
else if (auto* msg = raw.msg.AsStateRequest())
Handle(*msg);
@@ -637,10 +637,10 @@ private:
max_signal_->Remove(pc);
}
- void Handle(const rpc::StartLeakChecksRawT& msg)
+ void Handle(const rpc::CorpusTriagedRawT& msg)
{
// TODO: repair leak checking (#4728).
- debug("recv start leak checks\n");
+ debug("recv corpus triaged\n");
}
void Handle(const rpc::StateRequestRawT& msg)
diff --git a/pkg/flatrpc/flatrpc.fbs b/pkg/flatrpc/flatrpc.fbs
index b51ea0c70..58a6b3250 100644
--- a/pkg/flatrpc/flatrpc.fbs
+++ b/pkg/flatrpc/flatrpc.fbs
@@ -83,7 +83,7 @@ table FeatureInfoRaw {
union HostMessagesRaw {
ExecRequest :ExecRequestRaw,
SignalUpdate :SignalUpdateRaw,
- StartLeakChecks :StartLeakChecksRaw,
+ CorpusTriaged :CorpusTriagedRaw,
StateRequest :StateRequestRaw,
}
@@ -165,10 +165,10 @@ table SignalUpdateRaw {
drop_max :[uint64];
}
-// Leak checking is very slow so we don't do it while triaging the corpus
-// (otherwise it takes infinity). This message serves as a signal that
-// the corpus was triaged and the fuzzer can start leak checking.
-table StartLeakChecksRaw {
+// This message serves as a signal that the corpus was triaged and the fuzzer
+// can start activities that only make sense after corpus triage
+// (leak checking, restarting procs, etc).
+table CorpusTriagedRaw {
}
table StateRequestRaw {
diff --git a/pkg/flatrpc/flatrpc.go b/pkg/flatrpc/flatrpc.go
index 28c28ca8e..0e46dddbd 100644
--- a/pkg/flatrpc/flatrpc.go
+++ b/pkg/flatrpc/flatrpc.go
@@ -92,27 +92,27 @@ func (v Feature) String() string {
type HostMessagesRaw byte
const (
- HostMessagesRawNONE HostMessagesRaw = 0
- HostMessagesRawExecRequest HostMessagesRaw = 1
- HostMessagesRawSignalUpdate HostMessagesRaw = 2
- HostMessagesRawStartLeakChecks HostMessagesRaw = 3
- HostMessagesRawStateRequest HostMessagesRaw = 4
+ HostMessagesRawNONE HostMessagesRaw = 0
+ HostMessagesRawExecRequest HostMessagesRaw = 1
+ HostMessagesRawSignalUpdate HostMessagesRaw = 2
+ HostMessagesRawCorpusTriaged HostMessagesRaw = 3
+ HostMessagesRawStateRequest HostMessagesRaw = 4
)
var EnumNamesHostMessagesRaw = map[HostMessagesRaw]string{
- HostMessagesRawNONE: "NONE",
- HostMessagesRawExecRequest: "ExecRequest",
- HostMessagesRawSignalUpdate: "SignalUpdate",
- HostMessagesRawStartLeakChecks: "StartLeakChecks",
- HostMessagesRawStateRequest: "StateRequest",
+ HostMessagesRawNONE: "NONE",
+ HostMessagesRawExecRequest: "ExecRequest",
+ HostMessagesRawSignalUpdate: "SignalUpdate",
+ HostMessagesRawCorpusTriaged: "CorpusTriaged",
+ HostMessagesRawStateRequest: "StateRequest",
}
var EnumValuesHostMessagesRaw = map[string]HostMessagesRaw{
- "NONE": HostMessagesRawNONE,
- "ExecRequest": HostMessagesRawExecRequest,
- "SignalUpdate": HostMessagesRawSignalUpdate,
- "StartLeakChecks": HostMessagesRawStartLeakChecks,
- "StateRequest": HostMessagesRawStateRequest,
+ "NONE": HostMessagesRawNONE,
+ "ExecRequest": HostMessagesRawExecRequest,
+ "SignalUpdate": HostMessagesRawSignalUpdate,
+ "CorpusTriaged": HostMessagesRawCorpusTriaged,
+ "StateRequest": HostMessagesRawStateRequest,
}
func (v HostMessagesRaw) String() string {
@@ -136,8 +136,8 @@ func (t *HostMessagesRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse
return t.Value.(*ExecRequestRawT).Pack(builder)
case HostMessagesRawSignalUpdate:
return t.Value.(*SignalUpdateRawT).Pack(builder)
- case HostMessagesRawStartLeakChecks:
- return t.Value.(*StartLeakChecksRawT).Pack(builder)
+ case HostMessagesRawCorpusTriaged:
+ return t.Value.(*CorpusTriagedRawT).Pack(builder)
case HostMessagesRawStateRequest:
return t.Value.(*StateRequestRawT).Pack(builder)
}
@@ -152,9 +152,9 @@ func (rcv HostMessagesRaw) UnPack(table flatbuffers.Table) *HostMessagesRawT {
case HostMessagesRawSignalUpdate:
x := SignalUpdateRaw{_tab: table}
return &HostMessagesRawT{Type: HostMessagesRawSignalUpdate, Value: x.UnPack()}
- case HostMessagesRawStartLeakChecks:
- x := StartLeakChecksRaw{_tab: table}
- return &HostMessagesRawT{Type: HostMessagesRawStartLeakChecks, Value: x.UnPack()}
+ case HostMessagesRawCorpusTriaged:
+ x := CorpusTriagedRaw{_tab: table}
+ return &HostMessagesRawT{Type: HostMessagesRawCorpusTriaged, Value: x.UnPack()}
case HostMessagesRawStateRequest:
x := StateRequestRaw{_tab: table}
return &HostMessagesRawT{Type: HostMessagesRawStateRequest, Value: x.UnPack()}
@@ -2177,60 +2177,60 @@ func SignalUpdateRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
-type StartLeakChecksRawT struct {
+type CorpusTriagedRawT struct {
}
-func (t *StartLeakChecksRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+func (t *CorpusTriagedRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
if t == nil {
return 0
}
- StartLeakChecksRawStart(builder)
- return StartLeakChecksRawEnd(builder)
+ CorpusTriagedRawStart(builder)
+ return CorpusTriagedRawEnd(builder)
}
-func (rcv *StartLeakChecksRaw) UnPackTo(t *StartLeakChecksRawT) {
+func (rcv *CorpusTriagedRaw) UnPackTo(t *CorpusTriagedRawT) {
}
-func (rcv *StartLeakChecksRaw) UnPack() *StartLeakChecksRawT {
+func (rcv *CorpusTriagedRaw) UnPack() *CorpusTriagedRawT {
if rcv == nil {
return nil
}
- t := &StartLeakChecksRawT{}
+ t := &CorpusTriagedRawT{}
rcv.UnPackTo(t)
return t
}
-type StartLeakChecksRaw struct {
+type CorpusTriagedRaw struct {
_tab flatbuffers.Table
}
-func GetRootAsStartLeakChecksRaw(buf []byte, offset flatbuffers.UOffsetT) *StartLeakChecksRaw {
+func GetRootAsCorpusTriagedRaw(buf []byte, offset flatbuffers.UOffsetT) *CorpusTriagedRaw {
n := flatbuffers.GetUOffsetT(buf[offset:])
- x := &StartLeakChecksRaw{}
+ x := &CorpusTriagedRaw{}
x.Init(buf, n+offset)
return x
}
-func GetSizePrefixedRootAsStartLeakChecksRaw(buf []byte, offset flatbuffers.UOffsetT) *StartLeakChecksRaw {
+func GetSizePrefixedRootAsCorpusTriagedRaw(buf []byte, offset flatbuffers.UOffsetT) *CorpusTriagedRaw {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
- x := &StartLeakChecksRaw{}
+ x := &CorpusTriagedRaw{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
-func (rcv *StartLeakChecksRaw) Init(buf []byte, i flatbuffers.UOffsetT) {
+func (rcv *CorpusTriagedRaw) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
-func (rcv *StartLeakChecksRaw) Table() flatbuffers.Table {
+func (rcv *CorpusTriagedRaw) Table() flatbuffers.Table {
return rcv._tab
}
-func StartLeakChecksRawStart(builder *flatbuffers.Builder) {
+func CorpusTriagedRawStart(builder *flatbuffers.Builder) {
builder.StartObject(0)
}
-func StartLeakChecksRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+func CorpusTriagedRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
diff --git a/pkg/flatrpc/flatrpc.h b/pkg/flatrpc/flatrpc.h
index 6f448c410..e3c2de7af 100644
--- a/pkg/flatrpc/flatrpc.h
+++ b/pkg/flatrpc/flatrpc.h
@@ -61,9 +61,9 @@ struct SignalUpdateRaw;
struct SignalUpdateRawBuilder;
struct SignalUpdateRawT;
-struct StartLeakChecksRaw;
-struct StartLeakChecksRawBuilder;
-struct StartLeakChecksRawT;
+struct CorpusTriagedRaw;
+struct CorpusTriagedRawBuilder;
+struct CorpusTriagedRawT;
struct StateRequestRaw;
struct StateRequestRawBuilder;
@@ -176,7 +176,7 @@ enum class HostMessagesRaw : uint8_t {
NONE = 0,
ExecRequest = 1,
SignalUpdate = 2,
- StartLeakChecks = 3,
+ CorpusTriaged = 3,
StateRequest = 4,
MIN = NONE,
MAX = StateRequest
@@ -187,7 +187,7 @@ inline const HostMessagesRaw (&EnumValuesHostMessagesRaw())[5] {
HostMessagesRaw::NONE,
HostMessagesRaw::ExecRequest,
HostMessagesRaw::SignalUpdate,
- HostMessagesRaw::StartLeakChecks,
+ HostMessagesRaw::CorpusTriaged,
HostMessagesRaw::StateRequest
};
return values;
@@ -198,7 +198,7 @@ inline const char * const *EnumNamesHostMessagesRaw() {
"NONE",
"ExecRequest",
"SignalUpdate",
- "StartLeakChecks",
+ "CorpusTriaged",
"StateRequest",
nullptr
};
@@ -223,8 +223,8 @@ template<> struct HostMessagesRawTraits<rpc::SignalUpdateRaw> {
static const HostMessagesRaw enum_value = HostMessagesRaw::SignalUpdate;
};
-template<> struct HostMessagesRawTraits<rpc::StartLeakChecksRaw> {
- static const HostMessagesRaw enum_value = HostMessagesRaw::StartLeakChecks;
+template<> struct HostMessagesRawTraits<rpc::CorpusTriagedRaw> {
+ static const HostMessagesRaw enum_value = HostMessagesRaw::CorpusTriaged;
};
template<> struct HostMessagesRawTraits<rpc::StateRequestRaw> {
@@ -243,8 +243,8 @@ template<> struct HostMessagesRawUnionTraits<rpc::SignalUpdateRawT> {
static const HostMessagesRaw enum_value = HostMessagesRaw::SignalUpdate;
};
-template<> struct HostMessagesRawUnionTraits<rpc::StartLeakChecksRawT> {
- static const HostMessagesRaw enum_value = HostMessagesRaw::StartLeakChecks;
+template<> struct HostMessagesRawUnionTraits<rpc::CorpusTriagedRawT> {
+ static const HostMessagesRaw enum_value = HostMessagesRaw::CorpusTriaged;
};
template<> struct HostMessagesRawUnionTraits<rpc::StateRequestRawT> {
@@ -297,13 +297,13 @@ struct HostMessagesRawUnion {
return type == HostMessagesRaw::SignalUpdate ?
reinterpret_cast<const rpc::SignalUpdateRawT *>(value) : nullptr;
}
- rpc::StartLeakChecksRawT *AsStartLeakChecks() {
- return type == HostMessagesRaw::StartLeakChecks ?
- reinterpret_cast<rpc::StartLeakChecksRawT *>(value) : nullptr;
+ rpc::CorpusTriagedRawT *AsCorpusTriaged() {
+ return type == HostMessagesRaw::CorpusTriaged ?
+ reinterpret_cast<rpc::CorpusTriagedRawT *>(value) : nullptr;
}
- const rpc::StartLeakChecksRawT *AsStartLeakChecks() const {
- return type == HostMessagesRaw::StartLeakChecks ?
- reinterpret_cast<const rpc::StartLeakChecksRawT *>(value) : nullptr;
+ const rpc::CorpusTriagedRawT *AsCorpusTriaged() const {
+ return type == HostMessagesRaw::CorpusTriaged ?
+ reinterpret_cast<const rpc::CorpusTriagedRawT *>(value) : nullptr;
}
rpc::StateRequestRawT *AsStateRequest() {
return type == HostMessagesRaw::StateRequest ?
@@ -1477,8 +1477,8 @@ struct HostMessageRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const rpc::SignalUpdateRaw *msg_as_SignalUpdate() const {
return msg_type() == rpc::HostMessagesRaw::SignalUpdate ? static_cast<const rpc::SignalUpdateRaw *>(msg()) : nullptr;
}
- const rpc::StartLeakChecksRaw *msg_as_StartLeakChecks() const {
- return msg_type() == rpc::HostMessagesRaw::StartLeakChecks ? static_cast<const rpc::StartLeakChecksRaw *>(msg()) : nullptr;
+ const rpc::CorpusTriagedRaw *msg_as_CorpusTriaged() const {
+ return msg_type() == rpc::HostMessagesRaw::CorpusTriaged ? static_cast<const rpc::CorpusTriagedRaw *>(msg()) : nullptr;
}
const rpc::StateRequestRaw *msg_as_StateRequest() const {
return msg_type() == rpc::HostMessagesRaw::StateRequest ? static_cast<const rpc::StateRequestRaw *>(msg()) : nullptr;
@@ -1503,8 +1503,8 @@ template<> inline const rpc::SignalUpdateRaw *HostMessageRaw::msg_as<rpc::Signal
return msg_as_SignalUpdate();
}
-template<> inline const rpc::StartLeakChecksRaw *HostMessageRaw::msg_as<rpc::StartLeakChecksRaw>() const {
- return msg_as_StartLeakChecks();
+template<> inline const rpc::CorpusTriagedRaw *HostMessageRaw::msg_as<rpc::CorpusTriagedRaw>() const {
+ return msg_as_CorpusTriaged();
}
template<> inline const rpc::StateRequestRaw *HostMessageRaw::msg_as<rpc::StateRequestRaw>() const {
@@ -1826,44 +1826,44 @@ inline flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRawDirect(
flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw(flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateRawT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
-struct StartLeakChecksRawT : public flatbuffers::NativeTable {
- typedef StartLeakChecksRaw TableType;
+struct CorpusTriagedRawT : public flatbuffers::NativeTable {
+ typedef CorpusTriagedRaw TableType;
};
-struct StartLeakChecksRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
- typedef StartLeakChecksRawT NativeTableType;
- typedef StartLeakChecksRawBuilder Builder;
+struct CorpusTriagedRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef CorpusTriagedRawT NativeTableType;
+ typedef CorpusTriagedRawBuilder Builder;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
- StartLeakChecksRawT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
- void UnPackTo(StartLeakChecksRawT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
- static flatbuffers::Offset<StartLeakChecksRaw> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StartLeakChecksRawT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+ CorpusTriagedRawT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(CorpusTriagedRawT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<CorpusTriagedRaw> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CorpusTriagedRawT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
-struct StartLeakChecksRawBuilder {
- typedef StartLeakChecksRaw Table;
+struct CorpusTriagedRawBuilder {
+ typedef CorpusTriagedRaw Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- explicit StartLeakChecksRawBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit CorpusTriagedRawBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<StartLeakChecksRaw> Finish() {
+ flatbuffers::Offset<CorpusTriagedRaw> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StartLeakChecksRaw>(end);
+ auto o = flatbuffers::Offset<CorpusTriagedRaw>(end);
return o;
}
};
-inline flatbuffers::Offset<StartLeakChecksRaw> CreateStartLeakChecksRaw(
+inline flatbuffers::Offset<CorpusTriagedRaw> CreateCorpusTriagedRaw(
flatbuffers::FlatBufferBuilder &_fbb) {
- StartLeakChecksRawBuilder builder_(_fbb);
+ CorpusTriagedRawBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<StartLeakChecksRaw> CreateStartLeakChecksRaw(flatbuffers::FlatBufferBuilder &_fbb, const StartLeakChecksRawT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+flatbuffers::Offset<CorpusTriagedRaw> CreateCorpusTriagedRaw(flatbuffers::FlatBufferBuilder &_fbb, const CorpusTriagedRawT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct StateRequestRawT : public flatbuffers::NativeTable {
typedef StateRequestRaw TableType;
@@ -2808,26 +2808,26 @@ inline flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw(flatbuffers::F
_drop_max);
}
-inline StartLeakChecksRawT *StartLeakChecksRaw::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
- auto _o = std::unique_ptr<StartLeakChecksRawT>(new StartLeakChecksRawT());
+inline CorpusTriagedRawT *CorpusTriagedRaw::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = std::unique_ptr<CorpusTriagedRawT>(new CorpusTriagedRawT());
UnPackTo(_o.get(), _resolver);
return _o.release();
}
-inline void StartLeakChecksRaw::UnPackTo(StartLeakChecksRawT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+inline void CorpusTriagedRaw::UnPackTo(CorpusTriagedRawT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
-inline flatbuffers::Offset<StartLeakChecksRaw> StartLeakChecksRaw::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StartLeakChecksRawT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
- return CreateStartLeakChecksRaw(_fbb, _o, _rehasher);
+inline flatbuffers::Offset<CorpusTriagedRaw> CorpusTriagedRaw::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CorpusTriagedRawT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateCorpusTriagedRaw(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StartLeakChecksRaw> CreateStartLeakChecksRaw(flatbuffers::FlatBufferBuilder &_fbb, const StartLeakChecksRawT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline flatbuffers::Offset<CorpusTriagedRaw> CreateCorpusTriagedRaw(flatbuffers::FlatBufferBuilder &_fbb, const CorpusTriagedRawT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
- struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StartLeakChecksRawT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
- return rpc::CreateStartLeakChecksRaw(
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CorpusTriagedRawT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ return rpc::CreateCorpusTriagedRaw(
_fbb);
}
@@ -3073,8 +3073,8 @@ inline bool VerifyHostMessagesRaw(flatbuffers::Verifier &verifier, const void *o
auto ptr = reinterpret_cast<const rpc::SignalUpdateRaw *>(obj);
return verifier.VerifyTable(ptr);
}
- case HostMessagesRaw::StartLeakChecks: {
- auto ptr = reinterpret_cast<const rpc::StartLeakChecksRaw *>(obj);
+ case HostMessagesRaw::CorpusTriaged: {
+ auto ptr = reinterpret_cast<const rpc::CorpusTriagedRaw *>(obj);
return verifier.VerifyTable(ptr);
}
case HostMessagesRaw::StateRequest: {
@@ -3108,8 +3108,8 @@ inline void *HostMessagesRawUnion::UnPack(const void *obj, HostMessagesRaw type,
auto ptr = reinterpret_cast<const rpc::SignalUpdateRaw *>(obj);
return ptr->UnPack(resolver);
}
- case HostMessagesRaw::StartLeakChecks: {
- auto ptr = reinterpret_cast<const rpc::StartLeakChecksRaw *>(obj);
+ case HostMessagesRaw::CorpusTriaged: {
+ auto ptr = reinterpret_cast<const rpc::CorpusTriagedRaw *>(obj);
return ptr->UnPack(resolver);
}
case HostMessagesRaw::StateRequest: {
@@ -3131,9 +3131,9 @@ inline flatbuffers::Offset<void> HostMessagesRawUnion::Pack(flatbuffers::FlatBuf
auto ptr = reinterpret_cast<const rpc::SignalUpdateRawT *>(value);
return CreateSignalUpdateRaw(_fbb, ptr, _rehasher).Union();
}
- case HostMessagesRaw::StartLeakChecks: {
- auto ptr = reinterpret_cast<const rpc::StartLeakChecksRawT *>(value);
- return CreateStartLeakChecksRaw(_fbb, ptr, _rehasher).Union();
+ case HostMessagesRaw::CorpusTriaged: {
+ auto ptr = reinterpret_cast<const rpc::CorpusTriagedRawT *>(value);
+ return CreateCorpusTriagedRaw(_fbb, ptr, _rehasher).Union();
}
case HostMessagesRaw::StateRequest: {
auto ptr = reinterpret_cast<const rpc::StateRequestRawT *>(value);
@@ -3153,8 +3153,8 @@ inline HostMessagesRawUnion::HostMessagesRawUnion(const HostMessagesRawUnion &u)
value = new rpc::SignalUpdateRawT(*reinterpret_cast<rpc::SignalUpdateRawT *>(u.value));
break;
}
- case HostMessagesRaw::StartLeakChecks: {
- value = new rpc::StartLeakChecksRawT(*reinterpret_cast<rpc::StartLeakChecksRawT *>(u.value));
+ case HostMessagesRaw::CorpusTriaged: {
+ value = new rpc::CorpusTriagedRawT(*reinterpret_cast<rpc::CorpusTriagedRawT *>(u.value));
break;
}
case HostMessagesRaw::StateRequest: {
@@ -3178,8 +3178,8 @@ inline void HostMessagesRawUnion::Reset() {
delete ptr;
break;
}
- case HostMessagesRaw::StartLeakChecks: {
- auto ptr = reinterpret_cast<rpc::StartLeakChecksRawT *>(value);
+ case HostMessagesRaw::CorpusTriaged: {
+ auto ptr = reinterpret_cast<rpc::CorpusTriagedRawT *>(value);
delete ptr;
break;
}
diff --git a/pkg/flatrpc/helpers.go b/pkg/flatrpc/helpers.go
index b85951615..4c15bb836 100644
--- a/pkg/flatrpc/helpers.go
+++ b/pkg/flatrpc/helpers.go
@@ -28,7 +28,7 @@ type ExecutorMessage = ExecutorMessageRawT
type ExecRequest = ExecRequestRawT
type StateRequest = StateRequestRawT
type SignalUpdate = SignalUpdateRawT
-type StartLeakChecks = StartLeakChecksRawT
+type CorpusTriaged = CorpusTriagedRawT
type ExecutingMessage = ExecutingMessageRawT
type CallInfo = CallInfoRawT
type Comparison = ComparisonRawT
diff --git a/pkg/rpcserver/rpcserver.go b/pkg/rpcserver/rpcserver.go
index e2a321803..1a9140537 100644
--- a/pkg/rpcserver/rpcserver.go
+++ b/pkg/rpcserver/rpcserver.go
@@ -220,7 +220,7 @@ func (serv *Server) handleConn(conn *flatrpc.Conn) {
defer close(runner.finished)
if serv.triagedCorpus.Load() {
- if err := runner.sendStartLeakChecks(); err != nil {
+ if err := runner.sendCorpusTriaged(); err != nil {
log.Logf(2, "%v", err)
return
}
@@ -477,7 +477,7 @@ func (serv *Server) DistributeSignalDelta(plus, minus signal.Signal) {
func (serv *Server) TriagedCorpus() {
serv.triagedCorpus.Store(true)
serv.foreachRunnerAsync(func(runner *Runner) {
- runner.sendStartLeakChecks()
+ runner.sendCorpusTriaged()
})
}
diff --git a/pkg/rpcserver/runner.go b/pkg/rpcserver/runner.go
index 22d85f0c6..0c41346ee 100644
--- a/pkg/rpcserver/runner.go
+++ b/pkg/rpcserver/runner.go
@@ -281,11 +281,11 @@ func (runner *Runner) sendSignalUpdate(plus, minus []uint64) error {
return flatrpc.Send(runner.conn, msg)
}
-func (runner *Runner) sendStartLeakChecks() error {
+func (runner *Runner) sendCorpusTriaged() error {
msg := &flatrpc.HostMessage{
Msg: &flatrpc.HostMessages{
- Type: flatrpc.HostMessagesRawStartLeakChecks,
- Value: &flatrpc.StartLeakChecks{},
+ Type: flatrpc.HostMessagesRawCorpusTriaged,
+ Value: &flatrpc.CorpusTriaged{},
},
}
return flatrpc.Send(runner.conn, msg)
generated by ggit (джигит) mrf-deployment (git 2.46.0) at 2026-03-11 22:26:24 +0000