├── vendor ├── google.golang.org │ ├── grpc │ │ ├── AUTHORS │ │ ├── GOVERNANCE.md │ │ ├── CODE-OF-CONDUCT.md │ │ ├── SECURITY.md │ │ ├── NOTICE.txt │ │ ├── codegen.sh │ │ ├── version.go │ │ ├── internal │ │ │ ├── grpcutil │ │ │ │ ├── grpcutil.go │ │ │ │ └── regex.go │ │ │ ├── channelz │ │ │ │ └── util_nonlinux.go │ │ │ └── grpcsync │ │ │ │ └── oncefunc.go │ │ ├── doc.go │ │ └── Makefile │ └── protobuf │ │ ├── internal │ │ ├── editiondefaults │ │ │ ├── editions_defaults.binpb │ │ │ └── defaults.go │ │ ├── flags │ │ │ ├── proto_legacy_enable.go │ │ │ └── proto_legacy_disable.go │ │ ├── impl │ │ │ ├── codec_map_go112.go │ │ │ ├── codec_unsafe.go │ │ │ ├── enum.go │ │ │ └── codec_map_go111.go │ │ ├── errors │ │ │ ├── is_go113.go │ │ │ └── is_go112.go │ │ ├── genid │ │ │ ├── doc.go │ │ │ ├── wrappers.go │ │ │ ├── map_entry.go │ │ │ ├── empty_gen.go │ │ │ ├── goname.go │ │ │ ├── field_mask_gen.go │ │ │ └── source_context_gen.go │ │ ├── editionssupport │ │ │ └── editions.go │ │ └── strs │ │ │ └── strings_pure.go │ │ ├── encoding │ │ ├── prototext │ │ │ └── doc.go │ │ └── protojson │ │ │ └── doc.go │ │ ├── runtime │ │ └── protoiface │ │ │ └── legacy.go │ │ └── proto │ │ ├── proto_reflect.go │ │ └── proto_methods.go ├── github.com │ ├── spf13 │ │ ├── pflag │ │ │ ├── .gitignore │ │ │ └── .travis.yml │ │ └── cobra │ │ │ ├── .mailmap │ │ │ ├── MAINTAINERS │ │ │ ├── .gitignore │ │ │ ├── command_notwin.go │ │ │ └── Makefile │ ├── containerd │ │ ├── ttrpc │ │ │ ├── .gitattributes │ │ │ ├── .gitignore │ │ │ ├── test.proto │ │ │ ├── request.proto │ │ │ ├── stream_server.go │ │ │ └── doc.go │ │ ├── nri │ │ │ └── pkg │ │ │ │ ├── api │ │ │ │ ├── doc.go │ │ │ │ └── timeouts.go │ │ │ │ └── net │ │ │ │ ├── socketpair_cloexec_linux.go │ │ │ │ ├── multiplex │ │ │ │ └── ttrpc.go │ │ │ │ └── socketpair_cloexec_windows.go │ │ └── log │ │ │ ├── .golangci.yml │ │ │ └── README.md │ ├── sirupsen │ │ └── logrus │ │ │ ├── .gitignore │ │ │ ├── terminal_check_js.go │ │ │ ├── terminal_check_appengine.go │ │ │ ├── terminal_check_no_terminal.go │ │ │ ├── terminal_check_solaris.go │ │ │ ├── terminal_check_unix.go │ │ │ ├── appveyor.yml │ │ │ ├── terminal_check_bsd.go │ │ │ ├── terminal_check_notappengine.go │ │ │ ├── .travis.yml │ │ │ ├── terminal_check_windows.go │ │ │ ├── doc.go │ │ │ └── buffer_pool.go │ ├── tetratelabs │ │ └── wazero │ │ │ ├── NOTICE │ │ │ ├── internal │ │ │ ├── wasip1 │ │ │ │ ├── random.go │ │ │ │ ├── sched.go │ │ │ │ ├── proc.go │ │ │ │ ├── args.go │ │ │ │ ├── environ.go │ │ │ │ ├── poll.go │ │ │ │ ├── clock.go │ │ │ │ └── wasi.go │ │ │ ├── engine │ │ │ │ ├── wazevo │ │ │ │ │ ├── wazevoapi │ │ │ │ │ │ ├── perfmap_disabled.go │ │ │ │ │ │ ├── perfmap_enabled.go │ │ │ │ │ │ ├── resetmap.go │ │ │ │ │ │ ├── queue.go │ │ │ │ │ │ └── ptr.go │ │ │ │ │ ├── backend │ │ │ │ │ │ ├── backend.go │ │ │ │ │ │ ├── vdef.go │ │ │ │ │ │ └── isa │ │ │ │ │ │ │ ├── amd64 │ │ │ │ │ │ │ ├── abi_entry_amd64.go │ │ │ │ │ │ │ └── ext.go │ │ │ │ │ │ │ └── arm64 │ │ │ │ │ │ │ └── abi_entry_arm64.go │ │ │ │ │ ├── memmove.go │ │ │ │ │ ├── frontend │ │ │ │ │ │ ├── misc.go │ │ │ │ │ │ └── sort_id.go │ │ │ │ │ ├── ssa │ │ │ │ │ │ ├── funcref.go │ │ │ │ │ │ ├── basic_block_sort.go │ │ │ │ │ │ └── ssa.go │ │ │ │ │ ├── entrypoint_others.go │ │ │ │ │ ├── entrypoint_amd64.go │ │ │ │ │ └── entrypoint_arm64.go │ │ │ │ └── interpreter │ │ │ │ │ └── format.go │ │ │ ├── expctxkeys │ │ │ │ ├── expctxkeys.go │ │ │ │ ├── memory.go │ │ │ │ ├── close.go │ │ │ │ ├── importresolver.go │ │ │ │ ├── listener.go │ │ │ │ └── checkpoint.go │ │ │ ├── platform │ │ │ │ ├── time_notcgo.go │ │ │ │ ├── path.go │ │ │ │ ├── platform_arm64.go │ │ │ │ ├── platform_amd64.go │ │ │ │ ├── time_cgo.go │ │ │ │ ├── cpuid_amd64.s │ │ │ │ ├── mmap_other.go │ │ │ │ ├── crypto.go │ │ │ │ ├── path_windows.go │ │ │ │ ├── mmap_unsupported.go │ │ │ │ └── cpuid_unsupported.go │ │ │ ├── internalapi │ │ │ │ └── internal.go │ │ │ ├── sock │ │ │ │ ├── sock_unsupported.go │ │ │ │ └── sock_supported.go │ │ │ ├── sysfs │ │ │ │ ├── datasync_tinygo.go │ │ │ │ ├── sync.go │ │ │ │ ├── unlink_plan9.go │ │ │ │ ├── poll_darwin.s │ │ │ │ ├── rename_plan9.go │ │ │ │ ├── datasync_linux.go │ │ │ │ ├── futimens_darwin.s │ │ │ │ ├── nonblock_unsupported.go │ │ │ │ ├── sysfs.go │ │ │ │ ├── datasync_unsupported.go │ │ │ │ ├── rename.go │ │ │ │ ├── ino_tinygo.go │ │ │ │ ├── ino_plan9.go │ │ │ │ ├── unlink.go │ │ │ │ ├── poll_unsupported.go │ │ │ │ ├── nonblock_unix.go │ │ │ │ ├── stat.go │ │ │ │ ├── syscall6_darwin.go │ │ │ │ ├── open_file_unsupported.go │ │ │ │ ├── sync_windows.go │ │ │ │ ├── ino.go │ │ │ │ ├── futimens_unsupported.go │ │ │ │ ├── unlink_windows.go │ │ │ │ ├── open_file_tinygo.go │ │ │ │ ├── poll.go │ │ │ │ ├── open_file_freebsd.go │ │ │ │ ├── nonblock_windows.go │ │ │ │ ├── open_file_darwin.go │ │ │ │ ├── open_file_notwindows.go │ │ │ │ ├── dir.go │ │ │ │ ├── file_unsupported.go │ │ │ │ ├── open_file_linux.go │ │ │ │ ├── ino_windows.go │ │ │ │ ├── open_file_sun.go │ │ │ │ ├── oflag.go │ │ │ │ ├── file_unix.go │ │ │ │ ├── futimens.go │ │ │ │ ├── stat_bsd.go │ │ │ │ └── dirfs_unsupported.go │ │ │ ├── u32 │ │ │ │ └── u32.go │ │ │ ├── u64 │ │ │ │ └── u64.go │ │ │ ├── wasm │ │ │ │ └── binary │ │ │ │ │ ├── errors.go │ │ │ │ │ ├── header.go │ │ │ │ │ ├── custom.go │ │ │ │ │ └── export.go │ │ │ ├── fsapi │ │ │ │ ├── poll.go │ │ │ │ └── unimplemented.go │ │ │ └── ieee754 │ │ │ │ └── ieee754.go │ │ │ ├── .gitattributes │ │ │ ├── .editorconfig │ │ │ ├── .gitmodules │ │ │ ├── experimental │ │ │ ├── sys │ │ │ │ ├── syscall_errno_unsupported.go │ │ │ │ ├── syscall_errno_notwindows.go │ │ │ │ ├── time.go │ │ │ │ └── error.go │ │ │ ├── importresolver.go │ │ │ └── features.go │ │ │ ├── config_unsupported.go │ │ │ ├── codecov.yml │ │ │ ├── netlify.toml │ │ │ ├── sys │ │ │ ├── stat_unsupported.go │ │ │ ├── stat_bsd.go │ │ │ ├── stat_windows.go │ │ │ └── stat_linux.go │ │ │ ├── config_supported.go │ │ │ ├── imports │ │ │ └── wasi_snapshot_preview1 │ │ │ │ └── sched.go │ │ │ └── .gitignore │ ├── jedib0t │ │ └── go-pretty │ │ │ └── v6 │ │ │ ├── text │ │ │ ├── ansi_unix.go │ │ │ ├── filter.go │ │ │ ├── README.md │ │ │ ├── hyperlink.go │ │ │ ├── direction.go │ │ │ ├── ansi_windows.go │ │ │ └── cursor.go │ │ │ ├── table │ │ │ └── pager_options.go │ │ │ └── LICENSE │ ├── golang │ │ └── protobuf │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ └── ptypes │ │ │ └── doc.go │ ├── mattn │ │ └── go-runewidth │ │ │ ├── runewidth_appengine.go │ │ │ ├── runewidth_js.go │ │ │ ├── runewidth_windows.go │ │ │ └── README.md │ ├── rivo │ │ └── uniseg │ │ │ └── doc.go │ ├── inconshreveable │ │ └── mousetrap │ │ │ ├── trap_others.go │ │ │ └── README.md │ ├── gogo │ │ └── protobuf │ │ │ ├── AUTHORS │ │ │ └── CONTRIBUTORS │ ├── opencontainers │ │ └── runtime-spec │ │ │ └── specs-go │ │ │ └── version.go │ ├── knqyf263 │ │ └── go-plugin │ │ │ └── wasm │ │ │ └── plugin.go │ └── NVIDIA │ │ └── go-nvml │ │ └── pkg │ │ ├── dl │ │ └── dl_linux.go │ │ └── nvml │ │ ├── doc.go │ │ ├── cgo_helpers.h │ │ ├── refcount.go │ │ └── const_static.go ├── golang.org │ └── x │ │ ├── net │ │ ├── http2 │ │ │ └── .gitignore │ │ └── idna │ │ │ ├── pre_go118.go │ │ │ ├── go118.go │ │ │ ├── trie12.0.0.go │ │ │ └── trie13.0.0.go │ │ ├── sys │ │ ├── unix │ │ │ ├── .gitignore │ │ │ ├── ptrace_ios.go │ │ │ ├── syscall_linux_amd64_gc.go │ │ │ ├── endian_big.go │ │ │ ├── ptrace_darwin.go │ │ │ ├── constants.go │ │ │ ├── endian_little.go │ │ │ ├── mmap_nomremap.go │ │ │ ├── aliases.go │ │ │ ├── readdirent_getdents.go │ │ │ ├── pagesize_unix.go │ │ │ ├── sysvshm_unix_other.go │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── syscall_linux_gc_arm.go │ │ │ ├── asm_solaris_amd64.s │ │ │ ├── fcntl_linux_32bit.go │ │ │ ├── syscall_linux_alarm.go │ │ │ ├── gccgo_linux_amd64.go │ │ │ ├── syscall_linux_gc.go │ │ │ ├── syscall_hurd_386.go │ │ │ ├── sysvshm_linux.go │ │ │ ├── sockcmsg_dragonfly.go │ │ │ ├── race0.go │ │ │ ├── syscall_linux_gc_386.go │ │ │ ├── syscall_linux_gccgo_arm.go │ │ │ ├── syscall_unix_gc.go │ │ │ ├── syscall_solaris_amd64.go │ │ │ ├── race.go │ │ │ ├── syscall_hurd.go │ │ │ ├── env_unix.go │ │ │ ├── asm_bsd_arm.s │ │ │ ├── readdirent_getdirentries.go │ │ │ ├── zptrace_linux_arm64.go │ │ │ ├── asm_openbsd_mips64.s │ │ │ ├── asm_bsd_386.s │ │ │ ├── asm_bsd_arm64.s │ │ │ ├── asm_bsd_riscv64.s │ │ │ ├── asm_bsd_amd64.s │ │ │ ├── asm_bsd_ppc64.s │ │ │ ├── bluetooth_linux.go │ │ │ ├── dev_aix_ppc.go │ │ │ ├── dev_darwin.go │ │ │ ├── syscall_unix_gc_ppc64x.go │ │ │ ├── fdset.go │ │ │ ├── fcntl_darwin.go │ │ │ ├── dev_zos.go │ │ │ ├── dev_aix_ppc64.go │ │ │ ├── syscall_netbsd_amd64.go │ │ │ ├── syscall_netbsd_arm64.go │ │ │ ├── syscall_netbsd_386.go │ │ │ ├── syscall_netbsd_arm.go │ │ │ ├── dev_netbsd.go │ │ │ ├── dev_openbsd.go │ │ │ ├── asm_linux_ppc64x.s │ │ │ ├── syscall_linux_gccgo_386.go │ │ │ ├── dev_freebsd.go │ │ │ └── syscall_openbsd_mips64.go │ │ └── windows │ │ │ ├── aliases.go │ │ │ ├── mksyscall.go │ │ │ ├── race0.go │ │ │ ├── str.go │ │ │ ├── race.go │ │ │ ├── eventlog.go │ │ │ ├── types_windows_amd64.go │ │ │ ├── types_windows_arm64.go │ │ │ ├── types_windows_386.go │ │ │ └── types_windows_arm.go │ │ └── text │ │ ├── secure │ │ └── bidirule │ │ │ ├── bidirule10.0.0.go │ │ │ └── bidirule9.0.0.go │ │ └── width │ │ ├── trieval.go │ │ └── kind_string.go └── sigs.k8s.io │ └── yaml │ ├── code-of-conduct.md │ ├── .gitignore │ ├── .travis.yml │ ├── OWNERS │ ├── goyaml.v2 │ ├── OWNERS │ ├── NOTICE │ └── writerc.go │ ├── RELEASE.md │ ├── SECURITY_CONTACTS │ └── yaml_go110.go ├── .github ├── chart-releaser.yaml └── workflows │ └── helm-lint.yaml ├── charts └── fake-gpu │ ├── templates │ ├── configmap.yaml │ ├── serviceaccount.yaml │ └── NOTES.txt │ └── .helmignore ├── cmd └── nvidia-smi │ └── main.go ├── pkg └── nvidia │ └── common │ └── gpu.go ├── .clang-format └── .gitignore /vendor/google.golang.org/grpc/AUTHORS: -------------------------------------------------------------------------------- 1 | Google Inc. 2 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/pflag/.gitignore: -------------------------------------------------------------------------------- 1 | .idea/* 2 | 3 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | h2i/h2i 3 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/.gitignore: -------------------------------------------------------------------------------- 1 | _obj/ 2 | unix.test 3 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/ttrpc/.gitattributes: -------------------------------------------------------------------------------- 1 | *.go text eol=lf 2 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/.gitignore: -------------------------------------------------------------------------------- 1 | logrus 2 | vendor 3 | 4 | .idea/ 5 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/NOTICE: -------------------------------------------------------------------------------- 1 | wazero 2 | Copyright 2020-2023 wazero authors 3 | -------------------------------------------------------------------------------- /.github/chart-releaser.yaml: -------------------------------------------------------------------------------- 1 | owner: chaunceyjiang 2 | git-repo: fake-gpu 3 | release-name-template: "{{ .Version }}" -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasip1/random.go: -------------------------------------------------------------------------------- 1 | package wasip1 2 | 3 | const RandomGetName = "random_get" 4 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasip1/sched.go: -------------------------------------------------------------------------------- 1 | package wasip1 2 | 3 | const SchedYieldName = "sched_yield" 4 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/.gitattributes: -------------------------------------------------------------------------------- 1 | # Improves experience of commands like `make format` on Windows 2 | * text=auto eol=lf 3 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_js.go: -------------------------------------------------------------------------------- 1 | // +build js 2 | 3 | package logrus 4 | 5 | func isTerminal(fd int) bool { 6 | return false 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasip1/proc.go: -------------------------------------------------------------------------------- 1 | package wasip1 2 | 3 | const ( 4 | ProcExitName = "proc_exit" 5 | ProcRaiseName = "proc_raise" 6 | ) 7 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/wazevoapi/perfmap_disabled.go: -------------------------------------------------------------------------------- 1 | //go:build !perfmap 2 | 3 | package wazevoapi 4 | 5 | const PerfMapEnabled = false 6 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/wazevoapi/perfmap_enabled.go: -------------------------------------------------------------------------------- 1 | //go:build perfmap 2 | 3 | package wazevoapi 4 | 5 | const PerfMapEnabled = true 6 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasip1/args.go: -------------------------------------------------------------------------------- 1 | package wasip1 2 | 3 | const ( 4 | ArgsGetName = "args_get" 5 | ArgsSizesGetName = "args_sizes_get" 6 | ) 7 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/.editorconfig: -------------------------------------------------------------------------------- 1 | root = true 2 | 3 | [*] 4 | charset = utf-8 5 | end_of_line = lf 6 | insert_final_newline = true 7 | trim_trailing_whitespace = true 8 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/expctxkeys/expctxkeys.go: -------------------------------------------------------------------------------- 1 | // Package expctxkeys provides keys for the context used to store the experimental APIs. 2 | package expctxkeys 3 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/GOVERNANCE.md: -------------------------------------------------------------------------------- 1 | This repository is governed by the gRPC organization's [governance rules](https://github.com/grpc/grpc-community/blob/master/governance.md). 2 | -------------------------------------------------------------------------------- /vendor/github.com/jedib0t/go-pretty/v6/text/ansi_unix.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | // +build !windows 3 | 4 | package text 5 | 6 | func areANSICodesSupported() bool { 7 | return true 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "site/themes/hello-friend"] 2 | path = site/themes/hello-friend 3 | url = https://github.com/panr/hugo-theme-hello-friend.git 4 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasip1/environ.go: -------------------------------------------------------------------------------- 1 | package wasip1 2 | 3 | const ( 4 | EnvironGetName = "environ_get" 5 | EnvironSizesGetName = "environ_sizes_get" 6 | ) 7 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/time_notcgo.go: -------------------------------------------------------------------------------- 1 | //go:build !cgo && !windows 2 | 3 | package platform 4 | 5 | func nanotime() int64 { 6 | return nanotimePortable() 7 | } 8 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/CODE-OF-CONDUCT.md: -------------------------------------------------------------------------------- 1 | ## Community Code of Conduct 2 | 3 | gRPC follows the [CNCF Code of Conduct](https://github.com/cncf/foundation/blob/master/code-of-conduct.md). 4 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/code-of-conduct.md: -------------------------------------------------------------------------------- 1 | # Kubernetes Community Code of Conduct 2 | 3 | Please refer to our [Kubernetes Community Code of Conduct](https://git.k8s.io/community/code-of-conduct.md) 4 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/experimental/sys/syscall_errno_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build plan9 || aix 2 | 3 | package sys 4 | 5 | func syscallToErrno(err error) (Errno, bool) { 6 | return 0, false 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/.mailmap: -------------------------------------------------------------------------------- 1 | Steve Francia 2 | Bjørn Erik Pedersen 3 | Fabiano Franz 4 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/expctxkeys/memory.go: -------------------------------------------------------------------------------- 1 | package expctxkeys 2 | 3 | // MemoryAllocatorKey is a context.Context key for the experimental memory allocator. 4 | type MemoryAllocatorKey struct{} 5 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chaunceyjiang/fake-gpu/HEAD/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb -------------------------------------------------------------------------------- /charts/fake-gpu/templates/configmap.yaml: -------------------------------------------------------------------------------- 1 | apiVersion: v1 2 | kind: ConfigMap 3 | metadata: 4 | name: {{ .Release.Name }}-configmap 5 | data: 6 | fake-gpu.yaml: |- 7 | {{ .Files.Get "files/fake-gpu.yaml" | indent 4 }} 8 | -------------------------------------------------------------------------------- /vendor/github.com/golang/protobuf/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/golang/protobuf/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_appengine.go: -------------------------------------------------------------------------------- 1 | // +build appengine 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | ) 8 | 9 | func checkIfTerminal(w io.Writer) bool { 10 | return true 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go: -------------------------------------------------------------------------------- 1 | // +build js nacl plan9 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | ) 8 | 9 | func checkIfTerminal(w io.Writer) bool { 10 | return false 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/backend.go: -------------------------------------------------------------------------------- 1 | // Package backend must be free of Wasm-specific concept. In other words, 2 | // this package must not import internal/wasm package. 3 | package backend 4 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/expctxkeys/close.go: -------------------------------------------------------------------------------- 1 | package expctxkeys 2 | 3 | // CloseNotifierKey is a context.Context Value key. Its associated value should be a 4 | // Notifier. 5 | type CloseNotifierKey struct{} 6 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/MAINTAINERS: -------------------------------------------------------------------------------- 1 | maintainers: 2 | - spf13 3 | - johnSchnake 4 | - jpmcb 5 | - marckhouzam 6 | inactive: 7 | - anthonyfok 8 | - bep 9 | - bogem 10 | - broady 11 | - eparis 12 | - jharshman 13 | - wfernandes 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/internalapi/internal.go: -------------------------------------------------------------------------------- 1 | package internalapi 2 | 3 | type WazeroOnly interface { 4 | wazeroOnly() 5 | } 6 | 7 | type WazeroOnlyType struct{} 8 | 9 | func (WazeroOnlyType) wazeroOnly() {} 10 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/path.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | 3 | package platform 4 | 5 | // ToPosixPath returns the input, as only windows might return backslashes. 6 | func ToPosixPath(in string) string { return in } 7 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/SECURITY.md: -------------------------------------------------------------------------------- 1 | # Security Policy 2 | 3 | For information on gRPC Security Policy and reporting potentional security issues, please see [gRPC CVE Process](https://github.com/grpc/proposal/blob/master/P4-grpc-cve-process.md). 4 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/runewidth_appengine.go: -------------------------------------------------------------------------------- 1 | //go:build appengine 2 | // +build appengine 3 | 4 | package runewidth 5 | 6 | // IsEastAsian return true if the current locale is CJK 7 | func IsEastAsian() bool { 8 | return false 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/expctxkeys/importresolver.go: -------------------------------------------------------------------------------- 1 | package expctxkeys 2 | 3 | // ImportResolverKey is a context.Context Value key. 4 | // Its associated value should be an ImportResolver. 5 | // See issue 2294. 6 | type ImportResolverKey struct{} 7 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/platform_arm64.go: -------------------------------------------------------------------------------- 1 | package platform 2 | 3 | // init verifies that the current CPU supports the required ARM64 features 4 | func init() { 5 | // No further checks currently needed. 6 | archRequirementsVerified = true 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sock/sock_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build plan9 || js || tinygo 2 | 3 | package sock 4 | 5 | // plan9/js doesn't declare these constants 6 | const ( 7 | SHUT_RD = 1 << iota 8 | SHUT_WR 9 | SHUT_RDWR = SHUT_RD | SHUT_WR 10 | ) 11 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sock/sock_supported.go: -------------------------------------------------------------------------------- 1 | //go:build !plan9 && !js && !tinygo 2 | 3 | package sock 4 | 5 | import "syscall" 6 | 7 | const ( 8 | SHUT_RD = syscall.SHUT_RD 9 | SHUT_RDWR = syscall.SHUT_RDWR 10 | SHUT_WR = syscall.SHUT_WR 11 | ) 12 | -------------------------------------------------------------------------------- /cmd/nvidia-smi/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | 7 | "github.com/chaunceyjiang/fake-gpu/pkg/nvidia" 8 | ) 9 | 10 | func main() { 11 | if err := nvidia.RootCmd.Execute(); err != nil { 12 | fmt.Println("Error:", err) 13 | os.Exit(1) 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_tinygo.go: -------------------------------------------------------------------------------- 1 | //go:build tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "os" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | func datasync(f *os.File) sys.Errno { 12 | return sys.ENOSYS 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/rivo/uniseg/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package uniseg implements Unicode Text Segmentation according to Unicode 3 | Standard Annex #29 (http://unicode.org/reports/tr29/). 4 | 5 | At this point, only the determination of grapheme cluster boundaries is 6 | implemented. 7 | */ 8 | package uniseg 9 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/sync.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | 3 | package sysfs 4 | 5 | import ( 6 | "os" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | func fsync(f *os.File) sys.Errno { 12 | return sys.UnwrapOSError(f.Sync()) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/runewidth_js.go: -------------------------------------------------------------------------------- 1 | //go:build js && !appengine 2 | // +build js,!appengine 3 | 4 | package runewidth 5 | 6 | func IsEastAsian() bool { 7 | // TODO: Implement this for the web. Detect east asian in a compatible way, and return true. 8 | return false 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/memmove.go: -------------------------------------------------------------------------------- 1 | package wazevo 2 | 3 | import ( 4 | "reflect" 5 | "unsafe" 6 | ) 7 | 8 | //go:linkname memmove runtime.memmove 9 | func memmove(_, _ unsafe.Pointer, _ uintptr) 10 | 11 | var memmovPtr = reflect.ValueOf(memmove).Pointer() 12 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/platform_amd64.go: -------------------------------------------------------------------------------- 1 | package platform 2 | 3 | // init verifies that the current CPU supports the required AMD64 instructions 4 | func init() { 5 | // Ensure SSE4.1 is supported. 6 | archRequirementsVerified = CpuFeatures.Has(CpuFeatureAmd64SSE4_1) 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/ttrpc/.gitignore: -------------------------------------------------------------------------------- 1 | # Binaries for programs and plugins 2 | /bin/ 3 | *.exe 4 | *.dll 5 | *.so 6 | *.dylib 7 | 8 | # Test binary, build with `go test -c` 9 | *.test 10 | 11 | # Output of the go coverage tool, specifically when used with LiteIDE 12 | *.out 13 | coverage.txt 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/config_unsupported.go: -------------------------------------------------------------------------------- 1 | // This is the opposite constraint of config_supported.go 2 | //go:build !(amd64 || arm64) || !(darwin || linux || freebsd || windows) 3 | 4 | package wazero 5 | 6 | func newRuntimeConfig() RuntimeConfig { 7 | return NewRuntimeConfigInterpreter() 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink_plan9.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "syscall" 5 | 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | ) 8 | 9 | func unlink(name string) sys.Errno { 10 | err := syscall.Remove(name) 11 | return sys.UnwrapOSError(err) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_solaris.go: -------------------------------------------------------------------------------- 1 | package logrus 2 | 3 | import ( 4 | "golang.org/x/sys/unix" 5 | ) 6 | 7 | // IsTerminal returns true if the given file descriptor is a terminal. 8 | func isTerminal(fd int) bool { 9 | _, err := unix.IoctlGetTermio(fd, unix.TCGETA) 10 | return err == nil 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/expctxkeys/listener.go: -------------------------------------------------------------------------------- 1 | package expctxkeys 2 | 3 | // FunctionListenerFactoryKey is a context.Context Value key. 4 | // Its associated value should be a FunctionListenerFactory. 5 | // 6 | // See https://github.com/tetratelabs/wazero/issues/451 7 | type FunctionListenerFactoryKey struct{} 8 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_darwin.s: -------------------------------------------------------------------------------- 1 | // lifted from golang.org/x/sys unix 2 | #include "textflag.h" 3 | 4 | TEXT libc_poll_trampoline<>(SB), NOSPLIT, $0-0 5 | JMP libc_poll(SB) 6 | 7 | GLOBL ·libc_poll_trampoline_addr(SB), RODATA, $8 8 | DATA ·libc_poll_trampoline_addr(SB)/8, $libc_poll_trampoline<>(SB) 9 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/rename_plan9.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "os" 5 | 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | ) 8 | 9 | func rename(from, to string) sys.Errno { 10 | if from == to { 11 | return 0 12 | } 13 | return sys.UnwrapOSError(os.Rename(from, to)) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/u32/u32.go: -------------------------------------------------------------------------------- 1 | package u32 2 | 3 | // LeBytes returns a byte slice corresponding to the 4 bytes in the uint32 in little-endian byte order. 4 | func LeBytes(v uint32) []byte { 5 | return []byte{ 6 | byte(v), 7 | byte(v >> 8), 8 | byte(v >> 16), 9 | byte(v >> 24), 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/experimental/sys/syscall_errno_notwindows.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | 3 | package sys 4 | 5 | func errorToErrno(err error) Errno { 6 | if errno, ok := err.(Errno); ok { 7 | return errno 8 | } 9 | if errno, ok := syscallToErrno(err); ok { 10 | return errno 11 | } 12 | return EIO 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/jedib0t/go-pretty/v6/table/pager_options.go: -------------------------------------------------------------------------------- 1 | package table 2 | 3 | // PagerOption helps control Paging. 4 | type PagerOption func(t *Table) 5 | 6 | // PageSize sets the size of each page rendered. 7 | func PageSize(pageSize int) PagerOption { 8 | return func(t *Table) { 9 | t.pager.size = pageSize 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_unix.go: -------------------------------------------------------------------------------- 1 | // +build linux aix zos 2 | // +build !js 3 | 4 | package logrus 5 | 6 | import "golang.org/x/sys/unix" 7 | 8 | const ioctlReadTermios = unix.TCGETS 9 | 10 | func isTerminal(fd int) bool { 11 | _, err := unix.IoctlGetTermios(fd, ioctlReadTermios) 12 | return err == nil 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/frontend/misc.go: -------------------------------------------------------------------------------- 1 | package frontend 2 | 3 | import ( 4 | "github.com/tetratelabs/wazero/internal/engine/wazevo/ssa" 5 | "github.com/tetratelabs/wazero/internal/wasm" 6 | ) 7 | 8 | func FunctionIndexToFuncRef(idx wasm.Index) ssa.FuncRef { 9 | return ssa.FuncRef(idx) 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_linux.go: -------------------------------------------------------------------------------- 1 | //go:build linux && !tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "os" 7 | "syscall" 8 | 9 | "github.com/tetratelabs/wazero/experimental/sys" 10 | ) 11 | 12 | func datasync(f *os.File) sys.Errno { 13 | return sys.UnwrapOSError(syscall.Fdatasync(int(f.Fd()))) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/encoding/prototext/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package prototext marshals and unmarshals protocol buffer messages as the 6 | // textproto format. 7 | package prototext 8 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/ttrpc/test.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package ttrpc; 4 | 5 | option go_package = "github.com/containerd/ttrpc/internal"; 6 | 7 | message TestPayload { 8 | string foo = 1; 9 | int64 deadline = 2; 10 | string metadata = 3; 11 | } 12 | 13 | message EchoPayload { 14 | int64 seq = 1; 15 | string msg = 2; 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/wazevoapi/resetmap.go: -------------------------------------------------------------------------------- 1 | package wazevoapi 2 | 3 | // ResetMap resets the map to an empty state, or creates a new map if it is nil. 4 | func ResetMap[K comparable, V any](m map[K]V) map[K]V { 5 | if m == nil { 6 | m = make(map[K]V) 7 | } else { 8 | clear(m) 9 | } 10 | return m 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_darwin.s: -------------------------------------------------------------------------------- 1 | // lifted from golang.org/x/sys unix 2 | #include "textflag.h" 3 | 4 | TEXT libc_futimens_trampoline<>(SB), NOSPLIT, $0-0 5 | JMP libc_futimens(SB) 6 | 7 | GLOBL ·libc_futimens_trampoline_addr(SB), RODATA, $8 8 | DATA ·libc_futimens_trampoline_addr(SB)/8, $libc_futimens_trampoline<>(SB) 9 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build plan9 || tinygo 2 | 3 | package sysfs 4 | 5 | import "github.com/tetratelabs/wazero/experimental/sys" 6 | 7 | func setNonblock(fd uintptr, enable bool) sys.Errno { 8 | return sys.ENOSYS 9 | } 10 | 11 | func isNonblock(f *osFile) bool { 12 | return false 13 | } 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build protolegacy 6 | // +build protolegacy 7 | 8 | package flags 9 | 10 | const protoLegacy = true 11 | -------------------------------------------------------------------------------- /vendor/github.com/jedib0t/go-pretty/v6/text/filter.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | // Filter filters the slice 's' to items which return truth when passed to 'f'. 4 | func Filter(s []string, f func(string) bool) []string { 5 | var out []string 6 | for _, item := range s { 7 | if f(item) { 8 | out = append(out, item) 9 | } 10 | } 11 | return out 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/frontend/sort_id.go: -------------------------------------------------------------------------------- 1 | package frontend 2 | 3 | import ( 4 | "slices" 5 | 6 | "github.com/tetratelabs/wazero/internal/engine/wazevo/ssa" 7 | ) 8 | 9 | func sortSSAValueIDs(IDs []ssa.ValueID) { 10 | slices.SortFunc(IDs, func(i, j ssa.ValueID) int { 11 | return int(i) - int(j) 12 | }) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/sysfs.go: -------------------------------------------------------------------------------- 1 | // Package sysfs includes a low-level filesystem interface and utilities needed 2 | // for WebAssembly host functions (ABI) such as WASI. 3 | // 4 | // The name sysfs was chosen because wazero's public API has a "sys" package, 5 | // which was named after https://github.com/golang/sys. 6 | package sysfs 7 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !protolegacy 6 | // +build !protolegacy 7 | 8 | package flags 9 | 10 | const protoLegacy = false 11 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: "{build}" 2 | platform: x64 3 | clone_folder: c:\gopath\src\github.com\sirupsen\logrus 4 | environment: 5 | GOPATH: c:\gopath 6 | branches: 7 | only: 8 | - master 9 | install: 10 | - set PATH=%GOPATH%\bin;c:\go\bin;%PATH% 11 | - go version 12 | build_script: 13 | - go get -t 14 | - go test 15 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/codecov.yml: -------------------------------------------------------------------------------- 1 | # Codecov for main is visible here https://app.codecov.io/gh/tetratelabs/wazero 2 | 3 | # We use codecov only as a UI, so we disable PR comments and commit status. 4 | # See https://docs.codecov.com/docs/pull-request-comments 5 | comment: false 6 | coverage: 7 | status: 8 | project: off 9 | patch: off 10 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build !linux 2 | 3 | package sysfs 4 | 5 | import ( 6 | "os" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | func datasync(f *os.File) sys.Errno { 12 | // Attempt to sync everything, even if we only need to sync the data. 13 | return fsync(f) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_bsd.go: -------------------------------------------------------------------------------- 1 | // +build darwin dragonfly freebsd netbsd openbsd 2 | // +build !js 3 | 4 | package logrus 5 | 6 | import "golang.org/x/sys/unix" 7 | 8 | const ioctlReadTermios = unix.TIOCGETA 9 | 10 | func isTerminal(fd int) bool { 11 | _, err := unix.IoctlGetTermios(fd, ioctlReadTermios) 12 | return err == nil 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go: -------------------------------------------------------------------------------- 1 | // +build !appengine,!js,!windows,!nacl,!plan9 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | "os" 8 | ) 9 | 10 | func checkIfTerminal(w io.Writer) bool { 11 | switch v := w.(type) { 12 | case *os.File: 13 | return isTerminal(int(v.Fd())) 14 | default: 15 | return false 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/ptrace_ios.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) { 10 | return ENOTSUP 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/aliases.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | import "syscall" 10 | 11 | type Errno = syscall.Errno 12 | type SysProcAttr = syscall.SysProcAttr 13 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/time_cgo.go: -------------------------------------------------------------------------------- 1 | //go:build cgo && !windows 2 | 3 | package platform 4 | 5 | import _ "unsafe" // for go:linkname 6 | 7 | // nanotime uses runtime.nanotime as it is available on all platforms and 8 | // benchmarks faster than using time.Since. 9 | // 10 | //go:linkname nanotime runtime.nanotime 11 | func nanotime() int64 12 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go_import_path: github.com/sirupsen/logrus 3 | git: 4 | depth: 1 5 | env: 6 | - GO111MODULE=on 7 | go: 1.15.x 8 | os: linux 9 | install: 10 | - ./travis/install.sh 11 | script: 12 | - cd ci 13 | - go run mage.go -v -w ../ crossBuild 14 | - go run mage.go -v -w ../ lint 15 | - go run mage.go -v -w ../ test 16 | -------------------------------------------------------------------------------- /vendor/github.com/jedib0t/go-pretty/v6/text/README.md: -------------------------------------------------------------------------------- 1 | # text 2 | 3 | [![Go Reference](https://pkg.go.dev/badge/github.com/jedib0t/go-pretty/v6.svg)](https://pkg.go.dev/github.com/jedib0t/go-pretty/v6/text) 4 | 5 | Package with utility functions to manipulate strings/text. 6 | 7 | Used heavily in the other packages in this repo ([list](../list), 8 | [progress](../progress), and [table](../table)). -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/rename.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !plan9 && !tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "syscall" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | func rename(from, to string) sys.Errno { 12 | if from == to { 13 | return 0 14 | } 15 | return sys.UnwrapOSError(syscall.Rename(from, to)) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/idna/pre_go118.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | // Copyright 2021 The Go Authors. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | //go:build !go1.18 8 | 9 | package idna 10 | 11 | const transitionalLookup = true 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && linux && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //go:noescape 12 | func gettimeofday(tv *Timeval) (err syscall.Errno) 13 | -------------------------------------------------------------------------------- /vendor/github.com/jedib0t/go-pretty/v6/text/hyperlink.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | import "fmt" 4 | 5 | func Hyperlink(url, text string) string { 6 | if url == "" { 7 | return text 8 | } 9 | if text == "" { 10 | return url 11 | } 12 | // source https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda 13 | return fmt.Sprintf("\x1b]8;;%s\x1b\\%s\x1b]8;;\x1b\\", url, text) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/pflag/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | 3 | language: go 4 | 5 | go: 6 | - 1.9.x 7 | - 1.10.x 8 | - 1.11.x 9 | - tip 10 | 11 | matrix: 12 | allow_failures: 13 | - go: tip 14 | 15 | install: 16 | - go get golang.org/x/lint/golint 17 | - export PATH=$GOPATH/bin:$PATH 18 | - go install ./... 19 | 20 | script: 21 | - verify/all.sh -v 22 | - go test ./... 23 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/funcref.go: -------------------------------------------------------------------------------- 1 | package ssa 2 | 3 | import "fmt" 4 | 5 | // FuncRef is a unique identifier for a function of the frontend, 6 | // and is used to reference the function in function call. 7 | type FuncRef uint32 8 | 9 | // String implements fmt.Stringer. 10 | func (r FuncRef) String() string { 11 | return fmt.Sprintf("f%d", r) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_tinygo.go: -------------------------------------------------------------------------------- 1 | //go:build tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "io/fs" 7 | 8 | experimentalsys "github.com/tetratelabs/wazero/experimental/sys" 9 | "github.com/tetratelabs/wazero/sys" 10 | ) 11 | 12 | func inoFromFileInfo(_ string, info fs.FileInfo) (sys.Inode, experimentalsys.Errno) { 13 | return 0, experimentalsys.ENOTSUP 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_big.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | //go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64 6 | 7 | package unix 8 | 9 | const isBigEndian = true 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/ptrace_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin && !ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) error { 10 | return ptrace1(request, pid, addr, data) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/.gitignore: -------------------------------------------------------------------------------- 1 | # OSX leaves these everywhere on SMB shares 2 | ._* 3 | 4 | # Eclipse files 5 | .classpath 6 | .project 7 | .settings/** 8 | 9 | # Idea files 10 | .idea/** 11 | .idea/ 12 | 13 | # Emacs save files 14 | *~ 15 | 16 | # Vim-related files 17 | [._]*.s[a-w][a-z] 18 | [._]s[a-w][a-z] 19 | *.un~ 20 | Session.vim 21 | .netrwhist 22 | 23 | # Go test binaries 24 | *.test 25 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | arch: arm64 3 | dist: focal 4 | go: 1.15.x 5 | script: 6 | - diff -u <(echo -n) <(gofmt -d *.go) 7 | - diff -u <(echo -n) <(golint $(go list -e ./...) | grep -v YAMLToJSON) 8 | - GO111MODULE=on go vet . 9 | - GO111MODULE=on go test -v -race ./... 10 | - git diff --exit-code 11 | install: 12 | - GO111MODULE=off go get golang.org/x/lint/golint 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/constants.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | const ( 10 | R_OK = 0x4 11 | W_OK = 0x2 12 | X_OK = 0x1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.12 6 | // +build go1.12 7 | 8 | package impl 9 | 10 | import "reflect" 11 | 12 | func mapRange(v reflect.Value) *reflect.MapIter { return v.MapRange() } 13 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/u64/u64.go: -------------------------------------------------------------------------------- 1 | package u64 2 | 3 | // LeBytes returns a byte slice corresponding to the 8 bytes in the uint64 in little-endian byte order. 4 | func LeBytes(v uint64) []byte { 5 | return []byte{ 6 | byte(v), 7 | byte(v >> 8), 8 | byte(v >> 16), 9 | byte(v >> 24), 10 | byte(v >> 32), 11 | byte(v >> 40), 12 | byte(v >> 48), 13 | byte(v >> 56), 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/OWNERS: -------------------------------------------------------------------------------- 1 | # See the OWNERS docs at https://go.k8s.io/owners 2 | 3 | approvers: 4 | - dims 5 | - jpbetz 6 | - smarterclayton 7 | - deads2k 8 | - sttts 9 | - liggitt 10 | reviewers: 11 | - dims 12 | - thockin 13 | - jpbetz 14 | - smarterclayton 15 | - wojtek-t 16 | - deads2k 17 | - derekwaynecarr 18 | - mikedanese 19 | - liggitt 20 | - sttts 21 | - tallclair 22 | labels: 23 | - sig/api-machinery 24 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/experimental/sys/time.go: -------------------------------------------------------------------------------- 1 | package sys 2 | 3 | import "math" 4 | 5 | // UTIME_OMIT is a special constant for use in updating times via FS.Utimens 6 | // or File.Utimens. When used for atim or mtim, the value is retained. 7 | // 8 | // Note: This may be implemented via a stat when the underlying filesystem 9 | // does not support this value. 10 | const UTIME_OMIT int64 = math.MinInt64 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.10 6 | 7 | package bidirule 8 | 9 | func (t *Transformer) isFinal() bool { 10 | return t.state == ruleLTRFinal || t.state == ruleRTLFinal || t.state == ruleInitial 11 | } 12 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/errors/is_go113.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.13 6 | // +build go1.13 7 | 8 | package errors 9 | 10 | import "errors" 11 | 12 | // Is is errors.Is. 13 | func Is(err, target error) bool { return errors.Is(err, target) } 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_plan9.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "io/fs" 5 | 6 | experimentalsys "github.com/tetratelabs/wazero/experimental/sys" 7 | "github.com/tetratelabs/wazero/sys" 8 | ) 9 | 10 | func inoFromFileInfo(_ string, info fs.FileInfo) (sys.Inode, experimentalsys.Errno) { 11 | if v, ok := info.Sys().(*sys.Stat_t); ok { 12 | return v.Ino, 0 13 | } 14 | return 0, 0 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !plan9 && !tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "syscall" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | func unlink(name string) (errno sys.Errno) { 12 | err := syscall.Unlink(name) 13 | if errno = sys.UnwrapOSError(err); errno == sys.EPERM { 14 | errno = sys.EISDIR 15 | } 16 | return errno 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_little.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | //go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh 6 | 7 | package unix 8 | 9 | const isBigEndian = false 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/mmap_nomremap.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | var mapper = &mmapper{ 10 | active: make(map[*byte][]byte), 11 | mmap: mmap, 12 | munmap: munmap, 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/mksyscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build generate 6 | 7 | package windows 8 | 9 | //go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go setupapi_windows.go 10 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package protoiface 6 | 7 | type MessageV1 interface { 8 | Reset() 9 | String() string 10 | ProtoMessage() 11 | } 12 | 13 | type ExtensionRangeV1 struct { 14 | Start, End int32 // both inclusive 15 | } 16 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/goyaml.v2/OWNERS: -------------------------------------------------------------------------------- 1 | # See the OWNERS docs at https://go.k8s.io/owners 2 | 3 | approvers: 4 | - dims 5 | - jpbetz 6 | - smarterclayton 7 | - deads2k 8 | - sttts 9 | - liggitt 10 | - natasha41575 11 | - knverey 12 | reviewers: 13 | - dims 14 | - thockin 15 | - jpbetz 16 | - smarterclayton 17 | - deads2k 18 | - derekwaynecarr 19 | - mikedanese 20 | - liggitt 21 | - sttts 22 | - tallclair 23 | labels: 24 | - sig/api-machinery 25 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/cpuid_amd64.s: -------------------------------------------------------------------------------- 1 | #include "textflag.h" 2 | 3 | // lifted from github.com/intel-go/cpuid and src/internal/cpu/cpu_x86.s 4 | // func cpuid(arg1, arg2 uint32) (eax, ebx, ecx, edx uint32) 5 | TEXT ·cpuid(SB), NOSPLIT, $0-24 6 | MOVL arg1+0(FP), AX 7 | MOVL arg2+4(FP), CX 8 | CPUID 9 | MOVL AX, eax+8(FP) 10 | MOVL BX, ebx+12(FP) 11 | MOVL CX, ecx+16(FP) 12 | MOVL DX, edx+20(FP) 13 | RET 14 | 15 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build !(linux || darwin || windows) || tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | "github.com/tetratelabs/wazero/internal/fsapi" 8 | ) 9 | 10 | // poll implements `Poll` as documented on fsapi.File via a file descriptor. 11 | func poll(uintptr, fsapi.Pflag, int32) (bool, sys.Errno) { 12 | return false, sys.ENOSYS 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasm/binary/errors.go: -------------------------------------------------------------------------------- 1 | package binary 2 | 3 | import "errors" 4 | 5 | var ( 6 | ErrInvalidByte = errors.New("invalid byte") 7 | ErrInvalidMagicNumber = errors.New("invalid magic number") 8 | ErrInvalidVersion = errors.New("invalid version header") 9 | ErrInvalidSectionID = errors.New("invalid section id") 10 | ErrCustomSectionNotFound = errors.New("custom section not found") 11 | ) 12 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/editiondefaults/defaults.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package editiondefaults contains the binary representation of the editions 6 | // defaults. 7 | package editiondefaults 8 | 9 | import _ "embed" 10 | 11 | //go:embed editions_defaults.binpb 12 | var Defaults []byte 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.10 6 | 7 | package bidirule 8 | 9 | func (t *Transformer) isFinal() bool { 10 | if !t.isRTL() { 11 | return true 12 | } 13 | return t.state == ruleLTRFinal || t.state == ruleRTLFinal || t.state == ruleInitial 14 | } 15 | -------------------------------------------------------------------------------- /charts/fake-gpu/.helmignore: -------------------------------------------------------------------------------- 1 | # Patterns to ignore when building packages. 2 | # This supports shell glob matching, relative path matching, and 3 | # negation (prefixed with !). Only one pattern per line. 4 | .DS_Store 5 | # Common VCS dirs 6 | .git/ 7 | .gitignore 8 | .bzr/ 9 | .bzrignore 10 | .hg/ 11 | .hgignore 12 | .svn/ 13 | # Common backup files 14 | *.swp 15 | *.bak 16 | *.tmp 17 | *.orig 18 | *~ 19 | # Various IDEs 20 | .project 21 | .idea/ 22 | *.tmproj 23 | .vscode/ 24 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_unix.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !plan9 && !tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "syscall" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | func setNonblock(fd uintptr, enable bool) sys.Errno { 12 | return sys.UnwrapOSError(syscall.SetNonblock(int(fd), enable)) 13 | } 14 | 15 | func isNonblock(f *osFile) bool { 16 | return f.flag&sys.O_NONBLOCK == sys.O_NONBLOCK 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/aliases.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | type Signal = syscall.Signal 12 | type Errno = syscall.Errno 13 | type SysProcAttr = syscall.SysProcAttr 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/stat.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "io/fs" 5 | 6 | experimentalsys "github.com/tetratelabs/wazero/experimental/sys" 7 | "github.com/tetratelabs/wazero/sys" 8 | ) 9 | 10 | func defaultStatFile(f fs.File) (sys.Stat_t, experimentalsys.Errno) { 11 | if info, err := f.Stat(); err != nil { 12 | return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) 13 | } else { 14 | return sys.NewStat_t(info), 0 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /charts/fake-gpu/templates/serviceaccount.yaml: -------------------------------------------------------------------------------- 1 | {{- if .Values.serviceAccount.create -}} 2 | apiVersion: v1 3 | kind: ServiceAccount 4 | metadata: 5 | name: {{ include "fake-gpu.serviceAccountName" . }} 6 | labels: 7 | {{- include "fake-gpu.labels" . | nindent 4 }} 8 | {{- with .Values.serviceAccount.annotations }} 9 | annotations: 10 | {{- toYaml . | nindent 4 }} 11 | {{- end }} 12 | automountServiceAccountToken: {{ .Values.serviceAccount.automount }} 13 | {{- end }} 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/idna/go118.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | // Copyright 2021 The Go Authors. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | //go:build go1.18 8 | 9 | package idna 10 | 11 | // Transitional processing is disabled by default in Go 1.18. 12 | // https://golang.org/issue/47510 13 | const transitionalLookup = false 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/readdirent_getdents.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || dragonfly || freebsd || linux || netbsd || openbsd 6 | 7 | package unix 8 | 9 | // ReadDirent reads directory entries from fd and writes them into buf. 10 | func ReadDirent(fd int, buf []byte) (n int, err error) { 11 | return Getdents(fd, buf) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/syscall6_darwin.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "syscall" 5 | _ "unsafe" 6 | ) 7 | 8 | // syscall_syscall6 is a private symbol that we link below. We need to use this 9 | // instead of syscall.Syscall6 because the public syscall.Syscall6 won't work 10 | // when fn is an address. 11 | // 12 | //go:linkname syscall_syscall6 syscall.syscall6 13 | func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/pagesize_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | // For Unix, get the pagesize from the runtime. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getpagesize() int { 14 | return syscall.Getpagesize() 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sysvshm_unix_other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin && !ios) || zos 6 | 7 | package unix 8 | 9 | // SysvShmCtl performs control operations on the shared memory segment 10 | // specified by id. 11 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 12 | return shmctl(id, cmd, desc) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasm/binary/header.go: -------------------------------------------------------------------------------- 1 | package binary 2 | 3 | // Magic is the 4 byte preamble (literally "\0asm") of the binary format 4 | // See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-magic 5 | var Magic = []byte{0x00, 0x61, 0x73, 0x6D} 6 | 7 | // version is format version and doesn't change between known specification versions 8 | // See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-version 9 | var version = []byte{0x01, 0x00, 0x00, 0x00} 10 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/netlify.toml: -------------------------------------------------------------------------------- 1 | [build] 2 | base = "site" 3 | publish = "public" 4 | 5 | [build.environment] 6 | HUGO_VERSION = "0.115.2" 7 | 8 | [context.production] 9 | command = "git submodule update --init && hugo --gc --minify" 10 | 11 | [context.deploy-preview] 12 | command = "git submodule update --init && hugo --gc --minify -b $DEPLOY_PRIME_URL" 13 | 14 | [context.branch-deploy] 15 | command = "git submodule update --init && hugo --gc --minify -b $DEPLOY_PRIME_URL" 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_aix_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 11 | // 12 | 13 | TEXT ·syscall6(SB),NOSPLIT,$0-88 14 | JMP syscall·syscall6(SB) 15 | 16 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSyscall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm && gc && linux 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package genid contains constants for declarations in descriptor.proto 6 | // and the well-known types. 7 | package genid 8 | 9 | import protoreflect "google.golang.org/protobuf/reflect/protoreflect" 10 | 11 | const GoogleProtobuf_package protoreflect.FullName = "google.protobuf" 12 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/mmap_other.go: -------------------------------------------------------------------------------- 1 | // Separated from linux which has support for huge pages. 2 | //go:build darwin || freebsd 3 | 4 | package platform 5 | 6 | import "syscall" 7 | 8 | func mmapCodeSegment(size, prot int) ([]byte, error) { 9 | return syscall.Mmap( 10 | -1, 11 | 0, 12 | size, 13 | prot, 14 | // Anonymous as this is not an actual file, but a memory, 15 | // Private as this is in-process memory region. 16 | syscall.MAP_ANON|syscall.MAP_PRIVATE, 17 | ) 18 | } 19 | -------------------------------------------------------------------------------- /.github/workflows/helm-lint.yaml: -------------------------------------------------------------------------------- 1 | name: helm linter 2 | 3 | on: 4 | pull_request: 5 | paths: 6 | - 'charts/**' 7 | 8 | jobs: 9 | lint-test: 10 | runs-on: ubuntu-latest 11 | steps: 12 | - name: Checkout 13 | uses: actions/checkout@v4 14 | with: 15 | fetch-depth: 0 16 | 17 | - name: Set up Helm 18 | uses: azure/setup-helm@v4.0.0 19 | with: 20 | version: v3.11.2 21 | 22 | - name: Run linter for all the charts 23 | run: helm lint charts/* -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasip1/poll.go: -------------------------------------------------------------------------------- 1 | package wasip1 2 | 3 | // https://github.com/WebAssembly/WASI/blob/snapshot-01/phases/snapshot/docs.md#-eventtype-enumu8 4 | const ( 5 | // EventTypeClock is the timeout event named "name". 6 | EventTypeClock = iota 7 | // EventTypeFdRead is the data available event named "fd_read". 8 | EventTypeFdRead 9 | // EventTypeFdWrite is the capacity available event named "fd_write". 10 | EventTypeFdWrite 11 | ) 12 | 13 | const ( 14 | PollOneoffName = "poll_oneoff" 15 | ) 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_solaris_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go 11 | // 12 | 13 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88 14 | JMP syscall·sysvicall6(SB) 15 | 16 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSysvicall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle) || (linux && ppc) 6 | 7 | package unix 8 | 9 | func init() { 10 | // On 32-bit Linux systems, the fcntl syscall that matches Go's 11 | // Flock_t type is SYS_FCNTL64, not SYS_FCNTL. 12 | fcntl64Syscall = SYS_FCNTL64 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_alarm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (386 || amd64 || mips || mipsle || mips64 || mipsle || ppc64 || ppc64le || ppc || s390x || sparc64) 6 | 7 | package unix 8 | 9 | // SYS_ALARM is not defined on arm or riscv, but is available for other GOARCH 10 | // values. 11 | 12 | //sys Alarm(seconds uint) (remaining uint, err error) 13 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build !darwin && !linux && !windows && !illumos && !solaris && !freebsd 2 | 3 | package sysfs 4 | 5 | import ( 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | ) 8 | 9 | const supportedSyscallOflag = sys.Oflag(0) 10 | 11 | func withSyscallOflag(oflag sys.Oflag, flag int) int { 12 | // O_DIRECTORY not defined 13 | // O_DSYNC not defined 14 | // O_NOFOLLOW not defined 15 | // O_NONBLOCK not defined 16 | // O_RSYNC not defined 17 | return flag 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/golang/protobuf/ptypes/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package ptypes provides functionality for interacting with well-known types. 6 | // 7 | // Deprecated: Well-known types have specialized functionality directly 8 | // injected into the generated packages for each message type. 9 | // See the deprecation notice for each function for the suggested alternative. 10 | package ptypes 11 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/interpreter/format.go: -------------------------------------------------------------------------------- 1 | package interpreter 2 | 3 | import ( 4 | "bytes" 5 | ) 6 | 7 | func format(ops []unionOperation) string { 8 | buf := bytes.NewBuffer(nil) 9 | 10 | _, _ = buf.WriteString(".entrypoint\n") 11 | for i := range ops { 12 | op := &ops[i] 13 | str := op.String() 14 | isLabel := op.Kind == operationKindLabel 15 | if !isLabel { 16 | const indent = "\t" 17 | str = indent + str 18 | } 19 | _, _ = buf.WriteString(str + "\n") 20 | } 21 | return buf.String() 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/crypto.go: -------------------------------------------------------------------------------- 1 | package platform 2 | 3 | import ( 4 | "io" 5 | "math/rand" 6 | ) 7 | 8 | // seed is a fixed seed value for NewFakeRandSource. 9 | // 10 | // Trivia: While arbitrary, 42 was chosen as it is the "Ultimate Answer" in 11 | // the Douglas Adams novel "The Hitchhiker's Guide to the Galaxy." 12 | const seed = int64(42) 13 | 14 | // NewFakeRandSource returns a deterministic source of random values. 15 | func NewFakeRandSource() io.Reader { 16 | return rand.New(rand.NewSource(seed)) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/editionssupport/editions.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package editionssupport defines constants for editions that are supported. 6 | package editionssupport 7 | 8 | import descriptorpb "google.golang.org/protobuf/types/descriptorpb" 9 | 10 | const ( 11 | Minimum = descriptorpb.Edition_EDITION_PROTO2 12 | Maximum = descriptorpb.Edition_EDITION_2023 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/path_windows.go: -------------------------------------------------------------------------------- 1 | package platform 2 | 3 | import "strings" 4 | 5 | // ToPosixPath returns the input, converting any backslashes to forward ones. 6 | func ToPosixPath(in string) string { 7 | // strings.Map only allocates on change, which is good enough especially as 8 | // path.Join uses forward slash even on windows. 9 | return strings.Map(windowsToPosixSeparator, in) 10 | } 11 | 12 | func windowsToPosixSeparator(r rune) rune { 13 | if r == '\\' { 14 | return '/' 15 | } 16 | return r 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/sync_windows.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "os" 5 | 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | ) 8 | 9 | func fsync(f *os.File) sys.Errno { 10 | errno := sys.UnwrapOSError(f.Sync()) 11 | // Coerce error performing stat on a directory to 0, as it won't work 12 | // on Windows. 13 | switch errno { 14 | case sys.EACCES /* Go 1.20 */, sys.EBADF /* Go 1.19 */ : 15 | if st, err := f.Stat(); err == nil && st.IsDir() { 16 | errno = 0 17 | } 18 | } 19 | return errno 20 | } 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/wrappers.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package genid 6 | 7 | import protoreflect "google.golang.org/protobuf/reflect/protoreflect" 8 | 9 | // Generic field name and number for messages in wrappers.proto. 10 | const ( 11 | WrapperValue_Value_field_name protoreflect.Name = "value" 12 | WrapperValue_Value_field_number protoreflect.FieldNumber = 1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/entrypoint_others.go: -------------------------------------------------------------------------------- 1 | //go:build (!arm64 && !amd64) || tinygo 2 | 3 | package wazevo 4 | 5 | import ( 6 | "runtime" 7 | ) 8 | 9 | func entrypoint(preambleExecutable, functionExecutable *byte, executionContextPtr uintptr, moduleContextPtr *byte, paramResultStackPtr *uint64, goAllocatedStackSlicePtr uintptr) { 10 | panic(runtime.GOARCH) 11 | } 12 | 13 | func afterGoFunctionCallEntrypoint(executable *byte, executionContextPtr uintptr, stackPointer, framePointer uintptr) { 14 | panic(runtime.GOARCH) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/ino.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !plan9 && !tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "io/fs" 7 | "syscall" 8 | 9 | experimentalsys "github.com/tetratelabs/wazero/experimental/sys" 10 | "github.com/tetratelabs/wazero/sys" 11 | ) 12 | 13 | func inoFromFileInfo(_ string, info fs.FileInfo) (sys.Inode, experimentalsys.Errno) { 14 | switch v := info.Sys().(type) { 15 | case *sys.Stat_t: 16 | return v.Ino, 0 17 | case *syscall.Stat_t: 18 | return v.Ino, 0 19 | default: 20 | return 0, 0 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gccgo && linux && amd64 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //extern gettimeofday 12 | func realGettimeofday(*Timeval, *byte) int32 13 | 14 | func gettimeofday(tv *Timeval) (err syscall.Errno) { 15 | r := realGettimeofday(tv, nil) 16 | if r < 0 { 17 | return syscall.GetErrno() 18 | } 19 | return 0 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/sys/stat_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build (!((amd64 || arm64 || riscv64) && linux) && !((amd64 || arm64) && (darwin || freebsd)) && !((amd64 || arm64) && windows)) || js 2 | 3 | package sys 4 | 5 | import "io/fs" 6 | 7 | // sysParseable is only used here as we define "supported" as being able to 8 | // parse `info.Sys()`. The above `go:build` constraints exclude 32-bit until 9 | // that's requested. 10 | const sysParseable = false 11 | 12 | func statFromFileInfo(info fs.FileInfo) Stat_t { 13 | return defaultStatFromFileInfo(info) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/RELEASE.md: -------------------------------------------------------------------------------- 1 | # Release Process 2 | 3 | The `yaml` Project is released on an as-needed basis. The process is as follows: 4 | 5 | 1. An issue is proposing a new release with a changelog since the last release 6 | 1. All [OWNERS](OWNERS) must LGTM this release 7 | 1. An OWNER runs `git tag -s $VERSION` and inserts the changelog and pushes the tag with `git push $VERSION` 8 | 1. The release issue is closed 9 | 1. An announcement email is sent to `kubernetes-dev@googlegroups.com` with the subject `[ANNOUNCE] kubernetes-template-project $VERSION is released` 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gc 6 | 7 | package unix 8 | 9 | // SyscallNoError may be used instead of Syscall for syscalls that don't fail. 10 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 11 | 12 | // RawSyscallNoError may be used instead of RawSyscall for syscalls that don't 13 | // fail. 14 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/encoding/protojson/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package protojson marshals and unmarshals protocol buffer messages as JSON 6 | // format. It follows the guide at 7 | // https://protobuf.dev/programming-guides/proto3#json. 8 | // 9 | // This package produces a different output than the standard [encoding/json] 10 | // package, which does not operate correctly on protocol buffer messages. 11 | package protojson 12 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/ttrpc/request.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package ttrpc; 4 | 5 | import "proto/status.proto"; 6 | 7 | option go_package = "github.com/containerd/ttrpc"; 8 | 9 | message Request { 10 | string service = 1; 11 | string method = 2; 12 | bytes payload = 3; 13 | int64 timeout_nano = 4; 14 | repeated KeyValue metadata = 5; 15 | } 16 | 17 | message Response { 18 | Status status = 1; 19 | bytes payload = 2; 20 | } 21 | 22 | message StringList { 23 | repeated string list = 1; 24 | } 25 | 26 | message KeyValue { 27 | string key = 1; 28 | string value = 2; 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows && !race 6 | 7 | package windows 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/config_supported.go: -------------------------------------------------------------------------------- 1 | // Note: The build constraints here are about the compiler, which is more 2 | // narrow than the architectures supported by the assembler. 3 | // 4 | // Constraints here must match platform.CompilerSupported. 5 | // 6 | // Meanwhile, users who know their runtime.GOOS can operate with the compiler 7 | // may choose to use NewRuntimeConfigCompiler explicitly. 8 | //go:build (amd64 || arm64) && (darwin || linux || freebsd || windows) 9 | 10 | package wazero 11 | 12 | func newRuntimeConfig() RuntimeConfig { 13 | return NewRuntimeConfigCompiler() 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/wazevoapi/queue.go: -------------------------------------------------------------------------------- 1 | package wazevoapi 2 | 3 | // Queue is the resettable queue where the underlying slice is reused. 4 | type Queue[T any] struct { 5 | index int 6 | Data []T 7 | } 8 | 9 | func (q *Queue[T]) Enqueue(v T) { 10 | q.Data = append(q.Data, v) 11 | } 12 | 13 | func (q *Queue[T]) Dequeue() (ret T) { 14 | ret = q.Data[q.index] 15 | q.index++ 16 | return 17 | } 18 | 19 | func (q *Queue[T]) Empty() bool { 20 | return q.index >= len(q.Data) 21 | } 22 | 23 | func (q *Queue[T]) Reset() { 24 | q.index = 0 25 | q.Data = q.Data[:0] 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build (!windows && !linux && !darwin) || tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | ) 8 | 9 | func utimens(path string, atim, mtim int64) sys.Errno { 10 | return chtimes(path, atim, mtim) 11 | } 12 | 13 | func futimens(fd uintptr, atim, mtim int64) error { 14 | // Go exports syscall.Futimes, which is microsecond granularity, and 15 | // WASI tests expect nanosecond. We don't yet have a way to invoke the 16 | // futimens syscall portably. 17 | return sys.ENOSYS 18 | } 19 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_hurd_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 && hurd 6 | 7 | package unix 8 | 9 | const ( 10 | TIOCGETA = 0x62251713 11 | ) 12 | 13 | type Winsize struct { 14 | Row uint16 15 | Col uint16 16 | Xpixel uint16 17 | Ypixel uint16 18 | } 19 | 20 | type Termios struct { 21 | Iflag uint32 22 | Oflag uint32 23 | Cflag uint32 24 | Lflag uint32 25 | Cc [20]uint8 26 | Ispeed int32 27 | Ospeed int32 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/inconshreveable/mousetrap/trap_others.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | // +build !windows 3 | 4 | package mousetrap 5 | 6 | // StartedByExplorer returns true if the program was invoked by the user 7 | // double-clicking on the executable from explorer.exe 8 | // 9 | // It is conservative and returns false if any of the internal calls fail. 10 | // It does not guarantee that the program was run from a terminal. It only can tell you 11 | // whether it was launched from explorer.exe 12 | // 13 | // On non-Windows platforms, it always returns false. 14 | func StartedByExplorer() bool { 15 | return false 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink_windows.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "os" 5 | "syscall" 6 | 7 | "github.com/tetratelabs/wazero/experimental/sys" 8 | ) 9 | 10 | func unlink(name string) sys.Errno { 11 | err := syscall.Unlink(name) 12 | if err == nil { 13 | return 0 14 | } 15 | errno := sys.UnwrapOSError(err) 16 | if errno == sys.EBADF { 17 | lstat, errLstat := os.Lstat(name) 18 | if errLstat == nil && lstat.Mode()&os.ModeSymlink != 0 { 19 | errno = sys.UnwrapOSError(os.Remove(name)) 20 | } else { 21 | errno = sys.EISDIR 22 | } 23 | } 24 | return errno 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/expctxkeys/checkpoint.go: -------------------------------------------------------------------------------- 1 | package expctxkeys 2 | 3 | // EnableSnapshotterKey is a context key to indicate that snapshotting should be enabled. 4 | // The context.Context passed to a exported function invocation should have this key set 5 | // to a non-nil value, and host functions will be able to retrieve it using SnapshotterKey. 6 | type EnableSnapshotterKey struct{} 7 | 8 | // SnapshotterKey is a context key to access a Snapshotter from a host function. 9 | // It is only present if EnableSnapshotter was set in the function invocation context. 10 | type SnapshotterKey struct{} 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/str.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 10 | if val < 0 { 11 | return "-" + itoa(-val) 12 | } 13 | var buf [32]byte // big enough for int64 14 | i := len(buf) - 1 15 | for val >= 10 { 16 | buf[i] = byte(val%10 + '0') 17 | i-- 18 | val /= 10 19 | } 20 | buf[i] = byte(val + '0') 21 | return string(buf[i:]) 22 | } 23 | -------------------------------------------------------------------------------- /pkg/nvidia/common/gpu.go: -------------------------------------------------------------------------------- 1 | package common 2 | 3 | type GPU struct { 4 | Product string 5 | UUID string 6 | UsedMem uint64 7 | BusID string 8 | TotalMem uint64 9 | Util uint32 10 | Idx int 11 | Name string 12 | DriverVersion string 13 | CudaVersion string 14 | Temperature int 15 | PowerUsage int 16 | PowerCap int 17 | FanSpeed int 18 | Processes []Process 19 | } 20 | 21 | type Process struct { 22 | Name string 23 | PID uint32 24 | UsedMem uint64 25 | } 26 | 27 | type Opstion struct { 28 | Query []string 29 | Format []string 30 | } 31 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/NOTICE.txt: -------------------------------------------------------------------------------- 1 | Copyright 2014 gRPC authors. 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /.clang-format: -------------------------------------------------------------------------------- 1 | BasedOnStyle: Google 2 | 3 | IndentWidth: 4 4 | 5 | TabWidth: 4 6 | 7 | UseTab: Never 8 | 9 | IndentCaseLabels: true 10 | 11 | IndentWrappedFunctionNames: true 12 | 13 | ColumnLimit: 120 14 | 15 | AccessModifierOffset: -4 16 | 17 | AllowShortFunctionsOnASingleLine: Empty 18 | 19 | AllowShortIfStatementsOnASingleLine: false 20 | 21 | AllowShortLoopsOnASingleLine: false 22 | 23 | AllowShortBlocksOnASingleLine: false 24 | 25 | AllowShortCaseLabelsOnASingleLine: false 26 | 27 | KeepEmptyLinesAtTheStartOfBlocks: true 28 | 29 | MaxEmptyLinesToKeep: 1 30 | 31 | DerivePointerAlignment: false 32 | 33 | PointerAlignment: Right 34 | -------------------------------------------------------------------------------- /charts/fake-gpu/templates/NOTES.txt: -------------------------------------------------------------------------------- 1 | 2 | ______ _ _____ _____ _ _ 3 | | ____| | | / ____|| __ \ | | | | 4 | | |__ __ _ | | __ ___ | | __ | |__) || | | | 5 | | __|/ _` || |/ // _ \ | | |_ || ___/ | | | | 6 | | | | (_| || <| __/ | |__| || | | |__| | 7 | |_| \__,_||_|\_\\___| \_____||_| \____/ 8 | 9 | 10 | Note: 11 | Fake GPU is a fake GPU device. It cannot perform real GPU CUDA and will only return some query results. 12 | It is intended for testing and development purposes only. 13 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_tinygo.go: -------------------------------------------------------------------------------- 1 | //go:build tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "io/fs" 7 | "os" 8 | 9 | "github.com/tetratelabs/wazero/experimental/sys" 10 | ) 11 | 12 | const supportedSyscallOflag = sys.Oflag(0) 13 | 14 | func withSyscallOflag(oflag sys.Oflag, flag int) int { 15 | // O_DIRECTORY not defined 16 | // O_DSYNC not defined 17 | // O_NOFOLLOW not defined 18 | // O_NONBLOCK not defined 19 | // O_RSYNC not defined 20 | return flag 21 | } 22 | 23 | func openFile(path string, oflag sys.Oflag, perm fs.FileMode) (*os.File, sys.Errno) { 24 | return nil, sys.ENOSYS 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/poll.go: -------------------------------------------------------------------------------- 1 | //go:build windows || (linux && !tinygo) || darwin 2 | 3 | package sysfs 4 | 5 | import ( 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | "github.com/tetratelabs/wazero/internal/fsapi" 8 | ) 9 | 10 | // poll implements `Poll` as documented on sys.File via a file descriptor. 11 | func poll(fd uintptr, flag fsapi.Pflag, timeoutMillis int32) (ready bool, errno sys.Errno) { 12 | if flag != fsapi.POLLIN { 13 | return false, sys.ENOTSUP 14 | } 15 | fds := []pollFd{newPollFd(fd, _POLLIN, 0)} 16 | count, errno := _poll(fds, timeoutMillis) 17 | return count > 0, errno 18 | } 19 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sysvshm_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux 6 | 7 | package unix 8 | 9 | import "runtime" 10 | 11 | // SysvShmCtl performs control operations on the shared memory segment 12 | // specified by id. 13 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 14 | if runtime.GOARCH == "arm" || 15 | runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le" { 16 | cmd |= ipc_64 17 | } 18 | 19 | return shmctl(id, cmd, desc) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/proto/proto_reflect.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The protoreflect build tag disables use of fast-path methods. 6 | //go:build protoreflect 7 | // +build protoreflect 8 | 9 | package proto 10 | 11 | import ( 12 | "google.golang.org/protobuf/reflect/protoreflect" 13 | "google.golang.org/protobuf/runtime/protoiface" 14 | ) 15 | 16 | const hasProtoMethods = false 17 | 18 | func protoMethods(m protoreflect.Message) *protoiface.Methods { 19 | return nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/goyaml.v2/NOTICE: -------------------------------------------------------------------------------- 1 | Copyright 2011-2016 Canonical Ltd. 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !purego && !appengine 6 | // +build !purego,!appengine 7 | 8 | package impl 9 | 10 | // When using unsafe pointers, we can just treat enum values as int32s. 11 | 12 | var ( 13 | coderEnumNoZero = coderInt32NoZero 14 | coderEnum = coderInt32 15 | coderEnumPtr = coderInt32Ptr 16 | coderEnumSlice = coderInt32Slice 17 | coderEnumPackedSlice = coderInt32PackedSlice 18 | ) 19 | -------------------------------------------------------------------------------- /vendor/github.com/gogo/protobuf/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of GoGo authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS file, which 3 | # lists people. For example, employees are listed in CONTRIBUTORS, 4 | # but not in AUTHORS, because the employer holds the copyright. 5 | 6 | # Names should be added to this file as one of 7 | # Organization's name 8 | # Individual's name 9 | # Individual's name 10 | 11 | # Please keep the list sorted. 12 | 13 | Sendgrid, Inc 14 | Vastech SA (PTY) LTD 15 | Walter Schulze 16 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/runewidth_windows.go: -------------------------------------------------------------------------------- 1 | //go:build windows && !appengine 2 | // +build windows,!appengine 3 | 4 | package runewidth 5 | 6 | import ( 7 | "syscall" 8 | ) 9 | 10 | var ( 11 | kernel32 = syscall.NewLazyDLL("kernel32") 12 | procGetConsoleOutputCP = kernel32.NewProc("GetConsoleOutputCP") 13 | ) 14 | 15 | // IsEastAsian return true if the current locale is CJK 16 | func IsEastAsian() bool { 17 | r1, _, _ := procGetConsoleOutputCP.Call() 18 | if r1 == 0 { 19 | return false 20 | } 21 | 22 | switch int(r1) { 23 | case 932, 51932, 936, 949, 950: 24 | return true 25 | } 26 | 27 | return false 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasip1/clock.go: -------------------------------------------------------------------------------- 1 | package wasip1 2 | 3 | const ( 4 | ClockResGetName = "clock_res_get" 5 | ClockTimeGetName = "clock_time_get" 6 | ) 7 | 8 | // https://github.com/WebAssembly/WASI/blob/snapshot-01/phases/snapshot/docs.md#-clockid-enumu32 9 | const ( 10 | // ClockIDRealtime is the name ID named "realtime" like sys.Walltime 11 | ClockIDRealtime = iota 12 | // ClockIDMonotonic is the name ID named "monotonic" like sys.Nanotime 13 | ClockIDMonotonic 14 | // Note: clockIDProcessCputime and clockIDThreadCputime were removed by 15 | // WASI maintainers: https://github.com/WebAssembly/wasi-libc/pull/294 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sockcmsg_dragonfly.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | // Round the length of a raw sockaddr up to align it properly. 8 | func cmsgAlignOf(salen int) int { 9 | salign := SizeofPtr 10 | if SizeofPtr == 8 && !supportsABI(_dragonflyABIChangeVersion) { 11 | // 64-bit Dragonfly before the September 2019 ABI changes still requires 12 | // 32-bit aligned access to network subsystem. 13 | salign = 4 14 | } 15 | return (salen + salign - 1) & ^(salign - 1) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/vdef.go: -------------------------------------------------------------------------------- 1 | package backend 2 | 3 | import ( 4 | "github.com/tetratelabs/wazero/internal/engine/wazevo/ssa" 5 | ) 6 | 7 | // SSAValueDefinition represents a definition of an SSA value. 8 | type SSAValueDefinition struct { 9 | V ssa.Value 10 | // Instr is not nil if this is a definition from an instruction. 11 | Instr *ssa.Instruction 12 | // RefCount is the number of references to the result. 13 | RefCount uint32 14 | } 15 | 16 | // IsFromInstr returns true if this definition is from an instruction. 17 | func (d *SSAValueDefinition) IsFromInstr() bool { 18 | return d.Instr != nil 19 | } 20 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/proto/proto_methods.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The protoreflect build tag disables use of fast-path methods. 6 | //go:build !protoreflect 7 | // +build !protoreflect 8 | 9 | package proto 10 | 11 | import ( 12 | "google.golang.org/protobuf/reflect/protoreflect" 13 | "google.golang.org/protobuf/runtime/protoiface" 14 | ) 15 | 16 | const hasProtoMethods = true 17 | 18 | func protoMethods(m protoreflect.Message) *protoiface.Methods { 19 | return m.ProtoMethods() 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_windows.go: -------------------------------------------------------------------------------- 1 | // +build !appengine,!js,windows 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | "os" 8 | 9 | "golang.org/x/sys/windows" 10 | ) 11 | 12 | func checkIfTerminal(w io.Writer) bool { 13 | switch v := w.(type) { 14 | case *os.File: 15 | handle := windows.Handle(v.Fd()) 16 | var mode uint32 17 | if err := windows.GetConsoleMode(handle, &mode); err != nil { 18 | return false 19 | } 20 | mode |= windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING 21 | if err := windows.SetConsoleMode(handle, mode); err != nil { 22 | return false 23 | } 24 | return true 25 | } 26 | return false 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasm/binary/custom.go: -------------------------------------------------------------------------------- 1 | package binary 2 | 3 | import ( 4 | "bytes" 5 | 6 | "github.com/tetratelabs/wazero/internal/wasm" 7 | ) 8 | 9 | // decodeCustomSection deserializes the data **not** associated with the "name" key in SectionIDCustom. 10 | // 11 | // See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#custom-section%E2%91%A0 12 | func decodeCustomSection(r *bytes.Reader, name string, limit uint64) (result *wasm.CustomSection, err error) { 13 | buf := make([]byte, limit) 14 | _, err = r.Read(buf) 15 | 16 | result = &wasm.CustomSection{ 17 | Name: name, 18 | Data: buf, 19 | } 20 | 21 | return 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/opencontainers/runtime-spec/specs-go/version.go: -------------------------------------------------------------------------------- 1 | package specs 2 | 3 | import "fmt" 4 | 5 | const ( 6 | // VersionMajor is for an API incompatible changes 7 | VersionMajor = 1 8 | // VersionMinor is for functionality in a backwards-compatible manner 9 | VersionMinor = 0 10 | // VersionPatch is for backwards-compatible bug fixes 11 | VersionPatch = 2 12 | 13 | // VersionDev indicates development branch. Releases will be empty string. 14 | VersionDev = "-dev" 15 | ) 16 | 17 | // Version is the specification version that the package types support. 18 | var Version = fmt.Sprintf("%d.%d.%d%s", VersionMajor, VersionMinor, VersionPatch, VersionDev) 19 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/map_entry.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package genid 6 | 7 | import protoreflect "google.golang.org/protobuf/reflect/protoreflect" 8 | 9 | // Generic field names and numbers for synthetic map entry messages. 10 | const ( 11 | MapEntry_Key_field_name protoreflect.Name = "key" 12 | MapEntry_Value_field_name protoreflect.Name = "value" 13 | 14 | MapEntry_Key_field_number protoreflect.FieldNumber = 1 15 | MapEntry_Value_field_number protoreflect.FieldNumber = 2 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/empty_gen.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Code generated by generate-protos. DO NOT EDIT. 6 | 7 | package genid 8 | 9 | import ( 10 | protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 | ) 12 | 13 | const File_google_protobuf_empty_proto = "google/protobuf/empty.proto" 14 | 15 | // Names for google.protobuf.Empty. 16 | const ( 17 | Empty_message_name protoreflect.Name = "Empty" 18 | Empty_message_fullname protoreflect.FullName = "google.protobuf.Empty" 19 | ) 20 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_freebsd.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "syscall" 5 | 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | ) 8 | 9 | const supportedSyscallOflag = sys.O_DIRECTORY | sys.O_NOFOLLOW | sys.O_NONBLOCK 10 | 11 | func withSyscallOflag(oflag sys.Oflag, flag int) int { 12 | if oflag&sys.O_DIRECTORY != 0 { 13 | flag |= syscall.O_DIRECTORY 14 | } 15 | // syscall.O_DSYNC not defined on darwin 16 | if oflag&sys.O_NOFOLLOW != 0 { 17 | flag |= syscall.O_NOFOLLOW 18 | } 19 | if oflag&sys.O_NONBLOCK != 0 { 20 | flag |= syscall.O_NONBLOCK 21 | } 22 | // syscall.O_RSYNC not defined on darwin 23 | return flag 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/mmap_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build !(darwin || linux || freebsd || windows) || tinygo 2 | 3 | package platform 4 | 5 | import ( 6 | "fmt" 7 | "runtime" 8 | ) 9 | 10 | var errUnsupported = fmt.Errorf("mmap unsupported on GOOS=%s. Use interpreter instead.", runtime.GOOS) 11 | 12 | func munmapCodeSegment(code []byte) error { 13 | panic(errUnsupported) 14 | } 15 | 16 | func mmapCodeSegmentAMD64(size int) ([]byte, error) { 17 | panic(errUnsupported) 18 | } 19 | 20 | func mmapCodeSegmentARM64(size int) ([]byte, error) { 21 | panic(errUnsupported) 22 | } 23 | 24 | func MprotectRX(b []byte) (err error) { 25 | panic(errUnsupported) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || (darwin && !race) || (linux && !race) || (freebsd && !race) || netbsd || openbsd || solaris || dragonfly || zos 6 | 7 | package unix 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gc && 386 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | 15 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 16 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 17 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | # Vim files https://github.com/github/gitignore/blob/master/Global/Vim.gitignore 23 | # swap 24 | [._]*.s[a-w][a-z] 25 | [._]s[a-w][a-z] 26 | # session 27 | Session.vim 28 | # temporary 29 | .netrwhist 30 | *~ 31 | # auto-generated tag files 32 | tags 33 | 34 | *.exe 35 | cobra.test 36 | bin 37 | 38 | .idea/ 39 | *.iml 40 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # If you prefer the allow list template instead of the deny list, see community template: 2 | # https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore 3 | # 4 | # Binaries for programs and plugins 5 | *.exe 6 | *.exe~ 7 | *.dll 8 | *.so 9 | *.dylib 10 | 11 | # Test binary, built with `go test -c` 12 | *.test 13 | 14 | # Output of the go coverage tool, specifically when used with LiteIDE 15 | *.out 16 | 17 | # Dependency directories (remove the comment below to include it) 18 | # vendor/ 19 | 20 | # Go workspace file 21 | go.work 22 | go.work.sum 23 | 24 | # env file 25 | .env 26 | .vscode/ 27 | 28 | build/* 29 | output/* 30 | build.sh 31 | *.tar 32 | charts/fake-gpu/files/* -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_windows.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "io/fs" 5 | "syscall" 6 | 7 | "github.com/tetratelabs/wazero/experimental/sys" 8 | ) 9 | 10 | func setNonblock(fd uintptr, enable bool) sys.Errno { 11 | // We invoke the syscall, but this is currently no-op. 12 | return sys.UnwrapOSError(syscall.SetNonblock(syscall.Handle(fd), enable)) 13 | } 14 | 15 | func isNonblock(f *osFile) bool { 16 | // On Windows, we support non-blocking reads only on named pipes. 17 | isValid := false 18 | st, errno := f.Stat() 19 | if errno == 0 { 20 | isValid = st.Mode&fs.ModeNamedPipe != 0 21 | } 22 | return isValid && f.flag&sys.O_NONBLOCK == sys.O_NONBLOCK 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasip1/wasi.go: -------------------------------------------------------------------------------- 1 | // Package wasip1 is a helper to remove package cycles re-using constants. 2 | package wasip1 3 | 4 | import ( 5 | "strings" 6 | ) 7 | 8 | // InternalModuleName is not named ModuleName, to avoid a clash on dot imports. 9 | const InternalModuleName = "wasi_snapshot_preview1" 10 | 11 | func flagsString(names []string, f int) string { 12 | var builder strings.Builder 13 | first := true 14 | for i, sf := range names { 15 | target := 1 << i 16 | if target&f != 0 { 17 | if !first { 18 | builder.WriteByte('|') 19 | } else { 20 | first = false 21 | } 22 | builder.WriteString(sf) 23 | } 24 | } 25 | return builder.String() 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/nri/pkg/api/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright The containerd Authors. 3 | 4 | Licensed under the Apache License, Version 2.0 (the "License"); 5 | you may not use this file except in compliance with the License. 6 | You may obtain a copy of the License at 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | Unless required by applicable law or agreed to in writing, software 11 | distributed under the License is distributed on an "AS IS" BASIS, 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | See the License for the specific language governing permissions and 14 | limitations under the License. 15 | */ 16 | 17 | package api 18 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/SECURITY_CONTACTS: -------------------------------------------------------------------------------- 1 | # Defined below are the security contacts for this repo. 2 | # 3 | # They are the contact point for the Product Security Team to reach out 4 | # to for triaging and handling of incoming issues. 5 | # 6 | # The below names agree to abide by the 7 | # [Embargo Policy](https://github.com/kubernetes/sig-release/blob/master/security-release-process-documentation/security-release-process.md#embargo-policy) 8 | # and will be removed and replaced if they violate that agreement. 9 | # 10 | # DO NOT REPORT SECURITY VULNERABILITIES DIRECTLY TO THESE NAMES, FOLLOW THE 11 | # INSTRUCTIONS AT https://kubernetes.io/security/ 12 | 13 | cjcullen 14 | jessfraz 15 | liggitt 16 | philips 17 | tallclair 18 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_darwin.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "syscall" 5 | 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | ) 8 | 9 | const supportedSyscallOflag = sys.O_DIRECTORY | sys.O_DSYNC | sys.O_NOFOLLOW | sys.O_NONBLOCK 10 | 11 | func withSyscallOflag(oflag sys.Oflag, flag int) int { 12 | if oflag&sys.O_DIRECTORY != 0 { 13 | flag |= syscall.O_DIRECTORY 14 | } 15 | if oflag&sys.O_DSYNC != 0 { 16 | flag |= syscall.O_DSYNC 17 | } 18 | if oflag&sys.O_NOFOLLOW != 0 { 19 | flag |= syscall.O_NOFOLLOW 20 | } 21 | if oflag&sys.O_NONBLOCK != 0 { 22 | flag |= syscall.O_NONBLOCK 23 | } 24 | // syscall.O_RSYNC not defined on darwin 25 | return flag 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gccgo && arm 6 | 7 | package unix 8 | 9 | import ( 10 | "syscall" 11 | "unsafe" 12 | ) 13 | 14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 15 | var newoffset int64 16 | offsetLow := uint32(offset & 0xffffffff) 17 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 19 | return newoffset, err 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/log/.golangci.yml: -------------------------------------------------------------------------------- 1 | linters: 2 | enable: 3 | - exportloopref # Checks for pointers to enclosing loop variables 4 | - gofmt 5 | - goimports 6 | - gosec 7 | - ineffassign 8 | - misspell 9 | - nolintlint 10 | - revive 11 | - staticcheck 12 | - tenv # Detects using os.Setenv instead of t.Setenv since Go 1.17 13 | - unconvert 14 | - unused 15 | - vet 16 | - dupword # Checks for duplicate words in the source code 17 | disable: 18 | - errcheck 19 | 20 | run: 21 | timeout: 5m 22 | skip-dirs: 23 | - api 24 | - cluster 25 | - design 26 | - docs 27 | - docs/man 28 | - releases 29 | - reports 30 | - test # e2e scripts 31 | -------------------------------------------------------------------------------- /vendor/github.com/jedib0t/go-pretty/v6/text/direction.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | // Direction defines the overall flow of text. Similar to bidi.Direction, but 4 | // simplified and specific to this package. 5 | type Direction int 6 | 7 | // Available Directions. 8 | const ( 9 | Default Direction = iota 10 | LeftToRight 11 | RightToLeft 12 | ) 13 | 14 | const ( 15 | RuneL2R = '\u202a' 16 | RuneR2L = '\u202b' 17 | ) 18 | 19 | // Modifier returns a character to force the given direction for the text that 20 | // follows the modifier. 21 | func (d Direction) Modifier() string { 22 | switch d { 23 | case LeftToRight: 24 | return string(RuneL2R) 25 | case RightToLeft: 26 | return string(RuneR2L) 27 | } 28 | return "" 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package logrus is a structured logger for Go, completely API compatible with the standard library logger. 3 | 4 | 5 | The simplest way to use Logrus is simply the package-level exported logger: 6 | 7 | package main 8 | 9 | import ( 10 | log "github.com/sirupsen/logrus" 11 | ) 12 | 13 | func main() { 14 | log.WithFields(log.Fields{ 15 | "animal": "walrus", 16 | "number": 1, 17 | "size": 10, 18 | }).Info("A walrus appears") 19 | } 20 | 21 | Output: 22 | time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10 23 | 24 | For a full guide visit https://github.com/sirupsen/logrus 25 | */ 26 | package logrus 27 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_notwindows.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "io/fs" 7 | "os" 8 | 9 | "github.com/tetratelabs/wazero/experimental/sys" 10 | ) 11 | 12 | // openFile is like os.OpenFile except it accepts a sys.Oflag and returns 13 | // sys.Errno. A zero sys.Errno is success. 14 | func openFile(path string, oflag sys.Oflag, perm fs.FileMode) (*os.File, sys.Errno) { 15 | f, err := os.OpenFile(path, toOsOpenFlag(oflag), perm) 16 | // Note: This does not return a sys.File because sys.FS that returns 17 | // one may want to hide the real OS path. For example, this is needed for 18 | // pre-opens. 19 | return f, sys.UnwrapOSError(err) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_unix_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || dragonfly || freebsd || (linux && !ppc64 && !ppc64le) || netbsd || openbsd || solaris) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 12 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 13 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/enum.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package impl 6 | 7 | import ( 8 | "reflect" 9 | 10 | "google.golang.org/protobuf/reflect/protoreflect" 11 | ) 12 | 13 | type EnumInfo struct { 14 | GoReflectType reflect.Type // int32 kind 15 | Desc protoreflect.EnumDescriptor 16 | } 17 | 18 | func (t *EnumInfo) New(n protoreflect.EnumNumber) protoreflect.Enum { 19 | return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(protoreflect.Enum) 20 | } 21 | func (t *EnumInfo) Descriptor() protoreflect.EnumDescriptor { return t.Desc } 22 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/codegen.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | # This script serves as an example to demonstrate how to generate the gRPC-Go 4 | # interface and the related messages from .proto file. 5 | # 6 | # It assumes the installation of i) Google proto buffer compiler at 7 | # https://github.com/google/protobuf (after v2.6.1) and ii) the Go codegen 8 | # plugin at https://github.com/golang/protobuf (after 2015-02-20). If you have 9 | # not, please install them first. 10 | # 11 | # We recommend running this script at $GOPATH/src. 12 | # 13 | # If this is not what you need, feel free to make your own scripts. Again, this 14 | # script is for demonstration purpose. 15 | # 16 | proto=$1 17 | protoc --go_out=plugins=grpc:. $proto 18 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/dir.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "io" 5 | 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | ) 8 | 9 | func adjustReaddirErr(f sys.File, isClosed bool, err error) sys.Errno { 10 | if err == io.EOF { 11 | return 0 // e.g. Readdir on darwin returns io.EOF, but linux doesn't. 12 | } else if errno := sys.UnwrapOSError(err); errno != 0 { 13 | errno = dirError(f, isClosed, errno) 14 | // Comply with errors allowed on sys.File Readdir 15 | switch errno { 16 | case sys.EINVAL: // os.File Readdir can return this 17 | return sys.EBADF 18 | case sys.ENOTDIR: // dirError can return this 19 | return sys.EBADF 20 | } 21 | return errno 22 | } 23 | return 0 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/file_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build !(unix || windows) || tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "os" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | const ( 12 | nonBlockingFileReadSupported = false 13 | nonBlockingFileWriteSupported = false 14 | ) 15 | 16 | func rmdir(path string) sys.Errno { 17 | return sys.UnwrapOSError(os.Remove(path)) 18 | } 19 | 20 | // readFd returns ENOSYS on unsupported platforms. 21 | func readFd(fd uintptr, buf []byte) (int, sys.Errno) { 22 | return -1, sys.ENOSYS 23 | } 24 | 25 | // writeFd returns ENOSYS on unsupported platforms. 26 | func writeFd(fd uintptr, buf []byte) (int, sys.Errno) { 27 | return -1, sys.ENOSYS 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/experimental/importresolver.go: -------------------------------------------------------------------------------- 1 | package experimental 2 | 3 | import ( 4 | "context" 5 | 6 | "github.com/tetratelabs/wazero/api" 7 | "github.com/tetratelabs/wazero/internal/expctxkeys" 8 | ) 9 | 10 | // ImportResolver is an experimental func type that, if set, 11 | // will be used as the first step in resolving imports. 12 | // See issue 2294. 13 | // If the import name is not found, it should return nil. 14 | type ImportResolver func(name string) api.Module 15 | 16 | // WithImportResolver returns a new context with the given ImportResolver. 17 | func WithImportResolver(ctx context.Context, resolver ImportResolver) context.Context { 18 | return context.WithValue(ctx, expctxkeys.ImportResolverKey{}, resolver) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/basic_block_sort.go: -------------------------------------------------------------------------------- 1 | package ssa 2 | 3 | import ( 4 | "slices" 5 | ) 6 | 7 | func sortBlocks(blocks []*basicBlock) { 8 | slices.SortFunc(blocks, func(i, j *basicBlock) int { 9 | jIsReturn := j.ReturnBlock() 10 | iIsReturn := i.ReturnBlock() 11 | if iIsReturn && jIsReturn { 12 | return 0 13 | } 14 | if jIsReturn { 15 | return 1 16 | } 17 | if iIsReturn { 18 | return -1 19 | } 20 | iRoot, jRoot := i.rootInstr, j.rootInstr 21 | if iRoot == nil && jRoot == nil { // For testing. 22 | return 0 23 | } 24 | if jRoot == nil { 25 | return 1 26 | } 27 | if iRoot == nil { 28 | return -1 29 | } 30 | return i.rootInstr.id - j.rootInstr.id 31 | }) 32 | } 33 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && solaris 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func (iov *Iovec) SetLen(length int) { 18 | iov.Len = uint64(length) 19 | } 20 | 21 | func (msghdr *Msghdr) SetIovlen(length int) { 22 | msghdr.Iovlen = int32(length) 23 | } 24 | 25 | func (cmsg *Cmsghdr) SetLen(length int) { 26 | cmsg.Len = uint32(length) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows && race 6 | 7 | package windows 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/platform/cpuid_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || tinygo 2 | 3 | package platform 4 | 5 | var CpuFeatures CpuFeatureFlags = &cpuFeatureFlags{} 6 | 7 | // cpuFeatureFlags implements CpuFeatureFlags for unsupported platforms. 8 | type cpuFeatureFlags struct{} 9 | 10 | // Has implements the same method on the CpuFeatureFlags interface. 11 | func (c *cpuFeatureFlags) Has(cpuFeature CpuFeature) bool { return false } 12 | 13 | // HasExtra implements the same method on the CpuFeatureFlags interface. 14 | func (c *cpuFeatureFlags) HasExtra(cpuFeature CpuFeature) bool { return false } 15 | 16 | // Raw implements the same method on the CpuFeatureFlags interface. 17 | func (c *cpuFeatureFlags) Raw() uint64 { return 0 } 18 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/fsapi/poll.go: -------------------------------------------------------------------------------- 1 | package fsapi 2 | 3 | // Pflag are bit flags used for File.Poll. Values, including zero, should not 4 | // be interpreted numerically. Instead, use by constants prefixed with 'POLL'. 5 | // 6 | // # Notes 7 | // 8 | // - This is like `pollfd.events` flags for `poll` in POSIX. See 9 | // https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/poll.h.html 10 | type Pflag uint32 11 | 12 | // Only define bitflags we support and are needed by `poll_oneoff` in wasip1 13 | // See https://github.com/WebAssembly/WASI/blob/snapshot-01/phases/snapshot/docs.md#eventrwflags 14 | const ( 15 | // POLLIN is a read event. 16 | POLLIN Pflag = 1 << iota 17 | 18 | // POLLOUT is a write event. 19 | POLLOUT 20 | ) 21 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/sys/stat_bsd.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64) && (darwin || freebsd) 2 | 3 | package sys 4 | 5 | import ( 6 | "io/fs" 7 | "syscall" 8 | ) 9 | 10 | const sysParseable = true 11 | 12 | func statFromFileInfo(info fs.FileInfo) Stat_t { 13 | if d, ok := info.Sys().(*syscall.Stat_t); ok { 14 | st := Stat_t{} 15 | st.Dev = uint64(d.Dev) 16 | st.Ino = d.Ino 17 | st.Mode = info.Mode() 18 | st.Nlink = uint64(d.Nlink) 19 | st.Size = d.Size 20 | atime := d.Atimespec 21 | st.Atim = atime.Sec*1e9 + atime.Nsec 22 | mtime := d.Mtimespec 23 | st.Mtim = mtime.Sec*1e9 + mtime.Nsec 24 | ctime := d.Ctimespec 25 | st.Ctim = ctime.Sec*1e9 + ctime.Nsec 26 | return st 27 | } 28 | return defaultStatFromFileInfo(info) 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/sys/stat_windows.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64) && windows 2 | 3 | package sys 4 | 5 | import ( 6 | "io/fs" 7 | "syscall" 8 | ) 9 | 10 | const sysParseable = true 11 | 12 | func statFromFileInfo(info fs.FileInfo) Stat_t { 13 | if d, ok := info.Sys().(*syscall.Win32FileAttributeData); ok { 14 | st := Stat_t{} 15 | st.Ino = 0 // not in Win32FileAttributeData 16 | st.Dev = 0 // not in Win32FileAttributeData 17 | st.Mode = info.Mode() 18 | st.Nlink = 1 // not in Win32FileAttributeData 19 | st.Size = info.Size() 20 | st.Atim = d.LastAccessTime.Nanoseconds() 21 | st.Mtim = d.LastWriteTime.Nanoseconds() 22 | st.Ctim = d.CreationTime.Nanoseconds() 23 | return st 24 | } 25 | return defaultStatFromFileInfo(info) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/jedib0t/go-pretty/v6/text/ansi_windows.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | // +build windows 3 | 4 | package text 5 | 6 | import ( 7 | "os" 8 | "sync" 9 | 10 | "golang.org/x/sys/windows" 11 | ) 12 | 13 | var enableVTPMutex = sync.Mutex{} 14 | 15 | func areANSICodesSupported() bool { 16 | enableVTPMutex.Lock() 17 | defer enableVTPMutex.Unlock() 18 | 19 | outHandle := windows.Handle(os.Stdout.Fd()) 20 | var outMode uint32 21 | if err := windows.GetConsoleMode(outHandle, &outMode); err == nil { 22 | if outMode&windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING != 0 { 23 | return true 24 | } 25 | if err := windows.SetConsoleMode(outHandle, outMode|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING); err == nil { 26 | return true 27 | } 28 | } 29 | return false 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/knqyf263/go-plugin/wasm/plugin.go: -------------------------------------------------------------------------------- 1 | //go:build tinygo.wasm 2 | 3 | // This file is designed to be imported by plugins. 4 | 5 | package wasm 6 | 7 | // #include 8 | import "C" 9 | 10 | import ( 11 | "unsafe" 12 | ) 13 | 14 | func PtrToByte(ptr, size uint32) []byte { 15 | b := unsafe.Slice((*byte)(unsafe.Pointer(uintptr(ptr))), size) 16 | 17 | return b 18 | } 19 | 20 | func ByteToPtr(buf []byte) (uint32, uint32) { 21 | if len(buf) == 0 { 22 | return 0, 0 23 | } 24 | 25 | size := C.ulong(len(buf)) 26 | ptr := unsafe.Pointer(C.malloc(size)) 27 | 28 | copy(unsafe.Slice((*byte)(ptr), size), buf) 29 | 30 | return uint32(uintptr(ptr)), uint32(len(buf)) 31 | } 32 | 33 | func FreePtr(ptr uint32) { 34 | C.free(unsafe.Pointer(uintptr(ptr))) 35 | } 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin && race) || (linux && race) || (freebsd && race) 6 | 7 | package unix 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_linux.go: -------------------------------------------------------------------------------- 1 | //go:build !tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "syscall" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | const supportedSyscallOflag = sys.O_DIRECTORY | sys.O_DSYNC | sys.O_NOFOLLOW | sys.O_NONBLOCK | sys.O_RSYNC 12 | 13 | func withSyscallOflag(oflag sys.Oflag, flag int) int { 14 | if oflag&sys.O_DIRECTORY != 0 { 15 | flag |= syscall.O_DIRECTORY 16 | } 17 | if oflag&sys.O_DSYNC != 0 { 18 | flag |= syscall.O_DSYNC 19 | } 20 | if oflag&sys.O_NOFOLLOW != 0 { 21 | flag |= syscall.O_NOFOLLOW 22 | } 23 | if oflag&sys.O_NONBLOCK != 0 { 24 | flag |= syscall.O_NONBLOCK 25 | } 26 | if oflag&sys.O_RSYNC != 0 { 27 | flag |= syscall.O_RSYNC 28 | } 29 | return flag 30 | } 31 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/strs/strings_pure.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build purego || appengine 6 | // +build purego appengine 7 | 8 | package strs 9 | 10 | import pref "google.golang.org/protobuf/reflect/protoreflect" 11 | 12 | func UnsafeString(b []byte) string { 13 | return string(b) 14 | } 15 | 16 | func UnsafeBytes(s string) []byte { 17 | return []byte(s) 18 | } 19 | 20 | type Builder struct{} 21 | 22 | func (*Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName { 23 | return prefix.Append(name) 24 | } 25 | 26 | func (*Builder) MakeString(b []byte) string { 27 | return string(b) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_hurd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build hurd 6 | 7 | package unix 8 | 9 | /* 10 | #include 11 | int ioctl(int, unsigned long int, uintptr_t); 12 | */ 13 | import "C" 14 | 15 | func ioctl(fd int, req uint, arg uintptr) (err error) { 16 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) 17 | if r0 == -1 && er != nil { 18 | err = er 19 | } 20 | return 21 | } 22 | 23 | func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { 24 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(uintptr(arg))) 25 | if r0 == -1 && er != nil { 26 | err = er 27 | } 28 | return 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/command_notwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013-2023 The Cobra Authors 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | //go:build !windows 16 | // +build !windows 17 | 18 | package cobra 19 | 20 | var preExecHookFn func(*Command) 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/version.go: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright 2018 gRPC authors. 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | */ 18 | 19 | package grpc 20 | 21 | // Version is the current grpc version. 22 | const Version = "1.57.1" 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/env_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2010 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | // Unix environment variables. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getenv(key string) (value string, found bool) { 14 | return syscall.Getenv(key) 15 | } 16 | 17 | func Setenv(key, value string) error { 18 | return syscall.Setenv(key, value) 19 | } 20 | 21 | func Clearenv() { 22 | syscall.Clearenv() 23 | } 24 | 25 | func Environ() []string { 26 | return syscall.Environ() 27 | } 28 | 29 | func Unsetenv(key string) error { 30 | return syscall.Unsetenv(key) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/goyaml.v2/writerc.go: -------------------------------------------------------------------------------- 1 | package yaml 2 | 3 | // Set the writer error and return false. 4 | func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool { 5 | emitter.error = yaml_WRITER_ERROR 6 | emitter.problem = problem 7 | return false 8 | } 9 | 10 | // Flush the output buffer. 11 | func yaml_emitter_flush(emitter *yaml_emitter_t) bool { 12 | if emitter.write_handler == nil { 13 | panic("write handler not set") 14 | } 15 | 16 | // Check if the buffer is empty. 17 | if emitter.buffer_pos == 0 { 18 | return true 19 | } 20 | 21 | if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil { 22 | return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error()) 23 | } 24 | emitter.buffer_pos = 0 25 | return true 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/wazevoapi/ptr.go: -------------------------------------------------------------------------------- 1 | package wazevoapi 2 | 3 | import "unsafe" 4 | 5 | // PtrFromUintptr resurrects the original *T from the given uintptr. 6 | // The caller of this function MUST be sure that ptr is valid. 7 | func PtrFromUintptr[T any](ptr uintptr) *T { 8 | // Wraps ptrs as the double pointer in order to avoid the unsafe access as detected by race detector. 9 | // 10 | // For example, if we have (*function)(unsafe.Pointer(ptr)) instead, then the race detector's "checkptr" 11 | // subroutine wanrs as "checkptr: pointer arithmetic result points to invalid allocation" 12 | // https://github.com/golang/go/blob/1ce7fcf139417d618c2730010ede2afb41664211/src/runtime/checkptr.go#L69 13 | var wrapped *uintptr = &ptr 14 | return *(**T)(unsafe.Pointer(wrapped)) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/amd64/abi_entry_amd64.go: -------------------------------------------------------------------------------- 1 | package amd64 2 | 3 | // entrypoint enters the machine code generated by this backend which begins with the preamble generated by functionABI.EmitGoEntryPreamble below. 4 | // This implements wazevo.entrypoint, and see the comments there for detail. 5 | func entrypoint(preambleExecutable, functionExecutable *byte, executionContextPtr uintptr, moduleContextPtr *byte, paramResultPtr *uint64, goAllocatedStackSlicePtr uintptr) 6 | 7 | // afterGoFunctionCallEntrypoint enters the machine code after growing the stack. 8 | // This implements wazevo.afterGoFunctionCallEntrypoint, and see the comments there for detail. 9 | func afterGoFunctionCallEntrypoint(executable *byte, executionContextPtr uintptr, stackPointer, framePointer uintptr) 10 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi_entry_arm64.go: -------------------------------------------------------------------------------- 1 | package arm64 2 | 3 | // entrypoint enters the machine code generated by this backend which begins with the preamble generated by functionABI.EmitGoEntryPreamble below. 4 | // This implements wazevo.entrypoint, and see the comments there for detail. 5 | func entrypoint(preambleExecutable, functionExecutable *byte, executionContextPtr uintptr, moduleContextPtr *byte, paramResultPtr *uint64, goAllocatedStackSlicePtr uintptr) 6 | 7 | // afterGoFunctionCallEntrypoint enters the machine code after growing the stack. 8 | // This implements wazevo.afterGoFunctionCallEntrypoint, and see the comments there for detail. 9 | func afterGoFunctionCallEntrypoint(executable *byte, executionContextPtr uintptr, stackPointer, framePointer uintptr) 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | B syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | B syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | B syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | B syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | B syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/readdirent_getdirentries.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin || zos 6 | 7 | package unix 8 | 9 | import "unsafe" 10 | 11 | // ReadDirent reads directory entries from fd and writes them into buf. 12 | func ReadDirent(fd int, buf []byte) (n int, err error) { 13 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. 14 | // 64 bits should be enough. (32 bits isn't even on 386). Since the 15 | // actual system call is getdirentries64, 64 is a good guess. 16 | // TODO(rsc): Can we use a single global basep for all calls? 17 | var base = (*uintptr)(unsafe.Pointer(new(uint64))) 18 | return Getdirentries(fd, buf, base) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/zptrace_linux_arm64.go: -------------------------------------------------------------------------------- 1 | // Code generated by linux/mkall.go generatePtraceRegSet("arm64"). DO NOT EDIT. 2 | 3 | package unix 4 | 5 | import "unsafe" 6 | 7 | // PtraceGetRegSetArm64 fetches the registers used by arm64 binaries. 8 | func PtraceGetRegSetArm64(pid, addr int, regsout *PtraceRegsArm64) error { 9 | iovec := Iovec{(*byte)(unsafe.Pointer(regsout)), uint64(unsafe.Sizeof(*regsout))} 10 | return ptracePtr(PTRACE_GETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 11 | } 12 | 13 | // PtraceSetRegSetArm64 sets the registers used by arm64 binaries. 14 | func PtraceSetRegSetArm64(pid, addr int, regs *PtraceRegsArm64) error { 15 | iovec := Iovec{(*byte)(unsafe.Pointer(regs)), uint64(unsafe.Sizeof(*regs))} 16 | return ptracePtr(PTRACE_SETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for mips64, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/internal/grpcutil/grpcutil.go: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright 2021 gRPC authors. 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | */ 18 | 19 | // Package grpcutil provides utility functions used across the gRPC codebase. 20 | package grpcutil 21 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/ttrpc/stream_server.go: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright The containerd Authors. 3 | 4 | Licensed under the Apache License, Version 2.0 (the "License"); 5 | you may not use this file except in compliance with the License. 6 | You may obtain a copy of the License at 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | Unless required by applicable law or agreed to in writing, software 11 | distributed under the License is distributed on an "AS IS" BASIS, 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | See the License for the specific language governing permissions and 14 | limitations under the License. 15 | */ 16 | 17 | package ttrpc 18 | 19 | type StreamServer interface { 20 | SendMsg(m interface{}) error 21 | RecvMsg(m interface{}) error 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/entrypoint_amd64.go: -------------------------------------------------------------------------------- 1 | //go:build amd64 && !tinygo 2 | 3 | package wazevo 4 | 5 | import _ "unsafe" 6 | 7 | // entrypoint is implemented by the backend. 8 | // 9 | //go:linkname entrypoint github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/amd64.entrypoint 10 | func entrypoint(preambleExecutable, functionExecutable *byte, executionContextPtr uintptr, moduleContextPtr *byte, paramResultStackPtr *uint64, goAllocatedStackSlicePtr uintptr) 11 | 12 | // entrypoint is implemented by the backend. 13 | // 14 | //go:linkname afterGoFunctionCallEntrypoint github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/amd64.afterGoFunctionCallEntrypoint 15 | func afterGoFunctionCallEntrypoint(executable *byte, executionContextPtr uintptr, stackPointer, framePointer uintptr) 16 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/entrypoint_arm64.go: -------------------------------------------------------------------------------- 1 | //go:build arm64 && !tinygo 2 | 3 | package wazevo 4 | 5 | import _ "unsafe" 6 | 7 | // entrypoint is implemented by the backend. 8 | // 9 | //go:linkname entrypoint github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64.entrypoint 10 | func entrypoint(preambleExecutable, functionExecutable *byte, executionContextPtr uintptr, moduleContextPtr *byte, paramResultStackPtr *uint64, goAllocatedStackSlicePtr uintptr) 11 | 12 | // entrypoint is implemented by the backend. 13 | // 14 | //go:linkname afterGoFunctionCallEntrypoint github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64.afterGoFunctionCallEntrypoint 15 | func afterGoFunctionCallEntrypoint(executable *byte, executionContextPtr uintptr, stackPointer, framePointer uintptr) 16 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/fsapi/unimplemented.go: -------------------------------------------------------------------------------- 1 | package fsapi 2 | 3 | import experimentalsys "github.com/tetratelabs/wazero/experimental/sys" 4 | 5 | func Adapt(f experimentalsys.File) File { 6 | if f, ok := f.(File); ok { 7 | return f 8 | } 9 | return unimplementedFile{f} 10 | } 11 | 12 | type unimplementedFile struct{ experimentalsys.File } 13 | 14 | // IsNonblock implements File.IsNonblock 15 | func (unimplementedFile) IsNonblock() bool { 16 | return false 17 | } 18 | 19 | // SetNonblock implements File.SetNonblock 20 | func (unimplementedFile) SetNonblock(bool) experimentalsys.Errno { 21 | return experimentalsys.ENOSYS 22 | } 23 | 24 | // Poll implements File.Poll 25 | func (unimplementedFile) Poll(Pflag, int32) (ready bool, errno experimentalsys.Errno) { 26 | return false, experimentalsys.ENOSYS 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for 386 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1/sched.go: -------------------------------------------------------------------------------- 1 | package wasi_snapshot_preview1 2 | 3 | import ( 4 | "context" 5 | 6 | "github.com/tetratelabs/wazero/api" 7 | "github.com/tetratelabs/wazero/experimental/sys" 8 | "github.com/tetratelabs/wazero/internal/wasip1" 9 | "github.com/tetratelabs/wazero/internal/wasm" 10 | ) 11 | 12 | // schedYield is the WASI function named SchedYieldName which temporarily 13 | // yields execution of the calling thread. 14 | // 15 | // See https://github.com/WebAssembly/WASI/blob/snapshot-01/phases/snapshot/docs.md#-sched_yield---errno 16 | var schedYield = newHostFunc(wasip1.SchedYieldName, schedYieldFn, nil) 17 | 18 | func schedYieldFn(_ context.Context, mod api.Module, _ []uint64) sys.Errno { 19 | sysCtx := mod.(*wasm.ModuleInstance).Sys 20 | sysCtx.Osyield() 21 | return 0 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/experimental/features.go: -------------------------------------------------------------------------------- 1 | package experimental 2 | 3 | import "github.com/tetratelabs/wazero/api" 4 | 5 | // CoreFeaturesThreads enables threads instructions ("threads"). 6 | // 7 | // # Notes 8 | // 9 | // - The instruction list is too long to enumerate in godoc. 10 | // See https://github.com/WebAssembly/threads/blob/main/proposals/threads/Overview.md 11 | // - Atomic operations are guest-only until api.Memory or otherwise expose them to host functions. 12 | // - On systems without mmap available, the memory will pre-allocate to the maximum size. Many 13 | // binaries will use a theroetical maximum like 4GB, so if using such a binary on a system 14 | // without mmap, consider editing the binary to reduce the max size setting of memory. 15 | const CoreFeaturesThreads = api.CoreFeatureSIMD << 1 16 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/goname.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package genid 6 | 7 | // Go names of implementation-specific struct fields in generated messages. 8 | const ( 9 | State_goname = "state" 10 | 11 | SizeCache_goname = "sizeCache" 12 | SizeCacheA_goname = "XXX_sizecache" 13 | 14 | WeakFields_goname = "weakFields" 15 | WeakFieldsA_goname = "XXX_weak" 16 | 17 | UnknownFields_goname = "unknownFields" 18 | UnknownFieldsA_goname = "XXX_unrecognized" 19 | 20 | ExtensionFields_goname = "extensionFields" 21 | ExtensionFieldsA_goname = "XXX_InternalExtensions" 22 | ExtensionFieldsB_goname = "XXX_extensions" 23 | 24 | WeakFieldPrefix_goname = "XXX_weak_" 25 | ) 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_riscv64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for RISCV64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for AMD64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/width/trieval.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | package width 4 | 5 | // elem is an entry of the width trie. The high byte is used to encode the type 6 | // of the rune. The low byte is used to store the index to a mapping entry in 7 | // the inverseData array. 8 | type elem uint16 9 | 10 | const ( 11 | tagNeutral elem = iota << typeShift 12 | tagAmbiguous 13 | tagWide 14 | tagNarrow 15 | tagFullwidth 16 | tagHalfwidth 17 | ) 18 | 19 | const ( 20 | numTypeBits = 3 21 | typeShift = 16 - numTypeBits 22 | 23 | // tagNeedsFold is true for all fullwidth and halfwidth runes except for 24 | // the Won sign U+20A9. 25 | tagNeedsFold = 0x1000 26 | 27 | // The Korean Won sign is halfwidth, but SHOULD NOT be mapped to a wide 28 | // variant. 29 | wonSign rune = 0x20A9 30 | ) 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ppc64, BSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/bluetooth_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Bluetooth sockets and messages 6 | 7 | package unix 8 | 9 | // Bluetooth Protocols 10 | const ( 11 | BTPROTO_L2CAP = 0 12 | BTPROTO_HCI = 1 13 | BTPROTO_SCO = 2 14 | BTPROTO_RFCOMM = 3 15 | BTPROTO_BNEP = 4 16 | BTPROTO_CMTP = 5 17 | BTPROTO_HIDP = 6 18 | BTPROTO_AVDTP = 7 19 | ) 20 | 21 | const ( 22 | HCI_CHANNEL_RAW = 0 23 | HCI_CHANNEL_USER = 1 24 | HCI_CHANNEL_MONITOR = 2 25 | HCI_CHANNEL_CONTROL = 3 26 | HCI_CHANNEL_LOGGING = 4 27 | ) 28 | 29 | // Socketoption Level 30 | const ( 31 | SOL_BLUETOOTH = 0x112 32 | SOL_HCI = 0x0 33 | SOL_L2CAP = 0x6 34 | SOL_RFCOMM = 0x12 35 | SOL_SCO = 0x11 36 | ) 37 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_aix_ppc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix && ppc 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used by AIX. 9 | 10 | package unix 11 | 12 | // Major returns the major component of a Linux device number. 13 | func Major(dev uint64) uint32 { 14 | return uint32((dev >> 16) & 0xffff) 15 | } 16 | 17 | // Minor returns the minor component of a Linux device number. 18 | func Minor(dev uint64) uint32 { 19 | return uint32(dev & 0xffff) 20 | } 21 | 22 | // Mkdev returns a Linux device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | return uint64(((major) << 16) | (minor)) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in Darwin's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a Darwin device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev >> 24) & 0xff) 13 | } 14 | 15 | // Minor returns the minor component of a Darwin device number. 16 | func Minor(dev uint64) uint32 { 17 | return uint32(dev & 0xffffff) 18 | } 19 | 20 | // Mkdev returns a Darwin device number generated from the given major and minor 21 | // components. 22 | func Mkdev(major, minor uint32) uint64 { 23 | return (uint64(major) << 24) | uint64(minor) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_windows.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "io/fs" 5 | "path" 6 | 7 | experimentalsys "github.com/tetratelabs/wazero/experimental/sys" 8 | "github.com/tetratelabs/wazero/sys" 9 | ) 10 | 11 | // inoFromFileInfo uses stat to get the inode information of the file. 12 | func inoFromFileInfo(dirPath string, info fs.FileInfo) (ino sys.Inode, errno experimentalsys.Errno) { 13 | if v, ok := info.Sys().(*sys.Stat_t); ok { 14 | return v.Ino, 0 15 | } 16 | if dirPath == "" { 17 | // This is a FS.File backed implementation which doesn't have access to 18 | // the original file path. 19 | return 20 | } 21 | // Ino is no not in Win32FileAttributeData 22 | inoPath := path.Clean(path.Join(dirPath, info.Name())) 23 | var st sys.Stat_t 24 | if st, errno = lstat(inoPath); errno == 0 { 25 | ino = st.Ino 26 | } 27 | return 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/buffer_pool.go: -------------------------------------------------------------------------------- 1 | package logrus 2 | 3 | import ( 4 | "bytes" 5 | "sync" 6 | ) 7 | 8 | var ( 9 | bufferPool BufferPool 10 | ) 11 | 12 | type BufferPool interface { 13 | Put(*bytes.Buffer) 14 | Get() *bytes.Buffer 15 | } 16 | 17 | type defaultPool struct { 18 | pool *sync.Pool 19 | } 20 | 21 | func (p *defaultPool) Put(buf *bytes.Buffer) { 22 | p.pool.Put(buf) 23 | } 24 | 25 | func (p *defaultPool) Get() *bytes.Buffer { 26 | return p.pool.Get().(*bytes.Buffer) 27 | } 28 | 29 | // SetBufferPool allows to replace the default logrus buffer pool 30 | // to better meets the specific needs of an application. 31 | func SetBufferPool(bp BufferPool) { 32 | bufferPool = bp 33 | } 34 | 35 | func init() { 36 | SetBufferPool(&defaultPool{ 37 | pool: &sync.Pool{ 38 | New: func() interface{} { 39 | return new(bytes.Buffer) 40 | }, 41 | }, 42 | }) 43 | } 44 | -------------------------------------------------------------------------------- /vendor/github.com/NVIDIA/go-nvml/pkg/dl/dl_linux.go: -------------------------------------------------------------------------------- 1 | /** 2 | # Copyright (c) NVIDIA CORPORATION. All rights reserved. 3 | # 4 | # Licensed under the Apache License, Version 2.0 (the "License"); 5 | # you may not use this file except in compliance with the License. 6 | # You may obtain a copy of the License at 7 | # 8 | # http://www.apache.org/licenses/LICENSE-2.0 9 | # 10 | # Unless required by applicable law or agreed to in writing, software 11 | # distributed under the License is distributed on an "AS IS" BASIS, 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | # See the License for the specific language governing permissions and 14 | # limitations under the License. 15 | **/ 16 | 17 | package dl 18 | 19 | // #cgo LDFLAGS: -ldl 20 | // #include 21 | // #include 22 | import "C" 23 | 24 | const ( 25 | RTLD_DEEPBIND = C.RTLD_DEEPBIND 26 | ) 27 | -------------------------------------------------------------------------------- /vendor/github.com/NVIDIA/go-nvml/pkg/nvml/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. 16 | // Code generated by https://git.io/c-for-go. DO NOT EDIT. 17 | 18 | /* 19 | Package NVML bindings 20 | */ 21 | package nvml 22 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/amd64/ext.go: -------------------------------------------------------------------------------- 1 | package amd64 2 | 3 | // extMode represents the mode of extension in movzx/movsx. 4 | type extMode byte 5 | 6 | const ( 7 | // extModeBL represents Byte -> Longword. 8 | extModeBL extMode = iota 9 | // extModeBQ represents Byte -> Quadword. 10 | extModeBQ 11 | // extModeWL represents Word -> Longword. 12 | extModeWL 13 | // extModeWQ represents Word -> Quadword. 14 | extModeWQ 15 | // extModeLQ represents Longword -> Quadword. 16 | extModeLQ 17 | ) 18 | 19 | // String implements fmt.Stringer. 20 | func (e extMode) String() string { 21 | switch e { 22 | case extModeBL: 23 | return "bl" 24 | case extModeBQ: 25 | return "bq" 26 | case extModeWL: 27 | return "wl" 28 | case extModeWQ: 29 | return "wq" 30 | case extModeLQ: 31 | return "lq" 32 | default: 33 | panic("BUG: invalid ext mode") 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_sun.go: -------------------------------------------------------------------------------- 1 | //go:build illumos || solaris 2 | 3 | package sysfs 4 | 5 | import ( 6 | "syscall" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | const supportedSyscallOflag = sys.O_DIRECTORY | sys.O_DSYNC | sys.O_NOFOLLOW | sys.O_NONBLOCK | sys.O_RSYNC 12 | 13 | func withSyscallOflag(oflag sys.Oflag, flag int) int { 14 | if oflag&sys.O_DIRECTORY != 0 { 15 | // See https://github.com/illumos/illumos-gate/blob/edd580643f2cf1434e252cd7779e83182ea84945/usr/src/uts/common/sys/fcntl.h#L90 16 | flag |= 0x1000000 17 | } 18 | if oflag&sys.O_DSYNC != 0 { 19 | flag |= syscall.O_DSYNC 20 | } 21 | if oflag&sys.O_NOFOLLOW != 0 { 22 | flag |= syscall.O_NOFOLLOW 23 | } 24 | if oflag&sys.O_NONBLOCK != 0 { 25 | flag |= syscall.O_NONBLOCK 26 | } 27 | if oflag&sys.O_RSYNC != 0 { 28 | flag |= syscall.O_RSYNC 29 | } 30 | return flag 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/sys/stat_linux.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && linux 2 | 3 | // Note: This expression is not the same as compiler support, even if it looks 4 | // similar. Platform functions here are used in interpreter mode as well. 5 | 6 | package sys 7 | 8 | import ( 9 | "io/fs" 10 | "syscall" 11 | ) 12 | 13 | const sysParseable = true 14 | 15 | func statFromFileInfo(info fs.FileInfo) Stat_t { 16 | if d, ok := info.Sys().(*syscall.Stat_t); ok { 17 | st := Stat_t{} 18 | st.Dev = uint64(d.Dev) 19 | st.Ino = uint64(d.Ino) 20 | st.Mode = info.Mode() 21 | st.Nlink = uint64(d.Nlink) 22 | st.Size = d.Size 23 | atime := d.Atim 24 | st.Atim = atime.Sec*1e9 + atime.Nsec 25 | mtime := d.Mtim 26 | st.Mtim = mtime.Sec*1e9 + mtime.Nsec 27 | ctime := d.Ctim 28 | st.Ctim = ctime.Sec*1e9 + ctime.Nsec 29 | return st 30 | } 31 | return defaultStatFromFileInfo(info) 32 | } 33 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (ppc64le || ppc64) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 12 | return syscall.Syscall(trap, a1, a2, a3) 13 | } 14 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 15 | return syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6) 16 | } 17 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 18 | return syscall.RawSyscall(trap, a1, a2, a3) 19 | } 20 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 21 | return syscall.RawSyscall6(trap, a1, a2, a3, a4, a5, a6) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright 2015 gRPC authors. 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | */ 18 | 19 | //go:generate ./regenerate.sh 20 | 21 | /* 22 | Package grpc implements an RPC system called gRPC. 23 | 24 | See grpc.io for more information about gRPC. 25 | */ 26 | package grpc // import "google.golang.org/grpc" 27 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/ieee754/ieee754.go: -------------------------------------------------------------------------------- 1 | package ieee754 2 | 3 | import ( 4 | "encoding/binary" 5 | "io" 6 | "math" 7 | ) 8 | 9 | // DecodeFloat32 decodes a float32 in IEEE 754 binary representation. 10 | // See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#floating-point%E2%91%A2 11 | func DecodeFloat32(buf []byte) (float32, error) { 12 | if len(buf) < 4 { 13 | return 0, io.ErrUnexpectedEOF 14 | } 15 | 16 | raw := binary.LittleEndian.Uint32(buf[:4]) 17 | return math.Float32frombits(raw), nil 18 | } 19 | 20 | // DecodeFloat64 decodes a float64 in IEEE 754 binary representation. 21 | // See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#floating-point%E2%91%A2 22 | func DecodeFloat64(buf []byte) (float64, error) { 23 | if len(buf) < 8 { 24 | return 0, io.ErrUnexpectedEOF 25 | } 26 | 27 | raw := binary.LittleEndian.Uint64(buf) 28 | return math.Float64frombits(raw), nil 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fdset.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | // Set adds fd to the set fds. 10 | func (fds *FdSet) Set(fd int) { 11 | fds.Bits[fd/NFDBITS] |= (1 << (uintptr(fd) % NFDBITS)) 12 | } 13 | 14 | // Clear removes fd from the set fds. 15 | func (fds *FdSet) Clear(fd int) { 16 | fds.Bits[fd/NFDBITS] &^= (1 << (uintptr(fd) % NFDBITS)) 17 | } 18 | 19 | // IsSet returns whether fd is in the set fds. 20 | func (fds *FdSet) IsSet(fd int) bool { 21 | return fds.Bits[fd/NFDBITS]&(1<<(uintptr(fd)%NFDBITS)) != 0 22 | } 23 | 24 | // Zero clears the set fds. 25 | func (fds *FdSet) Zero() { 26 | for i := range fds.Bits { 27 | fds.Bits[i] = 0 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | import "unsafe" 8 | 9 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument. 10 | func FcntlInt(fd uintptr, cmd, arg int) (int, error) { 11 | return fcntl(int(fd), cmd, arg) 12 | } 13 | 14 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. 15 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { 16 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk)))) 17 | return err 18 | } 19 | 20 | // FcntlFstore performs a fcntl syscall for the F_PREALLOCATE command. 21 | func FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error { 22 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore)))) 23 | return err 24 | } 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/eventlog.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | const ( 10 | EVENTLOG_SUCCESS = 0 11 | EVENTLOG_ERROR_TYPE = 1 12 | EVENTLOG_WARNING_TYPE = 2 13 | EVENTLOG_INFORMATION_TYPE = 4 14 | EVENTLOG_AUDIT_SUCCESS = 8 15 | EVENTLOG_AUDIT_FAILURE = 16 16 | ) 17 | 18 | //sys RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW 19 | //sys DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource 20 | //sys ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/width/kind_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=Kind"; DO NOT EDIT. 2 | 3 | package width 4 | 5 | import "strconv" 6 | 7 | func _() { 8 | // An "invalid array index" compiler error signifies that the constant values have changed. 9 | // Re-run the stringer command to generate them again. 10 | var x [1]struct{} 11 | _ = x[Neutral-0] 12 | _ = x[EastAsianAmbiguous-1] 13 | _ = x[EastAsianWide-2] 14 | _ = x[EastAsianNarrow-3] 15 | _ = x[EastAsianFullwidth-4] 16 | _ = x[EastAsianHalfwidth-5] 17 | } 18 | 19 | const _Kind_name = "NeutralEastAsianAmbiguousEastAsianWideEastAsianNarrowEastAsianFullwidthEastAsianHalfwidth" 20 | 21 | var _Kind_index = [...]uint8{0, 7, 25, 38, 53, 71, 89} 22 | 23 | func (i Kind) String() string { 24 | if i < 0 || i >= Kind(len(_Kind_index)-1) { 25 | return "Kind(" + strconv.FormatInt(int64(i), 10) + ")" 26 | } 27 | return _Kind_name[_Kind_index[i]:_Kind_index[i+1]] 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/NVIDIA/go-nvml/pkg/nvml/cgo_helpers.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. 16 | // Code generated by https://git.io/c-for-go. DO NOT EDIT. 17 | 18 | #include "nvml.h" 19 | #include 20 | #pragma once 21 | 22 | #define __CGOGEN 1 23 | 24 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/wasm/binary/export.go: -------------------------------------------------------------------------------- 1 | package binary 2 | 3 | import ( 4 | "bytes" 5 | "fmt" 6 | 7 | "github.com/tetratelabs/wazero/internal/leb128" 8 | "github.com/tetratelabs/wazero/internal/wasm" 9 | ) 10 | 11 | func decodeExport(r *bytes.Reader, ret *wasm.Export) (err error) { 12 | if ret.Name, _, err = decodeUTF8(r, "export name"); err != nil { 13 | return 14 | } 15 | 16 | b, err := r.ReadByte() 17 | if err != nil { 18 | err = fmt.Errorf("error decoding export kind: %w", err) 19 | return 20 | } 21 | 22 | ret.Type = b 23 | switch ret.Type { 24 | case wasm.ExternTypeFunc, wasm.ExternTypeTable, wasm.ExternTypeMemory, wasm.ExternTypeGlobal: 25 | if ret.Index, _, err = leb128.DecodeUint32(r); err != nil { 26 | err = fmt.Errorf("error decoding export index: %w", err) 27 | } 28 | default: 29 | err = fmt.Errorf("%w: invalid byte for exportdesc: %#x", ErrInvalidByte, b) 30 | } 31 | return 32 | } 33 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/internal/channelz/util_nonlinux.go: -------------------------------------------------------------------------------- 1 | //go:build !linux 2 | // +build !linux 3 | 4 | /* 5 | * 6 | * Copyright 2018 gRPC authors. 7 | * 8 | * Licensed under the Apache License, Version 2.0 (the "License"); 9 | * you may not use this file except in compliance with the License. 10 | * You may obtain a copy of the License at 11 | * 12 | * http://www.apache.org/licenses/LICENSE-2.0 13 | * 14 | * Unless required by applicable law or agreed to in writing, software 15 | * distributed under the License is distributed on an "AS IS" BASIS, 16 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 | * See the License for the specific language governing permissions and 18 | * limitations under the License. 19 | * 20 | */ 21 | 22 | package channelz 23 | 24 | // GetSocketOption gets the socket option info of the conn. 25 | func GetSocketOption(c interface{}) *SocketOptionData { 26 | return nil 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/nri/pkg/net/socketpair_cloexec_linux.go: -------------------------------------------------------------------------------- 1 | //go:build linux 2 | 3 | /* 4 | Copyright The containerd Authors. 5 | 6 | Licensed under the Apache License, Version 2.0 (the "License"); 7 | you may not use this file except in compliance with the License. 8 | You may obtain a copy of the License at 9 | 10 | http://www.apache.org/licenses/LICENSE-2.0 11 | 12 | Unless required by applicable law or agreed to in writing, software 13 | distributed under the License is distributed on an "AS IS" BASIS, 14 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | See the License for the specific language governing permissions and 16 | limitations under the License. 17 | */ 18 | 19 | package net 20 | 21 | import ( 22 | "golang.org/x/sys/unix" 23 | ) 24 | 25 | func newSocketPairCLOEXEC() ([2]int, error) { 26 | return unix.Socketpair(unix.AF_UNIX, unix.SOCK_STREAM|unix.SOCK_CLOEXEC, 0) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/NVIDIA/go-nvml/pkg/nvml/refcount.go: -------------------------------------------------------------------------------- 1 | /** 2 | # Copyright 2024 NVIDIA CORPORATION 3 | # 4 | # Licensed under the Apache License, Version 2.0 (the "License"); 5 | # you may not use this file except in compliance with the License. 6 | # You may obtain a copy of the License at 7 | # 8 | # http://www.apache.org/licenses/LICENSE-2.0 9 | # 10 | # Unless required by applicable law or agreed to in writing, software 11 | # distributed under the License is distributed on an "AS IS" BASIS, 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | # See the License for the specific language governing permissions and 14 | # limitations under the License. 15 | **/ 16 | 17 | package nvml 18 | 19 | type refcount int 20 | 21 | func (r *refcount) IncOnNoError(err error) { 22 | if err == nil { 23 | (*r)++ 24 | } 25 | } 26 | 27 | func (r *refcount) DecOnNoError(err error) { 28 | if err == nil && (*r) > 0 { 29 | (*r)-- 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.12 6 | // +build !go1.12 7 | 8 | package impl 9 | 10 | import "reflect" 11 | 12 | type mapIter struct { 13 | v reflect.Value 14 | keys []reflect.Value 15 | } 16 | 17 | // mapRange provides a less-efficient equivalent to 18 | // the Go 1.12 reflect.Value.MapRange method. 19 | func mapRange(v reflect.Value) *mapIter { 20 | return &mapIter{v: v} 21 | } 22 | 23 | func (i *mapIter) Next() bool { 24 | if i.keys == nil { 25 | i.keys = i.v.MapKeys() 26 | } else { 27 | i.keys = i.keys[1:] 28 | } 29 | return len(i.keys) > 0 30 | } 31 | 32 | func (i *mapIter) Key() reflect.Value { 33 | return i.keys[0] 34 | } 35 | 36 | func (i *mapIter) Value() reflect.Value { 37 | return i.v.MapIndex(i.keys[0]) 38 | } 39 | -------------------------------------------------------------------------------- /vendor/github.com/gogo/protobuf/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | Anton Povarov 2 | Brian Goff 3 | Clayton Coleman 4 | Denis Smirnov 5 | DongYun Kang 6 | Dwayne Schultz 7 | Georg Apitz 8 | Gustav Paul 9 | Johan Brandhorst 10 | John Shahid 11 | John Tuley 12 | Laurent 13 | Patrick Lee 14 | Peter Edge 15 | Roger Johansson 16 | Sam Nguyen 17 | Sergio Arbeo 18 | Stephen J Day 19 | Tamir Duberstein 20 | Todd Eisenberger 21 | Tormod Erevik Lea 22 | Vyacheslav Kim 23 | Walter Schulze 24 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/README.md: -------------------------------------------------------------------------------- 1 | go-runewidth 2 | ============ 3 | 4 | [![Build Status](https://github.com/mattn/go-runewidth/workflows/test/badge.svg?branch=master)](https://github.com/mattn/go-runewidth/actions?query=workflow%3Atest) 5 | [![Codecov](https://codecov.io/gh/mattn/go-runewidth/branch/master/graph/badge.svg)](https://codecov.io/gh/mattn/go-runewidth) 6 | [![GoDoc](https://godoc.org/github.com/mattn/go-runewidth?status.svg)](http://godoc.org/github.com/mattn/go-runewidth) 7 | [![Go Report Card](https://goreportcard.com/badge/github.com/mattn/go-runewidth)](https://goreportcard.com/report/github.com/mattn/go-runewidth) 8 | 9 | Provides functions to get fixed width of the character or string. 10 | 11 | Usage 12 | ----- 13 | 14 | ```go 15 | runewidth.StringWidth("つのだ☆HIRO") == 12 16 | ``` 17 | 18 | 19 | Author 20 | ------ 21 | 22 | Yasuhiro Matsumoto 23 | 24 | License 25 | ------- 26 | 27 | under the MIT License: http://mattn.mit-license.org/2013 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_zos.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build zos && s390x 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used by z/OS. 9 | // 10 | // The information below is extracted and adapted from macros. 11 | 12 | package unix 13 | 14 | // Major returns the major component of a z/OS device number. 15 | func Major(dev uint64) uint32 { 16 | return uint32((dev >> 16) & 0x0000FFFF) 17 | } 18 | 19 | // Minor returns the minor component of a z/OS device number. 20 | func Minor(dev uint64) uint32 { 21 | return uint32(dev & 0x0000FFFF) 22 | } 23 | 24 | // Mkdev returns a z/OS device number generated from the given major and minor 25 | // components. 26 | func Mkdev(major, minor uint32) uint64 { 27 | return (uint64(major) << 16) | uint64(minor) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/inconshreveable/mousetrap/README.md: -------------------------------------------------------------------------------- 1 | # mousetrap 2 | 3 | mousetrap is a tiny library that answers a single question. 4 | 5 | On a Windows machine, was the process invoked by someone double clicking on 6 | the executable file while browsing in explorer? 7 | 8 | ### Motivation 9 | 10 | Windows developers unfamiliar with command line tools will often "double-click" 11 | the executable for a tool. Because most CLI tools print the help and then exit 12 | when invoked without arguments, this is often very frustrating for those users. 13 | 14 | mousetrap provides a way to detect these invocations so that you can provide 15 | more helpful behavior and instructions on how to run the CLI tool. To see what 16 | this looks like, both from an organizational and a technical perspective, see 17 | https://inconshreveable.com/09-09-2014/sweat-the-small-stuff/ 18 | 19 | ### The interface 20 | 21 | The library exposes a single interface: 22 | 23 | func StartedByExplorer() (bool) 24 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/oflag.go: -------------------------------------------------------------------------------- 1 | package sysfs 2 | 3 | import ( 4 | "os" 5 | 6 | "github.com/tetratelabs/wazero/experimental/sys" 7 | ) 8 | 9 | // toOsOpenFlag converts the input to the flag parameter of os.OpenFile 10 | func toOsOpenFlag(oflag sys.Oflag) (flag int) { 11 | // First flags are exclusive 12 | switch oflag & (sys.O_RDONLY | sys.O_RDWR | sys.O_WRONLY) { 13 | case sys.O_RDONLY: 14 | flag |= os.O_RDONLY 15 | case sys.O_RDWR: 16 | flag |= os.O_RDWR 17 | case sys.O_WRONLY: 18 | flag |= os.O_WRONLY 19 | } 20 | 21 | // Run down the flags defined in the os package 22 | if oflag&sys.O_APPEND != 0 { 23 | flag |= os.O_APPEND 24 | } 25 | if oflag&sys.O_CREAT != 0 { 26 | flag |= os.O_CREATE 27 | } 28 | if oflag&sys.O_EXCL != 0 { 29 | flag |= os.O_EXCL 30 | } 31 | if oflag&sys.O_SYNC != 0 { 32 | flag |= os.O_SYNC 33 | } 34 | if oflag&sys.O_TRUNC != 0 { 35 | flag |= os.O_TRUNC 36 | } 37 | return withSyscallOflag(oflag, flag) 38 | } 39 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/ttrpc/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright The containerd Authors. 3 | 4 | Licensed under the Apache License, Version 2.0 (the "License"); 5 | you may not use this file except in compliance with the License. 6 | You may obtain a copy of the License at 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | Unless required by applicable law or agreed to in writing, software 11 | distributed under the License is distributed on an "AS IS" BASIS, 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | See the License for the specific language governing permissions and 14 | limitations under the License. 15 | */ 16 | 17 | /* 18 | package ttrpc defines and implements a low level simple transfer protocol 19 | optimized for low latency and reliable connections between processes on the same 20 | host. The protocol uses simple framing for sending requests, responses, and data 21 | using multiple streams. 22 | */ 23 | package ttrpc 24 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/.gitignore: -------------------------------------------------------------------------------- 1 | # If you prefer the allow list template instead of the deny list, see community template: 2 | # https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore 3 | # 4 | # Binaries for programs and plugins 5 | *.exe 6 | *.exe~ 7 | *.dll 8 | *.so 9 | *.dylib 10 | /wazero 11 | build 12 | dist 13 | 14 | # Test binary, built with `go test -c` 15 | *.test 16 | 17 | # Output of the go coverage tool, specifically when used with LiteIDE 18 | *.out 19 | 20 | # Dependency directories (remove the comment below to include it) 21 | # vendor/ 22 | 23 | # Go workspace file 24 | go.work 25 | 26 | # Goland 27 | .idea 28 | 29 | # AssemblyScript 30 | node_modules 31 | package-lock.json 32 | 33 | # codecov.io 34 | /coverage.txt 35 | 36 | .vagrant 37 | 38 | zig-cache/ 39 | zig-out/ 40 | 41 | .DS_Store 42 | 43 | # Ignore compiled stdlib test cases. 44 | /internal/integration_test/stdlibs/testdata 45 | /internal/integration_test/libsodium/testdata 46 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/errors/is_go112.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.13 6 | // +build !go1.13 7 | 8 | package errors 9 | 10 | import "reflect" 11 | 12 | // Is is a copy of Go 1.13's errors.Is for use with older Go versions. 13 | func Is(err, target error) bool { 14 | if target == nil { 15 | return err == target 16 | } 17 | 18 | isComparable := reflect.TypeOf(target).Comparable() 19 | for { 20 | if isComparable && err == target { 21 | return true 22 | } 23 | if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) { 24 | return true 25 | } 26 | if err = unwrap(err); err == nil { 27 | return false 28 | } 29 | } 30 | } 31 | 32 | func unwrap(err error) error { 33 | u, ok := err.(interface { 34 | Unwrap() error 35 | }) 36 | if !ok { 37 | return nil 38 | } 39 | return u.Unwrap() 40 | } 41 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/idna/trie12.0.0.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | // Copyright 2016 The Go Authors. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | //go:build !go1.16 8 | 9 | package idna 10 | 11 | // appendMapping appends the mapping for the respective rune. isMapped must be 12 | // true. A mapping is a categorization of a rune as defined in UTS #46. 13 | func (c info) appendMapping(b []byte, s string) []byte { 14 | index := int(c >> indexShift) 15 | if c&xorBit == 0 { 16 | s := mappings[index:] 17 | return append(b, s[1:s[0]+1]...) 18 | } 19 | b = append(b, s...) 20 | if c&inlineXOR == inlineXOR { 21 | // TODO: support and handle two-byte inline masks 22 | b[len(b)-1] ^= byte(index) 23 | } else { 24 | for p := len(b) - int(xorData[index]); p < len(b); p++ { 25 | index++ 26 | b[p] ^= xorData[index] 27 | } 28 | } 29 | return b 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_aix_ppc64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix && ppc64 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used AIX. 9 | 10 | package unix 11 | 12 | // Major returns the major component of a Linux device number. 13 | func Major(dev uint64) uint32 { 14 | return uint32((dev & 0x3fffffff00000000) >> 32) 15 | } 16 | 17 | // Minor returns the minor component of a Linux device number. 18 | func Minor(dev uint64) uint32 { 19 | return uint32((dev & 0x00000000ffffffff) >> 0) 20 | } 21 | 22 | // Mkdev returns a Linux device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | var DEVNO64 uint64 26 | DEVNO64 = 0x8000000000000000 27 | return ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm64 && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/file_unix.go: -------------------------------------------------------------------------------- 1 | //go:build unix && !tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "syscall" 7 | 8 | "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | const ( 12 | nonBlockingFileReadSupported = true 13 | nonBlockingFileWriteSupported = true 14 | ) 15 | 16 | func rmdir(path string) sys.Errno { 17 | err := syscall.Rmdir(path) 18 | return sys.UnwrapOSError(err) 19 | } 20 | 21 | // readFd exposes syscall.Read. 22 | func readFd(fd uintptr, buf []byte) (int, sys.Errno) { 23 | if len(buf) == 0 { 24 | return 0, 0 // Short-circuit 0-len reads. 25 | } 26 | n, err := syscall.Read(int(fd), buf) 27 | errno := sys.UnwrapOSError(err) 28 | return n, errno 29 | } 30 | 31 | // writeFd exposes syscall.Write. 32 | func writeFd(fd uintptr, buf []byte) (int, sys.Errno) { 33 | if len(buf) == 0 { 34 | return 0, 0 // Short-circuit 0-len writes. 35 | } 36 | n, err := syscall.Write(int(fd), buf) 37 | errno := sys.UnwrapOSError(err) 38 | return n, errno 39 | } 40 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: int32(nsec)} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint32(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint32(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: int32(nsec)} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint32(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint32(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/idna/trie13.0.0.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | // Copyright 2016 The Go Authors. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | //go:build go1.16 8 | 9 | package idna 10 | 11 | // appendMapping appends the mapping for the respective rune. isMapped must be 12 | // true. A mapping is a categorization of a rune as defined in UTS #46. 13 | func (c info) appendMapping(b []byte, s string) []byte { 14 | index := int(c >> indexShift) 15 | if c&xorBit == 0 { 16 | p := index 17 | return append(b, mappings[mappingIndex[p]:mappingIndex[p+1]]...) 18 | } 19 | b = append(b, s...) 20 | if c&inlineXOR == inlineXOR { 21 | // TODO: support and handle two-byte inline masks 22 | b[len(b)-1] ^= byte(index) 23 | } else { 24 | for p := len(b) - int(xorData[index]); p < len(b); p++ { 25 | index++ 26 | b[p] ^= xorData[index] 27 | } 28 | } 29 | return b 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/NVIDIA/go-nvml/pkg/nvml/const_static.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package nvml 16 | 17 | import ( 18 | "reflect" 19 | ) 20 | 21 | const ( 22 | SYSTEM_PROCESS_NAME_BUFFER_SIZE = 256 23 | ) 24 | 25 | func STRUCT_VERSION(data interface{}, version uint32) uint32 { 26 | return uint32(uint32(reflect.Indirect(reflect.ValueOf(data)).Type().Size()) | (version << uint32(24))) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/log/README.md: -------------------------------------------------------------------------------- 1 | # log 2 | 3 | A Go package providing a common logging interface across containerd repositories and a way for clients to use and configure logging in containerd packages. 4 | 5 | This package is not intended to be used as a standalone logging package outside of the containerd ecosystem and is intended as an interface wrapper around a logging implementation. 6 | In the future this package may be replaced with a common go logging interface. 7 | 8 | ## Project details 9 | 10 | **log** is a containerd sub-project, licensed under the [Apache 2.0 license](./LICENSE). 11 | As a containerd sub-project, you will find the: 12 | * [Project governance](https://github.com/containerd/project/blob/main/GOVERNANCE.md), 13 | * [Maintainers](https://github.com/containerd/project/blob/main/MAINTAINERS), 14 | * and [Contributing guidelines](https://github.com/containerd/project/blob/main/CONTRIBUTING.md) 15 | 16 | information in our [`containerd/project`](https://github.com/containerd/project) repository. 17 | 18 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/internal/grpcsync/oncefunc.go: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright 2022 gRPC authors. 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | */ 18 | 19 | package grpcsync 20 | 21 | import ( 22 | "sync" 23 | ) 24 | 25 | // OnceFunc returns a function wrapping f which ensures f is only executed 26 | // once even if the returned function is executed multiple times. 27 | func OnceFunc(f func()) func() { 28 | var once sync.Once 29 | return func() { 30 | once.Do(f) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_netbsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in NetBSD's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a NetBSD device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev & 0x000fff00) >> 8) 13 | } 14 | 15 | // Minor returns the minor component of a NetBSD device number. 16 | func Minor(dev uint64) uint32 { 17 | minor := uint32((dev & 0x000000ff) >> 0) 18 | minor |= uint32((dev & 0xfff00000) >> 12) 19 | return minor 20 | } 21 | 22 | // Mkdev returns a NetBSD device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | dev := (uint64(major) << 8) & 0x000fff00 26 | dev |= (uint64(minor) << 12) & 0xfff00000 27 | dev |= (uint64(minor) << 0) & 0x000000ff 28 | return dev 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/nri/pkg/api/timeouts.go: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright The containerd Authors. 3 | 4 | Licensed under the Apache License, Version 2.0 (the "License"); 5 | you may not use this file except in compliance with the License. 6 | You may obtain a copy of the License at 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | Unless required by applicable law or agreed to in writing, software 11 | distributed under the License is distributed on an "AS IS" BASIS, 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | See the License for the specific language governing permissions and 14 | limitations under the License. 15 | */ 16 | 17 | package api 18 | 19 | import ( 20 | "time" 21 | ) 22 | 23 | const ( 24 | // DefaultPluginRegistrationTimeout is the default timeout for plugin registration. 25 | DefaultPluginRegistrationTimeout = 5 * time.Second 26 | // DefaultPluginRequestTimeout is the default timeout for plugins to handle a request. 27 | DefaultPluginRequestTimeout = 2 * time.Second 28 | ) 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_openbsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in OpenBSD's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of an OpenBSD device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev & 0x0000ff00) >> 8) 13 | } 14 | 15 | // Minor returns the minor component of an OpenBSD device number. 16 | func Minor(dev uint64) uint32 { 17 | minor := uint32((dev & 0x000000ff) >> 0) 18 | minor |= uint32((dev & 0xffff0000) >> 8) 19 | return minor 20 | } 21 | 22 | // Mkdev returns an OpenBSD device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | dev := (uint64(major) << 8) & 0x0000ff00 26 | dev |= (uint64(minor) << 8) & 0xffff0000 27 | dev |= (uint64(minor) << 0) & 0x000000ff 28 | return dev 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/nri/pkg/net/multiplex/ttrpc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright The containerd Authors. 3 | 4 | Licensed under the Apache License, Version 2.0 (the "License"); 5 | you may not use this file except in compliance with the License. 6 | You may obtain a copy of the License at 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | Unless required by applicable law or agreed to in writing, software 11 | distributed under the License is distributed on an "AS IS" BASIS, 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | See the License for the specific language governing permissions and 14 | limitations under the License. 15 | */ 16 | 17 | package multiplex 18 | 19 | const ( 20 | // PluginServiceConn is the mux connection ID for NRI plugin services. 21 | PluginServiceConn ConnID = iota + 1 22 | // RuntimeServiceConn is the mux connection ID for NRI runtime services. 23 | RuntimeServiceConn 24 | ) 25 | 26 | const ( 27 | ttrpcMessageHeaderLength = 10 28 | ttrpcMessageLengthMax = 4 << 20 29 | ) 30 | -------------------------------------------------------------------------------- /vendor/github.com/spf13/cobra/Makefile: -------------------------------------------------------------------------------- 1 | BIN="./bin" 2 | SRC=$(shell find . -name "*.go") 3 | 4 | ifeq (, $(shell which golangci-lint)) 5 | $(warning "could not find golangci-lint in $(PATH), run: curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh") 6 | endif 7 | 8 | .PHONY: fmt lint test install_deps clean 9 | 10 | default: all 11 | 12 | all: fmt test 13 | 14 | fmt: 15 | $(info ******************** checking formatting ********************) 16 | @test -z $(shell gofmt -l $(SRC)) || (gofmt -d $(SRC); exit 1) 17 | 18 | lint: 19 | $(info ******************** running lint tools ********************) 20 | golangci-lint run -v 21 | 22 | test: install_deps 23 | $(info ******************** running tests ********************) 24 | go test -v ./... 25 | 26 | richtest: install_deps 27 | $(info ******************** running tests with kyoh86/richgo ********************) 28 | richgo test -v ./... 29 | 30 | install_deps: 31 | $(info ******************** downloading dependencies ********************) 32 | go get -v ./... 33 | 34 | clean: 35 | rm -rf $(BIN) 36 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/ssa.go: -------------------------------------------------------------------------------- 1 | // Package ssa is used to construct SSA function. By nature this is free of Wasm specific thing 2 | // and ISA. 3 | // 4 | // We use the "block argument" variant of SSA: https://en.wikipedia.org/wiki/Static_single-assignment_form#Block_arguments 5 | // which is equivalent to the traditional PHI function based one, but more convenient during optimizations. 6 | // However, in this package's source code comment, we might use PHI whenever it seems necessary in order to be aligned with 7 | // existing literatures, e.g. SSA level optimization algorithms are often described using PHI nodes. 8 | // 9 | // The rationale doc for the choice of "block argument" by MLIR of LLVM is worth a read: 10 | // https://mlir.llvm.org/docs/Rationale/Rationale/#block-arguments-vs-phi-nodes 11 | // 12 | // The algorithm to resolve variable definitions used here is based on the paper 13 | // "Simple and Efficient Construction of Static Single Assignment Form": https://link.springer.com/content/pdf/10.1007/978-3-642-37051-9_6.pdf. 14 | package ssa 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/internal/grpcutil/regex.go: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright 2021 gRPC authors. 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | */ 18 | 19 | package grpcutil 20 | 21 | import "regexp" 22 | 23 | // FullMatchWithRegex returns whether the full text matches the regex provided. 24 | func FullMatchWithRegex(re *regexp.Regexp, text string) bool { 25 | if len(text) == 0 { 26 | return re.MatchString(text) 27 | } 28 | re.Longest() 29 | rem := re.FindString(text) 30 | return len(rem) == len(text) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/field_mask_gen.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Code generated by generate-protos. DO NOT EDIT. 6 | 7 | package genid 8 | 9 | import ( 10 | protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 | ) 12 | 13 | const File_google_protobuf_field_mask_proto = "google/protobuf/field_mask.proto" 14 | 15 | // Names for google.protobuf.FieldMask. 16 | const ( 17 | FieldMask_message_name protoreflect.Name = "FieldMask" 18 | FieldMask_message_fullname protoreflect.FullName = "google.protobuf.FieldMask" 19 | ) 20 | 21 | // Field names for google.protobuf.FieldMask. 22 | const ( 23 | FieldMask_Paths_field_name protoreflect.Name = "paths" 24 | 25 | FieldMask_Paths_field_fullname protoreflect.FullName = "google.protobuf.FieldMask.paths" 26 | ) 27 | 28 | // Field numbers for google.protobuf.FieldMask. 29 | const ( 30 | FieldMask_Paths_field_number protoreflect.FieldNumber = 1 31 | ) 32 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/experimental/sys/error.go: -------------------------------------------------------------------------------- 1 | package sys 2 | 3 | import ( 4 | "io" 5 | "io/fs" 6 | "os" 7 | ) 8 | 9 | // UnwrapOSError returns an Errno or zero if the input is nil. 10 | func UnwrapOSError(err error) Errno { 11 | if err == nil { 12 | return 0 13 | } 14 | err = underlyingError(err) 15 | switch err { 16 | case nil, io.EOF: 17 | return 0 // EOF is not a Errno 18 | case fs.ErrInvalid: 19 | return EINVAL 20 | case fs.ErrPermission: 21 | return EPERM 22 | case fs.ErrExist: 23 | return EEXIST 24 | case fs.ErrNotExist: 25 | return ENOENT 26 | case fs.ErrClosed: 27 | return EBADF 28 | } 29 | return errorToErrno(err) 30 | } 31 | 32 | // underlyingError returns the underlying error if a well-known OS error type. 33 | // 34 | // This impl is basically the same as os.underlyingError in os/error.go 35 | func underlyingError(err error) error { 36 | switch err := err.(type) { 37 | case *os.PathError: 38 | return err.Err 39 | case *os.LinkError: 40 | return err.Err 41 | case *os.SyscallError: 42 | return err.Err 43 | } 44 | return err 45 | } 46 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens.go: -------------------------------------------------------------------------------- 1 | //go:build (linux || darwin) && !tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "syscall" 7 | "unsafe" 8 | 9 | "github.com/tetratelabs/wazero/experimental/sys" 10 | ) 11 | 12 | func timesToPtr(times *[2]syscall.Timespec) unsafe.Pointer { //nolint:unused 13 | if times != nil { 14 | return unsafe.Pointer(×[0]) 15 | } 16 | return unsafe.Pointer(nil) 17 | } 18 | 19 | func timesToTimespecs(atim int64, mtim int64) (times *[2]syscall.Timespec) { 20 | // When both inputs are omitted, there is nothing to change. 21 | if atim == sys.UTIME_OMIT && mtim == sys.UTIME_OMIT { 22 | return 23 | } 24 | 25 | times = &[2]syscall.Timespec{} 26 | if atim == sys.UTIME_OMIT { 27 | times[0] = syscall.Timespec{Nsec: _UTIME_OMIT} 28 | times[1] = syscall.NsecToTimespec(mtim) 29 | } else if mtim == sys.UTIME_OMIT { 30 | times[0] = syscall.NsecToTimespec(atim) 31 | times[1] = syscall.Timespec{Nsec: _UTIME_OMIT} 32 | } else { 33 | times[0] = syscall.NsecToTimespec(atim) 34 | times[1] = syscall.NsecToTimespec(mtim) 35 | } 36 | return 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/jedib0t/go-pretty/v6/text/cursor.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // Cursor helps move the cursor on the console in multiple directions. 8 | type Cursor rune 9 | 10 | const ( 11 | // CursorDown helps move the Cursor Down X lines 12 | CursorDown Cursor = 'B' 13 | 14 | // CursorLeft helps move the Cursor Left X characters 15 | CursorLeft Cursor = 'D' 16 | 17 | // CursorRight helps move the Cursor Right X characters 18 | CursorRight Cursor = 'C' 19 | 20 | // CursorUp helps move the Cursor Up X lines 21 | CursorUp Cursor = 'A' 22 | 23 | // EraseLine helps erase all characters to the Right of the Cursor in the 24 | // current line 25 | EraseLine Cursor = 'K' 26 | ) 27 | 28 | // Sprint prints the Escape Sequence to move the Cursor once. 29 | func (c Cursor) Sprint() string { 30 | return fmt.Sprintf("%s%c", EscapeStart, c) 31 | } 32 | 33 | // Sprintn prints the Escape Sequence to move the Cursor "n" times. 34 | func (c Cursor) Sprintn(n int) string { 35 | if c == EraseLine { 36 | return c.Sprint() 37 | } 38 | return fmt.Sprintf("%s%d%c", EscapeStart, n, c) 39 | } 40 | -------------------------------------------------------------------------------- /vendor/sigs.k8s.io/yaml/yaml_go110.go: -------------------------------------------------------------------------------- 1 | // This file contains changes that are only compatible with go 1.10 and onwards. 2 | 3 | //go:build go1.10 4 | // +build go1.10 5 | 6 | /* 7 | Copyright 2021 The Kubernetes Authors. 8 | 9 | Licensed under the Apache License, Version 2.0 (the "License"); 10 | you may not use this file except in compliance with the License. 11 | You may obtain a copy of the License at 12 | 13 | http://www.apache.org/licenses/LICENSE-2.0 14 | 15 | Unless required by applicable law or agreed to in writing, software 16 | distributed under the License is distributed on an "AS IS" BASIS, 17 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 | See the License for the specific language governing permissions and 19 | limitations under the License. 20 | */ 21 | 22 | package yaml 23 | 24 | import "encoding/json" 25 | 26 | // DisallowUnknownFields configures the JSON decoder to error out if unknown 27 | // fields come along, instead of dropping them by default. 28 | func DisallowUnknownFields(d *json.Decoder) *json.Decoder { 29 | d.DisallowUnknownFields() 30 | return d 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/containerd/nri/pkg/net/socketpair_cloexec_windows.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | 3 | /* 4 | Copyright The containerd Authors. 5 | 6 | Licensed under the Apache License, Version 2.0 (the "License"); 7 | you may not use this file except in compliance with the License. 8 | You may obtain a copy of the License at 9 | 10 | http://www.apache.org/licenses/LICENSE-2.0 11 | 12 | Unless required by applicable law or agreed to in writing, software 13 | distributed under the License is distributed on an "AS IS" BASIS, 14 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | See the License for the specific language governing permissions and 16 | limitations under the License. 17 | */ 18 | 19 | package net 20 | 21 | import ( 22 | "errors" 23 | 24 | sys "golang.org/x/sys/windows" 25 | ) 26 | 27 | func newSocketPairCLOEXEC() ([2]sys.Handle, error) { 28 | // when implementing do use WSA_FLAG_NO_HANDLE_INHERIT to avoid leaking FDs 29 | return [2]sys.Handle{sys.InvalidHandle, sys.InvalidHandle}, errors.New("newSocketPairCLOEXEC unimplemented for windows") 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (ppc64 || ppc64le) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, Linux 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 17 | BL runtime·entersyscall(SB) 18 | MOVD a1+8(FP), R3 19 | MOVD a2+16(FP), R4 20 | MOVD a3+24(FP), R5 21 | MOVD R0, R6 22 | MOVD R0, R7 23 | MOVD R0, R8 24 | MOVD trap+0(FP), R9 // syscall entry 25 | SYSCALL R9 26 | MOVD R3, r1+32(FP) 27 | MOVD R4, r2+40(FP) 28 | BL runtime·exitsyscall(SB) 29 | RET 30 | 31 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 32 | MOVD a1+8(FP), R3 33 | MOVD a2+16(FP), R4 34 | MOVD a3+24(FP), R5 35 | MOVD R0, R6 36 | MOVD R0, R7 37 | MOVD R0, R8 38 | MOVD trap+0(FP), R9 // syscall entry 39 | SYSCALL R9 40 | MOVD R3, r1+32(FP) 41 | MOVD R4, r2+40(FP) 42 | RET 43 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_bsd.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64) && (darwin || freebsd) 2 | 3 | package sysfs 4 | 5 | import ( 6 | "io/fs" 7 | "os" 8 | 9 | experimentalsys "github.com/tetratelabs/wazero/experimental/sys" 10 | "github.com/tetratelabs/wazero/sys" 11 | ) 12 | 13 | // dirNlinkIncludesDot is true because even though os.File filters out dot 14 | // entries, the underlying syscall.Stat includes them. 15 | // 16 | // Note: this is only used in tests 17 | const dirNlinkIncludesDot = true 18 | 19 | func lstat(path string) (sys.Stat_t, experimentalsys.Errno) { 20 | if info, err := os.Lstat(path); err != nil { 21 | return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) 22 | } else { 23 | return sys.NewStat_t(info), 0 24 | } 25 | } 26 | 27 | func stat(path string) (sys.Stat_t, experimentalsys.Errno) { 28 | if info, err := os.Stat(path); err != nil { 29 | return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) 30 | } else { 31 | return sys.NewStat_t(info), 0 32 | } 33 | } 34 | 35 | func statFile(f fs.File) (sys.Stat_t, experimentalsys.Errno) { 36 | return defaultStatFile(f) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/Makefile: -------------------------------------------------------------------------------- 1 | all: vet test testrace 2 | 3 | build: 4 | go build google.golang.org/grpc/... 5 | 6 | clean: 7 | go clean -i google.golang.org/grpc/... 8 | 9 | deps: 10 | GO111MODULE=on go get -d -v google.golang.org/grpc/... 11 | 12 | proto: 13 | @ if ! which protoc > /dev/null; then \ 14 | echo "error: protoc not installed" >&2; \ 15 | exit 1; \ 16 | fi 17 | go generate google.golang.org/grpc/... 18 | 19 | test: 20 | go test -cpu 1,4 -timeout 7m google.golang.org/grpc/... 21 | 22 | testsubmodule: 23 | cd security/advancedtls && go test -cpu 1,4 -timeout 7m google.golang.org/grpc/security/advancedtls/... 24 | cd security/authorization && go test -cpu 1,4 -timeout 7m google.golang.org/grpc/security/authorization/... 25 | 26 | testrace: 27 | go test -race -cpu 1,4 -timeout 7m google.golang.org/grpc/... 28 | 29 | testdeps: 30 | GO111MODULE=on go get -d -v -t google.golang.org/grpc/... 31 | 32 | vet: vetdeps 33 | ./vet.sh 34 | 35 | vetdeps: 36 | ./vet.sh -install 37 | 38 | .PHONY: \ 39 | all \ 40 | build \ 41 | clean \ 42 | proto \ 43 | test \ 44 | testrace \ 45 | vet \ 46 | vetdeps 47 | -------------------------------------------------------------------------------- /vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs_unsupported.go: -------------------------------------------------------------------------------- 1 | //go:build tinygo 2 | 3 | package sysfs 4 | 5 | import ( 6 | "io/fs" 7 | 8 | experimentalsys "github.com/tetratelabs/wazero/experimental/sys" 9 | ) 10 | 11 | // Link implements the same method as documented on sys.FS 12 | func (d *dirFS) Link(oldName, newName string) experimentalsys.Errno { 13 | return experimentalsys.ENOSYS 14 | } 15 | 16 | // Unlink implements the same method as documented on sys.FS 17 | func (d *dirFS) Unlink(path string) (err experimentalsys.Errno) { 18 | return experimentalsys.ENOSYS 19 | } 20 | 21 | // Rename implements the same method as documented on sys.FS 22 | func (d *dirFS) Rename(from, to string) experimentalsys.Errno { 23 | return experimentalsys.ENOSYS 24 | } 25 | 26 | // Chmod implements the same method as documented on sys.FS 27 | func (d *dirFS) Chmod(path string, perm fs.FileMode) experimentalsys.Errno { 28 | return experimentalsys.ENOSYS 29 | } 30 | 31 | // Symlink implements the same method as documented on sys.FS 32 | func (d *dirFS) Symlink(oldName, link string) experimentalsys.Errno { 33 | return experimentalsys.ENOSYS 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gccgo_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gccgo && 386 6 | 7 | package unix 8 | 9 | import ( 10 | "syscall" 11 | "unsafe" 12 | ) 13 | 14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 15 | var newoffset int64 16 | offsetLow := uint32(offset & 0xffffffff) 17 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 19 | return newoffset, err 20 | } 21 | 22 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) { 23 | fd, _, err := Syscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0) 24 | return int(fd), err 25 | } 26 | 27 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) { 28 | fd, _, err := RawSyscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0) 29 | return int(fd), err 30 | } 31 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/source_context_gen.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Code generated by generate-protos. DO NOT EDIT. 6 | 7 | package genid 8 | 9 | import ( 10 | protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 | ) 12 | 13 | const File_google_protobuf_source_context_proto = "google/protobuf/source_context.proto" 14 | 15 | // Names for google.protobuf.SourceContext. 16 | const ( 17 | SourceContext_message_name protoreflect.Name = "SourceContext" 18 | SourceContext_message_fullname protoreflect.FullName = "google.protobuf.SourceContext" 19 | ) 20 | 21 | // Field names for google.protobuf.SourceContext. 22 | const ( 23 | SourceContext_FileName_field_name protoreflect.Name = "file_name" 24 | 25 | SourceContext_FileName_field_fullname protoreflect.FullName = "google.protobuf.SourceContext.file_name" 26 | ) 27 | 28 | // Field numbers for google.protobuf.SourceContext. 29 | const ( 30 | SourceContext_FileName_field_number protoreflect.FieldNumber = 1 31 | ) 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_freebsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in FreeBSD's sys/types.h header. 7 | // 8 | // The information below is extracted and adapted from sys/types.h: 9 | // 10 | // Minor gives a cookie instead of an index since in order to avoid changing the 11 | // meanings of bits 0-15 or wasting time and space shifting bits 16-31 for 12 | // devices that don't use them. 13 | 14 | package unix 15 | 16 | // Major returns the major component of a FreeBSD device number. 17 | func Major(dev uint64) uint32 { 18 | return uint32((dev >> 8) & 0xff) 19 | } 20 | 21 | // Minor returns the minor component of a FreeBSD device number. 22 | func Minor(dev uint64) uint32 { 23 | return uint32(dev & 0xffff00ff) 24 | } 25 | 26 | // Mkdev returns a FreeBSD device number generated from the given major and 27 | // minor components. 28 | func Mkdev(major, minor uint32) uint64 { 29 | return (uint64(major) << 8) | uint64(minor) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_openbsd_mips64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | func setTimespec(sec, nsec int64) Timespec { 8 | return Timespec{Sec: sec, Nsec: nsec} 9 | } 10 | 11 | func setTimeval(sec, usec int64) Timeval { 12 | return Timeval{Sec: sec, Usec: usec} 13 | } 14 | 15 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 16 | k.Ident = uint64(fd) 17 | k.Filter = int16(mode) 18 | k.Flags = uint16(flags) 19 | } 20 | 21 | func (iov *Iovec) SetLen(length int) { 22 | iov.Len = uint64(length) 23 | } 24 | 25 | func (msghdr *Msghdr) SetControllen(length int) { 26 | msghdr.Controllen = uint32(length) 27 | } 28 | 29 | func (msghdr *Msghdr) SetIovlen(length int) { 30 | msghdr.Iovlen = uint32(length) 31 | } 32 | 33 | func (cmsg *Cmsghdr) SetLen(length int) { 34 | cmsg.Len = uint32(length) 35 | } 36 | 37 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 38 | // of OpenBSD the syscall is called sysctl instead of __sysctl. 39 | const SYS___SYSCTL = SYS_SYSCTL 40 | -------------------------------------------------------------------------------- /vendor/github.com/jedib0t/go-pretty/v6/LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 jedib0t 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | --------------------------------------------------------------------------------