aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--pkg/flatrpc/flatrpc.fbs12
-rw-r--r--pkg/flatrpc/flatrpc.go175
-rw-r--r--pkg/flatrpc/flatrpc.h128
-rw-r--r--pkg/flatrpc/helpers.go8
-rw-r--r--pkg/fuzzer/fuzzer.go7
-rw-r--r--pkg/fuzzer/fuzzer_test.go2
-rw-r--r--pkg/fuzzer/queue/queue.go3
-rw-r--r--pkg/instance/instance.go4
-rw-r--r--pkg/ipc/ipc.go30
-rw-r--r--pkg/ipc/ipc_priv_test.go4
-rw-r--r--pkg/ipc/ipc_test.go4
-rw-r--r--pkg/ipc/ipcconfig/ipcconfig.go6
-rw-r--r--pkg/mgrconfig/config.go2
-rw-r--r--pkg/runtest/run.go4
-rw-r--r--pkg/vminfo/features.go3
-rw-r--r--pkg/vminfo/syscalls.go2
-rw-r--r--syz-fuzzer/proc.go11
-rw-r--r--syz-fuzzer/testing.go2
-rw-r--r--syz-manager/manager.go3
-rw-r--r--syz-manager/rpc.go10
-rw-r--r--tools/syz-execprog/execprog.go8
-rw-r--r--tools/syz-testbuild/testbuild.go2
22 files changed, 240 insertions, 190 deletions
diff --git a/pkg/flatrpc/flatrpc.fbs b/pkg/flatrpc/flatrpc.fbs
index 20ee1893b..c628d9b53 100644
--- a/pkg/flatrpc/flatrpc.fbs
+++ b/pkg/flatrpc/flatrpc.fbs
@@ -135,14 +135,20 @@ enum ExecFlag : uint64 (bit_flags) {
CoverFilter, // setup and use bitmap to do coverage filter
}
+struct ExecOptsRaw {
+ // Changing exec_flags between executions does not cause executor process restart.
+ // Changing env_flags/sandbox_arg does cause process restart.
+ env_flags :ExecEnv;
+ exec_flags :ExecFlag;
+ sandbox_arg :int64;
+}
+
// Request to execute a test program.
table ExecRequestRaw {
id :int64;
prog_data :[uint8];
+ exec_opts :ExecOptsRaw;
flags :RequestFlag;
- exec_env :ExecEnv;
- exec_flags :ExecFlag;
- sandbox_arg :int64;
signal_filter :[uint32];
signal_filter_call :int32;
// Repeat the program that many times (0 means 1).
diff --git a/pkg/flatrpc/flatrpc.go b/pkg/flatrpc/flatrpc.go
index d9b9b2c7e..12e9a773d 100644
--- a/pkg/flatrpc/flatrpc.go
+++ b/pkg/flatrpc/flatrpc.go
@@ -1614,16 +1614,83 @@ func ExecutorMessageRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
+type ExecOptsRawT struct {
+ EnvFlags ExecEnv `json:"env_flags"`
+ ExecFlags ExecFlag `json:"exec_flags"`
+ SandboxArg int64 `json:"sandbox_arg"`
+}
+
+func (t *ExecOptsRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ return CreateExecOptsRaw(builder, t.EnvFlags, t.ExecFlags, t.SandboxArg)
+}
+func (rcv *ExecOptsRaw) UnPackTo(t *ExecOptsRawT) {
+ t.EnvFlags = rcv.EnvFlags()
+ t.ExecFlags = rcv.ExecFlags()
+ t.SandboxArg = rcv.SandboxArg()
+}
+
+func (rcv *ExecOptsRaw) UnPack() *ExecOptsRawT {
+ if rcv == nil {
+ return nil
+ }
+ t := &ExecOptsRawT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type ExecOptsRaw struct {
+ _tab flatbuffers.Struct
+}
+
+func (rcv *ExecOptsRaw) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *ExecOptsRaw) Table() flatbuffers.Table {
+ return rcv._tab.Table
+}
+
+func (rcv *ExecOptsRaw) EnvFlags() ExecEnv {
+ return ExecEnv(rcv._tab.GetUint64(rcv._tab.Pos + flatbuffers.UOffsetT(0)))
+}
+func (rcv *ExecOptsRaw) MutateEnvFlags(n ExecEnv) bool {
+ return rcv._tab.MutateUint64(rcv._tab.Pos+flatbuffers.UOffsetT(0), uint64(n))
+}
+
+func (rcv *ExecOptsRaw) ExecFlags() ExecFlag {
+ return ExecFlag(rcv._tab.GetUint64(rcv._tab.Pos + flatbuffers.UOffsetT(8)))
+}
+func (rcv *ExecOptsRaw) MutateExecFlags(n ExecFlag) bool {
+ return rcv._tab.MutateUint64(rcv._tab.Pos+flatbuffers.UOffsetT(8), uint64(n))
+}
+
+func (rcv *ExecOptsRaw) SandboxArg() int64 {
+ return rcv._tab.GetInt64(rcv._tab.Pos + flatbuffers.UOffsetT(16))
+}
+func (rcv *ExecOptsRaw) MutateSandboxArg(n int64) bool {
+ return rcv._tab.MutateInt64(rcv._tab.Pos+flatbuffers.UOffsetT(16), n)
+}
+
+func CreateExecOptsRaw(builder *flatbuffers.Builder, envFlags ExecEnv, execFlags ExecFlag, sandboxArg int64) flatbuffers.UOffsetT {
+ builder.Prep(8, 24)
+ builder.PrependInt64(sandboxArg)
+ builder.PrependUint64(uint64(execFlags))
+ builder.PrependUint64(uint64(envFlags))
+ return builder.Offset()
+}
+
type ExecRequestRawT struct {
- Id int64 `json:"id"`
- ProgData []byte `json:"prog_data"`
- Flags RequestFlag `json:"flags"`
- ExecEnv ExecEnv `json:"exec_env"`
- ExecFlags ExecFlag `json:"exec_flags"`
- SandboxArg int64 `json:"sandbox_arg"`
- SignalFilter []uint32 `json:"signal_filter"`
- SignalFilterCall int32 `json:"signal_filter_call"`
- Repeat int32 `json:"repeat"`
+ Id int64 `json:"id"`
+ ProgData []byte `json:"prog_data"`
+ ExecOpts *ExecOptsRawT `json:"exec_opts"`
+ Flags RequestFlag `json:"flags"`
+ SignalFilter []uint32 `json:"signal_filter"`
+ SignalFilterCall int32 `json:"signal_filter_call"`
+ Repeat int32 `json:"repeat"`
}
func (t *ExecRequestRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -1646,10 +1713,9 @@ func (t *ExecRequestRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffset
ExecRequestRawStart(builder)
ExecRequestRawAddId(builder, t.Id)
ExecRequestRawAddProgData(builder, progDataOffset)
+ execOptsOffset := t.ExecOpts.Pack(builder)
+ ExecRequestRawAddExecOpts(builder, execOptsOffset)
ExecRequestRawAddFlags(builder, t.Flags)
- ExecRequestRawAddExecEnv(builder, t.ExecEnv)
- ExecRequestRawAddExecFlags(builder, t.ExecFlags)
- ExecRequestRawAddSandboxArg(builder, t.SandboxArg)
ExecRequestRawAddSignalFilter(builder, signalFilterOffset)
ExecRequestRawAddSignalFilterCall(builder, t.SignalFilterCall)
ExecRequestRawAddRepeat(builder, t.Repeat)
@@ -1659,10 +1725,8 @@ func (t *ExecRequestRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffset
func (rcv *ExecRequestRaw) UnPackTo(t *ExecRequestRawT) {
t.Id = rcv.Id()
t.ProgData = rcv.ProgDataBytes()
+ t.ExecOpts = rcv.ExecOpts(nil).UnPack()
t.Flags = rcv.Flags()
- t.ExecEnv = rcv.ExecEnv()
- t.ExecFlags = rcv.ExecFlags()
- t.SandboxArg = rcv.SandboxArg()
signalFilterLength := rcv.SignalFilterLength()
t.SignalFilter = make([]uint32, signalFilterLength)
for j := 0; j < signalFilterLength; j++ {
@@ -1754,56 +1818,33 @@ func (rcv *ExecRequestRaw) MutateProgData(j int, n byte) bool {
return false
}
-func (rcv *ExecRequestRaw) Flags() RequestFlag {
+func (rcv *ExecRequestRaw) ExecOpts(obj *ExecOptsRaw) *ExecOptsRaw {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
- return RequestFlag(rcv._tab.GetUint64(o + rcv._tab.Pos))
+ x := o + rcv._tab.Pos
+ if obj == nil {
+ obj = new(ExecOptsRaw)
+ }
+ obj.Init(rcv._tab.Bytes, x)
+ return obj
}
- return 0
-}
-
-func (rcv *ExecRequestRaw) MutateFlags(n RequestFlag) bool {
- return rcv._tab.MutateUint64Slot(8, uint64(n))
+ return nil
}
-func (rcv *ExecRequestRaw) ExecEnv() ExecEnv {
+func (rcv *ExecRequestRaw) Flags() RequestFlag {
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
if o != 0 {
- return ExecEnv(rcv._tab.GetUint64(o + rcv._tab.Pos))
+ return RequestFlag(rcv._tab.GetUint64(o + rcv._tab.Pos))
}
return 0
}
-func (rcv *ExecRequestRaw) MutateExecEnv(n ExecEnv) bool {
+func (rcv *ExecRequestRaw) MutateFlags(n RequestFlag) bool {
return rcv._tab.MutateUint64Slot(10, uint64(n))
}
-func (rcv *ExecRequestRaw) ExecFlags() ExecFlag {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
- if o != 0 {
- return ExecFlag(rcv._tab.GetUint64(o + rcv._tab.Pos))
- }
- return 0
-}
-
-func (rcv *ExecRequestRaw) MutateExecFlags(n ExecFlag) bool {
- return rcv._tab.MutateUint64Slot(12, uint64(n))
-}
-
-func (rcv *ExecRequestRaw) SandboxArg() int64 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
- if o != 0 {
- return rcv._tab.GetInt64(o + rcv._tab.Pos)
- }
- return 0
-}
-
-func (rcv *ExecRequestRaw) MutateSandboxArg(n int64) bool {
- return rcv._tab.MutateInt64Slot(14, n)
-}
-
func (rcv *ExecRequestRaw) SignalFilter(j int) uint32 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
a := rcv._tab.Vector(o)
return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4))
@@ -1812,7 +1853,7 @@ func (rcv *ExecRequestRaw) SignalFilter(j int) uint32 {
}
func (rcv *ExecRequestRaw) SignalFilterLength() int {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
return rcv._tab.VectorLen(o)
}
@@ -1820,7 +1861,7 @@ func (rcv *ExecRequestRaw) SignalFilterLength() int {
}
func (rcv *ExecRequestRaw) MutateSignalFilter(j int, n uint32) bool {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
a := rcv._tab.Vector(o)
return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n)
@@ -1829,7 +1870,7 @@ func (rcv *ExecRequestRaw) MutateSignalFilter(j int, n uint32) bool {
}
func (rcv *ExecRequestRaw) SignalFilterCall() int32 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
if o != 0 {
return rcv._tab.GetInt32(o + rcv._tab.Pos)
}
@@ -1837,11 +1878,11 @@ func (rcv *ExecRequestRaw) SignalFilterCall() int32 {
}
func (rcv *ExecRequestRaw) MutateSignalFilterCall(n int32) bool {
- return rcv._tab.MutateInt32Slot(18, n)
+ return rcv._tab.MutateInt32Slot(14, n)
}
func (rcv *ExecRequestRaw) Repeat() int32 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
if o != 0 {
return rcv._tab.GetInt32(o + rcv._tab.Pos)
}
@@ -1849,11 +1890,11 @@ func (rcv *ExecRequestRaw) Repeat() int32 {
}
func (rcv *ExecRequestRaw) MutateRepeat(n int32) bool {
- return rcv._tab.MutateInt32Slot(20, n)
+ return rcv._tab.MutateInt32Slot(16, n)
}
func ExecRequestRawStart(builder *flatbuffers.Builder) {
- builder.StartObject(9)
+ builder.StartObject(7)
}
func ExecRequestRawAddId(builder *flatbuffers.Builder, id int64) {
builder.PrependInt64Slot(0, id, 0)
@@ -1864,29 +1905,23 @@ func ExecRequestRawAddProgData(builder *flatbuffers.Builder, progData flatbuffer
func ExecRequestRawStartProgDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(1, numElems, 1)
}
-func ExecRequestRawAddFlags(builder *flatbuffers.Builder, flags RequestFlag) {
- builder.PrependUint64Slot(2, uint64(flags), 0)
-}
-func ExecRequestRawAddExecEnv(builder *flatbuffers.Builder, execEnv ExecEnv) {
- builder.PrependUint64Slot(3, uint64(execEnv), 0)
+func ExecRequestRawAddExecOpts(builder *flatbuffers.Builder, execOpts flatbuffers.UOffsetT) {
+ builder.PrependStructSlot(2, flatbuffers.UOffsetT(execOpts), 0)
}
-func ExecRequestRawAddExecFlags(builder *flatbuffers.Builder, execFlags ExecFlag) {
- builder.PrependUint64Slot(4, uint64(execFlags), 0)
-}
-func ExecRequestRawAddSandboxArg(builder *flatbuffers.Builder, sandboxArg int64) {
- builder.PrependInt64Slot(5, sandboxArg, 0)
+func ExecRequestRawAddFlags(builder *flatbuffers.Builder, flags RequestFlag) {
+ builder.PrependUint64Slot(3, uint64(flags), 0)
}
func ExecRequestRawAddSignalFilter(builder *flatbuffers.Builder, signalFilter flatbuffers.UOffsetT) {
- builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(signalFilter), 0)
+ builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(signalFilter), 0)
}
func ExecRequestRawStartSignalFilterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func ExecRequestRawAddSignalFilterCall(builder *flatbuffers.Builder, signalFilterCall int32) {
- builder.PrependInt32Slot(7, signalFilterCall, 0)
+ builder.PrependInt32Slot(5, signalFilterCall, 0)
}
func ExecRequestRawAddRepeat(builder *flatbuffers.Builder, repeat int32) {
- builder.PrependInt32Slot(8, repeat, 0)
+ builder.PrependInt32Slot(6, repeat, 0)
}
func ExecRequestRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
diff --git a/pkg/flatrpc/flatrpc.h b/pkg/flatrpc/flatrpc.h
index dab853dcc..5721ea90f 100644
--- a/pkg/flatrpc/flatrpc.h
+++ b/pkg/flatrpc/flatrpc.h
@@ -51,6 +51,8 @@ struct ExecutorMessageRaw;
struct ExecutorMessageRawBuilder;
struct ExecutorMessageRawT;
+struct ExecOptsRaw;
+
struct ExecRequestRaw;
struct ExecRequestRawBuilder;
struct ExecRequestRawT;
@@ -565,6 +567,35 @@ inline const char *EnumNameCallFlag(CallFlag e) {
return EnumNamesCallFlag()[index];
}
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ExecOptsRaw FLATBUFFERS_FINAL_CLASS {
+ private:
+ uint64_t env_flags_;
+ uint64_t exec_flags_;
+ int64_t sandbox_arg_;
+
+ public:
+ ExecOptsRaw()
+ : env_flags_(0),
+ exec_flags_(0),
+ sandbox_arg_(0) {
+ }
+ ExecOptsRaw(rpc::ExecEnv _env_flags, rpc::ExecFlag _exec_flags, int64_t _sandbox_arg)
+ : env_flags_(flatbuffers::EndianScalar(static_cast<uint64_t>(_env_flags))),
+ exec_flags_(flatbuffers::EndianScalar(static_cast<uint64_t>(_exec_flags))),
+ sandbox_arg_(flatbuffers::EndianScalar(_sandbox_arg)) {
+ }
+ rpc::ExecEnv env_flags() const {
+ return static_cast<rpc::ExecEnv>(flatbuffers::EndianScalar(env_flags_));
+ }
+ rpc::ExecFlag exec_flags() const {
+ return static_cast<rpc::ExecFlag>(flatbuffers::EndianScalar(exec_flags_));
+ }
+ int64_t sandbox_arg() const {
+ return flatbuffers::EndianScalar(sandbox_arg_);
+ }
+};
+FLATBUFFERS_STRUCT_END(ExecOptsRaw, 24);
+
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ComparisonRaw FLATBUFFERS_FINAL_CLASS {
private:
uint64_t op1_;
@@ -1426,13 +1457,15 @@ struct ExecRequestRawT : public flatbuffers::NativeTable {
typedef ExecRequestRaw TableType;
int64_t id = 0;
std::vector<uint8_t> prog_data{};
+ std::unique_ptr<rpc::ExecOptsRaw> exec_opts{};
rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0);
- rpc::ExecEnv exec_env = static_cast<rpc::ExecEnv>(0);
- rpc::ExecFlag exec_flags = static_cast<rpc::ExecFlag>(0);
- int64_t sandbox_arg = 0;
std::vector<uint32_t> signal_filter{};
int32_t signal_filter_call = 0;
int32_t repeat = 0;
+ ExecRequestRawT() = default;
+ ExecRequestRawT(const ExecRequestRawT &o);
+ ExecRequestRawT(ExecRequestRawT&&) FLATBUFFERS_NOEXCEPT = default;
+ ExecRequestRawT &operator=(ExecRequestRawT o) FLATBUFFERS_NOEXCEPT;
};
struct ExecRequestRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1441,13 +1474,11 @@ struct ExecRequestRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ID = 4,
VT_PROG_DATA = 6,
- VT_FLAGS = 8,
- VT_EXEC_ENV = 10,
- VT_EXEC_FLAGS = 12,
- VT_SANDBOX_ARG = 14,
- VT_SIGNAL_FILTER = 16,
- VT_SIGNAL_FILTER_CALL = 18,
- VT_REPEAT = 20
+ VT_EXEC_OPTS = 8,
+ VT_FLAGS = 10,
+ VT_SIGNAL_FILTER = 12,
+ VT_SIGNAL_FILTER_CALL = 14,
+ VT_REPEAT = 16
};
int64_t id() const {
return GetField<int64_t>(VT_ID, 0);
@@ -1455,18 +1486,12 @@ struct ExecRequestRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<uint8_t> *prog_data() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PROG_DATA);
}
+ const rpc::ExecOptsRaw *exec_opts() const {
+ return GetStruct<const rpc::ExecOptsRaw *>(VT_EXEC_OPTS);
+ }
rpc::RequestFlag flags() const {
return static_cast<rpc::RequestFlag>(GetField<uint64_t>(VT_FLAGS, 0));
}
- rpc::ExecEnv exec_env() const {
- return static_cast<rpc::ExecEnv>(GetField<uint64_t>(VT_EXEC_ENV, 0));
- }
- rpc::ExecFlag exec_flags() const {
- return static_cast<rpc::ExecFlag>(GetField<uint64_t>(VT_EXEC_FLAGS, 0));
- }
- int64_t sandbox_arg() const {
- return GetField<int64_t>(VT_SANDBOX_ARG, 0);
- }
const flatbuffers::Vector<uint32_t> *signal_filter() const {
return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIGNAL_FILTER);
}
@@ -1481,10 +1506,8 @@ struct ExecRequestRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int64_t>(verifier, VT_ID, 8) &&
VerifyOffset(verifier, VT_PROG_DATA) &&
verifier.VerifyVector(prog_data()) &&
+ VerifyField<rpc::ExecOptsRaw>(verifier, VT_EXEC_OPTS, 8) &&
VerifyField<uint64_t>(verifier, VT_FLAGS, 8) &&
- VerifyField<uint64_t>(verifier, VT_EXEC_ENV, 8) &&
- VerifyField<uint64_t>(verifier, VT_EXEC_FLAGS, 8) &&
- VerifyField<int64_t>(verifier, VT_SANDBOX_ARG, 8) &&
VerifyOffset(verifier, VT_SIGNAL_FILTER) &&
verifier.VerifyVector(signal_filter()) &&
VerifyField<int32_t>(verifier, VT_SIGNAL_FILTER_CALL, 4) &&
@@ -1506,18 +1529,12 @@ struct ExecRequestRawBuilder {
void add_prog_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> prog_data) {
fbb_.AddOffset(ExecRequestRaw::VT_PROG_DATA, prog_data);
}
+ void add_exec_opts(const rpc::ExecOptsRaw *exec_opts) {
+ fbb_.AddStruct(ExecRequestRaw::VT_EXEC_OPTS, exec_opts);
+ }
void add_flags(rpc::RequestFlag flags) {
fbb_.AddElement<uint64_t>(ExecRequestRaw::VT_FLAGS, static_cast<uint64_t>(flags), 0);
}
- void add_exec_env(rpc::ExecEnv exec_env) {
- fbb_.AddElement<uint64_t>(ExecRequestRaw::VT_EXEC_ENV, static_cast<uint64_t>(exec_env), 0);
- }
- void add_exec_flags(rpc::ExecFlag exec_flags) {
- fbb_.AddElement<uint64_t>(ExecRequestRaw::VT_EXEC_FLAGS, static_cast<uint64_t>(exec_flags), 0);
- }
- void add_sandbox_arg(int64_t sandbox_arg) {
- fbb_.AddElement<int64_t>(ExecRequestRaw::VT_SANDBOX_ARG, sandbox_arg, 0);
- }
void add_signal_filter(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> signal_filter) {
fbb_.AddOffset(ExecRequestRaw::VT_SIGNAL_FILTER, signal_filter);
}
@@ -1542,22 +1559,18 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(
flatbuffers::FlatBufferBuilder &_fbb,
int64_t id = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> prog_data = 0,
+ const rpc::ExecOptsRaw *exec_opts = nullptr,
rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0),
- rpc::ExecEnv exec_env = static_cast<rpc::ExecEnv>(0),
- rpc::ExecFlag exec_flags = static_cast<rpc::ExecFlag>(0),
- int64_t sandbox_arg = 0,
flatbuffers::Offset<flatbuffers::Vector<uint32_t>> signal_filter = 0,
int32_t signal_filter_call = 0,
int32_t repeat = 0) {
ExecRequestRawBuilder builder_(_fbb);
- builder_.add_sandbox_arg(sandbox_arg);
- builder_.add_exec_flags(exec_flags);
- builder_.add_exec_env(exec_env);
builder_.add_flags(flags);
builder_.add_id(id);
builder_.add_repeat(repeat);
builder_.add_signal_filter_call(signal_filter_call);
builder_.add_signal_filter(signal_filter);
+ builder_.add_exec_opts(exec_opts);
builder_.add_prog_data(prog_data);
return builder_.Finish();
}
@@ -1566,10 +1579,8 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRawDirect(
flatbuffers::FlatBufferBuilder &_fbb,
int64_t id = 0,
const std::vector<uint8_t> *prog_data = nullptr,
+ const rpc::ExecOptsRaw *exec_opts = nullptr,
rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0),
- rpc::ExecEnv exec_env = static_cast<rpc::ExecEnv>(0),
- rpc::ExecFlag exec_flags = static_cast<rpc::ExecFlag>(0),
- int64_t sandbox_arg = 0,
const std::vector<uint32_t> *signal_filter = nullptr,
int32_t signal_filter_call = 0,
int32_t repeat = 0) {
@@ -1579,10 +1590,8 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRawDirect(
_fbb,
id,
prog_data__,
+ exec_opts,
flags,
- exec_env,
- exec_flags,
- sandbox_arg,
signal_filter__,
signal_filter_call,
repeat);
@@ -2391,6 +2400,27 @@ inline flatbuffers::Offset<ExecutorMessageRaw> CreateExecutorMessageRaw(flatbuff
_msg);
}
+inline ExecRequestRawT::ExecRequestRawT(const ExecRequestRawT &o)
+ : id(o.id),
+ prog_data(o.prog_data),
+ exec_opts((o.exec_opts) ? new rpc::ExecOptsRaw(*o.exec_opts) : nullptr),
+ flags(o.flags),
+ signal_filter(o.signal_filter),
+ signal_filter_call(o.signal_filter_call),
+ repeat(o.repeat) {
+}
+
+inline ExecRequestRawT &ExecRequestRawT::operator=(ExecRequestRawT o) FLATBUFFERS_NOEXCEPT {
+ std::swap(id, o.id);
+ std::swap(prog_data, o.prog_data);
+ std::swap(exec_opts, o.exec_opts);
+ std::swap(flags, o.flags);
+ std::swap(signal_filter, o.signal_filter);
+ std::swap(signal_filter_call, o.signal_filter_call);
+ std::swap(repeat, o.repeat);
+ return *this;
+}
+
inline ExecRequestRawT *ExecRequestRaw::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<ExecRequestRawT>(new ExecRequestRawT());
UnPackTo(_o.get(), _resolver);
@@ -2402,10 +2432,8 @@ inline void ExecRequestRaw::UnPackTo(ExecRequestRawT *_o, const flatbuffers::res
(void)_resolver;
{ auto _e = id(); _o->id = _e; }
{ auto _e = prog_data(); if (_e) { _o->prog_data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->prog_data.begin()); } }
+ { auto _e = exec_opts(); if (_e) _o->exec_opts = std::unique_ptr<rpc::ExecOptsRaw>(new rpc::ExecOptsRaw(*_e)); }
{ auto _e = flags(); _o->flags = _e; }
- { auto _e = exec_env(); _o->exec_env = _e; }
- { auto _e = exec_flags(); _o->exec_flags = _e; }
- { auto _e = sandbox_arg(); _o->sandbox_arg = _e; }
{ auto _e = signal_filter(); if (_e) { _o->signal_filter.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->signal_filter[_i] = _e->Get(_i); } } }
{ auto _e = signal_filter_call(); _o->signal_filter_call = _e; }
{ auto _e = repeat(); _o->repeat = _e; }
@@ -2421,10 +2449,8 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(flatbuffers::Fla
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExecRequestRawT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _id = _o->id;
auto _prog_data = _o->prog_data.size() ? _fbb.CreateVector(_o->prog_data) : 0;
+ auto _exec_opts = _o->exec_opts ? _o->exec_opts.get() : nullptr;
auto _flags = _o->flags;
- auto _exec_env = _o->exec_env;
- auto _exec_flags = _o->exec_flags;
- auto _sandbox_arg = _o->sandbox_arg;
auto _signal_filter = _o->signal_filter.size() ? _fbb.CreateVector(_o->signal_filter) : 0;
auto _signal_filter_call = _o->signal_filter_call;
auto _repeat = _o->repeat;
@@ -2432,10 +2458,8 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(flatbuffers::Fla
_fbb,
_id,
_prog_data,
+ _exec_opts,
_flags,
- _exec_env,
- _exec_flags,
- _sandbox_arg,
_signal_filter,
_signal_filter_call,
_repeat);
diff --git a/pkg/flatrpc/helpers.go b/pkg/flatrpc/helpers.go
index 843b281d3..4ee5ad76b 100644
--- a/pkg/flatrpc/helpers.go
+++ b/pkg/flatrpc/helpers.go
@@ -29,6 +29,7 @@ type SignalUpdate = SignalUpdateRawT
type ExecutingMessage = ExecutingMessageRawT
type CallInfo = CallInfoRawT
type Comparison = ComparisonRawT
+type ExecOpts = ExecOptsRawT
type ProgInfo = ProgInfoRawT
type ExecResult = ExecResultRawT
@@ -68,3 +69,10 @@ func EmptyProgInfo(calls int) *ProgInfo {
}
return info
}
+
+func (eo ExecOpts) MergeFlags(diff ExecOpts) ExecOpts {
+ ret := eo
+ ret.ExecFlags |= diff.ExecFlags
+ ret.EnvFlags |= diff.EnvFlags
+ return ret
+}
diff --git a/pkg/fuzzer/fuzzer.go b/pkg/fuzzer/fuzzer.go
index f079e1dc7..9ad218433 100644
--- a/pkg/fuzzer/fuzzer.go
+++ b/pkg/fuzzer/fuzzer.go
@@ -14,7 +14,6 @@ import (
"github.com/google/syzkaller/pkg/corpus"
"github.com/google/syzkaller/pkg/flatrpc"
"github.com/google/syzkaller/pkg/fuzzer/queue"
- "github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/pkg/stats"
"github.com/google/syzkaller/prog"
)
@@ -136,7 +135,7 @@ func (fuzzer *Fuzzer) processResult(req *queue.Request, res *queue.Result, flags
type Config struct {
Debug bool
Corpus *corpus.Corpus
- BaseOpts ipc.ExecOpts // Fuzzer will use BaseOpts as a base for all requests.
+ BaseOpts flatrpc.ExecOpts // Fuzzer will use BaseOpts as a base for all requests.
Logf func(level int, msg string, args ...interface{})
Coverage bool
FaultInjection bool
@@ -329,8 +328,8 @@ func (fuzzer *Fuzzer) RotateMaxSignal(items int) {
fuzzer.Cover.subtract(delta)
}
-func setFlags(execFlags flatrpc.ExecFlag) ipc.ExecOpts {
- return ipc.ExecOpts{
+func setFlags(execFlags flatrpc.ExecFlag) flatrpc.ExecOpts {
+ return flatrpc.ExecOpts{
ExecFlags: execFlags,
}
}
diff --git a/pkg/fuzzer/fuzzer_test.go b/pkg/fuzzer/fuzzer_test.go
index 07e09e25a..9ac3376ac 100644
--- a/pkg/fuzzer/fuzzer_test.go
+++ b/pkg/fuzzer/fuzzer_test.go
@@ -277,7 +277,7 @@ func (f *testFuzzer) wait() {
// Looks like it's time to factor out this functionality.
type executorProc struct {
env *ipc.Env
- execOpts ipc.ExecOpts
+ execOpts flatrpc.ExecOpts
}
func newProc(t *testing.T, target *prog.Target, executor string) *executorProc {
diff --git a/pkg/fuzzer/queue/queue.go b/pkg/fuzzer/queue/queue.go
index 0e578c6f9..a9411c1bd 100644
--- a/pkg/fuzzer/queue/queue.go
+++ b/pkg/fuzzer/queue/queue.go
@@ -13,7 +13,6 @@ import (
"github.com/google/syzkaller/pkg/flatrpc"
"github.com/google/syzkaller/pkg/hash"
- "github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/pkg/signal"
"github.com/google/syzkaller/pkg/stats"
"github.com/google/syzkaller/prog"
@@ -21,7 +20,7 @@ import (
type Request struct {
Prog *prog.Prog
- ExecOpts ipc.ExecOpts
+ ExecOpts flatrpc.ExecOpts
// If specified, the resulting signal for call SignalFilterCall
// will include subset of it even if it's not new.
diff --git a/pkg/instance/instance.go b/pkg/instance/instance.go
index d47c093ec..4e5f95e2d 100644
--- a/pkg/instance/instance.go
+++ b/pkg/instance/instance.go
@@ -457,7 +457,7 @@ func (inst *inst) testRepro() ([]byte, error) {
type OptionalFuzzerArgs struct {
Slowdown int
- SandboxArg int
+ SandboxArg int64
PprofPort int
}
@@ -504,7 +504,7 @@ func FuzzerCmd(args *FuzzerCmdArgs) string {
args.Procs, args.Cover, args.Debug, args.Test, verbosityArg, optionalArg)
}
-func OldFuzzerCmd(fuzzer, executor, name, OS, arch, fwdAddr, sandbox string, sandboxArg, procs int,
+func OldFuzzerCmd(fuzzer, executor, name, OS, arch, fwdAddr, sandbox string, sandboxArg int64, procs int,
cover, test, optionalFlags bool, slowdown int) string {
var optional *OptionalFuzzerArgs
if optionalFlags {
diff --git a/pkg/ipc/ipc.go b/pkg/ipc/ipc.go
index 9b4f77d66..1b356c38c 100644
--- a/pkg/ipc/ipc.go
+++ b/pkg/ipc/ipc.go
@@ -24,21 +24,6 @@ import (
"github.com/google/syzkaller/sys/targets"
)
-type ExecOpts struct {
- // Changing ExecFlag between executions does not cause executor process restart.
- // Changing ExecEnv/SandboxArg does cause process restart.
- ExecFlags flatrpc.ExecFlag
- EnvFlags flatrpc.ExecEnv
- SandboxArg int
-}
-
-func (eo ExecOpts) MergeFlags(diff ExecOpts) ExecOpts {
- ret := eo
- ret.ExecFlags |= diff.ExecFlags
- ret.EnvFlags |= diff.EnvFlags
- return ret
-}
-
// Config is the configuration for Env.
type Config struct {
// Path to executor binary.
@@ -256,7 +241,7 @@ func (env *Env) Close() error {
// info: per-call info
// hanged: program hanged and was killed
// err0: failed to start the process or bug in executor itself.
-func (env *Env) ExecProg(opts *ExecOpts, progData []byte) (
+func (env *Env) ExecProg(opts *flatrpc.ExecOpts, progData []byte) (
output []byte, info *flatrpc.ProgInfo, hanged bool, err0 error) {
ncalls, err := prog.ExecCallCount(progData)
if err != nil {
@@ -301,7 +286,8 @@ func (env *Env) ExecProg(opts *ExecOpts, progData []byte) (
return
}
-func (env *Env) Exec(opts *ExecOpts, p *prog.Prog) (output []byte, info *flatrpc.ProgInfo, hanged bool, err0 error) {
+func (env *Env) Exec(opts *flatrpc.ExecOpts, p *prog.Prog) (
+ output []byte, info *flatrpc.ProgInfo, hanged bool, err0 error) {
progData, err := p.SerializeForExec()
if err != nil {
err0 = err
@@ -318,7 +304,7 @@ func (env *Env) ForceRestart() {
}
// RestartIfNeeded brings up an executor process if it was stopped.
-func (env *Env) RestartIfNeeded(opts *ExecOpts) error {
+func (env *Env) RestartIfNeeded(opts *flatrpc.ExecOpts) error {
if env.cmd != nil {
if env.cmd.flags == opts.EnvFlags && env.cmd.sandboxArg == opts.SandboxArg {
return nil
@@ -341,7 +327,7 @@ var (
rateLimiter <-chan time.Time
)
-func (env *Env) parseOutput(opts *ExecOpts, ncalls int) (*flatrpc.ProgInfo, error) {
+func (env *Env) parseOutput(opts *flatrpc.ExecOpts, ncalls int) (*flatrpc.ProgInfo, error) {
out := env.out
ncmd, ok := readUint32(&out)
if !ok {
@@ -500,7 +486,7 @@ type command struct {
pid int
config *Config
flags flatrpc.ExecEnv
- sandboxArg int
+ sandboxArg int64
timeout time.Duration
cmd *exec.Cmd
dir string
@@ -561,7 +547,7 @@ type callReply struct {
// signal/cover/comps follow
}
-func (env *Env) makeCommand(opts *ExecOpts, tmpDir string) (*command, error) {
+func (env *Env) makeCommand(opts *flatrpc.ExecOpts, tmpDir string) (*command, error) {
dir, err := os.MkdirTemp(tmpDir, "syzkaller-testdir")
if err != nil {
return nil, fmt.Errorf("failed to create temp dir: %w", err)
@@ -752,7 +738,7 @@ func (c *command) wait() error {
return <-c.exited
}
-func (c *command) exec(opts *ExecOpts, progData []byte) (output []byte, hanged bool, err0 error) {
+func (c *command) exec(opts *flatrpc.ExecOpts, progData []byte) (output []byte, hanged bool, err0 error) {
if c.flags != opts.EnvFlags || c.sandboxArg != opts.SandboxArg {
panic("wrong command")
}
diff --git a/pkg/ipc/ipc_priv_test.go b/pkg/ipc/ipc_priv_test.go
index 94c48af75..02c467daf 100644
--- a/pkg/ipc/ipc_priv_test.go
+++ b/pkg/ipc/ipc_priv_test.go
@@ -5,6 +5,8 @@ package ipc
import (
"testing"
+
+ "github.com/google/syzkaller/pkg/flatrpc"
)
func TestOutputDeadline(t *testing.T) {
@@ -18,7 +20,7 @@ func TestOutputDeadline(t *testing.T) {
pid: 1,
config: &Config{},
}
- c, err := env.makeCommand(&ExecOpts{}, t.TempDir())
+ c, err := env.makeCommand(&flatrpc.ExecOpts{}, t.TempDir())
if err != nil {
t.Fatal(err)
}
diff --git a/pkg/ipc/ipc_test.go b/pkg/ipc/ipc_test.go
index af9557e1b..74a055635 100644
--- a/pkg/ipc/ipc_test.go
+++ b/pkg/ipc/ipc_test.go
@@ -98,7 +98,7 @@ func TestExecute(t *testing.T) {
for i := 0; i < 10; i++ {
p := prepareTestProgram(target)
- opts := &ExecOpts{
+ opts := &flatrpc.ExecOpts{
ExecFlags: flag,
}
output, info, hanged, err := env.Exec(opts, p)
@@ -145,7 +145,7 @@ func TestParallel(t *testing.T) {
errs <- err
}()
p := target.DataMmapProg()
- opts := &ExecOpts{}
+ opts := &flatrpc.ExecOpts{}
output, info, hanged, err := env.Exec(opts, p)
if err != nil {
err = fmt.Errorf("failed to run executor: %w", err)
diff --git a/pkg/ipc/ipcconfig/ipcconfig.go b/pkg/ipc/ipcconfig/ipcconfig.go
index 343697c8f..3e4b6fd8e 100644
--- a/pkg/ipc/ipcconfig/ipcconfig.go
+++ b/pkg/ipc/ipcconfig/ipcconfig.go
@@ -22,7 +22,7 @@ var (
flagSlowdown = flag.Int("slowdown", 1, "execution slowdown caused by emulation/instrumentation")
)
-func Default(target *prog.Target) (*ipc.Config, *ipc.ExecOpts, error) {
+func Default(target *prog.Target) (*ipc.Config, *flatrpc.ExecOpts, error) {
sysTarget := targets.Get(target.OS, target.Arch)
c := &ipc.Config{
Executor: *flagExecutor,
@@ -32,7 +32,7 @@ func Default(target *prog.Target) (*ipc.Config, *ipc.ExecOpts, error) {
c.UseForkServer = sysTarget.ExecutorUsesForkServer
c.RateLimit = sysTarget.HostFuzzer && target.OS != targets.TestOS
- opts := &ipc.ExecOpts{
+ opts := &flatrpc.ExecOpts{
ExecFlags: flatrpc.ExecFlagDedupCover,
}
if *flagThreaded {
@@ -51,7 +51,7 @@ func Default(target *prog.Target) (*ipc.Config, *ipc.ExecOpts, error) {
if err != nil {
return nil, nil, err
}
- opts.SandboxArg = *flagSandboxArg
+ opts.SandboxArg = int64(*flagSandboxArg)
opts.EnvFlags |= sandboxFlags
return c, opts, nil
}
diff --git a/pkg/mgrconfig/config.go b/pkg/mgrconfig/config.go
index 19ba352f7..461d25afb 100644
--- a/pkg/mgrconfig/config.go
+++ b/pkg/mgrconfig/config.go
@@ -131,7 +131,7 @@ type Config struct {
// This value is passed as an argument to executor and allows to adjust sandbox behavior
// via manager config. For example you can switch between system and user accounts based
// on this value.
- SandboxArg int `json:"sandbox_arg"`
+ SandboxArg int64 `json:"sandbox_arg"`
// Use KCOV coverage (default: true).
Cover bool `json:"cover"`
diff --git a/pkg/runtest/run.go b/pkg/runtest/run.go
index 2c6a60d4a..79d47d603 100644
--- a/pkg/runtest/run.go
+++ b/pkg/runtest/run.go
@@ -420,7 +420,7 @@ func match(props, requires map[string]bool) bool {
}
func (ctx *Context) createSyzTest(p *prog.Prog, sandbox string, threaded, cov bool, times int) (*runRequest, error) {
- var opts ipc.ExecOpts
+ var opts flatrpc.ExecOpts
sandboxFlags, err := ipc.SandboxToFlags(sandbox)
if err != nil {
return nil, err
@@ -495,7 +495,7 @@ func (ctx *Context) createCTest(p *prog.Prog, sandbox string, threaded bool, tim
Request: &queue.Request{
Prog: p,
BinaryFile: bin,
- ExecOpts: ipc.ExecOpts{
+ ExecOpts: flatrpc.ExecOpts{
ExecFlags: ipcFlags,
},
Repeat: times,
diff --git a/pkg/vminfo/features.go b/pkg/vminfo/features.go
index 905fc630f..150b658fc 100644
--- a/pkg/vminfo/features.go
+++ b/pkg/vminfo/features.go
@@ -9,7 +9,6 @@ import (
"github.com/google/syzkaller/pkg/flatrpc"
"github.com/google/syzkaller/pkg/fuzzer/queue"
- "github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/prog"
)
@@ -56,7 +55,7 @@ func (ctx *checkContext) startFeaturesCheck() {
Prog: testProg,
ReturnOutput: true,
ReturnError: true,
- ExecOpts: ipc.ExecOpts{
+ ExecOpts: flatrpc.ExecOpts{
EnvFlags: envFlags,
ExecFlags: execFlags,
SandboxArg: ctx.cfg.SandboxArg,
diff --git a/pkg/vminfo/syscalls.go b/pkg/vminfo/syscalls.go
index 23c9504e2..8a533227b 100644
--- a/pkg/vminfo/syscalls.go
+++ b/pkg/vminfo/syscalls.go
@@ -254,7 +254,7 @@ func (ctx *checkContext) execRaw(calls []string, mode prog.DeserializeMode, root
}
req := &queue.Request{
Prog: p,
- ExecOpts: ipc.ExecOpts{
+ ExecOpts: flatrpc.ExecOpts{
EnvFlags: sandbox,
ExecFlags: 0,
SandboxArg: ctx.cfg.SandboxArg,
diff --git a/syz-fuzzer/proc.go b/syz-fuzzer/proc.go
index c243c8a31..cd2d76de2 100644
--- a/syz-fuzzer/proc.go
+++ b/syz-fuzzer/proc.go
@@ -45,7 +45,7 @@ func (proc *Proc) loop() {
// Do not let too much state accumulate.
const restartIn = 600
resetFlags := flatrpc.ExecFlagCollectSignal | flatrpc.ExecFlagCollectCover | flatrpc.ExecFlagCollectComps
- if (req.ExecFlags&resetFlags != 0 &&
+ if (req.ExecOpts.ExecFlags&resetFlags != 0 &&
rnd.Intn(restartIn) == 0) || req.Flags&flatrpc.RequestFlagResetState != 0 {
proc.env.ForceRestart()
}
@@ -119,23 +119,18 @@ func (proc *Proc) execute(req *flatrpc.ExecRequest, wait time.Duration) (
func (proc *Proc) executeProgram(req *flatrpc.ExecRequest, wait time.Duration) (*flatrpc.ProgInfo, []byte, error) {
returnError := req.Flags&flatrpc.RequestFlagReturnError != 0
- execOpts := &ipc.ExecOpts{
- EnvFlags: req.ExecEnv,
- ExecFlags: req.ExecFlags,
- SandboxArg: int(req.SandboxArg),
- }
for try := 0; ; try++ {
var output []byte
var info *flatrpc.ProgInfo
var hanged bool
// On a heavily loaded VM, syz-executor may take significant time to start.
// Let's do it outside of the gate ticket.
- err := proc.env.RestartIfNeeded(execOpts)
+ err := proc.env.RestartIfNeeded(req.ExecOpts)
if err == nil {
// Limit concurrency.
ticket := proc.tool.gate.Enter()
proc.tool.startExecutingCall(req.Id, proc.pid, try, wait)
- output, info, hanged, err = proc.env.ExecProg(execOpts, req.ProgData)
+ output, info, hanged, err = proc.env.ExecProg(req.ExecOpts, req.ProgData)
proc.tool.gate.Leave(ticket)
// Don't print output if returning error b/c it may contain SYZFAIL.
if !returnError {
diff --git a/syz-fuzzer/testing.go b/syz-fuzzer/testing.go
index e22813d2a..dbf0e9b70 100644
--- a/syz-fuzzer/testing.go
+++ b/syz-fuzzer/testing.go
@@ -23,7 +23,7 @@ type checkArgs struct {
gitRevision string
targetRevision string
ipcConfig *ipc.Config
- ipcExecOpts *ipc.ExecOpts
+ ipcExecOpts *flatrpc.ExecOpts
}
func testImage(hostAddr string, args *checkArgs) {
diff --git a/syz-manager/manager.go b/syz-manager/manager.go
index c85d59d36..4c0565a76 100644
--- a/syz-manager/manager.go
+++ b/syz-manager/manager.go
@@ -30,7 +30,6 @@ import (
"github.com/google/syzkaller/pkg/gce"
"github.com/google/syzkaller/pkg/hash"
"github.com/google/syzkaller/pkg/instance"
- "github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/pkg/log"
"github.com/google/syzkaller/pkg/mgrconfig"
"github.com/google/syzkaller/pkg/osutil"
@@ -1337,7 +1336,7 @@ func (mgr *Manager) currentBugFrames() BugFrames {
}
func (mgr *Manager) machineChecked(features flatrpc.Feature, enabledSyscalls map[*prog.Syscall]bool,
- opts ipc.ExecOpts) queue.Source {
+ opts flatrpc.ExecOpts) queue.Source {
mgr.mu.Lock()
defer mgr.mu.Unlock()
if mgr.checkDone {
diff --git a/syz-manager/rpc.go b/syz-manager/rpc.go
index 711c0a6a4..ea6427092 100644
--- a/syz-manager/rpc.go
+++ b/syz-manager/rpc.go
@@ -82,7 +82,7 @@ type RPCManagerView interface {
currentBugFrames() BugFrames
maxSignal() signal.Signal
machineChecked(features flatrpc.Feature, enabledSyscalls map[*prog.Syscall]bool,
- opts ipc.ExecOpts) queue.Source
+ opts flatrpc.ExecOpts) queue.Source
}
func startRPCServer(mgr *Manager) (*RPCServer, error) {
@@ -325,9 +325,7 @@ func (serv *RPCServer) sendRequest(runner *Runner, req *queue.Request) error {
Id: id,
ProgData: progData,
Flags: flags,
- ExecEnv: req.ExecOpts.EnvFlags,
- ExecFlags: req.ExecOpts.ExecFlags,
- SandboxArg: int64(req.ExecOpts.SandboxArg),
+ ExecOpts: &req.ExecOpts,
SignalFilter: signalFilter,
SignalFilterCall: int32(req.SignalFilterCall),
},
@@ -575,7 +573,7 @@ func (serv *RPCServer) updateCoverFilter(newCover []uint32) {
serv.statCoverFiltered.Add(filtered)
}
-func (serv *RPCServer) execOpts() ipc.ExecOpts {
+func (serv *RPCServer) execOpts() flatrpc.ExecOpts {
env := ipc.FeaturesToFlags(serv.enabledFeatures, nil)
if *flagDebug {
env |= flatrpc.ExecEnvDebug
@@ -596,7 +594,7 @@ func (serv *RPCServer) execOpts() ipc.ExecOpts {
if serv.cfg.HasCovFilter() {
exec |= flatrpc.ExecFlagCoverFilter
}
- return ipc.ExecOpts{
+ return flatrpc.ExecOpts{
EnvFlags: env,
ExecFlags: exec,
SandboxArg: serv.cfg.SandboxArg,
diff --git a/tools/syz-execprog/execprog.go b/tools/syz-execprog/execprog.go
index 066c1f4ee..cb51244b3 100644
--- a/tools/syz-execprog/execprog.go
+++ b/tools/syz-execprog/execprog.go
@@ -157,7 +157,7 @@ type Context struct {
progs []*prog.Prog
choiceTable *prog.ChoiceTable
config *ipc.Config
- execOpts *ipc.ExecOpts
+ execOpts *flatrpc.ExecOpts
gate *ipc.Gate
shutdown chan struct{}
logMu sync.Mutex
@@ -204,7 +204,7 @@ func (ctx *Context) execute(pid int, env *ipc.Env, p *prog.Prog, progIndex int)
callOpts := ctx.execOpts
if *flagOutput {
- ctx.logProgram(pid, p, callOpts)
+ ctx.logProgram(pid, p)
}
progData, err := p.SerializeForExec()
if err != nil {
@@ -244,7 +244,7 @@ func (ctx *Context) execute(pid int, env *ipc.Env, p *prog.Prog, progIndex int)
}
}
-func (ctx *Context) logProgram(pid int, p *prog.Prog, callOpts *ipc.ExecOpts) {
+func (ctx *Context) logProgram(pid int, p *prog.Prog) {
data := p.Serialize()
ctx.logMu.Lock()
log.Logf(0, "executing program %v:\n%s", pid, data)
@@ -394,7 +394,7 @@ func loadPrograms(target *prog.Target, files []string) []*prog.Prog {
}
func createConfig(target *prog.Target, featuresFlags csource.Features, syscalls []int) (
- *ipc.Config, *ipc.ExecOpts, map[*prog.Syscall]bool, flatrpc.Feature) {
+ *ipc.Config, *flatrpc.ExecOpts, map[*prog.Syscall]bool, flatrpc.Feature) {
config, execOpts, err := ipcconfig.Default(target)
if err != nil {
log.Fatalf("%v", err)
diff --git a/tools/syz-testbuild/testbuild.go b/tools/syz-testbuild/testbuild.go
index a0d80f057..b7d4af6fc 100644
--- a/tools/syz-testbuild/testbuild.go
+++ b/tools/syz-testbuild/testbuild.go
@@ -76,7 +76,7 @@ func main() {
KernelObj: *flagKernelSrc,
Syzkaller: *flagSyzkaller,
Sandbox: *flagSandbox,
- SandboxArg: *flagSandboxArg,
+ SandboxArg: int64(*flagSandboxArg),
SSHUser: "root",
Procs: 1,
Cover: false,
generated by ggit (джигит) mrf-deployment (git 2.46.0) at 2026-03-11 20:39:15 +0000