aboutsummaryrefslogtreecommitdiffstats
path: root/pkg/flatrpc
diff options
context:
space:
mode:
authorDmitry Vyukov <dvyukov@google.com>2024-06-04 12:55:41 +0200
committerDmitry Vyukov <dvyukov@google.com>2024-06-24 09:57:34 +0000
commite16e2c9a4cb6937323e861b646792a6c4c978a3c (patch)
tree6c513e98e5f465b44a98546d8984485d2c128582 /pkg/flatrpc
parent90d67044dab68568e8f35bc14b68055dbd166eff (diff)
executor: add runner mode
Move all syz-fuzzer logic into syz-executor and remove syz-fuzzer. Also restore syz-runtest functionality in the manager. Update #4917 (sets most signal handlers to SIG_IGN)
Diffstat (limited to 'pkg/flatrpc')
-rw-r--r--pkg/flatrpc/conn.go60
-rw-r--r--pkg/flatrpc/conn_test.go67
-rw-r--r--pkg/flatrpc/flatrpc.fbs25
-rw-r--r--pkg/flatrpc/flatrpc.go537
-rw-r--r--pkg/flatrpc/flatrpc.h523
-rw-r--r--pkg/flatrpc/helpers.go34
6 files changed, 895 insertions, 351 deletions
diff --git a/pkg/flatrpc/conn.go b/pkg/flatrpc/conn.go
index ba028fe62..9d8d1ce59 100644
--- a/pkg/flatrpc/conn.go
+++ b/pkg/flatrpc/conn.go
@@ -8,10 +8,9 @@ import (
"fmt"
"io"
"net"
- "os"
+ "reflect"
"slices"
"sync"
- "time"
flatbuffers "github.com/google/flatbuffers/go"
"github.com/google/syzkaller/pkg/log"
@@ -50,7 +49,7 @@ func ListenAndServe(addr string, handler func(*Conn)) (*Serv, error) {
continue
}
go func() {
- c := newConn(conn)
+ c := NewConn(conn)
defer c.Close()
handler(c)
}()
@@ -77,22 +76,7 @@ type Conn struct {
lastMsg int
}
-func Dial(addr string, timeScale time.Duration) (*Conn, error) {
- var conn net.Conn
- var err error
- if addr == "stdin" {
- // This is used by vm/gvisor which passes us a unix socket connection in stdin.
- conn, err = net.FileConn(os.Stdin)
- } else {
- conn, err = net.DialTimeout("tcp", addr, time.Minute*timeScale)
- }
- if err != nil {
- return nil, err
- }
- return newConn(conn), nil
-}
-
-func newConn(conn net.Conn) *Conn {
+func NewConn(conn net.Conn) *Conn {
return &Conn{
conn: conn,
builder: flatbuffers.NewBuilder(0),
@@ -125,14 +109,31 @@ func Send[T sendMsg](c *Conn, msg T) error {
return nil
}
-// Recv received an RPC message.
-// The type T is supposed to be a normal flatbuffers type (not ending with T, e.g. ConnectRequest).
+// Recv receives an RPC message.
+// The type T is supposed to be a pointer to a normal flatbuffers type (not ending with T, e.g. *ConnectRequestRaw).
// Receiving should be done from a single goroutine, the received message is valid
// only until the next Recv call (messages share the same underlying receive buffer).
-func Recv[T any, PT interface {
- *T
+func Recv[Raw interface {
+ UnPack() *T
flatbuffers.FlatBuffer
-}](c *Conn) (*T, error) {
+}, T any](c *Conn) (res *T, err0 error) {
+ defer func() {
+ if err1 := recover(); err1 != nil {
+ if err2, ok := err1.(error); ok {
+ err0 = err2
+ } else {
+ err0 = fmt.Errorf("%v", err1)
+ }
+ }
+ }()
+ raw, err := RecvRaw[Raw](c)
+ if err != nil {
+ return nil, err
+ }
+ return raw.UnPack(), nil
+}
+
+func RecvRaw[T flatbuffers.FlatBuffer](c *Conn) (T, error) {
// First, discard the previous message.
// For simplicity we copy any data from the next message to the beginning of the buffer.
// Theoretically we could something more efficient, e.g. don't copy if we already
@@ -146,21 +147,24 @@ func Recv[T any, PT interface {
sizePrefixSize = flatbuffers.SizeUint32
maxMessageSize = 64 << 20
)
- msg := PT(new(T))
+ var msg T
// Then, receive at least the size prefix (4 bytes).
// And then the full message, if we have not got it yet.
if err := c.recv(sizePrefixSize); err != nil {
- return nil, fmt.Errorf("failed to recv %T: %w", msg, err)
+ return msg, fmt.Errorf("failed to recv %T: %w", msg, err)
}
size := int(flatbuffers.GetSizePrefix(c.data, 0))
if size > maxMessageSize {
- return nil, fmt.Errorf("message %T has too large size %v", msg, size)
+ return msg, fmt.Errorf("message %T has too large size %v", msg, size)
}
c.lastMsg = sizePrefixSize + size
if err := c.recv(c.lastMsg); err != nil {
- return nil, fmt.Errorf("failed to recv %T: %w", msg, err)
+ return msg, fmt.Errorf("failed to recv %T: %w", msg, err)
}
statRecv.Add(c.lastMsg)
+ // This probably can't be expressed w/o reflect as "new U" where U is *T,
+ // but I failed to express that as generic constraints.
+ msg = reflect.New(reflect.TypeOf(msg).Elem()).Interface().(T)
data := c.data[sizePrefixSize:c.lastMsg]
msg.Init(data, flatbuffers.GetUOffsetT(data))
return msg, nil
diff --git a/pkg/flatrpc/conn_test.go b/pkg/flatrpc/conn_test.go
index 38b9e6980..a6f7f23f9 100644
--- a/pkg/flatrpc/conn_test.go
+++ b/pkg/flatrpc/conn_test.go
@@ -4,7 +4,11 @@
package flatrpc
import (
+ "net"
+ "os"
+ "syscall"
"testing"
+ "time"
"github.com/stretchr/testify/assert"
)
@@ -40,22 +44,22 @@ func TestConn(t *testing.T) {
}()
serv, err := ListenAndServe(":0", func(c *Conn) {
defer close(done)
- connectReqGot, err := Recv[ConnectRequestRaw](c)
+ connectReqGot, err := Recv[*ConnectRequestRaw](c)
if err != nil {
t.Fatal(err)
}
- assert.Equal(t, connectReq, connectReqGot.UnPack())
+ assert.Equal(t, connectReq, connectReqGot)
if err := Send(c, connectReply); err != nil {
t.Fatal(err)
}
for i := 0; i < 10; i++ {
- got, err := Recv[ExecutorMessageRaw](c)
+ got, err := Recv[*ExecutorMessageRaw](c)
if err != nil {
t.Fatal(err)
}
- assert.Equal(t, executorMsg, got.UnPack())
+ assert.Equal(t, executorMsg, got)
}
})
if err != nil {
@@ -63,21 +67,18 @@ func TestConn(t *testing.T) {
}
defer serv.Close()
- c, err := Dial(serv.Addr.String(), 1)
- if err != nil {
- t.Fatal(err)
- }
+ c := dial(t, serv.Addr.String())
defer c.Close()
if err := Send(c, connectReq); err != nil {
t.Fatal(err)
}
- connectReplyGot, err := Recv[ConnectReplyRaw](c)
+ connectReplyGot, err := Recv[*ConnectReplyRaw](c)
if err != nil {
t.Fatal(err)
}
- assert.Equal(t, connectReply, connectReplyGot.UnPack())
+ assert.Equal(t, connectReply, connectReplyGot)
for i := 0; i < 10; i++ {
if err := Send(c, executorMsg); err != nil {
@@ -108,7 +109,7 @@ func BenchmarkConn(b *testing.B) {
serv, err := ListenAndServe(":0", func(c *Conn) {
defer close(done)
for i := 0; i < b.N; i++ {
- _, err := Recv[ConnectRequestRaw](c)
+ _, err := Recv[*ConnectRequestRaw](c)
if err != nil {
b.Fatal(err)
}
@@ -122,10 +123,7 @@ func BenchmarkConn(b *testing.B) {
}
defer serv.Close()
- c, err := Dial(serv.Addr.String(), 1)
- if err != nil {
- b.Fatal(err)
- }
+ c := dial(b, serv.Addr.String())
defer c.Close()
b.ReportAllocs()
@@ -134,9 +132,46 @@ func BenchmarkConn(b *testing.B) {
if err := Send(c, connectReq); err != nil {
b.Fatal(err)
}
- _, err := Recv[ConnectReplyRaw](c)
+ _, err := Recv[*ConnectReplyRaw](c)
if err != nil {
b.Fatal(err)
}
}
}
+
+func dial(t testing.TB, addr string) *Conn {
+ conn, err := net.DialTimeout("tcp", addr, time.Minute)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return NewConn(conn)
+}
+
+func FuzzRecv(f *testing.F) {
+ f.Fuzz(func(t *testing.T, data []byte) {
+ data = data[:min(len(data), 1<<10)]
+ fds, err := syscall.Socketpair(syscall.AF_LOCAL, syscall.SOCK_STREAM, 0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ w := os.NewFile(uintptr(fds[0]), "")
+ r := os.NewFile(uintptr(fds[1]), "")
+ defer w.Close()
+ defer r.Close()
+ if _, err := w.Write(data); err != nil {
+ t.Fatal(err)
+ }
+ w.Close()
+ n, err := net.FileConn(r)
+ if err != nil {
+ t.Fatal(err)
+ }
+ c := NewConn(n)
+ for {
+ _, err := Recv[*ExecutorMessageRaw](c)
+ if err != nil {
+ break
+ }
+ }
+ })
+}
diff --git a/pkg/flatrpc/flatrpc.fbs b/pkg/flatrpc/flatrpc.fbs
index 78adc8ec5..b51ea0c70 100644
--- a/pkg/flatrpc/flatrpc.fbs
+++ b/pkg/flatrpc/flatrpc.fbs
@@ -8,6 +8,7 @@ enum Feature : uint64 (bit_flags) {
Comparisons,
ExtraCoverage,
DelayKcovMmap,
+ SandboxNone,
SandboxSetuid,
SandboxNamespace,
SandboxAndroid,
@@ -35,8 +36,11 @@ table ConnectRequestRaw {
table ConnectReplyRaw {
debug :bool;
+ cover :bool;
procs :int32;
slowdown :int32;
+ syscall_timeout_ms :int32;
+ program_timeout_ms :int32;
leak_frames :[string];
race_frames :[string];
// Fuzzer sets up these features and returns results in InfoRequest.features.
@@ -79,7 +83,8 @@ table FeatureInfoRaw {
union HostMessagesRaw {
ExecRequest :ExecRequestRaw,
SignalUpdate :SignalUpdateRaw,
- StartLeakChecks :StartLeakChecksRaw
+ StartLeakChecks :StartLeakChecksRaw,
+ StateRequest :StateRequestRaw,
}
table HostMessageRaw {
@@ -90,6 +95,7 @@ table HostMessageRaw {
union ExecutorMessagesRaw {
ExecResult :ExecResultRaw,
Executing :ExecutingMessageRaw,
+ State :StateResultRaw,
}
table ExecutorMessageRaw {
@@ -100,8 +106,6 @@ enum RequestFlag : uint64 (bit_flags) {
// If set, prog_data contains compiled executable binary
// that needs to be written to disk and executed.
IsBinary,
- // If set, fully reset executor state befor executing the test.
- ResetState,
// If set, collect program output and return in output field.
ReturnOutput,
// If set, don't fail on program failures, instead return the error in error field.
@@ -112,6 +116,8 @@ enum RequestFlag : uint64 (bit_flags) {
enum ExecEnv : uint64 (bit_flags) {
Debug, // debug output from executor
Signal, // collect feedback signals (coverage)
+ ResetState, // fully reset executor state befor executing the test
+ SandboxNone, // minimal sandboxing
SandboxSetuid, // impersonate nobody user
SandboxNamespace, // use namespaces for sandboxing
SandboxAndroid, // use Android sandboxing for the untrusted_app domain
@@ -150,12 +156,8 @@ table ExecRequestRaw {
prog_data :[uint8];
exec_opts :ExecOptsRaw;
flags :RequestFlag;
- signal_filter :[uint64];
- signal_filter_call :int32;
// Return all signal for these calls.
all_signal :[int32];
- // Repeat the program that many times (0 means 1).
- repeat :int32;
}
table SignalUpdateRaw {
@@ -169,6 +171,9 @@ table SignalUpdateRaw {
table StartLeakChecksRaw {
}
+table StateRequestRaw {
+}
+
// Notification from the executor that it started executing the program 'id'.
// We want this request to be as small and as fast as possible b/c we need it
// to reach the host (or at least leave the VM) before the VM crashes
@@ -209,6 +214,8 @@ struct ComparisonRaw {
table ProgInfoRaw {
calls :[CallInfoRaw];
// Contains signal and cover collected from background threads.
+ // The raw version is exported by executor, and them merged into extra on the host.
+ extra_raw :[CallInfoRaw];
extra :CallInfoRaw;
// Total execution time of the program in nanoseconds.
elapsed :uint64;
@@ -223,3 +230,7 @@ table ExecResultRaw {
error :string;
info :ProgInfoRaw;
}
+
+table StateResultRaw {
+ data :[uint8];
+}
diff --git a/pkg/flatrpc/flatrpc.go b/pkg/flatrpc/flatrpc.go
index b561334fe..28c28ca8e 100644
--- a/pkg/flatrpc/flatrpc.go
+++ b/pkg/flatrpc/flatrpc.go
@@ -15,22 +15,23 @@ const (
FeatureComparisons Feature = 2
FeatureExtraCoverage Feature = 4
FeatureDelayKcovMmap Feature = 8
- FeatureSandboxSetuid Feature = 16
- FeatureSandboxNamespace Feature = 32
- FeatureSandboxAndroid Feature = 64
- FeatureFault Feature = 128
- FeatureLeak Feature = 256
- FeatureNetInjection Feature = 512
- FeatureNetDevices Feature = 1024
- FeatureKCSAN Feature = 2048
- FeatureDevlinkPCI Feature = 4096
- FeatureNicVF Feature = 8192
- FeatureUSBEmulation Feature = 16384
- FeatureVhciInjection Feature = 32768
- FeatureWifiEmulation Feature = 65536
- FeatureLRWPANEmulation Feature = 131072
- FeatureBinFmtMisc Feature = 262144
- FeatureSwap Feature = 524288
+ FeatureSandboxNone Feature = 16
+ FeatureSandboxSetuid Feature = 32
+ FeatureSandboxNamespace Feature = 64
+ FeatureSandboxAndroid Feature = 128
+ FeatureFault Feature = 256
+ FeatureLeak Feature = 512
+ FeatureNetInjection Feature = 1024
+ FeatureNetDevices Feature = 2048
+ FeatureKCSAN Feature = 4096
+ FeatureDevlinkPCI Feature = 8192
+ FeatureNicVF Feature = 16384
+ FeatureUSBEmulation Feature = 32768
+ FeatureVhciInjection Feature = 65536
+ FeatureWifiEmulation Feature = 131072
+ FeatureLRWPANEmulation Feature = 262144
+ FeatureBinFmtMisc Feature = 524288
+ FeatureSwap Feature = 1048576
)
var EnumNamesFeature = map[Feature]string{
@@ -38,6 +39,7 @@ var EnumNamesFeature = map[Feature]string{
FeatureComparisons: "Comparisons",
FeatureExtraCoverage: "ExtraCoverage",
FeatureDelayKcovMmap: "DelayKcovMmap",
+ FeatureSandboxNone: "SandboxNone",
FeatureSandboxSetuid: "SandboxSetuid",
FeatureSandboxNamespace: "SandboxNamespace",
FeatureSandboxAndroid: "SandboxAndroid",
@@ -61,6 +63,7 @@ var EnumValuesFeature = map[string]Feature{
"Comparisons": FeatureComparisons,
"ExtraCoverage": FeatureExtraCoverage,
"DelayKcovMmap": FeatureDelayKcovMmap,
+ "SandboxNone": FeatureSandboxNone,
"SandboxSetuid": FeatureSandboxSetuid,
"SandboxNamespace": FeatureSandboxNamespace,
"SandboxAndroid": FeatureSandboxAndroid,
@@ -93,6 +96,7 @@ const (
HostMessagesRawExecRequest HostMessagesRaw = 1
HostMessagesRawSignalUpdate HostMessagesRaw = 2
HostMessagesRawStartLeakChecks HostMessagesRaw = 3
+ HostMessagesRawStateRequest HostMessagesRaw = 4
)
var EnumNamesHostMessagesRaw = map[HostMessagesRaw]string{
@@ -100,6 +104,7 @@ var EnumNamesHostMessagesRaw = map[HostMessagesRaw]string{
HostMessagesRawExecRequest: "ExecRequest",
HostMessagesRawSignalUpdate: "SignalUpdate",
HostMessagesRawStartLeakChecks: "StartLeakChecks",
+ HostMessagesRawStateRequest: "StateRequest",
}
var EnumValuesHostMessagesRaw = map[string]HostMessagesRaw{
@@ -107,6 +112,7 @@ var EnumValuesHostMessagesRaw = map[string]HostMessagesRaw{
"ExecRequest": HostMessagesRawExecRequest,
"SignalUpdate": HostMessagesRawSignalUpdate,
"StartLeakChecks": HostMessagesRawStartLeakChecks,
+ "StateRequest": HostMessagesRawStateRequest,
}
func (v HostMessagesRaw) String() string {
@@ -132,6 +138,8 @@ func (t *HostMessagesRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse
return t.Value.(*SignalUpdateRawT).Pack(builder)
case HostMessagesRawStartLeakChecks:
return t.Value.(*StartLeakChecksRawT).Pack(builder)
+ case HostMessagesRawStateRequest:
+ return t.Value.(*StateRequestRawT).Pack(builder)
}
return 0
}
@@ -147,6 +155,9 @@ func (rcv HostMessagesRaw) UnPack(table flatbuffers.Table) *HostMessagesRawT {
case HostMessagesRawStartLeakChecks:
x := StartLeakChecksRaw{_tab: table}
return &HostMessagesRawT{Type: HostMessagesRawStartLeakChecks, Value: x.UnPack()}
+ case HostMessagesRawStateRequest:
+ x := StateRequestRaw{_tab: table}
+ return &HostMessagesRawT{Type: HostMessagesRawStateRequest, Value: x.UnPack()}
}
return nil
}
@@ -157,18 +168,21 @@ const (
ExecutorMessagesRawNONE ExecutorMessagesRaw = 0
ExecutorMessagesRawExecResult ExecutorMessagesRaw = 1
ExecutorMessagesRawExecuting ExecutorMessagesRaw = 2
+ ExecutorMessagesRawState ExecutorMessagesRaw = 3
)
var EnumNamesExecutorMessagesRaw = map[ExecutorMessagesRaw]string{
ExecutorMessagesRawNONE: "NONE",
ExecutorMessagesRawExecResult: "ExecResult",
ExecutorMessagesRawExecuting: "Executing",
+ ExecutorMessagesRawState: "State",
}
var EnumValuesExecutorMessagesRaw = map[string]ExecutorMessagesRaw{
"NONE": ExecutorMessagesRawNONE,
"ExecResult": ExecutorMessagesRawExecResult,
"Executing": ExecutorMessagesRawExecuting,
+ "State": ExecutorMessagesRawState,
}
func (v ExecutorMessagesRaw) String() string {
@@ -192,6 +206,8 @@ func (t *ExecutorMessagesRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UO
return t.Value.(*ExecResultRawT).Pack(builder)
case ExecutorMessagesRawExecuting:
return t.Value.(*ExecutingMessageRawT).Pack(builder)
+ case ExecutorMessagesRawState:
+ return t.Value.(*StateResultRawT).Pack(builder)
}
return 0
}
@@ -204,6 +220,9 @@ func (rcv ExecutorMessagesRaw) UnPack(table flatbuffers.Table) *ExecutorMessages
case ExecutorMessagesRawExecuting:
x := ExecutingMessageRaw{_tab: table}
return &ExecutorMessagesRawT{Type: ExecutorMessagesRawExecuting, Value: x.UnPack()}
+ case ExecutorMessagesRawState:
+ x := StateResultRaw{_tab: table}
+ return &ExecutorMessagesRawT{Type: ExecutorMessagesRawState, Value: x.UnPack()}
}
return nil
}
@@ -212,21 +231,18 @@ type RequestFlag uint64
const (
RequestFlagIsBinary RequestFlag = 1
- RequestFlagResetState RequestFlag = 2
- RequestFlagReturnOutput RequestFlag = 4
- RequestFlagReturnError RequestFlag = 8
+ RequestFlagReturnOutput RequestFlag = 2
+ RequestFlagReturnError RequestFlag = 4
)
var EnumNamesRequestFlag = map[RequestFlag]string{
RequestFlagIsBinary: "IsBinary",
- RequestFlagResetState: "ResetState",
RequestFlagReturnOutput: "ReturnOutput",
RequestFlagReturnError: "ReturnError",
}
var EnumValuesRequestFlag = map[string]RequestFlag{
"IsBinary": RequestFlagIsBinary,
- "ResetState": RequestFlagResetState,
"ReturnOutput": RequestFlagReturnOutput,
"ReturnError": RequestFlagReturnError,
}
@@ -243,25 +259,29 @@ type ExecEnv uint64
const (
ExecEnvDebug ExecEnv = 1
ExecEnvSignal ExecEnv = 2
- ExecEnvSandboxSetuid ExecEnv = 4
- ExecEnvSandboxNamespace ExecEnv = 8
- ExecEnvSandboxAndroid ExecEnv = 16
- ExecEnvExtraCover ExecEnv = 32
- ExecEnvEnableTun ExecEnv = 64
- ExecEnvEnableNetDev ExecEnv = 128
- ExecEnvEnableNetReset ExecEnv = 256
- ExecEnvEnableCgroups ExecEnv = 512
- ExecEnvEnableCloseFds ExecEnv = 1024
- ExecEnvEnableDevlinkPCI ExecEnv = 2048
- ExecEnvEnableVhciInjection ExecEnv = 4096
- ExecEnvEnableWifi ExecEnv = 8192
- ExecEnvDelayKcovMmap ExecEnv = 16384
- ExecEnvEnableNicVF ExecEnv = 32768
+ ExecEnvResetState ExecEnv = 4
+ ExecEnvSandboxNone ExecEnv = 8
+ ExecEnvSandboxSetuid ExecEnv = 16
+ ExecEnvSandboxNamespace ExecEnv = 32
+ ExecEnvSandboxAndroid ExecEnv = 64
+ ExecEnvExtraCover ExecEnv = 128
+ ExecEnvEnableTun ExecEnv = 256
+ ExecEnvEnableNetDev ExecEnv = 512
+ ExecEnvEnableNetReset ExecEnv = 1024
+ ExecEnvEnableCgroups ExecEnv = 2048
+ ExecEnvEnableCloseFds ExecEnv = 4096
+ ExecEnvEnableDevlinkPCI ExecEnv = 8192
+ ExecEnvEnableVhciInjection ExecEnv = 16384
+ ExecEnvEnableWifi ExecEnv = 32768
+ ExecEnvDelayKcovMmap ExecEnv = 65536
+ ExecEnvEnableNicVF ExecEnv = 131072
)
var EnumNamesExecEnv = map[ExecEnv]string{
ExecEnvDebug: "Debug",
ExecEnvSignal: "Signal",
+ ExecEnvResetState: "ResetState",
+ ExecEnvSandboxNone: "SandboxNone",
ExecEnvSandboxSetuid: "SandboxSetuid",
ExecEnvSandboxNamespace: "SandboxNamespace",
ExecEnvSandboxAndroid: "SandboxAndroid",
@@ -281,6 +301,8 @@ var EnumNamesExecEnv = map[ExecEnv]string{
var EnumValuesExecEnv = map[string]ExecEnv{
"Debug": ExecEnvDebug,
"Signal": ExecEnvSignal,
+ "ResetState": ExecEnvResetState,
+ "SandboxNone": ExecEnvSandboxNone,
"SandboxSetuid": ExecEnvSandboxSetuid,
"SandboxNamespace": ExecEnvSandboxNamespace,
"SandboxAndroid": ExecEnvSandboxAndroid,
@@ -485,14 +507,17 @@ func ConnectRequestRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
}
type ConnectReplyRawT struct {
- Debug bool `json:"debug"`
- Procs int32 `json:"procs"`
- Slowdown int32 `json:"slowdown"`
- LeakFrames []string `json:"leak_frames"`
- RaceFrames []string `json:"race_frames"`
- Features Feature `json:"features"`
- Files []string `json:"files"`
- Globs []string `json:"globs"`
+ Debug bool `json:"debug"`
+ Cover bool `json:"cover"`
+ Procs int32 `json:"procs"`
+ Slowdown int32 `json:"slowdown"`
+ SyscallTimeoutMs int32 `json:"syscall_timeout_ms"`
+ ProgramTimeoutMs int32 `json:"program_timeout_ms"`
+ LeakFrames []string `json:"leak_frames"`
+ RaceFrames []string `json:"race_frames"`
+ Features Feature `json:"features"`
+ Files []string `json:"files"`
+ Globs []string `json:"globs"`
}
func (t *ConnectReplyRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -553,8 +578,11 @@ func (t *ConnectReplyRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse
}
ConnectReplyRawStart(builder)
ConnectReplyRawAddDebug(builder, t.Debug)
+ ConnectReplyRawAddCover(builder, t.Cover)
ConnectReplyRawAddProcs(builder, t.Procs)
ConnectReplyRawAddSlowdown(builder, t.Slowdown)
+ ConnectReplyRawAddSyscallTimeoutMs(builder, t.SyscallTimeoutMs)
+ ConnectReplyRawAddProgramTimeoutMs(builder, t.ProgramTimeoutMs)
ConnectReplyRawAddLeakFrames(builder, leakFramesOffset)
ConnectReplyRawAddRaceFrames(builder, raceFramesOffset)
ConnectReplyRawAddFeatures(builder, t.Features)
@@ -565,8 +593,11 @@ func (t *ConnectReplyRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse
func (rcv *ConnectReplyRaw) UnPackTo(t *ConnectReplyRawT) {
t.Debug = rcv.Debug()
+ t.Cover = rcv.Cover()
t.Procs = rcv.Procs()
t.Slowdown = rcv.Slowdown()
+ t.SyscallTimeoutMs = rcv.SyscallTimeoutMs()
+ t.ProgramTimeoutMs = rcv.ProgramTimeoutMs()
leakFramesLength := rcv.LeakFramesLength()
t.LeakFrames = make([]string, leakFramesLength)
for j := 0; j < leakFramesLength; j++ {
@@ -638,20 +669,32 @@ func (rcv *ConnectReplyRaw) MutateDebug(n bool) bool {
return rcv._tab.MutateBoolSlot(4, n)
}
-func (rcv *ConnectReplyRaw) Procs() int32 {
+func (rcv *ConnectReplyRaw) Cover() bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
+ return rcv._tab.GetBool(o + rcv._tab.Pos)
+ }
+ return false
+}
+
+func (rcv *ConnectReplyRaw) MutateCover(n bool) bool {
+ return rcv._tab.MutateBoolSlot(6, n)
+}
+
+func (rcv *ConnectReplyRaw) Procs() int32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
return rcv._tab.GetInt32(o + rcv._tab.Pos)
}
return 0
}
func (rcv *ConnectReplyRaw) MutateProcs(n int32) bool {
- return rcv._tab.MutateInt32Slot(6, n)
+ return rcv._tab.MutateInt32Slot(8, n)
}
func (rcv *ConnectReplyRaw) Slowdown() int32 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
if o != 0 {
return rcv._tab.GetInt32(o + rcv._tab.Pos)
}
@@ -659,11 +702,35 @@ func (rcv *ConnectReplyRaw) Slowdown() int32 {
}
func (rcv *ConnectReplyRaw) MutateSlowdown(n int32) bool {
- return rcv._tab.MutateInt32Slot(8, n)
+ return rcv._tab.MutateInt32Slot(10, n)
+}
+
+func (rcv *ConnectReplyRaw) SyscallTimeoutMs() int32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+ if o != 0 {
+ return rcv._tab.GetInt32(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ConnectReplyRaw) MutateSyscallTimeoutMs(n int32) bool {
+ return rcv._tab.MutateInt32Slot(12, n)
+}
+
+func (rcv *ConnectReplyRaw) ProgramTimeoutMs() int32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+ if o != 0 {
+ return rcv._tab.GetInt32(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ConnectReplyRaw) MutateProgramTimeoutMs(n int32) bool {
+ return rcv._tab.MutateInt32Slot(14, n)
}
func (rcv *ConnectReplyRaw) LeakFrames(j int) []byte {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
if o != 0 {
a := rcv._tab.Vector(o)
return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
@@ -672,7 +739,7 @@ func (rcv *ConnectReplyRaw) LeakFrames(j int) []byte {
}
func (rcv *ConnectReplyRaw) LeakFramesLength() int {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
if o != 0 {
return rcv._tab.VectorLen(o)
}
@@ -680,7 +747,7 @@ func (rcv *ConnectReplyRaw) LeakFramesLength() int {
}
func (rcv *ConnectReplyRaw) RaceFrames(j int) []byte {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
if o != 0 {
a := rcv._tab.Vector(o)
return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
@@ -689,7 +756,7 @@ func (rcv *ConnectReplyRaw) RaceFrames(j int) []byte {
}
func (rcv *ConnectReplyRaw) RaceFramesLength() int {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
if o != 0 {
return rcv._tab.VectorLen(o)
}
@@ -697,7 +764,7 @@ func (rcv *ConnectReplyRaw) RaceFramesLength() int {
}
func (rcv *ConnectReplyRaw) Features() Feature {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
if o != 0 {
return Feature(rcv._tab.GetUint64(o + rcv._tab.Pos))
}
@@ -705,11 +772,11 @@ func (rcv *ConnectReplyRaw) Features() Feature {
}
func (rcv *ConnectReplyRaw) MutateFeatures(n Feature) bool {
- return rcv._tab.MutateUint64Slot(14, uint64(n))
+ return rcv._tab.MutateUint64Slot(20, uint64(n))
}
func (rcv *ConnectReplyRaw) Files(j int) []byte {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
if o != 0 {
a := rcv._tab.Vector(o)
return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
@@ -718,7 +785,7 @@ func (rcv *ConnectReplyRaw) Files(j int) []byte {
}
func (rcv *ConnectReplyRaw) FilesLength() int {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
if o != 0 {
return rcv._tab.VectorLen(o)
}
@@ -726,7 +793,7 @@ func (rcv *ConnectReplyRaw) FilesLength() int {
}
func (rcv *ConnectReplyRaw) Globs(j int) []byte {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
if o != 0 {
a := rcv._tab.Vector(o)
return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
@@ -735,7 +802,7 @@ func (rcv *ConnectReplyRaw) Globs(j int) []byte {
}
func (rcv *ConnectReplyRaw) GlobsLength() int {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
if o != 0 {
return rcv._tab.VectorLen(o)
}
@@ -743,40 +810,49 @@ func (rcv *ConnectReplyRaw) GlobsLength() int {
}
func ConnectReplyRawStart(builder *flatbuffers.Builder) {
- builder.StartObject(8)
+ builder.StartObject(11)
}
func ConnectReplyRawAddDebug(builder *flatbuffers.Builder, debug bool) {
builder.PrependBoolSlot(0, debug, false)
}
+func ConnectReplyRawAddCover(builder *flatbuffers.Builder, cover bool) {
+ builder.PrependBoolSlot(1, cover, false)
+}
func ConnectReplyRawAddProcs(builder *flatbuffers.Builder, procs int32) {
- builder.PrependInt32Slot(1, procs, 0)
+ builder.PrependInt32Slot(2, procs, 0)
}
func ConnectReplyRawAddSlowdown(builder *flatbuffers.Builder, slowdown int32) {
- builder.PrependInt32Slot(2, slowdown, 0)
+ builder.PrependInt32Slot(3, slowdown, 0)
+}
+func ConnectReplyRawAddSyscallTimeoutMs(builder *flatbuffers.Builder, syscallTimeoutMs int32) {
+ builder.PrependInt32Slot(4, syscallTimeoutMs, 0)
+}
+func ConnectReplyRawAddProgramTimeoutMs(builder *flatbuffers.Builder, programTimeoutMs int32) {
+ builder.PrependInt32Slot(5, programTimeoutMs, 0)
}
func ConnectReplyRawAddLeakFrames(builder *flatbuffers.Builder, leakFrames flatbuffers.UOffsetT) {
- builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(leakFrames), 0)
+ builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(leakFrames), 0)
}
func ConnectReplyRawStartLeakFramesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func ConnectReplyRawAddRaceFrames(builder *flatbuffers.Builder, raceFrames flatbuffers.UOffsetT) {
- builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(raceFrames), 0)
+ builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(raceFrames), 0)
}
func ConnectReplyRawStartRaceFramesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func ConnectReplyRawAddFeatures(builder *flatbuffers.Builder, features Feature) {
- builder.PrependUint64Slot(5, uint64(features), 0)
+ builder.PrependUint64Slot(8, uint64(features), 0)
}
func ConnectReplyRawAddFiles(builder *flatbuffers.Builder, files flatbuffers.UOffsetT) {
- builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(files), 0)
+ builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(files), 0)
}
func ConnectReplyRawStartFilesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func ConnectReplyRawAddGlobs(builder *flatbuffers.Builder, globs flatbuffers.UOffsetT) {
- builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(globs), 0)
+ builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(globs), 0)
}
func ConnectReplyRawStartGlobsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
@@ -1741,14 +1817,11 @@ func CreateExecOptsRaw(builder *flatbuffers.Builder, envFlags ExecEnv, execFlags
}
type ExecRequestRawT struct {
- Id int64 `json:"id"`
- ProgData []byte `json:"prog_data"`
- ExecOpts *ExecOptsRawT `json:"exec_opts"`
- Flags RequestFlag `json:"flags"`
- SignalFilter []uint64 `json:"signal_filter"`
- SignalFilterCall int32 `json:"signal_filter_call"`
- AllSignal []int32 `json:"all_signal"`
- Repeat int32 `json:"repeat"`
+ Id int64 `json:"id"`
+ ProgData []byte `json:"prog_data"`
+ ExecOpts *ExecOptsRawT `json:"exec_opts"`
+ Flags RequestFlag `json:"flags"`
+ AllSignal []int32 `json:"all_signal"`
}
func (t *ExecRequestRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -1759,15 +1832,6 @@ func (t *ExecRequestRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffset
if t.ProgData != nil {
progDataOffset = builder.CreateByteString(t.ProgData)
}
- signalFilterOffset := flatbuffers.UOffsetT(0)
- if t.SignalFilter != nil {
- signalFilterLength := len(t.SignalFilter)
- ExecRequestRawStartSignalFilterVector(builder, signalFilterLength)
- for j := signalFilterLength - 1; j >= 0; j-- {
- builder.PrependUint64(t.SignalFilter[j])
- }
- signalFilterOffset = builder.EndVector(signalFilterLength)
- }
allSignalOffset := flatbuffers.UOffsetT(0)
if t.AllSignal != nil {
allSignalLength := len(t.AllSignal)
@@ -1783,10 +1847,7 @@ func (t *ExecRequestRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffset
execOptsOffset := t.ExecOpts.Pack(builder)
ExecRequestRawAddExecOpts(builder, execOptsOffset)
ExecRequestRawAddFlags(builder, t.Flags)
- ExecRequestRawAddSignalFilter(builder, signalFilterOffset)
- ExecRequestRawAddSignalFilterCall(builder, t.SignalFilterCall)
ExecRequestRawAddAllSignal(builder, allSignalOffset)
- ExecRequestRawAddRepeat(builder, t.Repeat)
return ExecRequestRawEnd(builder)
}
@@ -1795,18 +1856,11 @@ func (rcv *ExecRequestRaw) UnPackTo(t *ExecRequestRawT) {
t.ProgData = rcv.ProgDataBytes()
t.ExecOpts = rcv.ExecOpts(nil).UnPack()
t.Flags = rcv.Flags()
- signalFilterLength := rcv.SignalFilterLength()
- t.SignalFilter = make([]uint64, signalFilterLength)
- for j := 0; j < signalFilterLength; j++ {
- t.SignalFilter[j] = rcv.SignalFilter(j)
- }
- t.SignalFilterCall = rcv.SignalFilterCall()
allSignalLength := rcv.AllSignalLength()
t.AllSignal = make([]int32, allSignalLength)
for j := 0; j < allSignalLength; j++ {
t.AllSignal[j] = rcv.AllSignal(j)
}
- t.Repeat = rcv.Repeat()
}
func (rcv *ExecRequestRaw) UnPack() *ExecRequestRawT {
@@ -1916,46 +1970,8 @@ func (rcv *ExecRequestRaw) MutateFlags(n RequestFlag) bool {
return rcv._tab.MutateUint64Slot(10, uint64(n))
}
-func (rcv *ExecRequestRaw) SignalFilter(j int) uint64 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
- if o != 0 {
- a := rcv._tab.Vector(o)
- return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8))
- }
- return 0
-}
-
-func (rcv *ExecRequestRaw) SignalFilterLength() int {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
- if o != 0 {
- return rcv._tab.VectorLen(o)
- }
- return 0
-}
-
-func (rcv *ExecRequestRaw) MutateSignalFilter(j int, n uint64) bool {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
- if o != 0 {
- a := rcv._tab.Vector(o)
- return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n)
- }
- return false
-}
-
-func (rcv *ExecRequestRaw) SignalFilterCall() int32 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
- if o != 0 {
- return rcv._tab.GetInt32(o + rcv._tab.Pos)
- }
- return 0
-}
-
-func (rcv *ExecRequestRaw) MutateSignalFilterCall(n int32) bool {
- return rcv._tab.MutateInt32Slot(14, n)
-}
-
func (rcv *ExecRequestRaw) AllSignal(j int) int32 {
- 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.GetInt32(a + flatbuffers.UOffsetT(j*4))
@@ -1964,7 +1980,7 @@ func (rcv *ExecRequestRaw) AllSignal(j int) int32 {
}
func (rcv *ExecRequestRaw) AllSignalLength() int {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
return rcv._tab.VectorLen(o)
}
@@ -1972,7 +1988,7 @@ func (rcv *ExecRequestRaw) AllSignalLength() int {
}
func (rcv *ExecRequestRaw) MutateAllSignal(j int, n int32) 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.MutateInt32(a+flatbuffers.UOffsetT(j*4), n)
@@ -1980,20 +1996,8 @@ func (rcv *ExecRequestRaw) MutateAllSignal(j int, n int32) bool {
return false
}
-func (rcv *ExecRequestRaw) Repeat() int32 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
- if o != 0 {
- return rcv._tab.GetInt32(o + rcv._tab.Pos)
- }
- return 0
-}
-
-func (rcv *ExecRequestRaw) MutateRepeat(n int32) bool {
- return rcv._tab.MutateInt32Slot(18, n)
-}
-
func ExecRequestRawStart(builder *flatbuffers.Builder) {
- builder.StartObject(8)
+ builder.StartObject(5)
}
func ExecRequestRawAddId(builder *flatbuffers.Builder, id int64) {
builder.PrependInt64Slot(0, id, 0)
@@ -2010,24 +2014,12 @@ func ExecRequestRawAddExecOpts(builder *flatbuffers.Builder, execOpts flatbuffer
func ExecRequestRawAddFlags(builder *flatbuffers.Builder, flags RequestFlag) {
builder.PrependUint64Slot(3, uint64(flags), 0)
}
-func ExecRequestRawAddSignalFilter(builder *flatbuffers.Builder, signalFilter flatbuffers.UOffsetT) {
- builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(signalFilter), 0)
-}
-func ExecRequestRawStartSignalFilterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
- return builder.StartVector(8, numElems, 8)
-}
-func ExecRequestRawAddSignalFilterCall(builder *flatbuffers.Builder, signalFilterCall int32) {
- builder.PrependInt32Slot(5, signalFilterCall, 0)
-}
func ExecRequestRawAddAllSignal(builder *flatbuffers.Builder, allSignal flatbuffers.UOffsetT) {
- builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(allSignal), 0)
+ builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(allSignal), 0)
}
func ExecRequestRawStartAllSignalVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
-func ExecRequestRawAddRepeat(builder *flatbuffers.Builder, repeat int32) {
- builder.PrependInt32Slot(7, repeat, 0)
-}
func ExecRequestRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
@@ -2242,6 +2234,63 @@ func StartLeakChecksRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
+type StateRequestRawT struct {
+}
+
+func (t *StateRequestRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ StateRequestRawStart(builder)
+ return StateRequestRawEnd(builder)
+}
+
+func (rcv *StateRequestRaw) UnPackTo(t *StateRequestRawT) {
+}
+
+func (rcv *StateRequestRaw) UnPack() *StateRequestRawT {
+ if rcv == nil {
+ return nil
+ }
+ t := &StateRequestRawT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type StateRequestRaw struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsStateRequestRaw(buf []byte, offset flatbuffers.UOffsetT) *StateRequestRaw {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &StateRequestRaw{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsStateRequestRaw(buf []byte, offset flatbuffers.UOffsetT) *StateRequestRaw {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &StateRequestRaw{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *StateRequestRaw) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *StateRequestRaw) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func StateRequestRawStart(builder *flatbuffers.Builder) {
+ builder.StartObject(0)
+}
+func StateRequestRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
type ExecutingMessageRawT struct {
Id int64 `json:"id"`
ProcId int32 `json:"proc_id"`
@@ -2664,6 +2713,7 @@ func CreateComparisonRaw(builder *flatbuffers.Builder, op1 uint64, op2 uint64) f
type ProgInfoRawT struct {
Calls []*CallInfoRawT `json:"calls"`
+ ExtraRaw []*CallInfoRawT `json:"extra_raw"`
Extra *CallInfoRawT `json:"extra"`
Elapsed uint64 `json:"elapsed"`
Freshness uint64 `json:"freshness"`
@@ -2686,9 +2736,23 @@ func (t *ProgInfoRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
}
callsOffset = builder.EndVector(callsLength)
}
+ extraRawOffset := flatbuffers.UOffsetT(0)
+ if t.ExtraRaw != nil {
+ extraRawLength := len(t.ExtraRaw)
+ extraRawOffsets := make([]flatbuffers.UOffsetT, extraRawLength)
+ for j := 0; j < extraRawLength; j++ {
+ extraRawOffsets[j] = t.ExtraRaw[j].Pack(builder)
+ }
+ ProgInfoRawStartExtraRawVector(builder, extraRawLength)
+ for j := extraRawLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(extraRawOffsets[j])
+ }
+ extraRawOffset = builder.EndVector(extraRawLength)
+ }
extraOffset := t.Extra.Pack(builder)
ProgInfoRawStart(builder)
ProgInfoRawAddCalls(builder, callsOffset)
+ ProgInfoRawAddExtraRaw(builder, extraRawOffset)
ProgInfoRawAddExtra(builder, extraOffset)
ProgInfoRawAddElapsed(builder, t.Elapsed)
ProgInfoRawAddFreshness(builder, t.Freshness)
@@ -2703,6 +2767,13 @@ func (rcv *ProgInfoRaw) UnPackTo(t *ProgInfoRawT) {
rcv.Calls(&x, j)
t.Calls[j] = x.UnPack()
}
+ extraRawLength := rcv.ExtraRawLength()
+ t.ExtraRaw = make([]*CallInfoRawT, extraRawLength)
+ for j := 0; j < extraRawLength; j++ {
+ x := CallInfoRaw{}
+ rcv.ExtraRaw(&x, j)
+ t.ExtraRaw[j] = x.UnPack()
+ }
t.Extra = rcv.Extra(nil).UnPack()
t.Elapsed = rcv.Elapsed()
t.Freshness = rcv.Freshness()
@@ -2764,9 +2835,29 @@ func (rcv *ProgInfoRaw) CallsLength() int {
return 0
}
-func (rcv *ProgInfoRaw) Extra(obj *CallInfoRaw) *CallInfoRaw {
+func (rcv *ProgInfoRaw) ExtraRaw(obj *CallInfoRaw, j int) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ x := rcv._tab.Vector(o)
+ x += flatbuffers.UOffsetT(j) * 4
+ x = rcv._tab.Indirect(x)
+ obj.Init(rcv._tab.Bytes, x)
+ return true
+ }
+ return false
+}
+
+func (rcv *ProgInfoRaw) ExtraRawLength() int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *ProgInfoRaw) Extra(obj *CallInfoRaw) *CallInfoRaw {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
x := rcv._tab.Indirect(o + rcv._tab.Pos)
if obj == nil {
obj = new(CallInfoRaw)
@@ -2778,7 +2869,7 @@ func (rcv *ProgInfoRaw) Extra(obj *CallInfoRaw) *CallInfoRaw {
}
func (rcv *ProgInfoRaw) Elapsed() uint64 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
if o != 0 {
return rcv._tab.GetUint64(o + rcv._tab.Pos)
}
@@ -2786,11 +2877,11 @@ func (rcv *ProgInfoRaw) Elapsed() uint64 {
}
func (rcv *ProgInfoRaw) MutateElapsed(n uint64) bool {
- return rcv._tab.MutateUint64Slot(8, n)
+ return rcv._tab.MutateUint64Slot(10, n)
}
func (rcv *ProgInfoRaw) Freshness() uint64 {
- o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
return rcv._tab.GetUint64(o + rcv._tab.Pos)
}
@@ -2798,11 +2889,11 @@ func (rcv *ProgInfoRaw) Freshness() uint64 {
}
func (rcv *ProgInfoRaw) MutateFreshness(n uint64) bool {
- return rcv._tab.MutateUint64Slot(10, n)
+ return rcv._tab.MutateUint64Slot(12, n)
}
func ProgInfoRawStart(builder *flatbuffers.Builder) {
- builder.StartObject(4)
+ builder.StartObject(5)
}
func ProgInfoRawAddCalls(builder *flatbuffers.Builder, calls flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(calls), 0)
@@ -2810,14 +2901,20 @@ func ProgInfoRawAddCalls(builder *flatbuffers.Builder, calls flatbuffers.UOffset
func ProgInfoRawStartCallsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
+func ProgInfoRawAddExtraRaw(builder *flatbuffers.Builder, extraRaw flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(extraRaw), 0)
+}
+func ProgInfoRawStartExtraRawVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
func ProgInfoRawAddExtra(builder *flatbuffers.Builder, extra flatbuffers.UOffsetT) {
- builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(extra), 0)
+ builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(extra), 0)
}
func ProgInfoRawAddElapsed(builder *flatbuffers.Builder, elapsed uint64) {
- builder.PrependUint64Slot(2, elapsed, 0)
+ builder.PrependUint64Slot(3, elapsed, 0)
}
func ProgInfoRawAddFreshness(builder *flatbuffers.Builder, freshness uint64) {
- builder.PrependUint64Slot(3, freshness, 0)
+ builder.PrependUint64Slot(4, freshness, 0)
}
func ProgInfoRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
@@ -2979,3 +3076,107 @@ func ExecResultRawAddInfo(builder *flatbuffers.Builder, info flatbuffers.UOffset
func ExecResultRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
+
+type StateResultRawT struct {
+ Data []byte `json:"data"`
+}
+
+func (t *StateResultRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ dataOffset := flatbuffers.UOffsetT(0)
+ if t.Data != nil {
+ dataOffset = builder.CreateByteString(t.Data)
+ }
+ StateResultRawStart(builder)
+ StateResultRawAddData(builder, dataOffset)
+ return StateResultRawEnd(builder)
+}
+
+func (rcv *StateResultRaw) UnPackTo(t *StateResultRawT) {
+ t.Data = rcv.DataBytes()
+}
+
+func (rcv *StateResultRaw) UnPack() *StateResultRawT {
+ if rcv == nil {
+ return nil
+ }
+ t := &StateResultRawT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type StateResultRaw struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsStateResultRaw(buf []byte, offset flatbuffers.UOffsetT) *StateResultRaw {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &StateResultRaw{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsStateResultRaw(buf []byte, offset flatbuffers.UOffsetT) *StateResultRaw {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &StateResultRaw{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *StateResultRaw) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *StateResultRaw) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *StateResultRaw) Data(j int) byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
+ }
+ return 0
+}
+
+func (rcv *StateResultRaw) DataLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *StateResultRaw) DataBytes() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *StateResultRaw) MutateData(j int, n byte) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
+ }
+ return false
+}
+
+func StateResultRawStart(builder *flatbuffers.Builder) {
+ builder.StartObject(1)
+}
+func StateResultRawAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(data), 0)
+}
+func StateResultRawStartDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(1, numElems, 1)
+}
+func StateResultRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
diff --git a/pkg/flatrpc/flatrpc.h b/pkg/flatrpc/flatrpc.h
index d430e48f2..6f448c410 100644
--- a/pkg/flatrpc/flatrpc.h
+++ b/pkg/flatrpc/flatrpc.h
@@ -65,6 +65,10 @@ struct StartLeakChecksRaw;
struct StartLeakChecksRawBuilder;
struct StartLeakChecksRawT;
+struct StateRequestRaw;
+struct StateRequestRawBuilder;
+struct StateRequestRawT;
+
struct ExecutingMessageRaw;
struct ExecutingMessageRawBuilder;
struct ExecutingMessageRawT;
@@ -83,38 +87,44 @@ struct ExecResultRaw;
struct ExecResultRawBuilder;
struct ExecResultRawT;
+struct StateResultRaw;
+struct StateResultRawBuilder;
+struct StateResultRawT;
+
enum class Feature : uint64_t {
Coverage = 1ULL,
Comparisons = 2ULL,
ExtraCoverage = 4ULL,
DelayKcovMmap = 8ULL,
- SandboxSetuid = 16ULL,
- SandboxNamespace = 32ULL,
- SandboxAndroid = 64ULL,
- Fault = 128ULL,
- Leak = 256ULL,
- NetInjection = 512ULL,
- NetDevices = 1024ULL,
- KCSAN = 2048ULL,
- DevlinkPCI = 4096ULL,
- NicVF = 8192ULL,
- USBEmulation = 16384ULL,
- VhciInjection = 32768ULL,
- WifiEmulation = 65536ULL,
- LRWPANEmulation = 131072ULL,
- BinFmtMisc = 262144ULL,
- Swap = 524288ULL,
+ SandboxNone = 16ULL,
+ SandboxSetuid = 32ULL,
+ SandboxNamespace = 64ULL,
+ SandboxAndroid = 128ULL,
+ Fault = 256ULL,
+ Leak = 512ULL,
+ NetInjection = 1024ULL,
+ NetDevices = 2048ULL,
+ KCSAN = 4096ULL,
+ DevlinkPCI = 8192ULL,
+ NicVF = 16384ULL,
+ USBEmulation = 32768ULL,
+ VhciInjection = 65536ULL,
+ WifiEmulation = 131072ULL,
+ LRWPANEmulation = 262144ULL,
+ BinFmtMisc = 524288ULL,
+ Swap = 1048576ULL,
NONE = 0,
- ANY = 1048575ULL
+ ANY = 2097151ULL
};
FLATBUFFERS_DEFINE_BITMASK_OPERATORS(Feature, uint64_t)
-inline const Feature (&EnumValuesFeature())[20] {
+inline const Feature (&EnumValuesFeature())[21] {
static const Feature values[] = {
Feature::Coverage,
Feature::Comparisons,
Feature::ExtraCoverage,
Feature::DelayKcovMmap,
+ Feature::SandboxNone,
Feature::SandboxSetuid,
Feature::SandboxNamespace,
Feature::SandboxAndroid,
@@ -141,6 +151,7 @@ inline const char *EnumNameFeature(Feature e) {
case Feature::Comparisons: return "Comparisons";
case Feature::ExtraCoverage: return "ExtraCoverage";
case Feature::DelayKcovMmap: return "DelayKcovMmap";
+ case Feature::SandboxNone: return "SandboxNone";
case Feature::SandboxSetuid: return "SandboxSetuid";
case Feature::SandboxNamespace: return "SandboxNamespace";
case Feature::SandboxAndroid: return "SandboxAndroid";
@@ -166,33 +177,36 @@ enum class HostMessagesRaw : uint8_t {
ExecRequest = 1,
SignalUpdate = 2,
StartLeakChecks = 3,
+ StateRequest = 4,
MIN = NONE,
- MAX = StartLeakChecks
+ MAX = StateRequest
};
-inline const HostMessagesRaw (&EnumValuesHostMessagesRaw())[4] {
+inline const HostMessagesRaw (&EnumValuesHostMessagesRaw())[5] {
static const HostMessagesRaw values[] = {
HostMessagesRaw::NONE,
HostMessagesRaw::ExecRequest,
HostMessagesRaw::SignalUpdate,
- HostMessagesRaw::StartLeakChecks
+ HostMessagesRaw::StartLeakChecks,
+ HostMessagesRaw::StateRequest
};
return values;
}
inline const char * const *EnumNamesHostMessagesRaw() {
- static const char * const names[5] = {
+ static const char * const names[6] = {
"NONE",
"ExecRequest",
"SignalUpdate",
"StartLeakChecks",
+ "StateRequest",
nullptr
};
return names;
}
inline const char *EnumNameHostMessagesRaw(HostMessagesRaw e) {
- if (flatbuffers::IsOutRange(e, HostMessagesRaw::NONE, HostMessagesRaw::StartLeakChecks)) return "";
+ if (flatbuffers::IsOutRange(e, HostMessagesRaw::NONE, HostMessagesRaw::StateRequest)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesHostMessagesRaw()[index];
}
@@ -213,6 +227,10 @@ template<> struct HostMessagesRawTraits<rpc::StartLeakChecksRaw> {
static const HostMessagesRaw enum_value = HostMessagesRaw::StartLeakChecks;
};
+template<> struct HostMessagesRawTraits<rpc::StateRequestRaw> {
+ static const HostMessagesRaw enum_value = HostMessagesRaw::StateRequest;
+};
+
template<typename T> struct HostMessagesRawUnionTraits {
static const HostMessagesRaw enum_value = HostMessagesRaw::NONE;
};
@@ -229,6 +247,10 @@ template<> struct HostMessagesRawUnionTraits<rpc::StartLeakChecksRawT> {
static const HostMessagesRaw enum_value = HostMessagesRaw::StartLeakChecks;
};
+template<> struct HostMessagesRawUnionTraits<rpc::StateRequestRawT> {
+ static const HostMessagesRaw enum_value = HostMessagesRaw::StateRequest;
+};
+
struct HostMessagesRawUnion {
HostMessagesRaw type;
void *value;
@@ -283,6 +305,14 @@ struct HostMessagesRawUnion {
return type == HostMessagesRaw::StartLeakChecks ?
reinterpret_cast<const rpc::StartLeakChecksRawT *>(value) : nullptr;
}
+ rpc::StateRequestRawT *AsStateRequest() {
+ return type == HostMessagesRaw::StateRequest ?
+ reinterpret_cast<rpc::StateRequestRawT *>(value) : nullptr;
+ }
+ const rpc::StateRequestRawT *AsStateRequest() const {
+ return type == HostMessagesRaw::StateRequest ?
+ reinterpret_cast<const rpc::StateRequestRawT *>(value) : nullptr;
+ }
};
bool VerifyHostMessagesRaw(flatbuffers::Verifier &verifier, const void *obj, HostMessagesRaw type);
@@ -292,31 +322,34 @@ enum class ExecutorMessagesRaw : uint8_t {
NONE = 0,
ExecResult = 1,
Executing = 2,
+ State = 3,
MIN = NONE,
- MAX = Executing
+ MAX = State
};
-inline const ExecutorMessagesRaw (&EnumValuesExecutorMessagesRaw())[3] {
+inline const ExecutorMessagesRaw (&EnumValuesExecutorMessagesRaw())[4] {
static const ExecutorMessagesRaw values[] = {
ExecutorMessagesRaw::NONE,
ExecutorMessagesRaw::ExecResult,
- ExecutorMessagesRaw::Executing
+ ExecutorMessagesRaw::Executing,
+ ExecutorMessagesRaw::State
};
return values;
}
inline const char * const *EnumNamesExecutorMessagesRaw() {
- static const char * const names[4] = {
+ static const char * const names[5] = {
"NONE",
"ExecResult",
"Executing",
+ "State",
nullptr
};
return names;
}
inline const char *EnumNameExecutorMessagesRaw(ExecutorMessagesRaw e) {
- if (flatbuffers::IsOutRange(e, ExecutorMessagesRaw::NONE, ExecutorMessagesRaw::Executing)) return "";
+ if (flatbuffers::IsOutRange(e, ExecutorMessagesRaw::NONE, ExecutorMessagesRaw::State)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesExecutorMessagesRaw()[index];
}
@@ -333,6 +366,10 @@ template<> struct ExecutorMessagesRawTraits<rpc::ExecutingMessageRaw> {
static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::Executing;
};
+template<> struct ExecutorMessagesRawTraits<rpc::StateResultRaw> {
+ static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::State;
+};
+
template<typename T> struct ExecutorMessagesRawUnionTraits {
static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::NONE;
};
@@ -345,6 +382,10 @@ template<> struct ExecutorMessagesRawUnionTraits<rpc::ExecutingMessageRawT> {
static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::Executing;
};
+template<> struct ExecutorMessagesRawUnionTraits<rpc::StateResultRawT> {
+ static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::State;
+};
+
struct ExecutorMessagesRawUnion {
ExecutorMessagesRaw type;
void *value;
@@ -391,6 +432,14 @@ struct ExecutorMessagesRawUnion {
return type == ExecutorMessagesRaw::Executing ?
reinterpret_cast<const rpc::ExecutingMessageRawT *>(value) : nullptr;
}
+ rpc::StateResultRawT *AsState() {
+ return type == ExecutorMessagesRaw::State ?
+ reinterpret_cast<rpc::StateResultRawT *>(value) : nullptr;
+ }
+ const rpc::StateResultRawT *AsState() const {
+ return type == ExecutorMessagesRaw::State ?
+ reinterpret_cast<const rpc::StateResultRawT *>(value) : nullptr;
+ }
};
bool VerifyExecutorMessagesRaw(flatbuffers::Verifier &verifier, const void *obj, ExecutorMessagesRaw type);
@@ -398,18 +447,16 @@ bool VerifyExecutorMessagesRawVector(flatbuffers::Verifier &verifier, const flat
enum class RequestFlag : uint64_t {
IsBinary = 1ULL,
- ResetState = 2ULL,
- ReturnOutput = 4ULL,
- ReturnError = 8ULL,
+ ReturnOutput = 2ULL,
+ ReturnError = 4ULL,
NONE = 0,
- ANY = 15ULL
+ ANY = 7ULL
};
FLATBUFFERS_DEFINE_BITMASK_OPERATORS(RequestFlag, uint64_t)
-inline const RequestFlag (&EnumValuesRequestFlag())[4] {
+inline const RequestFlag (&EnumValuesRequestFlag())[3] {
static const RequestFlag values[] = {
RequestFlag::IsBinary,
- RequestFlag::ResetState,
RequestFlag::ReturnOutput,
RequestFlag::ReturnError
};
@@ -417,14 +464,10 @@ inline const RequestFlag (&EnumValuesRequestFlag())[4] {
}
inline const char * const *EnumNamesRequestFlag() {
- static const char * const names[9] = {
+ static const char * const names[5] = {
"IsBinary",
- "ResetState",
- "",
"ReturnOutput",
"",
- "",
- "",
"ReturnError",
nullptr
};
@@ -440,29 +483,33 @@ inline const char *EnumNameRequestFlag(RequestFlag e) {
enum class ExecEnv : uint64_t {
Debug = 1ULL,
Signal = 2ULL,
- SandboxSetuid = 4ULL,
- SandboxNamespace = 8ULL,
- SandboxAndroid = 16ULL,
- ExtraCover = 32ULL,
- EnableTun = 64ULL,
- EnableNetDev = 128ULL,
- EnableNetReset = 256ULL,
- EnableCgroups = 512ULL,
- EnableCloseFds = 1024ULL,
- EnableDevlinkPCI = 2048ULL,
- EnableVhciInjection = 4096ULL,
- EnableWifi = 8192ULL,
- DelayKcovMmap = 16384ULL,
- EnableNicVF = 32768ULL,
+ ResetState = 4ULL,
+ SandboxNone = 8ULL,
+ SandboxSetuid = 16ULL,
+ SandboxNamespace = 32ULL,
+ SandboxAndroid = 64ULL,
+ ExtraCover = 128ULL,
+ EnableTun = 256ULL,
+ EnableNetDev = 512ULL,
+ EnableNetReset = 1024ULL,
+ EnableCgroups = 2048ULL,
+ EnableCloseFds = 4096ULL,
+ EnableDevlinkPCI = 8192ULL,
+ EnableVhciInjection = 16384ULL,
+ EnableWifi = 32768ULL,
+ DelayKcovMmap = 65536ULL,
+ EnableNicVF = 131072ULL,
NONE = 0,
- ANY = 65535ULL
+ ANY = 262143ULL
};
FLATBUFFERS_DEFINE_BITMASK_OPERATORS(ExecEnv, uint64_t)
-inline const ExecEnv (&EnumValuesExecEnv())[16] {
+inline const ExecEnv (&EnumValuesExecEnv())[18] {
static const ExecEnv values[] = {
ExecEnv::Debug,
ExecEnv::Signal,
+ ExecEnv::ResetState,
+ ExecEnv::SandboxNone,
ExecEnv::SandboxSetuid,
ExecEnv::SandboxNamespace,
ExecEnv::SandboxAndroid,
@@ -485,6 +532,8 @@ inline const char *EnumNameExecEnv(ExecEnv e) {
switch (e) {
case ExecEnv::Debug: return "Debug";
case ExecEnv::Signal: return "Signal";
+ case ExecEnv::ResetState: return "ResetState";
+ case ExecEnv::SandboxNone: return "SandboxNone";
case ExecEnv::SandboxSetuid: return "SandboxSetuid";
case ExecEnv::SandboxNamespace: return "SandboxNamespace";
case ExecEnv::SandboxAndroid: return "SandboxAndroid";
@@ -757,8 +806,11 @@ flatbuffers::Offset<ConnectRequestRaw> CreateConnectRequestRaw(flatbuffers::Flat
struct ConnectReplyRawT : public flatbuffers::NativeTable {
typedef ConnectReplyRaw TableType;
bool debug = false;
+ bool cover = false;
int32_t procs = 0;
int32_t slowdown = 0;
+ int32_t syscall_timeout_ms = 0;
+ int32_t program_timeout_ms = 0;
std::vector<std::string> leak_frames{};
std::vector<std::string> race_frames{};
rpc::Feature features = static_cast<rpc::Feature>(0);
@@ -771,23 +823,35 @@ struct ConnectReplyRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ConnectReplyRawBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DEBUG = 4,
- VT_PROCS = 6,
- VT_SLOWDOWN = 8,
- VT_LEAK_FRAMES = 10,
- VT_RACE_FRAMES = 12,
- VT_FEATURES = 14,
- VT_FILES = 16,
- VT_GLOBS = 18
+ VT_COVER = 6,
+ VT_PROCS = 8,
+ VT_SLOWDOWN = 10,
+ VT_SYSCALL_TIMEOUT_MS = 12,
+ VT_PROGRAM_TIMEOUT_MS = 14,
+ VT_LEAK_FRAMES = 16,
+ VT_RACE_FRAMES = 18,
+ VT_FEATURES = 20,
+ VT_FILES = 22,
+ VT_GLOBS = 24
};
bool debug() const {
return GetField<uint8_t>(VT_DEBUG, 0) != 0;
}
+ bool cover() const {
+ return GetField<uint8_t>(VT_COVER, 0) != 0;
+ }
int32_t procs() const {
return GetField<int32_t>(VT_PROCS, 0);
}
int32_t slowdown() const {
return GetField<int32_t>(VT_SLOWDOWN, 0);
}
+ int32_t syscall_timeout_ms() const {
+ return GetField<int32_t>(VT_SYSCALL_TIMEOUT_MS, 0);
+ }
+ int32_t program_timeout_ms() const {
+ return GetField<int32_t>(VT_PROGRAM_TIMEOUT_MS, 0);
+ }
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *leak_frames() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_LEAK_FRAMES);
}
@@ -806,8 +870,11 @@ struct ConnectReplyRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_DEBUG, 1) &&
+ VerifyField<uint8_t>(verifier, VT_COVER, 1) &&
VerifyField<int32_t>(verifier, VT_PROCS, 4) &&
VerifyField<int32_t>(verifier, VT_SLOWDOWN, 4) &&
+ VerifyField<int32_t>(verifier, VT_SYSCALL_TIMEOUT_MS, 4) &&
+ VerifyField<int32_t>(verifier, VT_PROGRAM_TIMEOUT_MS, 4) &&
VerifyOffset(verifier, VT_LEAK_FRAMES) &&
verifier.VerifyVector(leak_frames()) &&
verifier.VerifyVectorOfStrings(leak_frames()) &&
@@ -835,12 +902,21 @@ struct ConnectReplyRawBuilder {
void add_debug(bool debug) {
fbb_.AddElement<uint8_t>(ConnectReplyRaw::VT_DEBUG, static_cast<uint8_t>(debug), 0);
}
+ void add_cover(bool cover) {
+ fbb_.AddElement<uint8_t>(ConnectReplyRaw::VT_COVER, static_cast<uint8_t>(cover), 0);
+ }
void add_procs(int32_t procs) {
fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_PROCS, procs, 0);
}
void add_slowdown(int32_t slowdown) {
fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_SLOWDOWN, slowdown, 0);
}
+ void add_syscall_timeout_ms(int32_t syscall_timeout_ms) {
+ fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_SYSCALL_TIMEOUT_MS, syscall_timeout_ms, 0);
+ }
+ void add_program_timeout_ms(int32_t program_timeout_ms) {
+ fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_PROGRAM_TIMEOUT_MS, program_timeout_ms, 0);
+ }
void add_leak_frames(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> leak_frames) {
fbb_.AddOffset(ConnectReplyRaw::VT_LEAK_FRAMES, leak_frames);
}
@@ -870,8 +946,11 @@ struct ConnectReplyRawBuilder {
inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(
flatbuffers::FlatBufferBuilder &_fbb,
bool debug = false,
+ bool cover = false,
int32_t procs = 0,
int32_t slowdown = 0,
+ int32_t syscall_timeout_ms = 0,
+ int32_t program_timeout_ms = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> leak_frames = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> race_frames = 0,
rpc::Feature features = static_cast<rpc::Feature>(0),
@@ -883,8 +962,11 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(
builder_.add_files(files);
builder_.add_race_frames(race_frames);
builder_.add_leak_frames(leak_frames);
+ builder_.add_program_timeout_ms(program_timeout_ms);
+ builder_.add_syscall_timeout_ms(syscall_timeout_ms);
builder_.add_slowdown(slowdown);
builder_.add_procs(procs);
+ builder_.add_cover(cover);
builder_.add_debug(debug);
return builder_.Finish();
}
@@ -892,8 +974,11 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(
inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRawDirect(
flatbuffers::FlatBufferBuilder &_fbb,
bool debug = false,
+ bool cover = false,
int32_t procs = 0,
int32_t slowdown = 0,
+ int32_t syscall_timeout_ms = 0,
+ int32_t program_timeout_ms = 0,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *leak_frames = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *race_frames = nullptr,
rpc::Feature features = static_cast<rpc::Feature>(0),
@@ -906,8 +991,11 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRawDirect(
return rpc::CreateConnectReplyRaw(
_fbb,
debug,
+ cover,
procs,
slowdown,
+ syscall_timeout_ms,
+ program_timeout_ms,
leak_frames__,
race_frames__,
features,
@@ -1392,6 +1480,9 @@ struct HostMessageRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const rpc::StartLeakChecksRaw *msg_as_StartLeakChecks() const {
return msg_type() == rpc::HostMessagesRaw::StartLeakChecks ? static_cast<const rpc::StartLeakChecksRaw *>(msg()) : nullptr;
}
+ const rpc::StateRequestRaw *msg_as_StateRequest() const {
+ return msg_type() == rpc::HostMessagesRaw::StateRequest ? static_cast<const rpc::StateRequestRaw *>(msg()) : nullptr;
+ }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MSG_TYPE, 1) &&
@@ -1416,6 +1507,10 @@ template<> inline const rpc::StartLeakChecksRaw *HostMessageRaw::msg_as<rpc::Sta
return msg_as_StartLeakChecks();
}
+template<> inline const rpc::StateRequestRaw *HostMessageRaw::msg_as<rpc::StateRequestRaw>() const {
+ return msg_as_StateRequest();
+}
+
struct HostMessageRawBuilder {
typedef HostMessageRaw Table;
flatbuffers::FlatBufferBuilder &fbb_;
@@ -1474,6 +1569,9 @@ struct ExecutorMessageRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const rpc::ExecutingMessageRaw *msg_as_Executing() const {
return msg_type() == rpc::ExecutorMessagesRaw::Executing ? static_cast<const rpc::ExecutingMessageRaw *>(msg()) : nullptr;
}
+ const rpc::StateResultRaw *msg_as_State() const {
+ return msg_type() == rpc::ExecutorMessagesRaw::State ? static_cast<const rpc::StateResultRaw *>(msg()) : nullptr;
+ }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MSG_TYPE, 1) &&
@@ -1494,6 +1592,10 @@ template<> inline const rpc::ExecutingMessageRaw *ExecutorMessageRaw::msg_as<rpc
return msg_as_Executing();
}
+template<> inline const rpc::StateResultRaw *ExecutorMessageRaw::msg_as<rpc::StateResultRaw>() const {
+ return msg_as_State();
+}
+
struct ExecutorMessageRawBuilder {
typedef ExecutorMessageRaw Table;
flatbuffers::FlatBufferBuilder &fbb_;
@@ -1533,10 +1635,7 @@ struct ExecRequestRawT : public flatbuffers::NativeTable {
std::vector<uint8_t> prog_data{};
std::unique_ptr<rpc::ExecOptsRaw> exec_opts{};
rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0);
- std::vector<uint64_t> signal_filter{};
- int32_t signal_filter_call = 0;
std::vector<int32_t> all_signal{};
- int32_t repeat = 0;
ExecRequestRawT() = default;
ExecRequestRawT(const ExecRequestRawT &o);
ExecRequestRawT(ExecRequestRawT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1551,10 +1650,7 @@ struct ExecRequestRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_PROG_DATA = 6,
VT_EXEC_OPTS = 8,
VT_FLAGS = 10,
- VT_SIGNAL_FILTER = 12,
- VT_SIGNAL_FILTER_CALL = 14,
- VT_ALL_SIGNAL = 16,
- VT_REPEAT = 18
+ VT_ALL_SIGNAL = 12
};
int64_t id() const {
return GetField<int64_t>(VT_ID, 0);
@@ -1568,18 +1664,9 @@ struct ExecRequestRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
rpc::RequestFlag flags() const {
return static_cast<rpc::RequestFlag>(GetField<uint64_t>(VT_FLAGS, 0));
}
- const flatbuffers::Vector<uint64_t> *signal_filter() const {
- return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_SIGNAL_FILTER);
- }
- int32_t signal_filter_call() const {
- return GetField<int32_t>(VT_SIGNAL_FILTER_CALL, 0);
- }
const flatbuffers::Vector<int32_t> *all_signal() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_ALL_SIGNAL);
}
- int32_t repeat() const {
- return GetField<int32_t>(VT_REPEAT, 0);
- }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(verifier, VT_ID, 8) &&
@@ -1587,12 +1674,8 @@ struct ExecRequestRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(prog_data()) &&
VerifyField<rpc::ExecOptsRaw>(verifier, VT_EXEC_OPTS, 8) &&
VerifyField<uint64_t>(verifier, VT_FLAGS, 8) &&
- VerifyOffset(verifier, VT_SIGNAL_FILTER) &&
- verifier.VerifyVector(signal_filter()) &&
- VerifyField<int32_t>(verifier, VT_SIGNAL_FILTER_CALL, 4) &&
VerifyOffset(verifier, VT_ALL_SIGNAL) &&
verifier.VerifyVector(all_signal()) &&
- VerifyField<int32_t>(verifier, VT_REPEAT, 4) &&
verifier.EndTable();
}
ExecRequestRawT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1616,18 +1699,9 @@ struct ExecRequestRawBuilder {
void add_flags(rpc::RequestFlag flags) {
fbb_.AddElement<uint64_t>(ExecRequestRaw::VT_FLAGS, static_cast<uint64_t>(flags), 0);
}
- void add_signal_filter(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> signal_filter) {
- fbb_.AddOffset(ExecRequestRaw::VT_SIGNAL_FILTER, signal_filter);
- }
- void add_signal_filter_call(int32_t signal_filter_call) {
- fbb_.AddElement<int32_t>(ExecRequestRaw::VT_SIGNAL_FILTER_CALL, signal_filter_call, 0);
- }
void add_all_signal(flatbuffers::Offset<flatbuffers::Vector<int32_t>> all_signal) {
fbb_.AddOffset(ExecRequestRaw::VT_ALL_SIGNAL, all_signal);
}
- void add_repeat(int32_t repeat) {
- fbb_.AddElement<int32_t>(ExecRequestRaw::VT_REPEAT, repeat, 0);
- }
explicit ExecRequestRawBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -1645,17 +1719,11 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> prog_data = 0,
const rpc::ExecOptsRaw *exec_opts = nullptr,
rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0),
- flatbuffers::Offset<flatbuffers::Vector<uint64_t>> signal_filter = 0,
- int32_t signal_filter_call = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> all_signal = 0,
- int32_t repeat = 0) {
+ flatbuffers::Offset<flatbuffers::Vector<int32_t>> all_signal = 0) {
ExecRequestRawBuilder builder_(_fbb);
builder_.add_flags(flags);
builder_.add_id(id);
- builder_.add_repeat(repeat);
builder_.add_all_signal(all_signal);
- 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();
@@ -1667,12 +1735,8 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRawDirect(
const std::vector<uint8_t> *prog_data = nullptr,
const rpc::ExecOptsRaw *exec_opts = nullptr,
rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0),
- const std::vector<uint64_t> *signal_filter = nullptr,
- int32_t signal_filter_call = 0,
- const std::vector<int32_t> *all_signal = nullptr,
- int32_t repeat = 0) {
+ const std::vector<int32_t> *all_signal = nullptr) {
auto prog_data__ = prog_data ? _fbb.CreateVector<uint8_t>(*prog_data) : 0;
- auto signal_filter__ = signal_filter ? _fbb.CreateVector<uint64_t>(*signal_filter) : 0;
auto all_signal__ = all_signal ? _fbb.CreateVector<int32_t>(*all_signal) : 0;
return rpc::CreateExecRequestRaw(
_fbb,
@@ -1680,10 +1744,7 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRawDirect(
prog_data__,
exec_opts,
flags,
- signal_filter__,
- signal_filter_call,
- all_signal__,
- repeat);
+ all_signal__);
}
flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestRawT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -1804,6 +1865,45 @@ inline flatbuffers::Offset<StartLeakChecksRaw> CreateStartLeakChecksRaw(
flatbuffers::Offset<StartLeakChecksRaw> CreateStartLeakChecksRaw(flatbuffers::FlatBufferBuilder &_fbb, const StartLeakChecksRawT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+struct StateRequestRawT : public flatbuffers::NativeTable {
+ typedef StateRequestRaw TableType;
+};
+
+struct StateRequestRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef StateRequestRawT NativeTableType;
+ typedef StateRequestRawBuilder Builder;
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ verifier.EndTable();
+ }
+ StateRequestRawT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(StateRequestRawT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<StateRequestRaw> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StateRequestRawT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct StateRequestRawBuilder {
+ typedef StateRequestRaw Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ explicit StateRequestRawBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<StateRequestRaw> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<StateRequestRaw>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<StateRequestRaw> CreateStateRequestRaw(
+ flatbuffers::FlatBufferBuilder &_fbb) {
+ StateRequestRawBuilder builder_(_fbb);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<StateRequestRaw> CreateStateRequestRaw(flatbuffers::FlatBufferBuilder &_fbb, const StateRequestRawT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
struct ExecutingMessageRawT : public flatbuffers::NativeTable {
typedef ExecutingMessageRaw TableType;
int64_t id = 0;
@@ -2010,6 +2110,7 @@ flatbuffers::Offset<CallInfoRaw> CreateCallInfoRaw(flatbuffers::FlatBufferBuilde
struct ProgInfoRawT : public flatbuffers::NativeTable {
typedef ProgInfoRaw TableType;
std::vector<std::unique_ptr<rpc::CallInfoRawT>> calls{};
+ std::vector<std::unique_ptr<rpc::CallInfoRawT>> extra_raw{};
std::unique_ptr<rpc::CallInfoRawT> extra{};
uint64_t elapsed = 0;
uint64_t freshness = 0;
@@ -2024,13 +2125,17 @@ struct ProgInfoRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ProgInfoRawBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_CALLS = 4,
- VT_EXTRA = 6,
- VT_ELAPSED = 8,
- VT_FRESHNESS = 10
+ VT_EXTRA_RAW = 6,
+ VT_EXTRA = 8,
+ VT_ELAPSED = 10,
+ VT_FRESHNESS = 12
};
const flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfoRaw>> *calls() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfoRaw>> *>(VT_CALLS);
}
+ const flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfoRaw>> *extra_raw() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfoRaw>> *>(VT_EXTRA_RAW);
+ }
const rpc::CallInfoRaw *extra() const {
return GetPointer<const rpc::CallInfoRaw *>(VT_EXTRA);
}
@@ -2045,6 +2150,9 @@ struct ProgInfoRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_CALLS) &&
verifier.VerifyVector(calls()) &&
verifier.VerifyVectorOfTables(calls()) &&
+ VerifyOffset(verifier, VT_EXTRA_RAW) &&
+ verifier.VerifyVector(extra_raw()) &&
+ verifier.VerifyVectorOfTables(extra_raw()) &&
VerifyOffset(verifier, VT_EXTRA) &&
verifier.VerifyTable(extra()) &&
VerifyField<uint64_t>(verifier, VT_ELAPSED, 8) &&
@@ -2063,6 +2171,9 @@ struct ProgInfoRawBuilder {
void add_calls(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfoRaw>>> calls) {
fbb_.AddOffset(ProgInfoRaw::VT_CALLS, calls);
}
+ void add_extra_raw(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfoRaw>>> extra_raw) {
+ fbb_.AddOffset(ProgInfoRaw::VT_EXTRA_RAW, extra_raw);
+ }
void add_extra(flatbuffers::Offset<rpc::CallInfoRaw> extra) {
fbb_.AddOffset(ProgInfoRaw::VT_EXTRA, extra);
}
@@ -2086,6 +2197,7 @@ struct ProgInfoRawBuilder {
inline flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRaw(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfoRaw>>> calls = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfoRaw>>> extra_raw = 0,
flatbuffers::Offset<rpc::CallInfoRaw> extra = 0,
uint64_t elapsed = 0,
uint64_t freshness = 0) {
@@ -2093,6 +2205,7 @@ inline flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRaw(
builder_.add_freshness(freshness);
builder_.add_elapsed(elapsed);
builder_.add_extra(extra);
+ builder_.add_extra_raw(extra_raw);
builder_.add_calls(calls);
return builder_.Finish();
}
@@ -2100,13 +2213,16 @@ inline flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRaw(
inline flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRawDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<flatbuffers::Offset<rpc::CallInfoRaw>> *calls = nullptr,
+ const std::vector<flatbuffers::Offset<rpc::CallInfoRaw>> *extra_raw = nullptr,
flatbuffers::Offset<rpc::CallInfoRaw> extra = 0,
uint64_t elapsed = 0,
uint64_t freshness = 0) {
auto calls__ = calls ? _fbb.CreateVector<flatbuffers::Offset<rpc::CallInfoRaw>>(*calls) : 0;
+ auto extra_raw__ = extra_raw ? _fbb.CreateVector<flatbuffers::Offset<rpc::CallInfoRaw>>(*extra_raw) : 0;
return rpc::CreateProgInfoRaw(
_fbb,
calls__,
+ extra_raw__,
extra,
elapsed,
freshness);
@@ -2222,6 +2338,68 @@ inline flatbuffers::Offset<ExecResultRaw> CreateExecResultRawDirect(
flatbuffers::Offset<ExecResultRaw> CreateExecResultRaw(flatbuffers::FlatBufferBuilder &_fbb, const ExecResultRawT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+struct StateResultRawT : public flatbuffers::NativeTable {
+ typedef StateResultRaw TableType;
+ std::vector<uint8_t> data{};
+};
+
+struct StateResultRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef StateResultRawT NativeTableType;
+ typedef StateResultRawBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_DATA = 4
+ };
+ const flatbuffers::Vector<uint8_t> *data() const {
+ return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_DATA) &&
+ verifier.VerifyVector(data()) &&
+ verifier.EndTable();
+ }
+ StateResultRawT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(StateResultRawT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<StateResultRaw> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StateResultRawT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct StateResultRawBuilder {
+ typedef StateResultRaw Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
+ fbb_.AddOffset(StateResultRaw::VT_DATA, data);
+ }
+ explicit StateResultRawBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<StateResultRaw> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<StateResultRaw>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<StateResultRaw> CreateStateResultRaw(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
+ StateResultRawBuilder builder_(_fbb);
+ builder_.add_data(data);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<StateResultRaw> CreateStateResultRawDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<uint8_t> *data = nullptr) {
+ auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
+ return rpc::CreateStateResultRaw(
+ _fbb,
+ data__);
+}
+
+flatbuffers::Offset<StateResultRaw> CreateStateResultRaw(flatbuffers::FlatBufferBuilder &_fbb, const StateResultRawT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
inline ConnectRequestRawT *ConnectRequestRaw::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<ConnectRequestRawT>(new ConnectRequestRawT());
UnPackTo(_o.get(), _resolver);
@@ -2267,8 +2445,11 @@ inline void ConnectReplyRaw::UnPackTo(ConnectReplyRawT *_o, const flatbuffers::r
(void)_o;
(void)_resolver;
{ auto _e = debug(); _o->debug = _e; }
+ { auto _e = cover(); _o->cover = _e; }
{ auto _e = procs(); _o->procs = _e; }
{ auto _e = slowdown(); _o->slowdown = _e; }
+ { auto _e = syscall_timeout_ms(); _o->syscall_timeout_ms = _e; }
+ { auto _e = program_timeout_ms(); _o->program_timeout_ms = _e; }
{ auto _e = leak_frames(); if (_e) { _o->leak_frames.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->leak_frames[_i] = _e->Get(_i)->str(); } } }
{ auto _e = race_frames(); if (_e) { _o->race_frames.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->race_frames[_i] = _e->Get(_i)->str(); } } }
{ auto _e = features(); _o->features = _e; }
@@ -2285,8 +2466,11 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(flatbuffers::F
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConnectReplyRawT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _debug = _o->debug;
+ auto _cover = _o->cover;
auto _procs = _o->procs;
auto _slowdown = _o->slowdown;
+ auto _syscall_timeout_ms = _o->syscall_timeout_ms;
+ auto _program_timeout_ms = _o->program_timeout_ms;
auto _leak_frames = _o->leak_frames.size() ? _fbb.CreateVectorOfStrings(_o->leak_frames) : 0;
auto _race_frames = _o->race_frames.size() ? _fbb.CreateVectorOfStrings(_o->race_frames) : 0;
auto _features = _o->features;
@@ -2295,8 +2479,11 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(flatbuffers::F
return rpc::CreateConnectReplyRaw(
_fbb,
_debug,
+ _cover,
_procs,
_slowdown,
+ _syscall_timeout_ms,
+ _program_timeout_ms,
_leak_frames,
_race_frames,
_features,
@@ -2542,10 +2729,7 @@ inline ExecRequestRawT::ExecRequestRawT(const ExecRequestRawT &o)
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),
- all_signal(o.all_signal),
- repeat(o.repeat) {
+ all_signal(o.all_signal) {
}
inline ExecRequestRawT &ExecRequestRawT::operator=(ExecRequestRawT o) FLATBUFFERS_NOEXCEPT {
@@ -2553,10 +2737,7 @@ inline ExecRequestRawT &ExecRequestRawT::operator=(ExecRequestRawT o) FLATBUFFER
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(all_signal, o.all_signal);
- std::swap(repeat, o.repeat);
return *this;
}
@@ -2573,10 +2754,7 @@ inline void ExecRequestRaw::UnPackTo(ExecRequestRawT *_o, const flatbuffers::res
{ 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 = 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 = all_signal(); if (_e) { _o->all_signal.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->all_signal[_i] = _e->Get(_i); } } }
- { auto _e = repeat(); _o->repeat = _e; }
}
inline flatbuffers::Offset<ExecRequestRaw> ExecRequestRaw::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestRawT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2591,20 +2769,14 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(flatbuffers::Fla
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 _signal_filter = _o->signal_filter.size() ? _fbb.CreateVector(_o->signal_filter) : 0;
- auto _signal_filter_call = _o->signal_filter_call;
auto _all_signal = _o->all_signal.size() ? _fbb.CreateVector(_o->all_signal) : 0;
- auto _repeat = _o->repeat;
return rpc::CreateExecRequestRaw(
_fbb,
_id,
_prog_data,
_exec_opts,
_flags,
- _signal_filter,
- _signal_filter_call,
- _all_signal,
- _repeat);
+ _all_signal);
}
inline SignalUpdateRawT *SignalUpdateRaw::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -2659,6 +2831,29 @@ inline flatbuffers::Offset<StartLeakChecksRaw> CreateStartLeakChecksRaw(flatbuff
_fbb);
}
+inline StateRequestRawT *StateRequestRaw::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = std::unique_ptr<StateRequestRawT>(new StateRequestRawT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void StateRequestRaw::UnPackTo(StateRequestRawT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+}
+
+inline flatbuffers::Offset<StateRequestRaw> StateRequestRaw::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StateRequestRawT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateStateRequestRaw(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<StateRequestRaw> CreateStateRequestRaw(flatbuffers::FlatBufferBuilder &_fbb, const StateRequestRawT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StateRequestRawT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ return rpc::CreateStateRequestRaw(
+ _fbb);
+}
+
inline ExecutingMessageRawT *ExecutingMessageRaw::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<ExecutingMessageRawT>(new ExecutingMessageRawT());
UnPackTo(_o.get(), _resolver);
@@ -2738,10 +2933,13 @@ inline ProgInfoRawT::ProgInfoRawT(const ProgInfoRawT &o)
freshness(o.freshness) {
calls.reserve(o.calls.size());
for (const auto &calls_ : o.calls) { calls.emplace_back((calls_) ? new rpc::CallInfoRawT(*calls_) : nullptr); }
+ extra_raw.reserve(o.extra_raw.size());
+ for (const auto &extra_raw_ : o.extra_raw) { extra_raw.emplace_back((extra_raw_) ? new rpc::CallInfoRawT(*extra_raw_) : nullptr); }
}
inline ProgInfoRawT &ProgInfoRawT::operator=(ProgInfoRawT o) FLATBUFFERS_NOEXCEPT {
std::swap(calls, o.calls);
+ std::swap(extra_raw, o.extra_raw);
std::swap(extra, o.extra);
std::swap(elapsed, o.elapsed);
std::swap(freshness, o.freshness);
@@ -2758,6 +2956,7 @@ inline void ProgInfoRaw::UnPackTo(ProgInfoRawT *_o, const flatbuffers::resolver_
(void)_o;
(void)_resolver;
{ auto _e = calls(); if (_e) { _o->calls.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->calls[_i] = std::unique_ptr<rpc::CallInfoRawT>(_e->Get(_i)->UnPack(_resolver)); } } }
+ { auto _e = extra_raw(); if (_e) { _o->extra_raw.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->extra_raw[_i] = std::unique_ptr<rpc::CallInfoRawT>(_e->Get(_i)->UnPack(_resolver)); } } }
{ auto _e = extra(); if (_e) _o->extra = std::unique_ptr<rpc::CallInfoRawT>(_e->UnPack(_resolver)); }
{ auto _e = elapsed(); _o->elapsed = _e; }
{ auto _e = freshness(); _o->freshness = _e; }
@@ -2772,12 +2971,14 @@ inline flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRaw(flatbuffers::FlatBuffe
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ProgInfoRawT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _calls = _o->calls.size() ? _fbb.CreateVector<flatbuffers::Offset<rpc::CallInfoRaw>> (_o->calls.size(), [](size_t i, _VectorArgs *__va) { return CreateCallInfoRaw(*__va->__fbb, __va->__o->calls[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _extra_raw = _o->extra_raw.size() ? _fbb.CreateVector<flatbuffers::Offset<rpc::CallInfoRaw>> (_o->extra_raw.size(), [](size_t i, _VectorArgs *__va) { return CreateCallInfoRaw(*__va->__fbb, __va->__o->extra_raw[i].get(), __va->__rehasher); }, &_va ) : 0;
auto _extra = _o->extra ? CreateCallInfoRaw(_fbb, _o->extra.get(), _rehasher) : 0;
auto _elapsed = _o->elapsed;
auto _freshness = _o->freshness;
return rpc::CreateProgInfoRaw(
_fbb,
_calls,
+ _extra_raw,
_extra,
_elapsed,
_freshness);
@@ -2833,6 +3034,32 @@ inline flatbuffers::Offset<ExecResultRaw> CreateExecResultRaw(flatbuffers::FlatB
_info);
}
+inline StateResultRawT *StateResultRaw::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = std::unique_ptr<StateResultRawT>(new StateResultRawT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void StateResultRaw::UnPackTo(StateResultRawT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } }
+}
+
+inline flatbuffers::Offset<StateResultRaw> StateResultRaw::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StateResultRawT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateStateResultRaw(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<StateResultRaw> CreateStateResultRaw(flatbuffers::FlatBufferBuilder &_fbb, const StateResultRawT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StateResultRawT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
+ return rpc::CreateStateResultRaw(
+ _fbb,
+ _data);
+}
+
inline bool VerifyHostMessagesRaw(flatbuffers::Verifier &verifier, const void *obj, HostMessagesRaw type) {
switch (type) {
case HostMessagesRaw::NONE: {
@@ -2850,6 +3077,10 @@ inline bool VerifyHostMessagesRaw(flatbuffers::Verifier &verifier, const void *o
auto ptr = reinterpret_cast<const rpc::StartLeakChecksRaw *>(obj);
return verifier.VerifyTable(ptr);
}
+ case HostMessagesRaw::StateRequest: {
+ auto ptr = reinterpret_cast<const rpc::StateRequestRaw *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
default: return true;
}
}
@@ -2881,6 +3112,10 @@ inline void *HostMessagesRawUnion::UnPack(const void *obj, HostMessagesRaw type,
auto ptr = reinterpret_cast<const rpc::StartLeakChecksRaw *>(obj);
return ptr->UnPack(resolver);
}
+ case HostMessagesRaw::StateRequest: {
+ auto ptr = reinterpret_cast<const rpc::StateRequestRaw *>(obj);
+ return ptr->UnPack(resolver);
+ }
default: return nullptr;
}
}
@@ -2900,6 +3135,10 @@ inline flatbuffers::Offset<void> HostMessagesRawUnion::Pack(flatbuffers::FlatBuf
auto ptr = reinterpret_cast<const rpc::StartLeakChecksRawT *>(value);
return CreateStartLeakChecksRaw(_fbb, ptr, _rehasher).Union();
}
+ case HostMessagesRaw::StateRequest: {
+ auto ptr = reinterpret_cast<const rpc::StateRequestRawT *>(value);
+ return CreateStateRequestRaw(_fbb, ptr, _rehasher).Union();
+ }
default: return 0;
}
}
@@ -2918,6 +3157,10 @@ inline HostMessagesRawUnion::HostMessagesRawUnion(const HostMessagesRawUnion &u)
value = new rpc::StartLeakChecksRawT(*reinterpret_cast<rpc::StartLeakChecksRawT *>(u.value));
break;
}
+ case HostMessagesRaw::StateRequest: {
+ value = new rpc::StateRequestRawT(*reinterpret_cast<rpc::StateRequestRawT *>(u.value));
+ break;
+ }
default:
break;
}
@@ -2940,6 +3183,11 @@ inline void HostMessagesRawUnion::Reset() {
delete ptr;
break;
}
+ case HostMessagesRaw::StateRequest: {
+ auto ptr = reinterpret_cast<rpc::StateRequestRawT *>(value);
+ delete ptr;
+ break;
+ }
default: break;
}
value = nullptr;
@@ -2959,6 +3207,10 @@ inline bool VerifyExecutorMessagesRaw(flatbuffers::Verifier &verifier, const voi
auto ptr = reinterpret_cast<const rpc::ExecutingMessageRaw *>(obj);
return verifier.VerifyTable(ptr);
}
+ case ExecutorMessagesRaw::State: {
+ auto ptr = reinterpret_cast<const rpc::StateResultRaw *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
default: return true;
}
}
@@ -2986,6 +3238,10 @@ inline void *ExecutorMessagesRawUnion::UnPack(const void *obj, ExecutorMessagesR
auto ptr = reinterpret_cast<const rpc::ExecutingMessageRaw *>(obj);
return ptr->UnPack(resolver);
}
+ case ExecutorMessagesRaw::State: {
+ auto ptr = reinterpret_cast<const rpc::StateResultRaw *>(obj);
+ return ptr->UnPack(resolver);
+ }
default: return nullptr;
}
}
@@ -3001,6 +3257,10 @@ inline flatbuffers::Offset<void> ExecutorMessagesRawUnion::Pack(flatbuffers::Fla
auto ptr = reinterpret_cast<const rpc::ExecutingMessageRawT *>(value);
return CreateExecutingMessageRaw(_fbb, ptr, _rehasher).Union();
}
+ case ExecutorMessagesRaw::State: {
+ auto ptr = reinterpret_cast<const rpc::StateResultRawT *>(value);
+ return CreateStateResultRaw(_fbb, ptr, _rehasher).Union();
+ }
default: return 0;
}
}
@@ -3015,6 +3275,10 @@ inline ExecutorMessagesRawUnion::ExecutorMessagesRawUnion(const ExecutorMessages
value = new rpc::ExecutingMessageRawT(*reinterpret_cast<rpc::ExecutingMessageRawT *>(u.value));
break;
}
+ case ExecutorMessagesRaw::State: {
+ value = new rpc::StateResultRawT(*reinterpret_cast<rpc::StateResultRawT *>(u.value));
+ break;
+ }
default:
break;
}
@@ -3032,6 +3296,11 @@ inline void ExecutorMessagesRawUnion::Reset() {
delete ptr;
break;
}
+ case ExecutorMessagesRaw::State: {
+ auto ptr = reinterpret_cast<rpc::StateResultRawT *>(value);
+ delete ptr;
+ break;
+ }
default: break;
}
value = nullptr;
diff --git a/pkg/flatrpc/helpers.go b/pkg/flatrpc/helpers.go
index 22dc893fe..b85951615 100644
--- a/pkg/flatrpc/helpers.go
+++ b/pkg/flatrpc/helpers.go
@@ -4,6 +4,7 @@
package flatrpc
import (
+ "fmt"
"slices"
"syscall"
)
@@ -25,6 +26,7 @@ type HostMessage = HostMessageRawT
type ExecutorMessages = ExecutorMessagesRawT
type ExecutorMessage = ExecutorMessageRawT
type ExecRequest = ExecRequestRawT
+type StateRequest = StateRequestRawT
type SignalUpdate = SignalUpdateRawT
type StartLeakChecks = StartLeakChecksRawT
type ExecutingMessage = ExecutingMessageRawT
@@ -33,6 +35,7 @@ type Comparison = ComparisonRawT
type ExecOpts = ExecOptsRawT
type ProgInfo = ProgInfoRawT
type ExecResult = ExecResultRawT
+type StateResult = StateResultRawT
func (pi *ProgInfo) Clone() *ProgInfo {
if pi == nil {
@@ -71,9 +74,30 @@ 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
+func SandboxToFlags(sandbox string) (ExecEnv, error) {
+ switch sandbox {
+ case "none":
+ return ExecEnvSandboxNone, nil
+ case "setuid":
+ return ExecEnvSandboxSetuid, nil
+ case "namespace":
+ return ExecEnvSandboxNamespace, nil
+ case "android":
+ return ExecEnvSandboxAndroid, nil
+ default:
+ return 0, fmt.Errorf("sandbox must contain one of none/setuid/namespace/android")
+ }
+}
+
+func FlagsToSandbox(flags ExecEnv) string {
+ if flags&ExecEnvSandboxNone != 0 {
+ return "none"
+ } else if flags&ExecEnvSandboxSetuid != 0 {
+ return "setuid"
+ } else if flags&ExecEnvSandboxNamespace != 0 {
+ return "namespace"
+ } else if flags&ExecEnvSandboxAndroid != 0 {
+ return "android"
+ }
+ panic("no sandbox flags present")
}
generated by ggit (джигит) mrf-deployment (git 2.46.0) at 2026-04-11 12:20:20 +0000