pkg/ipc: remove ExecOpts

Switch to flatrpc.ExecOpts.

16 files changed, 226 insertions, 168 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,