visor/runsc/boot/zap.go

// Copyright 2026 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by zip; DO NOT EDIT.

package boot

import (
	"encoding/binary"
	"fmt"
	"net"
	"strings"
	"time"

	zap "github.com/zap-proto/go"
	checkpoint "gvisor.dev/gvisor/pkg/sentry/checkpoint"
	config "gvisor.dev/gvisor/runsc/config"
	specutils "gvisor.dev/gvisor/runsc/specutils"
)

// ---- CreateArgs --------------------------------------------------------

const (
	createArgsCIDAt         = 0
	createArgsFilePayloadAt = 8
	createArgsSize          = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*CreateArgs)(nil)

// MarshalZAP writes CreateArgs from constant offsets.
func (x *CreateArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(createArgsSize + 256)
	ob := b.StartObject(createArgsSize)
	ob.SetText(createArgsCIDAt, string(x.CID))
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createArgsFilePayloadAt, innerFilePayload)
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads CreateArgs out of the buffer that arrived.
func (x *CreateArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("CreateArgs: %w", err)
	}
	o := m.Root()
	x.CID = string(strings.Clone(o.Text(createArgsCIDAt)))
	if raw := o.Bytes(createArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- CreateLinksAndRoutesArgs ------------------------------------------

const (
	createLinksAndRoutesArgsFilePayloadAt             = 0
	createLinksAndRoutesArgsLoopbackLinksAt           = 8
	createLinksAndRoutesArgsFDBasedLinksAt            = 16
	createLinksAndRoutesArgsXDPLinksAt                = 24
	createLinksAndRoutesArgsDefaultv4GatewayAt        = 32
	createLinksAndRoutesArgsDefaultv6GatewayAt        = 40
	createLinksAndRoutesArgsPCAPAt                    = 48
	createLinksAndRoutesArgsLogPacketsAt              = 49
	createLinksAndRoutesArgsNATBlobAt                 = 50
	createLinksAndRoutesArgsPauseExternalNetworkingAt = 51
	createLinksAndRoutesArgsAllowConnectedOnSaveAt    = 52
	createLinksAndRoutesArgsIsRestoreAt               = 53
	createLinksAndRoutesArgsSize                      = 56
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*CreateLinksAndRoutesArgs)(nil)

// MarshalZAP writes CreateLinksAndRoutesArgs from constant offsets.
func (x *CreateLinksAndRoutesArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(createLinksAndRoutesArgsSize + 256)
	loopbackLinksAt, loopbackLinksN := 0, len(x.LoopbackLinks)
	if loopbackLinksN > 0 {
		var blob []byte
		for i := range x.LoopbackLinks {
			enc, err := x.LoopbackLinks[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		loopbackLinksAt = b.WriteBytes(blob)
	}
	fDBasedLinksAt, fDBasedLinksN := 0, len(x.FDBasedLinks)
	if fDBasedLinksN > 0 {
		var blob []byte
		for i := range x.FDBasedLinks {
			enc, err := x.FDBasedLinks[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		fDBasedLinksAt = b.WriteBytes(blob)
	}
	xDPLinksAt, xDPLinksN := 0, len(x.XDPLinks)
	if xDPLinksN > 0 {
		var blob []byte
		for i := range x.XDPLinks {
			enc, err := x.XDPLinks[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		xDPLinksAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(createLinksAndRoutesArgsSize)
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createLinksAndRoutesArgsFilePayloadAt, innerFilePayload)
	innerDefaultv4Gateway, err := x.Defaultv4Gateway.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createLinksAndRoutesArgsDefaultv4GatewayAt, innerDefaultv4Gateway)
	innerDefaultv6Gateway, err := x.Defaultv6Gateway.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createLinksAndRoutesArgsDefaultv6GatewayAt, innerDefaultv6Gateway)
	ob.SetBool(createLinksAndRoutesArgsPCAPAt, bool(x.PCAP))
	ob.SetBool(createLinksAndRoutesArgsLogPacketsAt, bool(x.LogPackets))
	ob.SetBool(createLinksAndRoutesArgsNATBlobAt, bool(x.NATBlob))
	ob.SetBool(createLinksAndRoutesArgsPauseExternalNetworkingAt, bool(x.PauseExternalNetworking))
	ob.SetBool(createLinksAndRoutesArgsAllowConnectedOnSaveAt, bool(x.AllowConnectedOnSave))
	ob.SetBool(createLinksAndRoutesArgsIsRestoreAt, bool(x.IsRestore))
	if loopbackLinksN > 0 {
		ob.SetList(createLinksAndRoutesArgsLoopbackLinksAt, loopbackLinksAt, loopbackLinksN)
	}
	if fDBasedLinksN > 0 {
		ob.SetList(createLinksAndRoutesArgsFDBasedLinksAt, fDBasedLinksAt, fDBasedLinksN)
	}
	if xDPLinksN > 0 {
		ob.SetList(createLinksAndRoutesArgsXDPLinksAt, xDPLinksAt, xDPLinksN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads CreateLinksAndRoutesArgs out of the buffer that arrived.
func (x *CreateLinksAndRoutesArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("CreateLinksAndRoutesArgs: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(createLinksAndRoutesArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if l := o.List(createLinksAndRoutesArgsLoopbackLinksAt); l.Len() > 0 {
		rows := make([]LoopbackLink, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.LoopbackLinks = rows
	}
	if l := o.List(createLinksAndRoutesArgsFDBasedLinksAt); l.Len() > 0 {
		rows := make([]FDBasedLink, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.FDBasedLinks = rows
	}
	if l := o.List(createLinksAndRoutesArgsXDPLinksAt); l.Len() > 0 {
		rows := make([]XDPLink, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.XDPLinks = rows
	}
	if raw := o.Bytes(createLinksAndRoutesArgsDefaultv4GatewayAt); len(raw) > 0 {
		if err := x.Defaultv4Gateway.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if raw := o.Bytes(createLinksAndRoutesArgsDefaultv6GatewayAt); len(raw) > 0 {
		if err := x.Defaultv6Gateway.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.PCAP = bool(o.Bool(createLinksAndRoutesArgsPCAPAt))
	x.LogPackets = bool(o.Bool(createLinksAndRoutesArgsLogPacketsAt))
	x.NATBlob = bool(o.Bool(createLinksAndRoutesArgsNATBlobAt))
	x.PauseExternalNetworking = bool(o.Bool(createLinksAndRoutesArgsPauseExternalNetworkingAt))
	x.AllowConnectedOnSave = bool(o.Bool(createLinksAndRoutesArgsAllowConnectedOnSaveAt))
	x.IsRestore = bool(o.Bool(createLinksAndRoutesArgsIsRestoreAt))
	return nil
}

// ---- CreateTraceSessionArgs --------------------------------------------

const (
	createTraceSessionArgsConfigAt      = 0
	createTraceSessionArgsForceAt       = 8
	createTraceSessionArgsFilePayloadAt = 16
	createTraceSessionArgsSize          = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*CreateTraceSessionArgs)(nil)

// MarshalZAP writes CreateTraceSessionArgs from constant offsets.
func (x *CreateTraceSessionArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(createTraceSessionArgsSize + 256)
	ob := b.StartObject(createTraceSessionArgsSize)
	innerConfig, err := x.Config.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createTraceSessionArgsConfigAt, innerConfig)
	ob.SetBool(createTraceSessionArgsForceAt, bool(x.Force))
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createTraceSessionArgsFilePayloadAt, innerFilePayload)
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads CreateTraceSessionArgs out of the buffer that arrived.
func (x *CreateTraceSessionArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("CreateTraceSessionArgs: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(createTraceSessionArgsConfigAt); len(raw) > 0 {
		if err := x.Config.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.Force = bool(o.Bool(createTraceSessionArgsForceAt))
	if raw := o.Bytes(createTraceSessionArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- DefaultRoute ------------------------------------------------------

const (
	defaultRouteRouteAt = 0
	defaultRouteNameAt  = 8
	defaultRouteSize    = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*DefaultRoute)(nil)

// MarshalZAP writes DefaultRoute from constant offsets.
func (x *DefaultRoute) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(defaultRouteSize + 256)
	ob := b.StartObject(defaultRouteSize)
	innerRoute, err := x.Route.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(defaultRouteRouteAt, innerRoute)
	ob.SetText(defaultRouteNameAt, string(x.Name))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads DefaultRoute out of the buffer that arrived.
func (x *DefaultRoute) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("DefaultRoute: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(defaultRouteRouteAt); len(raw) > 0 {
		if err := x.Route.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.Name = string(strings.Clone(o.Text(defaultRouteNameAt)))
	return nil
}

// ---- FDBasedLink -------------------------------------------------------

const (
	fDBasedLinkNameAt                 = 0
	fDBasedLinkInterfaceIndexAt       = 8
	fDBasedLinkMTUAt                  = 16
	fDBasedLinkAddressesAt            = 24
	fDBasedLinkRoutesAt               = 32
	fDBasedLinkGSOMaxSizeAt           = 40
	fDBasedLinkGVisorGSOEnabledAt     = 44
	fDBasedLinkGVisorGROAt            = 45
	fDBasedLinkTXChecksumOffloadAt    = 46
	fDBasedLinkRXChecksumOffloadAt    = 47
	fDBasedLinkLinkAddressAt          = 48
	fDBasedLinkQDiscAt                = 56
	fDBasedLinkTBFRateAt              = 64
	fDBasedLinkTBFBurstAt             = 72
	fDBasedLinkNeighborsAt            = 80
	fDBasedLinkNumChannelsAt          = 88
	fDBasedLinkProcessorsPerChannelAt = 96
	fDBasedLinkIsPacketAt             = 104
	fDBasedLinkPreConfiguredAt        = 112
	fDBasedLinkSize                   = 120
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*FDBasedLink)(nil)

// MarshalZAP writes FDBasedLink from constant offsets.
func (x *FDBasedLink) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(fDBasedLinkSize + 256)
	addressesAt, addressesN := 0, len(x.Addresses)
	if addressesN > 0 {
		var blob []byte
		for i := range x.Addresses {
			enc, err := x.Addresses[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		addressesAt = b.WriteBytes(blob)
	}
	routesAt, routesN := 0, len(x.Routes)
	if routesN > 0 {
		var blob []byte
		for i := range x.Routes {
			enc, err := x.Routes[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		routesAt = b.WriteBytes(blob)
	}
	neighborsAt, neighborsN := 0, len(x.Neighbors)
	if neighborsN > 0 {
		var blob []byte
		for i := range x.Neighbors {
			enc, err := x.Neighbors[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		neighborsAt = b.WriteBytes(blob)
	}
	isPacketAt, isPacketN := 0, len(x.IsPacket)
	if isPacketN > 0 {
		var blob []byte
		for i := range x.IsPacket {
			enc := []byte{0}
			if x.IsPacket[i] {
				enc[0] = 1
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		isPacketAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(fDBasedLinkSize)
	ob.SetText(fDBasedLinkNameAt, string(x.Name))
	ob.SetInt64(fDBasedLinkInterfaceIndexAt, int64(x.InterfaceIndex))
	ob.SetInt64(fDBasedLinkMTUAt, int64(x.MTU))
	ob.SetUint32(fDBasedLinkGSOMaxSizeAt, uint32(x.GSOMaxSize))
	ob.SetBool(fDBasedLinkGVisorGSOEnabledAt, bool(x.GVisorGSOEnabled))
	ob.SetBool(fDBasedLinkGVisorGROAt, bool(x.GVisorGRO))
	ob.SetBool(fDBasedLinkTXChecksumOffloadAt, bool(x.TXChecksumOffload))
	ob.SetBool(fDBasedLinkRXChecksumOffloadAt, bool(x.RXChecksumOffload))
	ob.SetBytes(fDBasedLinkLinkAddressAt, []byte(x.LinkAddress))
	ob.SetInt64(fDBasedLinkQDiscAt, int64(x.QDisc))
	ob.SetUint64(fDBasedLinkTBFRateAt, uint64(x.TBFRate))
	ob.SetUint32(fDBasedLinkTBFBurstAt, uint32(x.TBFBurst))
	ob.SetInt64(fDBasedLinkNumChannelsAt, int64(x.NumChannels))
	ob.SetInt64(fDBasedLinkProcessorsPerChannelAt, int64(x.ProcessorsPerChannel))
	ob.SetBool(fDBasedLinkPreConfiguredAt, bool(x.PreConfigured))
	if addressesN > 0 {
		ob.SetList(fDBasedLinkAddressesAt, addressesAt, addressesN)
	}
	if routesN > 0 {
		ob.SetList(fDBasedLinkRoutesAt, routesAt, routesN)
	}
	if neighborsN > 0 {
		ob.SetList(fDBasedLinkNeighborsAt, neighborsAt, neighborsN)
	}
	if isPacketN > 0 {
		ob.SetList(fDBasedLinkIsPacketAt, isPacketAt, isPacketN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads FDBasedLink out of the buffer that arrived.
func (x *FDBasedLink) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("FDBasedLink: %w", err)
	}
	o := m.Root()
	x.Name = string(strings.Clone(o.Text(fDBasedLinkNameAt)))
	x.InterfaceIndex = int(o.Int64(fDBasedLinkInterfaceIndexAt))
	x.MTU = int(o.Int64(fDBasedLinkMTUAt))
	if l := o.List(fDBasedLinkAddressesAt); l.Len() > 0 {
		rows := make([]IPWithPrefix, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Addresses = rows
	}
	if l := o.List(fDBasedLinkRoutesAt); l.Len() > 0 {
		rows := make([]Route, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Routes = rows
	}
	x.GSOMaxSize = uint32(o.Uint32(fDBasedLinkGSOMaxSizeAt))
	x.GVisorGSOEnabled = bool(o.Bool(fDBasedLinkGVisorGSOEnabledAt))
	x.GVisorGRO = bool(o.Bool(fDBasedLinkGVisorGROAt))
	x.TXChecksumOffload = bool(o.Bool(fDBasedLinkTXChecksumOffloadAt))
	x.RXChecksumOffload = bool(o.Bool(fDBasedLinkRXChecksumOffloadAt))
	x.LinkAddress = net.HardwareAddr(append([]byte(nil), o.Bytes(fDBasedLinkLinkAddressAt)...))
	x.QDisc = config.QueueingDiscipline(o.Int64(fDBasedLinkQDiscAt))
	x.TBFRate = uint64(o.Uint64(fDBasedLinkTBFRateAt))
	x.TBFBurst = uint32(o.Uint32(fDBasedLinkTBFBurstAt))
	if l := o.List(fDBasedLinkNeighborsAt); l.Len() > 0 {
		rows := make([]Neighbor, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Neighbors = rows
	}
	x.NumChannels = int(o.Int64(fDBasedLinkNumChannelsAt))
	x.ProcessorsPerChannel = int(o.Int64(fDBasedLinkProcessorsPerChannelAt))
	if l := o.List(fDBasedLinkIsPacketAt); l.Len() > 0 {
		rows := make([]bool, l.Len())
		for i := range rows {
			raw := l.BytesAt(i)
			rows[i] = bool(len(raw) > 0 && raw[0] != 0)
		}
		x.IsPacket = rows
	}
	x.PreConfigured = bool(o.Bool(fDBasedLinkPreConfiguredAt))
	return nil
}

// ---- FSSaveArgs --------------------------------------------------------

const (
	fSSaveArgsFilePayloadAt        = 0
	fSSaveArgsPathsAt              = 8
	fSSaveArgsExitAfterSavingAt    = 16
	fSSaveArgsUseCheckpointGoferAt = 17
	fSSaveArgsSize                 = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*FSSaveArgs)(nil)

// MarshalZAP writes FSSaveArgs from constant offsets.
func (x *FSSaveArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(fSSaveArgsSize + 256)
	pathsAt, pathsN := 0, len(x.Paths)
	if pathsN > 0 {
		var blob []byte
		for i := range x.Paths {
			enc, err := x.Paths[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		pathsAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(fSSaveArgsSize)
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(fSSaveArgsFilePayloadAt, innerFilePayload)
	ob.SetBool(fSSaveArgsExitAfterSavingAt, bool(x.ExitAfterSaving))
	ob.SetBool(fSSaveArgsUseCheckpointGoferAt, bool(x.UseCheckpointGofer))
	if pathsN > 0 {
		ob.SetList(fSSaveArgsPathsAt, pathsAt, pathsN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads FSSaveArgs out of the buffer that arrived.
func (x *FSSaveArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("FSSaveArgs: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(fSSaveArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if l := o.List(fSSaveArgsPathsAt); l.Len() > 0 {
		rows := make([]checkpoint.ResourceID, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Paths = rows
	}
	x.ExitAfterSaving = bool(o.Bool(fSSaveArgsExitAfterSavingAt))
	x.UseCheckpointGofer = bool(o.Bool(fSSaveArgsUseCheckpointGoferAt))
	return nil
}

// ---- IPWithPrefix ------------------------------------------------------

const (
	iPWithPrefixAddressAt   = 0
	iPWithPrefixPrefixLenAt = 8
	iPWithPrefixSize        = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*IPWithPrefix)(nil)

// MarshalZAP writes IPWithPrefix from constant offsets.
func (x *IPWithPrefix) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(iPWithPrefixSize + 256)
	ob := b.StartObject(iPWithPrefixSize)
	ob.SetBytes(iPWithPrefixAddressAt, []byte(x.Address))
	ob.SetInt64(iPWithPrefixPrefixLenAt, int64(x.PrefixLen))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads IPWithPrefix out of the buffer that arrived.
func (x *IPWithPrefix) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("IPWithPrefix: %w", err)
	}
	o := m.Root()
	x.Address = net.IP(append([]byte(nil), o.Bytes(iPWithPrefixAddressAt)...))
	x.PrefixLen = int(o.Int64(iPWithPrefixPrefixLenAt))
	return nil
}

// ---- InitPluginStackArgs -----------------------------------------------

const (
	initPluginStackArgsFilePayloadAt = 0
	initPluginStackArgsInitStrAt     = 8
	initPluginStackArgsSize          = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*InitPluginStackArgs)(nil)

// MarshalZAP writes InitPluginStackArgs from constant offsets.
func (x *InitPluginStackArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(initPluginStackArgsSize + 256)
	ob := b.StartObject(initPluginStackArgsSize)
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(initPluginStackArgsFilePayloadAt, innerFilePayload)
	ob.SetText(initPluginStackArgsInitStrAt, string(x.InitStr))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads InitPluginStackArgs out of the buffer that arrived.
func (x *InitPluginStackArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("InitPluginStackArgs: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(initPluginStackArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.InitStr = string(strings.Clone(o.Text(initPluginStackArgsInitStrAt)))
	return nil
}

// ---- LoopbackLink ------------------------------------------------------

const (
	loopbackLinkNameAt      = 0
	loopbackLinkAddressesAt = 8
	loopbackLinkRoutesAt    = 16
	loopbackLinkGVisorGROAt = 24
	loopbackLinkSize        = 32
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*LoopbackLink)(nil)

// MarshalZAP writes LoopbackLink from constant offsets.
func (x *LoopbackLink) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(loopbackLinkSize + 256)
	addressesAt, addressesN := 0, len(x.Addresses)
	if addressesN > 0 {
		var blob []byte
		for i := range x.Addresses {
			enc, err := x.Addresses[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		addressesAt = b.WriteBytes(blob)
	}
	routesAt, routesN := 0, len(x.Routes)
	if routesN > 0 {
		var blob []byte
		for i := range x.Routes {
			enc, err := x.Routes[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		routesAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(loopbackLinkSize)
	ob.SetText(loopbackLinkNameAt, string(x.Name))
	ob.SetBool(loopbackLinkGVisorGROAt, bool(x.GVisorGRO))
	if addressesN > 0 {
		ob.SetList(loopbackLinkAddressesAt, addressesAt, addressesN)
	}
	if routesN > 0 {
		ob.SetList(loopbackLinkRoutesAt, routesAt, routesN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads LoopbackLink out of the buffer that arrived.
func (x *LoopbackLink) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("LoopbackLink: %w", err)
	}
	o := m.Root()
	x.Name = string(strings.Clone(o.Text(loopbackLinkNameAt)))
	if l := o.List(loopbackLinkAddressesAt); l.Len() > 0 {
		rows := make([]IPWithPrefix, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Addresses = rows
	}
	if l := o.List(loopbackLinkRoutesAt); l.Len() > 0 {
		rows := make([]Route, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Routes = rows
	}
	x.GVisorGRO = bool(o.Bool(loopbackLinkGVisorGROAt))
	return nil
}

// ---- MountArgs ---------------------------------------------------------

const (
	mountArgsContainerIDAt = 0
	mountArgsSourceAt      = 8
	mountArgsDestinationAt = 16
	mountArgsFsTypeAt      = 24
	mountArgsFilePayloadAt = 32
	mountArgsSize          = 40
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*MountArgs)(nil)

// MarshalZAP writes MountArgs from constant offsets.
func (x *MountArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(mountArgsSize + 256)
	ob := b.StartObject(mountArgsSize)
	ob.SetText(mountArgsContainerIDAt, string(x.ContainerID))
	ob.SetText(mountArgsSourceAt, string(x.Source))
	ob.SetText(mountArgsDestinationAt, string(x.Destination))
	ob.SetText(mountArgsFsTypeAt, string(x.FsType))
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(mountArgsFilePayloadAt, innerFilePayload)
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads MountArgs out of the buffer that arrived.
func (x *MountArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("MountArgs: %w", err)
	}
	o := m.Root()
	x.ContainerID = string(strings.Clone(o.Text(mountArgsContainerIDAt)))
	x.Source = string(strings.Clone(o.Text(mountArgsSourceAt)))
	x.Destination = string(strings.Clone(o.Text(mountArgsDestinationAt)))
	x.FsType = string(strings.Clone(o.Text(mountArgsFsTypeAt)))
	if raw := o.Bytes(mountArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- Neighbor ----------------------------------------------------------

const (
	neighborIPAt           = 0
	neighborHardwareAddrAt = 8
	neighborSize           = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Neighbor)(nil)

// MarshalZAP writes Neighbor from constant offsets.
func (x *Neighbor) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(neighborSize + 256)
	ob := b.StartObject(neighborSize)
	ob.SetBytes(neighborIPAt, []byte(x.IP))
	ob.SetBytes(neighborHardwareAddrAt, []byte(x.HardwareAddr))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Neighbor out of the buffer that arrived.
func (x *Neighbor) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Neighbor: %w", err)
	}
	o := m.Root()
	x.IP = net.IP(append([]byte(nil), o.Bytes(neighborIPAt)...))
	x.HardwareAddr = net.HardwareAddr(append([]byte(nil), o.Bytes(neighborHardwareAddrAt)...))
	return nil
}

// ---- PortForwardOpts ---------------------------------------------------

const (
	portForwardOptsFilePayloadAt = 0
	portForwardOptsContainerIDAt = 8
	portForwardOptsPortAt        = 16
	portForwardOptsSize          = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*PortForwardOpts)(nil)

// MarshalZAP writes PortForwardOpts from constant offsets.
func (x *PortForwardOpts) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(portForwardOptsSize + 256)
	ob := b.StartObject(portForwardOptsSize)
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(portForwardOptsFilePayloadAt, innerFilePayload)
	ob.SetText(portForwardOptsContainerIDAt, string(x.ContainerID))
	ob.SetUint16(portForwardOptsPortAt, uint16(x.Port))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads PortForwardOpts out of the buffer that arrived.
func (x *PortForwardOpts) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("PortForwardOpts: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(portForwardOptsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.ContainerID = string(strings.Clone(o.Text(portForwardOptsContainerIDAt)))
	x.Port = uint16(o.Uint16(portForwardOptsPortAt))
	return nil
}

// ---- Route -------------------------------------------------------------

const (
	routeDestinationAt = 0
	routeGatewayAt     = 8
	routeMTUAt         = 16
	routeSize          = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Route)(nil)

// MarshalZAP writes Route from constant offsets.
func (x *Route) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(routeSize + 256)
	ob := b.StartObject(routeSize)
	innerDestination, err := x.Destination.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(routeDestinationAt, innerDestination)
	ob.SetBytes(routeGatewayAt, []byte(x.Gateway))
	ob.SetUint32(routeMTUAt, uint32(x.MTU))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Route out of the buffer that arrived.
func (x *Route) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Route: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(routeDestinationAt); len(raw) > 0 {
		if err := x.Destination.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.Gateway = net.IP(append([]byte(nil), o.Bytes(routeGatewayAt)...))
	x.MTU = uint32(o.Uint32(routeMTUAt))
	return nil
}

// ---- Savings -----------------------------------------------------------

const (
	savingsCPUTimeSavedAt  = 0
	savingsWallTimeSavedAt = 8
	savingsSize            = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Savings)(nil)

// MarshalZAP writes Savings from constant offsets.
func (x *Savings) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(savingsSize + 256)
	ob := b.StartObject(savingsSize)
	ob.SetInt64(savingsCPUTimeSavedAt, int64(x.CPUTimeSaved))
	ob.SetInt64(savingsWallTimeSavedAt, int64(x.WallTimeSaved))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Savings out of the buffer that arrived.
func (x *Savings) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Savings: %w", err)
	}
	o := m.Root()
	x.CPUTimeSaved = time.Duration(o.Int64(savingsCPUTimeSavedAt))
	x.WallTimeSaved = time.Duration(o.Int64(savingsWallTimeSavedAt))
	return nil
}

// ---- SignalArgs --------------------------------------------------------

const (
	signalArgsCIDAt   = 0
	signalArgsSignoAt = 8
	signalArgsPIDAt   = 12
	signalArgsModeAt  = 16
	signalArgsSize    = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*SignalArgs)(nil)

// MarshalZAP writes SignalArgs from constant offsets.
func (x *SignalArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(signalArgsSize + 256)
	ob := b.StartObject(signalArgsSize)
	ob.SetText(signalArgsCIDAt, string(x.CID))
	ob.SetInt32(signalArgsSignoAt, int32(x.Signo))
	ob.SetInt32(signalArgsPIDAt, int32(x.PID))
	ob.SetInt64(signalArgsModeAt, int64(x.Mode))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads SignalArgs out of the buffer that arrived.
func (x *SignalArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("SignalArgs: %w", err)
	}
	o := m.Root()
	x.CID = string(strings.Clone(o.Text(signalArgsCIDAt)))
	x.Signo = int32(o.Int32(signalArgsSignoAt))
	x.PID = int32(o.Int32(signalArgsPIDAt))
	x.Mode = SignalDeliveryMode(o.Int64(signalArgsModeAt))
	return nil
}

// ---- StartArgs ---------------------------------------------------------

const (
	startArgsSpecAt                        = 0
	startArgsConfAt                        = 8
	startArgsCIDAt                         = 16
	startArgsNumGoferFilestoreFDsAt        = 24
	startArgsIsDevIoFilePresentAt          = 32
	startArgsGoferMountConfsAt             = 40
	startArgsIsRootfsUpperTarFilePresentAt = 48
	startArgsFilePayloadAt                 = 56
	startArgsSize                          = 64
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*StartArgs)(nil)

// MarshalZAP writes StartArgs from constant offsets.
func (x *StartArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(startArgsSize + 256)
	goferMountConfsAt, goferMountConfsN := 0, len(x.GoferMountConfs)
	if goferMountConfsN > 0 {
		var blob []byte
		for i := range x.GoferMountConfs {
			enc, err := x.GoferMountConfs[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		goferMountConfsAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(startArgsSize)
	ob.SetBytes(startArgsSpecAt, []byte(x.Spec))
	if x.Conf != nil {
		innerConf, err := x.Conf.MarshalZAP()
		if err != nil {
			return nil, err
		}
		ob.SetBytes(startArgsConfAt, innerConf)
	}
	ob.SetText(startArgsCIDAt, string(x.CID))
	ob.SetInt64(startArgsNumGoferFilestoreFDsAt, int64(x.NumGoferFilestoreFDs))
	ob.SetBool(startArgsIsDevIoFilePresentAt, bool(x.IsDevIoFilePresent))
	ob.SetBool(startArgsIsRootfsUpperTarFilePresentAt, bool(x.IsRootfsUpperTarFilePresent))
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(startArgsFilePayloadAt, innerFilePayload)
	if goferMountConfsN > 0 {
		ob.SetList(startArgsGoferMountConfsAt, goferMountConfsAt, goferMountConfsN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads StartArgs out of the buffer that arrived.
func (x *StartArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("StartArgs: %w", err)
	}
	o := m.Root()
	x.Spec = []uint8(append([]byte(nil), o.Bytes(startArgsSpecAt)...))
	if raw := o.Bytes(startArgsConfAt); len(raw) > 0 {
		var v config.Config
		if err := v.UnmarshalZAP(raw); err != nil {
			return err
		}
		x.Conf = &v
	}
	x.CID = string(strings.Clone(o.Text(startArgsCIDAt)))
	x.NumGoferFilestoreFDs = int(o.Int64(startArgsNumGoferFilestoreFDsAt))
	x.IsDevIoFilePresent = bool(o.Bool(startArgsIsDevIoFilePresentAt))
	if l := o.List(startArgsGoferMountConfsAt); l.Len() > 0 {
		rows := make([]specutils.GoferMountConf, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.GoferMountConfs = rows
	}
	x.IsRootfsUpperTarFilePresent = bool(o.Bool(startArgsIsRootfsUpperTarFilePresentAt))
	if raw := o.Bytes(startArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- Subnet ------------------------------------------------------------

const (
	subnetIPAt   = 0
	subnetMaskAt = 8
	subnetSize   = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Subnet)(nil)

// MarshalZAP writes Subnet from constant offsets.
func (x *Subnet) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(subnetSize + 256)
	ob := b.StartObject(subnetSize)
	ob.SetBytes(subnetIPAt, []byte(x.IP))
	ob.SetBytes(subnetMaskAt, []byte(x.Mask))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Subnet out of the buffer that arrived.
func (x *Subnet) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Subnet: %w", err)
	}
	o := m.Root()
	x.IP = net.IP(append([]byte(nil), o.Bytes(subnetIPAt)...))
	x.Mask = net.IPMask(append([]byte(nil), o.Bytes(subnetMaskAt)...))
	return nil
}

// ---- WaitFSRestoreArgs -------------------------------------------------

const (
	waitFSRestoreArgsCIDAt = 0
	waitFSRestoreArgsSize  = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*WaitFSRestoreArgs)(nil)

// MarshalZAP writes WaitFSRestoreArgs from constant offsets.
func (x *WaitFSRestoreArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(waitFSRestoreArgsSize + 256)
	ob := b.StartObject(waitFSRestoreArgsSize)
	ob.SetText(waitFSRestoreArgsCIDAt, string(x.CID))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads WaitFSRestoreArgs out of the buffer that arrived.
func (x *WaitFSRestoreArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("WaitFSRestoreArgs: %w", err)
	}
	o := m.Root()
	x.CID = string(strings.Clone(o.Text(waitFSRestoreArgsCIDAt)))
	return nil
}

// ---- WaitPIDArgs -------------------------------------------------------

const (
	waitPIDArgsPIDAt = 0
	waitPIDArgsCIDAt = 8
	waitPIDArgsSize  = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*WaitPIDArgs)(nil)

// MarshalZAP writes WaitPIDArgs from constant offsets.
func (x *WaitPIDArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(waitPIDArgsSize + 256)
	ob := b.StartObject(waitPIDArgsSize)
	ob.SetInt32(waitPIDArgsPIDAt, int32(x.PID))
	ob.SetText(waitPIDArgsCIDAt, string(x.CID))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads WaitPIDArgs out of the buffer that arrived.
func (x *WaitPIDArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("WaitPIDArgs: %w", err)
	}
	o := m.Root()
	x.PID = int32(o.Int32(waitPIDArgsPIDAt))
	x.CID = string(strings.Clone(o.Text(waitPIDArgsCIDAt)))
	return nil
}

// ---- XDPLink -----------------------------------------------------------

const (
	xDPLinkNameAt              = 0
	xDPLinkInterfaceIndexAt    = 8
	xDPLinkMTUAt               = 16
	xDPLinkAddressesAt         = 24
	xDPLinkRoutesAt            = 32
	xDPLinkTXChecksumOffloadAt = 40
	xDPLinkRXChecksumOffloadAt = 41
	xDPLinkLinkAddressAt       = 48
	xDPLinkQDiscAt             = 56
	xDPLinkTBFRateAt           = 64
	xDPLinkTBFBurstAt          = 72
	xDPLinkNeighborsAt         = 80
	xDPLinkGVisorGROAt         = 88
	xDPLinkBindAt              = 96
	xDPLinkNumChannelsAt       = 104
	xDPLinkSize                = 112
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*XDPLink)(nil)

// MarshalZAP writes XDPLink from constant offsets.
func (x *XDPLink) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(xDPLinkSize + 256)
	addressesAt, addressesN := 0, len(x.Addresses)
	if addressesN > 0 {
		var blob []byte
		for i := range x.Addresses {
			enc, err := x.Addresses[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		addressesAt = b.WriteBytes(blob)
	}
	routesAt, routesN := 0, len(x.Routes)
	if routesN > 0 {
		var blob []byte
		for i := range x.Routes {
			enc, err := x.Routes[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		routesAt = b.WriteBytes(blob)
	}
	neighborsAt, neighborsN := 0, len(x.Neighbors)
	if neighborsN > 0 {
		var blob []byte
		for i := range x.Neighbors {
			enc, err := x.Neighbors[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		neighborsAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(xDPLinkSize)
	ob.SetText(xDPLinkNameAt, string(x.Name))
	ob.SetInt64(xDPLinkInterfaceIndexAt, int64(x.InterfaceIndex))
	ob.SetInt64(xDPLinkMTUAt, int64(x.MTU))
	ob.SetBool(xDPLinkTXChecksumOffloadAt, bool(x.TXChecksumOffload))
	ob.SetBool(xDPLinkRXChecksumOffloadAt, bool(x.RXChecksumOffload))
	ob.SetBytes(xDPLinkLinkAddressAt, []byte(x.LinkAddress))
	ob.SetInt64(xDPLinkQDiscAt, int64(x.QDisc))
	ob.SetUint64(xDPLinkTBFRateAt, uint64(x.TBFRate))
	ob.SetUint32(xDPLinkTBFBurstAt, uint32(x.TBFBurst))
	ob.SetBool(xDPLinkGVisorGROAt, bool(x.GVisorGRO))
	ob.SetInt64(xDPLinkBindAt, int64(x.Bind))
	ob.SetInt64(xDPLinkNumChannelsAt, int64(x.NumChannels))
	if addressesN > 0 {
		ob.SetList(xDPLinkAddressesAt, addressesAt, addressesN)
	}
	if routesN > 0 {
		ob.SetList(xDPLinkRoutesAt, routesAt, routesN)
	}
	if neighborsN > 0 {
		ob.SetList(xDPLinkNeighborsAt, neighborsAt, neighborsN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads XDPLink out of the buffer that arrived.
func (x *XDPLink) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("XDPLink: %w", err)
	}
	o := m.Root()
	x.Name = string(strings.Clone(o.Text(xDPLinkNameAt)))
	x.InterfaceIndex = int(o.Int64(xDPLinkInterfaceIndexAt))
	x.MTU = int(o.Int64(xDPLinkMTUAt))
	if l := o.List(xDPLinkAddressesAt); l.Len() > 0 {
		rows := make([]IPWithPrefix, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Addresses = rows
	}
	if l := o.List(xDPLinkRoutesAt); l.Len() > 0 {
		rows := make([]Route, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Routes = rows
	}
	x.TXChecksumOffload = bool(o.Bool(xDPLinkTXChecksumOffloadAt))
	x.RXChecksumOffload = bool(o.Bool(xDPLinkRXChecksumOffloadAt))
	x.LinkAddress = net.HardwareAddr(append([]byte(nil), o.Bytes(xDPLinkLinkAddressAt)...))
	x.QDisc = config.QueueingDiscipline(o.Int64(xDPLinkQDiscAt))
	x.TBFRate = uint64(o.Uint64(xDPLinkTBFRateAt))
	x.TBFBurst = uint32(o.Uint32(xDPLinkTBFBurstAt))
	if l := o.List(xDPLinkNeighborsAt); l.Len() > 0 {
		rows := make([]Neighbor, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Neighbors = rows
	}
	x.GVisorGRO = bool(o.Bool(xDPLinkGVisorGROAt))
	x.Bind = BindOpt(o.Int64(xDPLinkBindAt))
	x.NumChannels = int(o.Int64(xDPLinkNumChannelsAt))
	return nil
}