github.com/kubeshark/ebpf@v0.9.2/internal/unix/types_other.go (about)

     1  //go:build !linux
     2  // +build !linux
     3  
     4  package unix
     5  
     6  import (
     7  	"fmt"
     8  	"runtime"
     9  	"syscall"
    10  )
    11  
    12  var errNonLinux = fmt.Errorf("unsupported platform %s/%s", runtime.GOOS, runtime.GOARCH)
    13  
    14  const (
    15  	ENOENT = syscall.ENOENT
    16  	EEXIST = syscall.EEXIST
    17  	EAGAIN = syscall.EAGAIN
    18  	ENOSPC = syscall.ENOSPC
    19  	EINVAL = syscall.EINVAL
    20  	EINTR  = syscall.EINTR
    21  	EPERM  = syscall.EPERM
    22  	ESRCH  = syscall.ESRCH
    23  	ENODEV = syscall.ENODEV
    24  	EBADF  = syscall.Errno(0)
    25  	E2BIG  = syscall.Errno(0)
    26  	EFAULT = syscall.EFAULT
    27  	EACCES = syscall.Errno(0)
    28  	// ENOTSUPP is not the same as ENOTSUP or EOPNOTSUP
    29  	ENOTSUPP = syscall.Errno(0x20c)
    30  
    31  	BPF_F_NO_PREALLOC        = 0
    32  	BPF_F_NUMA_NODE          = 0
    33  	BPF_F_RDONLY             = 0
    34  	BPF_F_WRONLY             = 0
    35  	BPF_F_RDONLY_PROG        = 0
    36  	BPF_F_WRONLY_PROG        = 0
    37  	BPF_F_SLEEPABLE          = 0
    38  	BPF_F_MMAPABLE           = 0
    39  	BPF_F_INNER_MAP          = 0
    40  	BPF_OBJ_NAME_LEN         = 0x10
    41  	BPF_TAG_SIZE             = 0x8
    42  	BPF_RINGBUF_BUSY_BIT     = 0
    43  	BPF_RINGBUF_DISCARD_BIT  = 0
    44  	BPF_RINGBUF_HDR_SZ       = 0
    45  	SYS_BPF                  = 321
    46  	F_DUPFD_CLOEXEC          = 0x406
    47  	EPOLLIN                  = 0x1
    48  	EPOLL_CTL_ADD            = 0x1
    49  	EPOLL_CLOEXEC            = 0x80000
    50  	O_CLOEXEC                = 0x80000
    51  	O_NONBLOCK               = 0x800
    52  	PROT_READ                = 0x1
    53  	PROT_WRITE               = 0x2
    54  	MAP_SHARED               = 0x1
    55  	PERF_ATTR_SIZE_VER1      = 0
    56  	PERF_TYPE_SOFTWARE       = 0x1
    57  	PERF_TYPE_TRACEPOINT     = 0
    58  	PERF_COUNT_SW_BPF_OUTPUT = 0xa
    59  	PERF_EVENT_IOC_DISABLE   = 0
    60  	PERF_EVENT_IOC_ENABLE    = 0
    61  	PERF_EVENT_IOC_SET_BPF   = 0
    62  	PerfBitWatermark         = 0x4000
    63  	PERF_SAMPLE_RAW          = 0x400
    64  	PERF_FLAG_FD_CLOEXEC     = 0x8
    65  	RLIM_INFINITY            = 0x7fffffffffffffff
    66  	RLIMIT_MEMLOCK           = 8
    67  	BPF_STATS_RUN_TIME       = 0
    68  	PERF_RECORD_LOST         = 2
    69  	PERF_RECORD_SAMPLE       = 9
    70  	AT_FDCWD                 = -0x2
    71  	RENAME_NOREPLACE         = 0x1
    72  	SO_ATTACH_BPF            = 0x32
    73  	SO_DETACH_BPF            = 0x1b
    74  	SOL_SOCKET               = 0x1
    75  )
    76  
    77  // Statfs_t is a wrapper
    78  type Statfs_t struct {
    79  	Type    int64
    80  	Bsize   int64
    81  	Blocks  uint64
    82  	Bfree   uint64
    83  	Bavail  uint64
    84  	Files   uint64
    85  	Ffree   uint64
    86  	Fsid    [2]int32
    87  	Namelen int64
    88  	Frsize  int64
    89  	Flags   int64
    90  	Spare   [4]int64
    91  }
    92  
    93  type Stat_t struct{}
    94  
    95  // Rlimit is a wrapper
    96  type Rlimit struct {
    97  	Cur uint64
    98  	Max uint64
    99  }
   100  
   101  // Syscall is a wrapper
   102  func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
   103  	return 0, 0, syscall.Errno(1)
   104  }
   105  
   106  // FcntlInt is a wrapper
   107  func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
   108  	return -1, errNonLinux
   109  }
   110  
   111  // IoctlSetInt is a wrapper
   112  func IoctlSetInt(fd int, req uint, value int) error {
   113  	return errNonLinux
   114  }
   115  
   116  // Statfs is a wrapper
   117  func Statfs(path string, buf *Statfs_t) error {
   118  	return errNonLinux
   119  }
   120  
   121  // Close is a wrapper
   122  func Close(fd int) (err error) {
   123  	return errNonLinux
   124  }
   125  
   126  // EpollEvent is a wrapper
   127  type EpollEvent struct {
   128  	Events uint32
   129  	Fd     int32
   130  	Pad    int32
   131  }
   132  
   133  // EpollWait is a wrapper
   134  func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
   135  	return 0, errNonLinux
   136  }
   137  
   138  // EpollCtl is a wrapper
   139  func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
   140  	return errNonLinux
   141  }
   142  
   143  // Eventfd is a wrapper
   144  func Eventfd(initval uint, flags int) (fd int, err error) {
   145  	return 0, errNonLinux
   146  }
   147  
   148  // Write is a wrapper
   149  func Write(fd int, p []byte) (n int, err error) {
   150  	return 0, errNonLinux
   151  }
   152  
   153  // EpollCreate1 is a wrapper
   154  func EpollCreate1(flag int) (fd int, err error) {
   155  	return 0, errNonLinux
   156  }
   157  
   158  // PerfEventMmapPage is a wrapper
   159  type PerfEventMmapPage struct {
   160  	Version        uint32
   161  	Compat_version uint32
   162  	Lock           uint32
   163  	Index          uint32
   164  	Offset         int64
   165  	Time_enabled   uint64
   166  	Time_running   uint64
   167  	Capabilities   uint64
   168  	Pmc_width      uint16
   169  	Time_shift     uint16
   170  	Time_mult      uint32
   171  	Time_offset    uint64
   172  	Time_zero      uint64
   173  	Size           uint32
   174  
   175  	Data_head   uint64
   176  	Data_tail   uint64
   177  	Data_offset uint64
   178  	Data_size   uint64
   179  	Aux_head    uint64
   180  	Aux_tail    uint64
   181  	Aux_offset  uint64
   182  	Aux_size    uint64
   183  }
   184  
   185  // SetNonblock is a wrapper
   186  func SetNonblock(fd int, nonblocking bool) (err error) {
   187  	return errNonLinux
   188  }
   189  
   190  // Mmap is a wrapper
   191  func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
   192  	return []byte{}, errNonLinux
   193  }
   194  
   195  // Munmap is a wrapper
   196  func Munmap(b []byte) (err error) {
   197  	return errNonLinux
   198  }
   199  
   200  // PerfEventAttr is a wrapper
   201  type PerfEventAttr struct {
   202  	Type               uint32
   203  	Size               uint32
   204  	Config             uint64
   205  	Sample             uint64
   206  	Sample_type        uint64
   207  	Read_format        uint64
   208  	Bits               uint64
   209  	Wakeup             uint32
   210  	Bp_type            uint32
   211  	Ext1               uint64
   212  	Ext2               uint64
   213  	Branch_sample_type uint64
   214  	Sample_regs_user   uint64
   215  	Sample_stack_user  uint32
   216  	Clockid            int32
   217  	Sample_regs_intr   uint64
   218  	Aux_watermark      uint32
   219  	Sample_max_stack   uint16
   220  }
   221  
   222  // PerfEventOpen is a wrapper
   223  func PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error) {
   224  	return 0, errNonLinux
   225  }
   226  
   227  // Utsname is a wrapper
   228  type Utsname struct {
   229  	Release [65]byte
   230  	Version [65]byte
   231  }
   232  
   233  // Uname is a wrapper
   234  func Uname(buf *Utsname) (err error) {
   235  	return errNonLinux
   236  }
   237  
   238  // Getpid is a wrapper
   239  func Getpid() int {
   240  	return -1
   241  }
   242  
   243  // Gettid is a wrapper
   244  func Gettid() int {
   245  	return -1
   246  }
   247  
   248  // Tgkill is a wrapper
   249  func Tgkill(tgid int, tid int, sig syscall.Signal) (err error) {
   250  	return errNonLinux
   251  }
   252  
   253  // BytePtrFromString is a wrapper
   254  func BytePtrFromString(s string) (*byte, error) {
   255  	return nil, errNonLinux
   256  }
   257  
   258  // ByteSliceToString is a wrapper
   259  func ByteSliceToString(s []byte) string {
   260  	return ""
   261  }
   262  
   263  // Renameat2 is a wrapper
   264  func Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) error {
   265  	return errNonLinux
   266  }
   267  
   268  func Prlimit(pid, resource int, new, old *Rlimit) error {
   269  	return errNonLinux
   270  }
   271  
   272  func Open(path string, mode int, perm uint32) (int, error) {
   273  	return -1, errNonLinux
   274  }
   275  
   276  func Fstat(fd int, stat *Stat_t) error {
   277  	return errNonLinux
   278  }