github.com/google/syzkaller@v0.0.0-20251211124644-a066d2bc4b02/sys/generated/generated.go (about)

     1  // Copyright 2025 syzkaller project authors. All rights reserved.
     2  // Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
     3  
     4  package generated
     5  
     6  import (
     7  	"bytes"
     8  	"compress/flate"
     9  	"embed"
    10  	"encoding/gob"
    11  	"fmt"
    12  	"path/filepath"
    13  
    14  	"github.com/google/syzkaller/prog"
    15  	"github.com/google/syzkaller/sys/targets"
    16  )
    17  
    18  type Desc struct {
    19  	Syscalls  []*prog.Syscall
    20  	Resources []*prog.ResourceDesc
    21  	Consts    []prog.ConstValue
    22  	Flags     []prog.FlagDesc
    23  	Types     []prog.Type
    24  }
    25  
    26  func Register(os, arch, revision string, init func(*prog.Target), files embed.FS) {
    27  	// Does not call targets.Get b/c it does slow lazy initialization of targets.
    28  	sysTarget := targets.List[os][arch]
    29  	target := &prog.Target{
    30  		OS:         os,
    31  		Arch:       arch,
    32  		Revision:   revision,
    33  		PtrSize:    sysTarget.PtrSize,
    34  		PageSize:   sysTarget.PageSize,
    35  		NumPages:   sysTarget.NumPages,
    36  		DataOffset: sysTarget.DataOffset,
    37  		BigEndian:  sysTarget.BigEndian,
    38  	}
    39  	filler := func(target *prog.Target) {
    40  		fill(target, files)
    41  	}
    42  	prog.RegisterTarget(target, filler, init)
    43  }
    44  
    45  func fill(target *prog.Target, files embed.FS) {
    46  	data, err := files.ReadFile(FileName(target.OS, target.Arch))
    47  	if err != nil {
    48  		panic(err)
    49  	}
    50  	desc := new(Desc)
    51  	if err := gob.NewDecoder(flate.NewReader(bytes.NewReader(data))).Decode(desc); err != nil {
    52  		panic(err)
    53  	}
    54  	target.Syscalls = desc.Syscalls
    55  	target.Resources = desc.Resources
    56  	target.Consts = desc.Consts
    57  	target.Flags = desc.Flags
    58  	target.Types = desc.Types
    59  }
    60  
    61  func Serialize(desc *Desc) ([]byte, error) {
    62  	out := new(bytes.Buffer)
    63  	compressor, err := flate.NewWriter(out, flate.DefaultCompression)
    64  	if err != nil {
    65  		return nil, err
    66  	}
    67  	enc := gob.NewEncoder(compressor)
    68  	if err := enc.Encode(desc); err != nil {
    69  		return nil, err
    70  	}
    71  	if err := compressor.Close(); err != nil {
    72  		return nil, err
    73  	}
    74  	return out.Bytes(), nil
    75  }
    76  
    77  func FileName(os, arch string) string {
    78  	return fileName(fmt.Sprintf("%v_%v", os, arch))
    79  }
    80  
    81  func Glob() string {
    82  	return fileName("*")
    83  }
    84  
    85  func fileName(name string) string {
    86  	return filepath.Join("gen", fmt.Sprintf("%v.gob.flate", name))
    87  }
    88  
    89  func init() {
    90  	gob.Register(prog.Ref(0))
    91  	gob.Register(&prog.ResourceType{})
    92  	gob.Register(&prog.ConstType{})
    93  	gob.Register(&prog.IntType{})
    94  	gob.Register(&prog.FlagsType{})
    95  	gob.Register(&prog.LenType{})
    96  	gob.Register(&prog.ProcType{})
    97  	gob.Register(&prog.CsumType{})
    98  	gob.Register(&prog.VmaType{})
    99  	gob.Register(&prog.BufferType{})
   100  	gob.Register(&prog.ArrayType{})
   101  	gob.Register(&prog.PtrType{})
   102  	gob.Register(&prog.StructType{})
   103  	gob.Register(&prog.UnionType{})
   104  	gob.Register(&prog.BinaryExpression{})
   105  	gob.Register(&prog.Value{})
   106  }