├── .common-ci.yml ├── .github ├── copy-pr-bot.yaml ├── dependabot.yml └── workflows │ ├── ci.yaml │ ├── image.yaml │ └── precompiled.yaml ├── .gitignore ├── .gitlab-ci.yml ├── .nvidia-ci.yml ├── CONTRIBUTING.md ├── LICENSE ├── Makefile ├── README.md ├── RELEASE.md ├── azurelinux ├── Dockerfile ├── README.md └── nvidia-driver ├── base ├── Dockerfile └── generate-ci-config ├── centos7 ├── Dockerfile ├── README.md ├── empty ├── install.sh └── nvidia-driver ├── centos8 ├── Dockerfile ├── README.md ├── empty └── nvidia-driver ├── ci ├── Dockerfile ├── README.md ├── build.sh ├── centos │ └── CentOS-Base.repo ├── coreos │ └── build.sh ├── fedora │ └── .gitlab-ci-fcos.yml ├── flatcar │ └── build.sh ├── gitlab-get-driver-tags.sh ├── localbuild.sh ├── run.sh └── terraform.tf ├── coreos ├── Dockerfile ├── README.md ├── empty ├── nvidia-container-runtime │ ├── Gopkg.lock │ ├── Gopkg.toml │ ├── Makefile │ ├── main.go │ ├── main_test.go │ ├── test_spec.json │ └── vendor │ │ └── github.com │ │ ├── davecgh │ │ └── go-spew │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── cov_report.sh │ │ │ ├── spew │ │ │ ├── bypass.go │ │ │ ├── bypasssafe.go │ │ │ ├── common.go │ │ │ ├── common_test.go │ │ │ ├── config.go │ │ │ ├── doc.go │ │ │ ├── dump.go │ │ │ ├── dump_test.go │ │ │ ├── dumpcgo_test.go │ │ │ ├── dumpnocgo_test.go │ │ │ ├── example_test.go │ │ │ ├── format.go │ │ │ ├── format_test.go │ │ │ ├── internal_test.go │ │ │ ├── internalunsafe_test.go │ │ │ ├── spew.go │ │ │ ├── spew_test.go │ │ │ └── testdata │ │ │ │ └── dumpcgo.go │ │ │ └── test_coverage.txt │ │ ├── opencontainers │ │ └── runtime-spec │ │ │ ├── .gitattributes │ │ │ ├── .gitignore │ │ │ ├── .mailmap │ │ │ ├── .pullapprove.yml │ │ │ ├── .tool │ │ │ └── version-doc.go │ │ │ ├── .travis.yml │ │ │ ├── ChangeLog │ │ │ ├── GOVERNANCE.md │ │ │ ├── LICENSE │ │ │ ├── MAINTAINERS │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── RELEASES.md │ │ │ ├── bundle.md │ │ │ ├── config-linux.md │ │ │ ├── config-solaris.md │ │ │ ├── config-windows.md │ │ │ ├── config.md │ │ │ ├── glossary.md │ │ │ ├── implementations.md │ │ │ ├── meeting.ics │ │ │ ├── principles.md │ │ │ ├── project.md │ │ │ ├── runtime-linux.md │ │ │ ├── runtime.md │ │ │ ├── schema │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── config-linux.json │ │ │ ├── config-schema.json │ │ │ ├── config-solaris.json │ │ │ ├── config-windows.json │ │ │ ├── defs-linux.json │ │ │ ├── defs.json │ │ │ ├── state-schema.json │ │ │ ├── test │ │ │ │ ├── config │ │ │ │ │ ├── bad │ │ │ │ │ │ └── invalid-json.json │ │ │ │ │ └── good │ │ │ │ │ │ ├── minimal-for-start.json │ │ │ │ │ │ ├── minimal.json │ │ │ │ │ │ └── spec-example.json │ │ │ │ └── state │ │ │ │ │ ├── bad │ │ │ │ │ └── invalid-json.json │ │ │ │ │ └── good │ │ │ │ │ └── spec-example.json │ │ │ └── validate.go │ │ │ ├── spec.md │ │ │ ├── specs-go │ │ │ ├── config.go │ │ │ ├── state.go │ │ │ └── version.go │ │ │ └── style.md │ │ ├── pelletier │ │ └── go-toml │ │ │ ├── .circleci │ │ │ └── config.yml │ │ │ ├── .dockerignore │ │ │ ├── .github │ │ │ └── ISSUE_TEMPLATE │ │ │ │ ├── bug_report.md │ │ │ │ └── feature_request.md │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── CONTRIBUTING.md │ │ │ ├── Dockerfile │ │ │ ├── LICENSE │ │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ │ ├── README.md │ │ │ ├── appveyor.yml │ │ │ ├── benchmark.json │ │ │ ├── benchmark.sh │ │ │ ├── benchmark.toml │ │ │ ├── benchmark.yml │ │ │ ├── benchmark_test.go │ │ │ ├── cmd │ │ │ ├── tomljson │ │ │ │ ├── main.go │ │ │ │ └── main_test.go │ │ │ ├── tomll │ │ │ │ └── main.go │ │ │ └── tomltestgen │ │ │ │ └── main.go │ │ │ ├── doc.go │ │ │ ├── doc_test.go │ │ │ ├── example-crlf.toml │ │ │ ├── example.toml │ │ │ ├── fuzz.go │ │ │ ├── fuzz.sh │ │ │ ├── go.mod │ │ │ ├── go.sum │ │ │ ├── keysparsing.go │ │ │ ├── keysparsing_test.go │ │ │ ├── lexer.go │ │ │ ├── lexer_test.go │ │ │ ├── marshal.go │ │ │ ├── marshal_OrderPreserve_Map_test.toml │ │ │ ├── marshal_OrderPreserve_test.toml │ │ │ ├── marshal_test.go │ │ │ ├── marshal_test.toml │ │ │ ├── parser.go │ │ │ ├── parser_test.go │ │ │ ├── position.go │ │ │ ├── position_test.go │ │ │ ├── query │ │ │ ├── doc.go │ │ │ ├── lexer.go │ │ │ ├── lexer_test.go │ │ │ ├── match.go │ │ │ ├── match_test.go │ │ │ ├── parser.go │ │ │ ├── parser_test.go │ │ │ ├── query.go │ │ │ ├── query_test.go │ │ │ └── tokens.go │ │ │ ├── token.go │ │ │ ├── token_test.go │ │ │ ├── toml.go │ │ │ ├── toml_test.go │ │ │ ├── toml_testgen_support_test.go │ │ │ ├── toml_testgen_test.go │ │ │ ├── tomltree_create.go │ │ │ ├── tomltree_create_test.go │ │ │ ├── tomltree_write.go │ │ │ └── tomltree_write_test.go │ │ ├── pmezard │ │ └── go-difflib │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── difflib │ │ │ ├── difflib.go │ │ │ └── difflib_test.go │ │ └── stretchr │ │ └── testify │ │ ├── .gitignore │ │ ├── .travis.gofmt.sh │ │ ├── .travis.gogenerate.sh │ │ ├── .travis.govet.sh │ │ ├── .travis.yml │ │ ├── Gopkg.lock │ │ ├── Gopkg.toml │ │ ├── LICENSE │ │ ├── README.md │ │ ├── _codegen │ │ └── main.go │ │ ├── assert │ │ ├── assertion_format.go │ │ ├── assertion_format.go.tmpl │ │ ├── assertion_forward.go │ │ ├── assertion_forward.go.tmpl │ │ ├── assertions.go │ │ ├── assertions_test.go │ │ ├── doc.go │ │ ├── errors.go │ │ ├── forward_assertions.go │ │ ├── forward_assertions_test.go │ │ ├── http_assertions.go │ │ └── http_assertions_test.go │ │ ├── doc.go │ │ ├── go.mod │ │ ├── go.sum │ │ ├── http │ │ ├── doc.go │ │ ├── test_response_writer.go │ │ └── test_round_tripper.go │ │ ├── mock │ │ ├── doc.go │ │ ├── mock.go │ │ └── mock_test.go │ │ ├── package_test.go │ │ ├── require │ │ ├── doc.go │ │ ├── forward_requirements.go │ │ ├── forward_requirements_test.go │ │ ├── require.go │ │ ├── require.go.tmpl │ │ ├── require_forward.go │ │ ├── require_forward.go.tmpl │ │ ├── requirements.go │ │ └── requirements_test.go │ │ └── suite │ │ ├── doc.go │ │ ├── interfaces.go │ │ ├── suite.go │ │ └── suite_test.go └── nvidia-driver ├── fedora ├── Dockerfile ├── LICENSE ├── README.md ├── common.sh ├── drivers │ └── README.md ├── empty ├── install.sh └── nvidia-driver ├── flatcar ├── Dockerfile ├── README.md ├── empty └── nvidia-driver ├── multi-arch.mk ├── native-only.mk ├── photon3.0 ├── Dockerfile ├── README.md ├── empty └── nvidia-driver ├── rhel7 ├── Dockerfile ├── README.md ├── empty └── nvidia-driver ├── rhel8 ├── Dockerfile ├── LICENSE ├── README.md ├── common.sh ├── drivers │ └── README.md ├── empty ├── install.sh ├── nvidia-driver ├── ocp_dtk_entrypoint └── precompiled │ ├── .gitignore │ ├── Dockerfile │ ├── LICENSE │ ├── Makefile │ ├── README.md │ ├── common.sh │ ├── nvidia-driver │ ├── rhsm-register │ └── x509-configuration.ini ├── rhel9 ├── Dockerfile ├── LICENSE ├── README.md ├── common.sh ├── drivers │ └── README.md ├── empty ├── install.sh ├── nvidia-driver ├── ocp_dtk_entrypoint └── precompiled │ ├── .gitignore │ ├── Dockerfile │ ├── LICENSE │ ├── Makefile │ ├── README.md │ ├── clusterpolicy.json │ ├── common.sh │ ├── nvidia-driver │ ├── nvidiadriver.json │ ├── rhsm-register │ └── x509-configuration.ini ├── scripts └── precompiled.sh ├── sle15 ├── Dockerfile ├── LICENSE ├── README.md ├── drivers │ └── README.md ├── empty ├── install.sh └── nvidia-driver ├── tests ├── cases │ └── nvidia-driver.sh ├── ci-remote-exec.sh ├── ci-run-e2e.sh ├── holodeck_ubuntu22.04.yaml ├── holodeck_ubuntu24.04.yaml ├── local.sh ├── remote-exec-local.sh └── scripts │ ├── .definitions.sh │ ├── .local.sh │ ├── .rsync-includes │ ├── checks.sh │ ├── ci-precompiled-helpers.sh │ ├── end-to-end-nvidia-driver.sh │ ├── findkernelversion.sh │ ├── install-operator.sh │ ├── kernel-upgrade-helper.sh │ ├── prerequisites.sh │ ├── pull.sh │ ├── push.sh │ ├── remote.sh │ ├── remote_retry.sh │ ├── sync.sh │ ├── uninstall-operator.sh │ ├── upgrade-kernel.sh │ └── verify-operator.sh ├── ubuntu16.04 ├── Dockerfile ├── README.md ├── empty └── nvidia-driver ├── ubuntu18.04 ├── Dockerfile ├── README.md ├── empty └── nvidia-driver ├── ubuntu20.04 ├── Dockerfile ├── README.md ├── drivers │ └── README.md ├── empty ├── install.sh ├── nvidia-driver └── precompiled │ ├── Dockerfile │ └── nvidia-driver ├── ubuntu22.04 ├── Dockerfile ├── README.md ├── drivers │ └── README.md ├── empty ├── install.sh ├── nvidia-driver └── precompiled │ ├── Dockerfile │ ├── local-repo.sh │ └── nvidia-driver ├── ubuntu24.04 ├── Dockerfile ├── README.md ├── drivers │ └── README.md ├── empty ├── install.sh ├── nvidia-driver └── precompiled │ ├── Dockerfile │ ├── local-repo.sh │ └── nvidia-driver ├── versions.mk ├── vgpu-manager ├── README.md ├── rhel8 │ ├── Dockerfile │ ├── nvidia-driver │ └── ocp_dtk_entrypoint ├── ubuntu20.04 │ ├── Dockerfile │ └── nvidia-driver └── ubuntu22.04 │ ├── Dockerfile │ └── nvidia-driver └── vgpu ├── Dockerfile └── src ├── go.mod ├── go.sum ├── vendor ├── github.com │ ├── cpuguy83 │ │ └── go-md2man │ │ │ └── v2 │ │ │ ├── LICENSE.md │ │ │ └── md2man │ │ │ ├── md2man.go │ │ │ └── roff.go │ ├── russross │ │ └── blackfriday │ │ │ └── v2 │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE.txt │ │ │ ├── README.md │ │ │ ├── block.go │ │ │ ├── doc.go │ │ │ ├── entities.go │ │ │ ├── esc.go │ │ │ ├── html.go │ │ │ ├── inline.go │ │ │ ├── markdown.go │ │ │ ├── node.go │ │ │ └── smartypants.go │ ├── sirupsen │ │ └── logrus │ │ │ ├── .gitignore │ │ │ ├── .golangci.yml │ │ │ ├── .travis.yml │ │ │ ├── CHANGELOG.md │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── alt_exit.go │ │ │ ├── appveyor.yml │ │ │ ├── buffer_pool.go │ │ │ ├── doc.go │ │ │ ├── entry.go │ │ │ ├── exported.go │ │ │ ├── formatter.go │ │ │ ├── hooks.go │ │ │ ├── json_formatter.go │ │ │ ├── logger.go │ │ │ ├── logrus.go │ │ │ ├── terminal_check_appengine.go │ │ │ ├── terminal_check_bsd.go │ │ │ ├── terminal_check_js.go │ │ │ ├── terminal_check_no_terminal.go │ │ │ ├── terminal_check_notappengine.go │ │ │ ├── terminal_check_solaris.go │ │ │ ├── terminal_check_unix.go │ │ │ ├── terminal_check_windows.go │ │ │ ├── text_formatter.go │ │ │ └── writer.go │ ├── urfave │ │ └── cli │ │ │ └── v2 │ │ │ ├── .flake8 │ │ │ ├── .gitignore │ │ │ ├── CODE_OF_CONDUCT.md │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── app.go │ │ │ ├── args.go │ │ │ ├── category.go │ │ │ ├── cli.go │ │ │ ├── command.go │ │ │ ├── context.go │ │ │ ├── docs.go │ │ │ ├── errors.go │ │ │ ├── fish.go │ │ │ ├── flag-spec.yaml │ │ │ ├── flag.go │ │ │ ├── flag_bool.go │ │ │ ├── flag_duration.go │ │ │ ├── flag_ext.go │ │ │ ├── flag_float64.go │ │ │ ├── flag_float64_slice.go │ │ │ ├── flag_generic.go │ │ │ ├── flag_int.go │ │ │ ├── flag_int64.go │ │ │ ├── flag_int64_slice.go │ │ │ ├── flag_int_slice.go │ │ │ ├── flag_path.go │ │ │ ├── flag_string.go │ │ │ ├── flag_string_slice.go │ │ │ ├── flag_timestamp.go │ │ │ ├── flag_uint.go │ │ │ ├── flag_uint64.go │ │ │ ├── flag_uint64_slice.go │ │ │ ├── flag_uint_slice.go │ │ │ ├── funcs.go │ │ │ ├── godoc-current.txt │ │ │ ├── help.go │ │ │ ├── mkdocs-requirements.txt │ │ │ ├── mkdocs.yml │ │ │ ├── parse.go │ │ │ ├── sliceflag.go │ │ │ ├── sort.go │ │ │ ├── suggestions.go │ │ │ ├── template.go │ │ │ └── zz_generated.flags.go │ └── xrash │ │ └── smetrics │ │ ├── .travis.yml │ │ ├── LICENSE │ │ ├── README.md │ │ ├── doc.go │ │ ├── hamming.go │ │ ├── jaro-winkler.go │ │ ├── jaro.go │ │ ├── soundex.go │ │ ├── ukkonen.go │ │ └── wagner-fischer.go ├── golang.org │ └── x │ │ └── sys │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── internal │ │ └── unsafeheader │ │ │ └── unsafeheader.go │ │ ├── unix │ │ ├── .gitignore │ │ ├── README.md │ │ ├── affinity_linux.go │ │ ├── aliases.go │ │ ├── asm_aix_ppc64.s │ │ ├── asm_bsd_386.s │ │ ├── asm_bsd_amd64.s │ │ ├── asm_bsd_arm.s │ │ ├── asm_bsd_arm64.s │ │ ├── asm_bsd_ppc64.s │ │ ├── asm_bsd_riscv64.s │ │ ├── asm_linux_386.s │ │ ├── asm_linux_amd64.s │ │ ├── asm_linux_arm.s │ │ ├── asm_linux_arm64.s │ │ ├── asm_linux_loong64.s │ │ ├── asm_linux_mips64x.s │ │ ├── asm_linux_mipsx.s │ │ ├── asm_linux_ppc64x.s │ │ ├── asm_linux_riscv64.s │ │ ├── asm_linux_s390x.s │ │ ├── asm_openbsd_mips64.s │ │ ├── asm_solaris_amd64.s │ │ ├── asm_zos_s390x.s │ │ ├── bluetooth_linux.go │ │ ├── cap_freebsd.go │ │ ├── constants.go │ │ ├── dev_aix_ppc.go │ │ ├── dev_aix_ppc64.go │ │ ├── dev_darwin.go │ │ ├── dev_dragonfly.go │ │ ├── dev_freebsd.go │ │ ├── dev_linux.go │ │ ├── dev_netbsd.go │ │ ├── dev_openbsd.go │ │ ├── dev_zos.go │ │ ├── dirent.go │ │ ├── endian_big.go │ │ ├── endian_little.go │ │ ├── env_unix.go │ │ ├── epoll_zos.go │ │ ├── fcntl.go │ │ ├── fcntl_darwin.go │ │ ├── fcntl_linux_32bit.go │ │ ├── fdset.go │ │ ├── fstatfs_zos.go │ │ ├── gccgo.go │ │ ├── gccgo_c.c │ │ ├── gccgo_linux_amd64.go │ │ ├── ifreq_linux.go │ │ ├── ioctl_linux.go │ │ ├── ioctl_signed.go │ │ ├── ioctl_unsigned.go │ │ ├── ioctl_zos.go │ │ ├── mkall.sh │ │ ├── mkerrors.sh │ │ ├── pagesize_unix.go │ │ ├── pledge_openbsd.go │ │ ├── ptrace_darwin.go │ │ ├── ptrace_ios.go │ │ ├── race.go │ │ ├── race0.go │ │ ├── readdirent_getdents.go │ │ ├── readdirent_getdirentries.go │ │ ├── sockcmsg_dragonfly.go │ │ ├── sockcmsg_linux.go │ │ ├── sockcmsg_unix.go │ │ ├── sockcmsg_unix_other.go │ │ ├── syscall.go │ │ ├── syscall_aix.go │ │ ├── syscall_aix_ppc.go │ │ ├── syscall_aix_ppc64.go │ │ ├── syscall_bsd.go │ │ ├── syscall_darwin.go │ │ ├── syscall_darwin_amd64.go │ │ ├── syscall_darwin_arm64.go │ │ ├── syscall_darwin_libSystem.go │ │ ├── syscall_dragonfly.go │ │ ├── syscall_dragonfly_amd64.go │ │ ├── syscall_freebsd.go │ │ ├── syscall_freebsd_386.go │ │ ├── syscall_freebsd_amd64.go │ │ ├── syscall_freebsd_arm.go │ │ ├── syscall_freebsd_arm64.go │ │ ├── syscall_freebsd_riscv64.go │ │ ├── syscall_hurd.go │ │ ├── syscall_hurd_386.go │ │ ├── syscall_illumos.go │ │ ├── syscall_linux.go │ │ ├── syscall_linux_386.go │ │ ├── syscall_linux_alarm.go │ │ ├── syscall_linux_amd64.go │ │ ├── syscall_linux_amd64_gc.go │ │ ├── syscall_linux_arm.go │ │ ├── syscall_linux_arm64.go │ │ ├── syscall_linux_gc.go │ │ ├── syscall_linux_gc_386.go │ │ ├── syscall_linux_gc_arm.go │ │ ├── syscall_linux_gccgo_386.go │ │ ├── syscall_linux_gccgo_arm.go │ │ ├── syscall_linux_loong64.go │ │ ├── syscall_linux_mips64x.go │ │ ├── syscall_linux_mipsx.go │ │ ├── syscall_linux_ppc.go │ │ ├── syscall_linux_ppc64x.go │ │ ├── syscall_linux_riscv64.go │ │ ├── syscall_linux_s390x.go │ │ ├── syscall_linux_sparc64.go │ │ ├── syscall_netbsd.go │ │ ├── syscall_netbsd_386.go │ │ ├── syscall_netbsd_amd64.go │ │ ├── syscall_netbsd_arm.go │ │ ├── syscall_netbsd_arm64.go │ │ ├── syscall_openbsd.go │ │ ├── syscall_openbsd_386.go │ │ ├── syscall_openbsd_amd64.go │ │ ├── syscall_openbsd_arm.go │ │ ├── syscall_openbsd_arm64.go │ │ ├── syscall_openbsd_libc.go │ │ ├── syscall_openbsd_mips64.go │ │ ├── syscall_openbsd_ppc64.go │ │ ├── syscall_openbsd_riscv64.go │ │ ├── syscall_solaris.go │ │ ├── syscall_solaris_amd64.go │ │ ├── syscall_unix.go │ │ ├── syscall_unix_gc.go │ │ ├── syscall_unix_gc_ppc64x.go │ │ ├── syscall_zos_s390x.go │ │ ├── sysvshm_linux.go │ │ ├── sysvshm_unix.go │ │ ├── sysvshm_unix_other.go │ │ ├── timestruct.go │ │ ├── unveil_openbsd.go │ │ ├── xattr_bsd.go │ │ ├── zerrors_aix_ppc.go │ │ ├── zerrors_aix_ppc64.go │ │ ├── zerrors_darwin_amd64.go │ │ ├── zerrors_darwin_arm64.go │ │ ├── zerrors_dragonfly_amd64.go │ │ ├── zerrors_freebsd_386.go │ │ ├── zerrors_freebsd_amd64.go │ │ ├── zerrors_freebsd_arm.go │ │ ├── zerrors_freebsd_arm64.go │ │ ├── zerrors_freebsd_riscv64.go │ │ ├── zerrors_linux.go │ │ ├── zerrors_linux_386.go │ │ ├── zerrors_linux_amd64.go │ │ ├── zerrors_linux_arm.go │ │ ├── zerrors_linux_arm64.go │ │ ├── zerrors_linux_loong64.go │ │ ├── zerrors_linux_mips.go │ │ ├── zerrors_linux_mips64.go │ │ ├── zerrors_linux_mips64le.go │ │ ├── zerrors_linux_mipsle.go │ │ ├── zerrors_linux_ppc.go │ │ ├── zerrors_linux_ppc64.go │ │ ├── zerrors_linux_ppc64le.go │ │ ├── zerrors_linux_riscv64.go │ │ ├── zerrors_linux_s390x.go │ │ ├── zerrors_linux_sparc64.go │ │ ├── zerrors_netbsd_386.go │ │ ├── zerrors_netbsd_amd64.go │ │ ├── zerrors_netbsd_arm.go │ │ ├── zerrors_netbsd_arm64.go │ │ ├── zerrors_openbsd_386.go │ │ ├── zerrors_openbsd_amd64.go │ │ ├── zerrors_openbsd_arm.go │ │ ├── zerrors_openbsd_arm64.go │ │ ├── zerrors_openbsd_mips64.go │ │ ├── zerrors_openbsd_ppc64.go │ │ ├── zerrors_openbsd_riscv64.go │ │ ├── zerrors_solaris_amd64.go │ │ ├── zerrors_zos_s390x.go │ │ ├── zptrace_armnn_linux.go │ │ ├── zptrace_linux_arm64.go │ │ ├── zptrace_mipsnn_linux.go │ │ ├── zptrace_mipsnnle_linux.go │ │ ├── zptrace_x86_linux.go │ │ ├── zsyscall_aix_ppc.go │ │ ├── zsyscall_aix_ppc64.go │ │ ├── zsyscall_aix_ppc64_gc.go │ │ ├── zsyscall_aix_ppc64_gccgo.go │ │ ├── zsyscall_darwin_amd64.go │ │ ├── zsyscall_darwin_amd64.s │ │ ├── zsyscall_darwin_arm64.go │ │ ├── zsyscall_darwin_arm64.s │ │ ├── zsyscall_dragonfly_amd64.go │ │ ├── zsyscall_freebsd_386.go │ │ ├── zsyscall_freebsd_amd64.go │ │ ├── zsyscall_freebsd_arm.go │ │ ├── zsyscall_freebsd_arm64.go │ │ ├── zsyscall_freebsd_riscv64.go │ │ ├── zsyscall_illumos_amd64.go │ │ ├── zsyscall_linux.go │ │ ├── zsyscall_linux_386.go │ │ ├── zsyscall_linux_amd64.go │ │ ├── zsyscall_linux_arm.go │ │ ├── zsyscall_linux_arm64.go │ │ ├── zsyscall_linux_loong64.go │ │ ├── zsyscall_linux_mips.go │ │ ├── zsyscall_linux_mips64.go │ │ ├── zsyscall_linux_mips64le.go │ │ ├── zsyscall_linux_mipsle.go │ │ ├── zsyscall_linux_ppc.go │ │ ├── zsyscall_linux_ppc64.go │ │ ├── zsyscall_linux_ppc64le.go │ │ ├── zsyscall_linux_riscv64.go │ │ ├── zsyscall_linux_s390x.go │ │ ├── zsyscall_linux_sparc64.go │ │ ├── zsyscall_netbsd_386.go │ │ ├── zsyscall_netbsd_amd64.go │ │ ├── zsyscall_netbsd_arm.go │ │ ├── zsyscall_netbsd_arm64.go │ │ ├── zsyscall_openbsd_386.go │ │ ├── zsyscall_openbsd_386.s │ │ ├── zsyscall_openbsd_amd64.go │ │ ├── zsyscall_openbsd_amd64.s │ │ ├── zsyscall_openbsd_arm.go │ │ ├── zsyscall_openbsd_arm.s │ │ ├── zsyscall_openbsd_arm64.go │ │ ├── zsyscall_openbsd_arm64.s │ │ ├── zsyscall_openbsd_mips64.go │ │ ├── zsyscall_openbsd_mips64.s │ │ ├── zsyscall_openbsd_ppc64.go │ │ ├── zsyscall_openbsd_ppc64.s │ │ ├── zsyscall_openbsd_riscv64.go │ │ ├── zsyscall_openbsd_riscv64.s │ │ ├── zsyscall_solaris_amd64.go │ │ ├── zsyscall_zos_s390x.go │ │ ├── zsysctl_openbsd_386.go │ │ ├── zsysctl_openbsd_amd64.go │ │ ├── zsysctl_openbsd_arm.go │ │ ├── zsysctl_openbsd_arm64.go │ │ ├── zsysctl_openbsd_mips64.go │ │ ├── zsysctl_openbsd_ppc64.go │ │ ├── zsysctl_openbsd_riscv64.go │ │ ├── zsysnum_darwin_amd64.go │ │ ├── zsysnum_darwin_arm64.go │ │ ├── zsysnum_dragonfly_amd64.go │ │ ├── zsysnum_freebsd_386.go │ │ ├── zsysnum_freebsd_amd64.go │ │ ├── zsysnum_freebsd_arm.go │ │ ├── zsysnum_freebsd_arm64.go │ │ ├── zsysnum_freebsd_riscv64.go │ │ ├── zsysnum_linux_386.go │ │ ├── zsysnum_linux_amd64.go │ │ ├── zsysnum_linux_arm.go │ │ ├── zsysnum_linux_arm64.go │ │ ├── zsysnum_linux_loong64.go │ │ ├── zsysnum_linux_mips.go │ │ ├── zsysnum_linux_mips64.go │ │ ├── zsysnum_linux_mips64le.go │ │ ├── zsysnum_linux_mipsle.go │ │ ├── zsysnum_linux_ppc.go │ │ ├── zsysnum_linux_ppc64.go │ │ ├── zsysnum_linux_ppc64le.go │ │ ├── zsysnum_linux_riscv64.go │ │ ├── zsysnum_linux_s390x.go │ │ ├── zsysnum_linux_sparc64.go │ │ ├── zsysnum_netbsd_386.go │ │ ├── zsysnum_netbsd_amd64.go │ │ ├── zsysnum_netbsd_arm.go │ │ ├── zsysnum_netbsd_arm64.go │ │ ├── zsysnum_openbsd_386.go │ │ ├── zsysnum_openbsd_amd64.go │ │ ├── zsysnum_openbsd_arm.go │ │ ├── zsysnum_openbsd_arm64.go │ │ ├── zsysnum_openbsd_mips64.go │ │ ├── zsysnum_openbsd_ppc64.go │ │ ├── zsysnum_openbsd_riscv64.go │ │ ├── zsysnum_zos_s390x.go │ │ ├── ztypes_aix_ppc.go │ │ ├── ztypes_aix_ppc64.go │ │ ├── ztypes_darwin_amd64.go │ │ ├── ztypes_darwin_arm64.go │ │ ├── ztypes_dragonfly_amd64.go │ │ ├── ztypes_freebsd_386.go │ │ ├── ztypes_freebsd_amd64.go │ │ ├── ztypes_freebsd_arm.go │ │ ├── ztypes_freebsd_arm64.go │ │ ├── ztypes_freebsd_riscv64.go │ │ ├── ztypes_linux.go │ │ ├── ztypes_linux_386.go │ │ ├── ztypes_linux_amd64.go │ │ ├── ztypes_linux_arm.go │ │ ├── ztypes_linux_arm64.go │ │ ├── ztypes_linux_loong64.go │ │ ├── ztypes_linux_mips.go │ │ ├── ztypes_linux_mips64.go │ │ ├── ztypes_linux_mips64le.go │ │ ├── ztypes_linux_mipsle.go │ │ ├── ztypes_linux_ppc.go │ │ ├── ztypes_linux_ppc64.go │ │ ├── ztypes_linux_ppc64le.go │ │ ├── ztypes_linux_riscv64.go │ │ ├── ztypes_linux_s390x.go │ │ ├── ztypes_linux_sparc64.go │ │ ├── ztypes_netbsd_386.go │ │ ├── ztypes_netbsd_amd64.go │ │ ├── ztypes_netbsd_arm.go │ │ ├── ztypes_netbsd_arm64.go │ │ ├── ztypes_openbsd_386.go │ │ ├── ztypes_openbsd_amd64.go │ │ ├── ztypes_openbsd_arm.go │ │ ├── ztypes_openbsd_arm64.go │ │ ├── ztypes_openbsd_mips64.go │ │ ├── ztypes_openbsd_ppc64.go │ │ ├── ztypes_openbsd_riscv64.go │ │ ├── ztypes_solaris_amd64.go │ │ └── ztypes_zos_s390x.go │ │ └── windows │ │ ├── aliases.go │ │ ├── dll_windows.go │ │ ├── empty.s │ │ ├── env_windows.go │ │ ├── eventlog.go │ │ ├── exec_windows.go │ │ ├── memory_windows.go │ │ ├── mkerrors.bash │ │ ├── mkknownfolderids.bash │ │ ├── mksyscall.go │ │ ├── race.go │ │ ├── race0.go │ │ ├── security_windows.go │ │ ├── service.go │ │ ├── setupapi_windows.go │ │ ├── str.go │ │ ├── syscall.go │ │ ├── syscall_windows.go │ │ ├── types_windows.go │ │ ├── types_windows_386.go │ │ ├── types_windows_amd64.go │ │ ├── types_windows_arm.go │ │ ├── types_windows_arm64.go │ │ ├── zerrors_windows.go │ │ ├── zknownfolderids_windows.go │ │ └── zsyscall_windows.go ├── gopkg.in │ └── yaml.v2 │ │ ├── .travis.yml │ │ ├── LICENSE │ │ ├── LICENSE.libyaml │ │ ├── NOTICE │ │ ├── README.md │ │ ├── apic.go │ │ ├── decode.go │ │ ├── emitterc.go │ │ ├── encode.go │ │ ├── parserc.go │ │ ├── readerc.go │ │ ├── resolve.go │ │ ├── scannerc.go │ │ ├── sorter.go │ │ ├── writerc.go │ │ ├── yaml.go │ │ ├── yamlh.go │ │ └── yamlprivateh.go └── modules.txt └── vgpu-util.go /.github/copy-pr-bot.yaml: -------------------------------------------------------------------------------- 1 | # https://docs.gha-runners.nvidia.com/apps/copy-pr-bot/#configuration 2 | 3 | enabled: true 4 | -------------------------------------------------------------------------------- /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | # Please see the documentation for all configuration options: 2 | # https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates 3 | 4 | version: 2 5 | updates: 6 | - package-ecosystem: "gomod" 7 | target-branch: main 8 | directories: 9 | - "**/*" 10 | open-pull-requests-limit: 10 11 | schedule: 12 | interval: "weekly" 13 | day: "sunday" 14 | labels: 15 | - dependencies 16 | 17 | - package-ecosystem: "github-actions" 18 | directory: "/" 19 | schedule: 20 | interval: "daily" 21 | 22 | - package-ecosystem: "docker" 23 | directories: 24 | - "**/*" 25 | open-pull-requests-limit: 15 26 | schedule: 27 | interval: "daily" 28 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.tar 2 | *.swp 3 | *.swo 4 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # GPU Driver Container 2 | 3 | [![build status](https://gitlab.com/nvidia/container-images/driver/badges/master/pipeline.svg)](https://gitlab.com/nvidia/container-images/driver/-/commits/master) 4 | 5 | The NVIDIA GPU driver container allows the provisioning of the NVIDIA driver through the use of containers. 6 | 7 | ## Documentation 8 | 9 | [Driver Container documentation](https://docs.nvidia.com/datacenter/cloud-native/driver-containers/overview.html) 10 | 11 | ## Releases 12 | 13 | [NVIDIA GPU Driver at NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/driver) 14 | 15 | ## Building from Source 16 | 17 | ```sh 18 | platform=ubuntu22.04 # where ${platform} is one of the supported platforms (e.g. ubuntu22.04) 19 | docker build -t mydriver --build-arg DRIVER_VERSION="510.85.02" --build-arg CUDA_VERSION=11.7.1 --build-arg TARGETARCH=amd64 ${platform} 20 | ``` 21 | 22 | ## License 23 | 24 | [Apache License 2.0](LICENSE) 25 | [License For Customer Use of NVIDIA Software](https://www.nvidia.com/content/DriverDownload-March2009/licence.php?lang=us) 26 | -------------------------------------------------------------------------------- /azurelinux/Dockerfile: -------------------------------------------------------------------------------- 1 | ARG AZURE_LINUX_VERSION='' 2 | FROM mcr.microsoft.com/azurelinux/base/core:${AZURE_LINUX_VERSION} 3 | 4 | ARG AZURE_LINUX_VERSION 5 | ARG DRIVER_VERSION='' 6 | ENV DRIVER_VERSION=$DRIVER_VERSION 7 | ARG KERNEL_VERSION='' 8 | 9 | USER root 10 | 11 | COPY nvidia-driver /usr/local/bin 12 | 13 | RUN tdnf -y install util-linux ca-certificates 14 | 15 | RUN curl -fsSL -o /etc/yum.repos.d/mariner-nvidia.repo \ 16 | https://raw.githubusercontent.com/microsoft/azurelinux/${AZURE_LINUX_VERSION}/toolkit/docs/nvidia/mariner-nvidia.repo 17 | 18 | # Create a location to store the pre-downloaded RPMs for installation during container runtime 19 | RUN mkdir -p /opt/nvidia 20 | RUN tdnf -y --downloadonly --downloaddir=/opt/nvidia install cuda-${DRIVER_VERSION}-${KERNEL_VERSION} \ 21 | nvidia-fabric-manager-${DRIVER_VERSION} libnvidia-nscq-${DRIVER_VERSION} 22 | 23 | LABEL io.k8s.display-name="NVIDIA Driver Container" 24 | LABEL name="NVIDIA Driver Container" 25 | LABEL vendor="NVIDIA" 26 | LABEL version="${DRIVER_VERSION}" 27 | LABEL release="N/A" 28 | LABEL summary="Provision the NVIDIA driver through containers" 29 | 30 | ENTRYPOINT ["nvidia-driver", "init"] 31 | -------------------------------------------------------------------------------- /azurelinux/README.md: -------------------------------------------------------------------------------- 1 | # Azure Linux (EXPERIMENTAL) 2 | 3 | This directory contains the docker manifests used to run the precompiled gpu driver on Azure Linux/CBL-Mariner Linux, 4 | the fedora based Linux distribution provided by Microsoft 5 | 6 | The container image uses the driver rpm packages hosted here: https://packages.microsoft.com/cbl-mariner/2.0/prod/nvidia/x86_64/Packages/ 7 | 8 | The following driver versions are supported: 9 | 10 | - 535.129.03 11 | 12 | ## Running the container 13 | 14 | 1. Set the necessary environment variables 15 | 1. export DRIVER_VERSION=535.129.03 16 | 2. KERNEL_VERSION=5.15.148.2-2.cm2 17 | 18 | 2. Run the docker build with the following command: 19 | ``` 20 | docker build \ 21 | --build-arg DRIVER_VERSION="${DRIVER_VERSION}" \ 22 | --build-arg KERNEL_VERSION="${KERNEL_VERSION}" \ 23 | -t 24 | ``` 25 | 26 | 3. Once the docker is built successfully, you can issue the docker run command 27 | ``` 28 | docker run --name nvidia-driver -d --privileged --pid=host -v /run/nvidia:/run/nvidia:shared -v /var/log:/var/log -v /etc/os-release:/host-etc/os-release -v /dev/log:/dev/log 29 | ``` 30 | 31 | **NOTE**: This image is experimental and is still under evaluation. We do not recommend using this for any workloads other than for 32 | testing/development purposes. 33 | -------------------------------------------------------------------------------- /centos7/README.md: -------------------------------------------------------------------------------- 1 | # Centos7 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | See https://github.com/NVIDIA/nvidia-docker/wiki/Driver-containers-(Beta) 4 | -------------------------------------------------------------------------------- /centos7/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/centos7/empty -------------------------------------------------------------------------------- /centos8/README.md: -------------------------------------------------------------------------------- 1 | # Centos7 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | See https://github.com/NVIDIA/nvidia-docker/wiki/Driver-containers-(Beta) 4 | -------------------------------------------------------------------------------- /centos8/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/centos8/empty -------------------------------------------------------------------------------- /ci/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM ubuntu:16.04 2 | 3 | RUN apt-get update && apt-get install -y --no-install-recommends \ 4 | apt-transport-https \ 5 | ca-certificates \ 6 | curl \ 7 | software-properties-common \ 8 | && rm -rf /var/lib/apt/lists/* 9 | 10 | RUN curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add - 11 | RUN add-apt-repository \ 12 | "deb [arch=amd64] https://download.docker.com/linux/ubuntu \ 13 | $(lsb_release -cs) \ 14 | test" 15 | 16 | RUN apt-get update && apt-get install -y --no-install-recommends \ 17 | docker-ce \ 18 | git \ 19 | jq \ 20 | openssh-client \ 21 | python-pip \ 22 | python-setuptools \ 23 | unzip \ 24 | yum \ 25 | yum-utils \ 26 | && rm -rf /var/lib/apt/lists/* \ 27 | && pip install --upgrade pip 28 | 29 | ENV TF_VERSION=0.12.18 30 | RUN curl -fsSL https://releases.hashicorp.com/terraform/${TF_VERSION}/terraform_${TF_VERSION}_linux_amd64.zip -o terraform.zip \ 31 | && unzip terraform.zip \ 32 | && mv terraform /usr/local/bin/terraform \ 33 | && rm terraform.zip 34 | 35 | 36 | COPY centos/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo 37 | 38 | CMD ["/bin/bash"] 39 | -------------------------------------------------------------------------------- /ci/README.md: -------------------------------------------------------------------------------- 1 | # Driver Container CI 2 | 3 | ## Deployment 4 | 5 | You will need to add these variables to Gitlab CI variables: 6 | 7 | * `AWS_ACCESS_KEY_ID` 8 | * `AWS_SECRET_ACCESS_KEY` 9 | * `REGISTRY_USER` 10 | * `REGISTRY_TOKEN` 11 | * `SSH_PRIVATE_KEY` 12 | 13 | You can also optionally add the `REGISTRY` variable if you want to deploy to 14 | another docker registry than Docker Hub. 15 | 16 | ### AWS account 17 | 18 | The AWS account only needs permissions to create EC2 instances and new IAMs to 19 | store its key pairs. 20 | 21 | ### Generate SSH keys 22 | 23 | To ensure the security of the SSH connection, you must generate a host key pair 24 | and a client key pair which you will store in Gitlab CI variables. 25 | 26 | Generate the client key pair (`SSH_PRIVATE_KEY`): 27 | 28 | ``` 29 | ssh-keygen -t rsa -b 4096 -f id_rsa 30 | ``` 31 | 32 | ## Development 33 | 34 | You will need jq and terraform installed. 35 | 36 | 37 | Initialize terraform: 38 | ```sh 39 | terraform init 40 | ``` 41 | -------------------------------------------------------------------------------- /ci/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -o errexit 4 | set -o nounset 5 | set -o pipefail 6 | set -o xtrace 7 | 8 | # Utility functions & logging 9 | 10 | die() { 11 | echo -e "$0 \\033[0;41;30m[🛑] $*\\033[0m" >&2 12 | } 13 | 14 | warn() { 15 | echo -e "\\033[0;43;30m[⚠️] $*\\033[0m" >&2 16 | } 17 | 18 | log() { 19 | echo -e "\\033[1;32m[+] $*\\033[0m" >&2 20 | } 21 | 22 | # Sanity checks 23 | 24 | if [ -z "$SSH_PRIVATE_KEY" ]; then 25 | die "SSH private key must be specified with environment variable SSH_PRIVATE_KEY" 26 | fi 27 | 28 | # Setup SSH access 29 | 30 | eval "$(ssh-agent -s)" 31 | echo "${SSH_PRIVATE_KEY}" | ssh-add - &> /dev/null 32 | mkdir -p "${HOME}/.ssh" 33 | chmod 700 "${HOME}/.ssh" 34 | ssh-add -L > "${HOME}/.ssh/id_rsa.pub" 35 | 36 | # Run CI & Terraform 37 | 38 | cd ./ci 39 | terraform init -input=false 40 | CI_COMMIT_TAG="$(git describe --abbrev=0 --tags)" 41 | export CI_COMMIT_TAG 42 | export FORCE=true 43 | export REGISTRY=${IMAGE} 44 | export DRIVER_VERSION=${VERSION} 45 | ./run.sh 46 | -------------------------------------------------------------------------------- /ci/centos/CentOS-Base.repo: -------------------------------------------------------------------------------- 1 | [base] 2 | name=CentOS-7 - Base 3 | baseurl=http://mirror.centos.org/centos/7/os/$basearch/ 4 | gpgcheck=1 5 | gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7 6 | 7 | [updates] 8 | name=CentOS-7 - Updates 9 | baseurl=http://mirror.centos.org/centos/7/updates/$basearch/ 10 | gpgcheck=1 11 | gpgkey=https://www.centos.org/keys/RPM-GPG-KEY-CentOS-7 12 | -------------------------------------------------------------------------------- /ci/coreos/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -o errexit 4 | set -o nounset 5 | set -o pipefail 6 | set -o xtrace 7 | 8 | DRIVER_VERSION=${1} 9 | CONTAINER_VERSION=${2} 10 | REGISTRY=${3} 11 | 12 | # Get the kernel version 13 | kernel_version=$(uname -r) 14 | 15 | docker build -t "install-driver:${DRIVER_VERSION}" \ 16 | --build-arg DRIVER_VERSION="${DRIVER_VERSION}" "https://gitlab.com/nvidia/driver.git#master:coreos" 17 | 18 | docker run --privileged --name "compile_driver-${DRIVER_VERSION}" "install-driver:${DRIVER_VERSION}" \ 19 | update --kernel ${kernel_version} 20 | 21 | docker commit -m "Compile Linux kernel modules version ${kernel_version} for NVIDIA driver version ${DRIVER_VERSION}" \ 22 | --change='ENTRYPOINT ["nvidia-driver", "init"]' "compile_driver-${DRIVER_VERSION}" "${REGISTRY}:${CONTAINER_VERSION}-${kernel_version}-coreos" 23 | 24 | docker save "${REGISTRY}:${CONTAINER_VERSION}-${kernel_version}-coreos" -o "${CONTAINER_VERSION}-${kernel_version}-coreos.tar" 25 | -------------------------------------------------------------------------------- /ci/flatcar/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -o errexit 4 | set -o nounset 5 | set -o pipefail 6 | set -o xtrace 7 | 8 | DRIVER_VERSION=${1} 9 | # CONTAINER_VERSION ignored 10 | CONTAINER_VERSION=${2} 11 | REGISTRY=${3} 12 | CI_REPOSITORY_URL=${CI_REPOSITORY_URL:-https://gitlab.com/nvidia/driver.git} 13 | CI_COMMIT_REF_NAME=${CI_COMMIT_REF_NAME:-main} 14 | 15 | # Get the kernel version 16 | kernel_version=$(uname -r) 17 | 18 | docker build -t "install-driver:${DRIVER_VERSION}" \ 19 | --build-arg DRIVER_VERSION="${DRIVER_VERSION}" "${CI_REPOSITORY_URL}#${CI_COMMIT_REF_NAME}:flatcar" 20 | 21 | docker run --privileged --name "compile_driver-${DRIVER_VERSION}" "install-driver:${DRIVER_VERSION}" \ 22 | update --kernel "${kernel_version}" 23 | 24 | docker commit -m "Compile Linux kernel modules version ${kernel_version} for NVIDIA driver version ${DRIVER_VERSION}" \ 25 | --change='ENTRYPOINT ["nvidia-driver", "init"]' "compile_driver-${DRIVER_VERSION}" "${REGISTRY}:${DRIVER_VERSION}-${kernel_version}-flatcar" 26 | 27 | docker save "${REGISTRY}:${DRIVER_VERSION}-${kernel_version}-flatcar" -o "${DRIVER_VERSION}-${kernel_version}-flatcar.tar" 28 | -------------------------------------------------------------------------------- /coreos/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/coreos/empty -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/Gopkg.toml: -------------------------------------------------------------------------------- 1 | 2 | # Gopkg.toml example 3 | # 4 | # Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md 5 | # for detailed Gopkg.toml documentation. 6 | # 7 | # required = ["github.com/user/thing/cmd/thing"] 8 | # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] 9 | # 10 | # [[constraint]] 11 | # name = "github.com/user/project" 12 | # version = "1.0.0" 13 | # 14 | # [[constraint]] 15 | # name = "github.com/user/project2" 16 | # branch = "dev" 17 | # source = "github.com/myfork/project2" 18 | # 19 | # [[override]] 20 | # name = "github.com/x/y" 21 | # version = "2.4.0" 22 | 23 | 24 | [[constraint]] 25 | name = "github.com/opencontainers/runtime-spec" 26 | version = "1.0.1" 27 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/Makefile: -------------------------------------------------------------------------------- 1 | RUNTIME=nvidia-container-runtime 2 | MOCK_RUNC=$(CURDIR)/runc 3 | 4 | all: 5 | @go build -o ${RUNTIME} 6 | 7 | mock-runc: 8 | @(echo '#!/bin/bash\necho mock runc') > ${MOCK_RUNC} 9 | @chmod +x ${MOCK_RUNC} 10 | 11 | test: all mock-runc 12 | @go test -v 13 | @${RM} ${MOCK_RUNC} 14 | 15 | clean: 16 | @${RM} ${RUNTIME} 17 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/davecgh/go-spew/.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 | *.exe 23 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/davecgh/go-spew/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go_import_path: github.com/davecgh/go-spew 3 | go: 4 | - 1.6.x 5 | - 1.7.x 6 | - 1.8.x 7 | - 1.9.x 8 | - 1.10.x 9 | - tip 10 | sudo: false 11 | install: 12 | - go get -v github.com/alecthomas/gometalinter 13 | - gometalinter --install 14 | script: 15 | - export PATH=$PATH:$HOME/gopath/bin 16 | - export GORACE="halt_on_error=1" 17 | - test -z "$(gometalinter --disable-all 18 | --enable=gofmt 19 | --enable=golint 20 | --enable=vet 21 | --enable=gosimple 22 | --enable=unconvert 23 | --deadline=4m ./spew | tee /dev/stderr)" 24 | - go test -v -race -tags safe ./spew 25 | - go test -v -race -tags testcgo ./spew -covermode=atomic -coverprofile=profile.cov 26 | after_success: 27 | - go get -v github.com/mattn/goveralls 28 | - goveralls -coverprofile=profile.cov -service=travis-ci 29 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/davecgh/go-spew/LICENSE: -------------------------------------------------------------------------------- 1 | ISC License 2 | 3 | Copyright (c) 2012-2016 Dave Collins 4 | 5 | Permission to use, copy, modify, and/or distribute this software for any 6 | purpose with or without fee is hereby granted, provided that the above 7 | copyright notice and this permission notice appear in all copies. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/davecgh/go-spew/cov_report.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | # This script uses gocov to generate a test coverage report. 4 | # The gocov tool my be obtained with the following command: 5 | # go get github.com/axw/gocov/gocov 6 | # 7 | # It will be installed to $GOPATH/bin, so ensure that location is in your $PATH. 8 | 9 | # Check for gocov. 10 | if ! type gocov >/dev/null 2>&1; then 11 | echo >&2 "This script requires the gocov tool." 12 | echo >&2 "You may obtain it with the following command:" 13 | echo >&2 "go get github.com/axw/gocov/gocov" 14 | exit 1 15 | fi 16 | 17 | # Only run the cgo tests if gcc is installed. 18 | if type gcc >/dev/null 2>&1; then 19 | (cd spew && gocov test -tags testcgo | gocov report) 20 | else 21 | (cd spew && gocov test | gocov report) 22 | fi 23 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/davecgh/go-spew/spew/dumpnocgo_test.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2013 Dave Collins 2 | // 3 | // Permission to use, copy, modify, and distribute this software for any 4 | // purpose with or without fee is hereby granted, provided that the above 5 | // copyright notice and this permission notice appear in all copies. 6 | // 7 | // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 8 | // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 9 | // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 10 | // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 11 | // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 12 | // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 13 | // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 14 | 15 | // NOTE: Due to the following build constraints, this file will only be compiled 16 | // when either cgo is not supported or "-tags testcgo" is not added to the go 17 | // test command line. This file intentionally does not setup any cgo tests in 18 | // this scenario. 19 | // +build !cgo !testcgo 20 | 21 | package spew_test 22 | 23 | func addCgoDumpTests() { 24 | // Don't add any tests for cgo since this file is only compiled when 25 | // there should not be any cgo tests. 26 | } 27 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/.gitattributes: -------------------------------------------------------------------------------- 1 | # https://tools.ietf.org/html/rfc5545#section-3.1 2 | *.ics text eol=crlf 3 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/.gitignore: -------------------------------------------------------------------------------- 1 | output 2 | schema/validate 3 | version.md 4 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/.mailmap: -------------------------------------------------------------------------------- 1 | Aleksa Sarai 2 | Alexander Morozov 3 | Amit Saha 4 | Antonio Murdaca 5 | Brandon Philips 6 | Brandon Philips 7 | ChengTiesheng 8 | Daniel, Dao Quang Minh 9 | Doug Davis 10 | James O. D. Hunt 11 | John Howard 12 | LinZhinan(Zen Lin) 13 | Mrunal Patel 14 | Mrunal Patel 15 | Mrunal Patel 16 | Vincent Batts 17 | Vincent Batts 18 | Vishnu Kannan 19 | Vishnu Kannan 20 | Zefan Li 21 | 梁辰晔 (Liang Chenye) 22 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/.pullapprove.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | 3 | requirements: 4 | signed_off_by: 5 | required: true 6 | 7 | group_defaults: 8 | required: 2 9 | approve_by_comment: 10 | enabled: true 11 | approve_regex: ^LGTM 12 | reject_regex: ^Rejected 13 | reset_on_push: 14 | enabled: true 15 | author_approval: 16 | ignored: true 17 | always_pending: 18 | title_regex: ^WIP 19 | explanation: 'Work in progress...' 20 | conditions: 21 | branches: 22 | - master 23 | 24 | groups: 25 | runtime-spec: 26 | teams: 27 | - runtime-spec-maintainers 28 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/.tool/version-doc.go: -------------------------------------------------------------------------------- 1 | // +build ignore 2 | 3 | package main 4 | 5 | import ( 6 | "fmt" 7 | "html/template" 8 | "os" 9 | 10 | "github.com/opencontainers/runtime-spec/specs-go" 11 | ) 12 | 13 | var markdownTemplateString = ` 14 | 15 | **Specification Version:** *{{.}}* 16 | 17 | ` 18 | 19 | var markdownTemplate = template.Must(template.New("markdown").Parse(markdownTemplateString)) 20 | 21 | func main() { 22 | if err := markdownTemplate.Execute(os.Stdout, specs.Version); err != nil { 23 | fmt.Fprintln(os.Stderr, err) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - 1.7 4 | - 1.6.3 5 | - 1.5.4 6 | 7 | sudo: required 8 | 9 | services: 10 | - docker 11 | 12 | before_install: 13 | - make install.tools 14 | - docker pull vbatts/pandoc 15 | 16 | install: true 17 | 18 | script: 19 | - env | grep TRAVIS_ 20 | - make .govet 21 | - make .golint 22 | - echo "${TRAVIS_COMMIT_RANGE} -> ${TRAVIS_COMMIT_RANGE/.../..} (travis-ci/travis-ci#4596)" 23 | - TRAVIS_COMMIT_RANGE="${TRAVIS_COMMIT_RANGE/.../..}" make .gitvalidation 24 | - make docs 25 | - make -C schema test 26 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/MAINTAINERS: -------------------------------------------------------------------------------- 1 | Michael Crosby (@crosbymichael) 2 | Vishnu Kannan (@vishh) 3 | Mrunal Patel (@mrunalp) 4 | Vincent Batts (@vbatts) 5 | Daniel, Dao Quang Minh (@dqminh) 6 | Brandon Philips (@philips) 7 | Tianon Gravi (@tianon) 8 | Qiang Huang (@hqhq) 9 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/meeting.ics: -------------------------------------------------------------------------------- 1 | BEGIN:VCALENDAR 2 | VERSION:2.0 3 | PRODID:-//Open Containers Initiative//Developer Meeting//EN 4 | BEGIN:VTIMEZONE 5 | TZID:America/Los_Angeles 6 | LAST-MODIFIED:20050809T050000Z 7 | BEGIN:STANDARD 8 | DTSTART:20071104T020000 9 | RRULE:FREQ=YEARLY;BYMONTH=11;BYDAY=1SU 10 | TZOFFSETFROM:-0700 11 | TZOFFSETTO:-0800 12 | TZNAME:PST 13 | END:STANDARD 14 | BEGIN:DAYLIGHT 15 | DTSTART:20070311T020000 16 | RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=2SU 17 | TZOFFSETFROM:-0800 18 | TZOFFSETTO:-0700 19 | TZNAME:PDT 20 | END:DAYLIGHT 21 | END:VTIMEZONE 22 | BEGIN:VEVENT 23 | UID:tdc-meeting@opencontainers.org 24 | DTSTAMP:20170821T200000Z 25 | DTSTART;TZID=America/Los_Angeles:20170906T140000 26 | RRULE:FREQ=MONTHLY;INTERVAL=1;BYDAY=1WE 27 | DURATION:PT1H 28 | SUMMARY:OCI TDC Meeting 29 | DESCRIPTION;ALTREP="https://github.com/opencontainers/runtime-spec# 30 | meetings":Open Containers Initiative Developer Meeting\n 31 | https://github.com/opencontainers/runtime-spec#meetings\n 32 | Web: https://www.uberconference.com/opencontainers\n 33 | Audio-only: +1 415 968 0849 (no PIN needed) 34 | LOCATION:https://www.uberconference.com/opencontainers 35 | URL:https://github.com/opencontainers/runtime-spec/blob/master/meeting.ics 36 | END:VEVENT 37 | END:VCALENDAR 38 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/project.md: -------------------------------------------------------------------------------- 1 | # Project docs 2 | 3 | ## Release Process 4 | 5 | * Increment version in [`specs-go/version.go`](specs-go/version.go) 6 | * `git commit` version increment 7 | * `git tag` the prior commit (preferably signed tag) 8 | * `make docs` to produce PDF and HTML copies of the spec 9 | * Make a [release][releases] for the version. Attach the produced docs. 10 | 11 | 12 | [releases]: https://github.com/opencontainers/runtime-spec/releases 13 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/runtime-linux.md: -------------------------------------------------------------------------------- 1 | # Linux Runtime 2 | 3 | ## File descriptors 4 | 5 | By default, only the `stdin`, `stdout` and `stderr` file descriptors are kept open for the application by the runtime. 6 | The runtime MAY pass additional file descriptors to the application to support features such as [socket activation][socket-activated-containers]. 7 | Some of the file descriptors MAY be redirected to `/dev/null` even though they are open. 8 | 9 | ## Dev symbolic links 10 | 11 | While creating the container (step 2 in the [lifecycle](runtime.md#lifecycle)), runtimes MUST create the following symlinks if the source file exists after processing [`mounts`](config.md#mounts): 12 | 13 | | Source | Destination | 14 | | --------------- | ----------- | 15 | | /proc/self/fd | /dev/fd | 16 | | /proc/self/fd/0 | /dev/stdin | 17 | | /proc/self/fd/1 | /dev/stdout | 18 | | /proc/self/fd/2 | /dev/stderr | 19 | 20 | 21 | [socket-activated-containers]: http://0pointer.de/blog/projects/socket-activated-containers.html 22 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/schema/test/config/bad/invalid-json.json: -------------------------------------------------------------------------------- 1 | {] 2 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/schema/test/config/good/minimal-for-start.json: -------------------------------------------------------------------------------- 1 | { 2 | "ociVersion": "1.0.0", 3 | "root": { 4 | "path": "rootfs" 5 | }, 6 | "process": { 7 | "cwd": "/", 8 | "args": [ 9 | "sh" 10 | ], 11 | "user": { 12 | "uid": 0, 13 | "gid": 0 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/schema/test/config/good/minimal.json: -------------------------------------------------------------------------------- 1 | { 2 | "ociVersion": "1.0.0", 3 | "root": { 4 | "path": "rootfs" 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/schema/test/state/bad/invalid-json.json: -------------------------------------------------------------------------------- 1 | {] 2 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/schema/test/state/good/spec-example.json: -------------------------------------------------------------------------------- 1 | { 2 | "ociVersion": "0.2.0", 3 | "id": "oci-container1", 4 | "status": "running", 5 | "pid": 4422, 6 | "bundle": "/containers/redis", 7 | "annotations": { 8 | "myKey": "myValue" 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/opencontainers/runtime-spec/specs-go/state.go: -------------------------------------------------------------------------------- 1 | package specs 2 | 3 | // State holds information about the runtime state of the container. 4 | type State struct { 5 | // Version is the version of the specification that is supported. 6 | Version string `json:"ociVersion"` 7 | // ID is the container ID 8 | ID string `json:"id"` 9 | // Status is the runtime status of the container. 10 | Status string `json:"status"` 11 | // Pid is the process ID for the container process. 12 | Pid int `json:"pid,omitempty"` 13 | // Bundle is the path to the container's bundle directory. 14 | Bundle string `json:"bundle"` 15 | // Annotations are key values associated with the container. 16 | Annotations map[string]string `json:"annotations,omitempty"` 17 | } 18 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/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 = 1 12 | 13 | // VersionDev indicates development branch. Releases will be empty string. 14 | VersionDev = "" 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 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/.dockerignore: -------------------------------------------------------------------------------- 1 | cmd/tomll/tomll 2 | cmd/tomljson/tomljson 3 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | 5 | --- 6 | 7 | **Describe the bug** 8 | A clear and concise description of what the bug is. 9 | 10 | **To Reproduce** 11 | Steps to reproduce the behavior. Including TOML files. 12 | 13 | **Expected behavior** 14 | A clear and concise description of what you expected to happen, if other than "should work". 15 | 16 | **Versions** 17 | - go-toml: version (git sha) 18 | - go: version 19 | - operating system: e.g. macOS, Windows, Linux 20 | 21 | **Additional context** 22 | Add any other context about the problem here that you think may help to diagnose. 23 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: Suggest an idea for this project 4 | 5 | --- 6 | 7 | **Is your feature request related to a problem? Please describe.** 8 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 9 | 10 | **Describe the solution you'd like** 11 | A clear and concise description of what you want to happen. 12 | 13 | **Describe alternatives you've considered** 14 | A clear and concise description of any alternative solutions or features you've considered. 15 | 16 | **Additional context** 17 | Add any other context or screenshots about the feature request here. 18 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/.gitignore: -------------------------------------------------------------------------------- 1 | test_program/test_program_bin 2 | fuzz/ 3 | cmd/tomll/tomll 4 | cmd/tomljson/tomljson 5 | cmd/tomltestgen/tomltestgen 6 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | go: 4 | - 1.11.x 5 | - 1.12.x 6 | - tip 7 | matrix: 8 | allow_failures: 9 | - go: tip 10 | fast_finish: true 11 | env: 12 | - GO111MODULE=on 13 | script: 14 | - if [ -n "$(go fmt ./...)" ]; then exit 1; fi 15 | - go test github.com/pelletier/go-toml -race -coverprofile=coverage.txt -covermode=atomic 16 | - go test github.com/pelletier/go-toml/cmd/tomljson 17 | - go test github.com/pelletier/go-toml/cmd/tomll 18 | - go test github.com/pelletier/go-toml/query 19 | - ./benchmark.sh $TRAVIS_BRANCH https://github.com/$TRAVIS_REPO_SLUG.git 20 | 21 | after_success: 22 | - bash <(curl -s https://codecov.io/bash) 23 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM golang:1.12-alpine3.9 as builder 2 | WORKDIR /go/src/github.com/pelletier/go-toml 3 | COPY . . 4 | ENV CGO_ENABLED=0 5 | ENV GOOS=linux 6 | RUN go install ./... 7 | 8 | FROM scratch 9 | COPY --from=builder /go/bin/tomll /usr/bin/tomll 10 | COPY --from=builder /go/bin/tomljson /usr/bin/tomljson 11 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2013 - 2017 Thomas Pelletier, Eric Anderton 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 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | **Issue:** add link to pelletier/go-toml issue here 2 | 3 | Explanation of what this pull request does. 4 | 5 | More detailed description of the decisions being made and the reasons why (if the patch is non-trivial). 6 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: "{build}" 2 | 3 | # Source Config 4 | clone_folder: c:\gopath\src\github.com\pelletier\go-toml 5 | 6 | # Build host 7 | environment: 8 | GOPATH: c:\gopath 9 | DEPTESTBYPASS501: 1 10 | GOVERSION: 1.12 11 | GO111MODULE: on 12 | 13 | init: 14 | - git config --global core.autocrlf input 15 | 16 | # Build 17 | install: 18 | # Install the specific Go version. 19 | - rmdir c:\go /s /q 20 | - appveyor DownloadFile https://storage.googleapis.com/golang/go%GOVERSION%.windows-amd64.msi 21 | - msiexec /i go%GOVERSION%.windows-amd64.msi /q 22 | - choco install bzr 23 | - set Path=c:\go\bin;c:\gopath\bin;C:\Program Files (x86)\Bazaar\;C:\Program Files\Mercurial\%Path% 24 | - go version 25 | - go env 26 | 27 | build: false 28 | deploy: false 29 | 30 | test_script: 31 | - go test github.com/pelletier/go-toml 32 | - go test github.com/pelletier/go-toml/cmd/tomljson 33 | - go test github.com/pelletier/go-toml/cmd/tomll 34 | - go test github.com/pelletier/go-toml/query 35 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/benchmark.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -e 4 | 5 | reference_ref=${1:-master} 6 | reference_git=${2:-.} 7 | 8 | if ! `hash benchstat 2>/dev/null`; then 9 | echo "Installing benchstat" 10 | go get golang.org/x/perf/cmd/benchstat 11 | go install golang.org/x/perf/cmd/benchstat 12 | fi 13 | 14 | tempdir=`mktemp -d /tmp/go-toml-benchmark-XXXXXX` 15 | ref_tempdir="${tempdir}/ref" 16 | ref_benchmark="${ref_tempdir}/benchmark-`echo -n ${reference_ref}|tr -s '/' '-'`.txt" 17 | local_benchmark="`pwd`/benchmark-local.txt" 18 | 19 | echo "=== ${reference_ref} (${ref_tempdir})" 20 | git clone ${reference_git} ${ref_tempdir} >/dev/null 2>/dev/null 21 | pushd ${ref_tempdir} >/dev/null 22 | git checkout ${reference_ref} >/dev/null 2>/dev/null 23 | go test -bench=. -benchmem | tee ${ref_benchmark} 24 | popd >/dev/null 25 | 26 | echo "" 27 | echo "=== local" 28 | go test -bench=. -benchmem | tee ${local_benchmark} 29 | 30 | echo "" 31 | echo "=== diff" 32 | benchstat -delta-test=none ${ref_benchmark} ${local_benchmark} -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/doc.go: -------------------------------------------------------------------------------- 1 | // Package toml is a TOML parser and manipulation library. 2 | // 3 | // This version supports the specification as described in 4 | // https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md 5 | // 6 | // Marshaling 7 | // 8 | // Go-toml can marshal and unmarshal TOML documents from and to data 9 | // structures. 10 | // 11 | // TOML document as a tree 12 | // 13 | // Go-toml can operate on a TOML document as a tree. Use one of the Load* 14 | // functions to parse TOML data and obtain a Tree instance, then one of its 15 | // methods to manipulate the tree. 16 | // 17 | // JSONPath-like queries 18 | // 19 | // The package github.com/pelletier/go-toml/query implements a system 20 | // similar to JSONPath to quickly retrieve elements of a TOML document using a 21 | // single expression. See the package documentation for more information. 22 | // 23 | package toml 24 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/example-crlf.toml: -------------------------------------------------------------------------------- 1 | # This is a TOML document. Boom. 2 | 3 | title = "TOML Example" 4 | 5 | [owner] 6 | name = "Tom Preston-Werner" 7 | organization = "GitHub" 8 | bio = "GitHub Cofounder & CEO\nLikes tater tots and beer." 9 | dob = 1979-05-27T07:32:00Z # First class dates? Why not? 10 | 11 | [database] 12 | server = "192.168.1.1" 13 | ports = [ 8001, 8001, 8002 ] 14 | connection_max = 5000 15 | enabled = true 16 | 17 | [servers] 18 | 19 | # You can indent as you please. Tabs or spaces. TOML don't care. 20 | [servers.alpha] 21 | ip = "10.0.0.1" 22 | dc = "eqdc10" 23 | 24 | [servers.beta] 25 | ip = "10.0.0.2" 26 | dc = "eqdc10" 27 | 28 | [clients] 29 | data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it 30 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/example.toml: -------------------------------------------------------------------------------- 1 | # This is a TOML document. Boom. 2 | 3 | title = "TOML Example" 4 | 5 | [owner] 6 | name = "Tom Preston-Werner" 7 | organization = "GitHub" 8 | bio = "GitHub Cofounder & CEO\nLikes tater tots and beer." 9 | dob = 1979-05-27T07:32:00Z # First class dates? Why not? 10 | 11 | [database] 12 | server = "192.168.1.1" 13 | ports = [ 8001, 8001, 8002 ] 14 | connection_max = 5000 15 | enabled = true 16 | 17 | [servers] 18 | 19 | # You can indent as you please. Tabs or spaces. TOML don't care. 20 | [servers.alpha] 21 | ip = "10.0.0.1" 22 | dc = "eqdc10" 23 | 24 | [servers.beta] 25 | ip = "10.0.0.2" 26 | dc = "eqdc10" 27 | 28 | [clients] 29 | data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it 30 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/fuzz.go: -------------------------------------------------------------------------------- 1 | // +build gofuzz 2 | 3 | package toml 4 | 5 | func Fuzz(data []byte) int { 6 | tree, err := LoadBytes(data) 7 | if err != nil { 8 | if tree != nil { 9 | panic("tree must be nil if there is an error") 10 | } 11 | return 0 12 | } 13 | 14 | str, err := tree.ToTomlString() 15 | if err != nil { 16 | if str != "" { 17 | panic(`str must be "" if there is an error`) 18 | } 19 | panic(err) 20 | } 21 | 22 | tree, err = Load(str) 23 | if err != nil { 24 | if tree != nil { 25 | panic("tree must be nil if there is an error") 26 | } 27 | return 0 28 | } 29 | 30 | return 1 31 | } 32 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/fuzz.sh: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | set -eu 3 | 4 | go get github.com/dvyukov/go-fuzz/go-fuzz 5 | go get github.com/dvyukov/go-fuzz/go-fuzz-build 6 | 7 | if [ ! -e toml-fuzz.zip ]; then 8 | go-fuzz-build github.com/pelletier/go-toml 9 | fi 10 | 11 | rm -fr fuzz 12 | mkdir -p fuzz/corpus 13 | cp *.toml fuzz/corpus 14 | 15 | go-fuzz -bin=toml-fuzz.zip -workdir=fuzz 16 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/pelletier/go-toml 2 | 3 | go 1.12 4 | 5 | require ( 6 | github.com/BurntSushi/toml v0.3.1 7 | github.com/davecgh/go-spew v1.1.1 8 | gopkg.in/yaml.v2 v2.2.2 9 | ) 10 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/go.sum: -------------------------------------------------------------------------------- 1 | github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ= 2 | github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= 3 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 4 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 5 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 6 | gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= 7 | gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= 8 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/marshal_OrderPreserve_Map_test.toml: -------------------------------------------------------------------------------- 1 | title = "TOML Marshal Testing" 2 | 3 | [basic_map] 4 | one = "one" 5 | two = "two" 6 | 7 | [long_map] 8 | a7 = "1" 9 | b3 = "2" 10 | c8 = "3" 11 | d4 = "4" 12 | e6 = "5" 13 | f5 = "6" 14 | g10 = "7" 15 | h1 = "8" 16 | i2 = "9" 17 | j9 = "10" 18 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/marshal_OrderPreserve_test.toml: -------------------------------------------------------------------------------- 1 | title = "TOML Marshal Testing" 2 | 3 | [basic_lists] 4 | floats = [12.3,45.6,78.9] 5 | bools = [true,false,true] 6 | dates = [1979-05-27T07:32:00Z,1980-05-27T07:32:00Z] 7 | ints = [8001,8001,8002] 8 | uints = [5002,5003] 9 | strings = ["One","Two","Three"] 10 | 11 | [[subdocptrs]] 12 | name = "Second" 13 | 14 | [basic_map] 15 | one = "one" 16 | two = "two" 17 | 18 | [subdoc] 19 | 20 | [subdoc.second] 21 | name = "Second" 22 | 23 | [subdoc.first] 24 | name = "First" 25 | 26 | [basic] 27 | uint = 5001 28 | bool = true 29 | float = 123.4 30 | int = 5000 31 | string = "Bite me" 32 | date = 1979-05-27T07:32:00Z 33 | 34 | [[subdoclist]] 35 | name = "List.First" 36 | 37 | [[subdoclist]] 38 | name = "List.Second" 39 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/marshal_test.toml: -------------------------------------------------------------------------------- 1 | title = "TOML Marshal Testing" 2 | 3 | [basic] 4 | bool = true 5 | date = 1979-05-27T07:32:00Z 6 | float = 123.4 7 | int = 5000 8 | string = "Bite me" 9 | uint = 5001 10 | 11 | [basic_lists] 12 | bools = [true,false,true] 13 | dates = [1979-05-27T07:32:00Z,1980-05-27T07:32:00Z] 14 | floats = [12.3,45.6,78.9] 15 | ints = [8001,8001,8002] 16 | strings = ["One","Two","Three"] 17 | uints = [5002,5003] 18 | 19 | [basic_map] 20 | one = "one" 21 | two = "two" 22 | 23 | [subdoc] 24 | 25 | [subdoc.first] 26 | name = "First" 27 | 28 | [subdoc.second] 29 | name = "Second" 30 | 31 | [[subdoclist]] 32 | name = "List.First" 33 | 34 | [[subdoclist]] 35 | name = "List.Second" 36 | 37 | [[subdocptrs]] 38 | name = "Second" 39 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/position.go: -------------------------------------------------------------------------------- 1 | // Position support for go-toml 2 | 3 | package toml 4 | 5 | import ( 6 | "fmt" 7 | ) 8 | 9 | // Position of a document element within a TOML document. 10 | // 11 | // Line and Col are both 1-indexed positions for the element's line number and 12 | // column number, respectively. Values of zero or less will cause Invalid(), 13 | // to return true. 14 | type Position struct { 15 | Line int // line within the document 16 | Col int // column within the line 17 | } 18 | 19 | // String representation of the position. 20 | // Displays 1-indexed line and column numbers. 21 | func (p Position) String() string { 22 | return fmt.Sprintf("(%d, %d)", p.Line, p.Col) 23 | } 24 | 25 | // Invalid returns whether or not the position is valid (i.e. with negative or 26 | // null values) 27 | func (p Position) Invalid() bool { 28 | return p.Line <= 0 || p.Col <= 0 29 | } 30 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pelletier/go-toml/position_test.go: -------------------------------------------------------------------------------- 1 | // Testing support for go-toml 2 | 3 | package toml 4 | 5 | import ( 6 | "testing" 7 | ) 8 | 9 | func TestPositionString(t *testing.T) { 10 | p := Position{123, 456} 11 | expected := "(123, 456)" 12 | value := p.String() 13 | 14 | if value != expected { 15 | t.Errorf("Expected %v, got %v instead", expected, value) 16 | } 17 | } 18 | 19 | func TestInvalid(t *testing.T) { 20 | for i, v := range []Position{ 21 | {0, 1234}, 22 | {1234, 0}, 23 | {0, 0}, 24 | } { 25 | if !v.Invalid() { 26 | t.Errorf("Position at %v is valid: %v", i, v) 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pmezard/go-difflib/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - 1.5 4 | - tip 5 | 6 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/pmezard/go-difflib/README.md: -------------------------------------------------------------------------------- 1 | go-difflib 2 | ========== 3 | 4 | [![Build Status](https://travis-ci.org/pmezard/go-difflib.png?branch=master)](https://travis-ci.org/pmezard/go-difflib) 5 | [![GoDoc](https://godoc.org/github.com/pmezard/go-difflib/difflib?status.svg)](https://godoc.org/github.com/pmezard/go-difflib/difflib) 6 | 7 | Go-difflib is a partial port of python 3 difflib package. Its main goal 8 | was to make unified and context diff available in pure Go, mostly for 9 | testing purposes. 10 | 11 | The following class and functions (and related tests) have be ported: 12 | 13 | * `SequenceMatcher` 14 | * `unified_diff()` 15 | * `context_diff()` 16 | 17 | ## Installation 18 | 19 | ```bash 20 | $ go get github.com/pmezard/go-difflib/difflib 21 | ``` 22 | 23 | ### Quick Start 24 | 25 | Diffs are configured with Unified (or ContextDiff) structures, and can 26 | be output to an io.Writer or returned as a string. 27 | 28 | ```Go 29 | diff := UnifiedDiff{ 30 | A: difflib.SplitLines("foo\nbar\n"), 31 | B: difflib.SplitLines("foo\nbaz\n"), 32 | FromFile: "Original", 33 | ToFile: "Current", 34 | Context: 3, 35 | } 36 | text, _ := GetUnifiedDiffString(diff) 37 | fmt.Printf(text) 38 | ``` 39 | 40 | would output: 41 | 42 | ``` 43 | --- Original 44 | +++ Current 45 | @@ -1,3 +1,3 @@ 46 | foo 47 | -bar 48 | +baz 49 | ``` 50 | 51 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/.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 | *.exe 23 | 24 | .DS_Store 25 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/.travis.gofmt.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ -n "$(gofmt -l .)" ]; then 4 | echo "Go code is not formatted:" 5 | gofmt -d . 6 | exit 1 7 | fi 8 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/.travis.gogenerate.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [[ "$TRAVIS_GO_VERSION" =~ ^1\.[45](\..*)?$ ]]; then 4 | exit 0 5 | fi 6 | 7 | go get github.com/ernesto-jimenez/gogen/imports 8 | go generate ./... 9 | if [ -n "$(git diff)" ]; then 10 | echo "Go generate had not been run" 11 | git diff 12 | exit 1 13 | fi 14 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/.travis.govet.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | cd "$(dirname $0)" 4 | DIRS=". assert require mock _codegen" 5 | set -e 6 | for subdir in $DIRS; do 7 | pushd $subdir 8 | go vet 9 | popd 10 | done 11 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | sudo: false 4 | 5 | matrix: 6 | include: 7 | - go: "1.8.x" 8 | - go: "1.9.x" 9 | - go: "1.10.x" 10 | - go: "1.11.x" 11 | env: GO111MODULE=off 12 | - go: "1.11.x" 13 | env: GO111MODULE=on 14 | - go: tip 15 | script: 16 | - ./.travis.gogenerate.sh 17 | - ./.travis.gofmt.sh 18 | - ./.travis.govet.sh 19 | - go test -v -race $(go list ./... | grep -v vendor) 20 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/Gopkg.lock: -------------------------------------------------------------------------------- 1 | # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. 2 | 3 | 4 | [[projects]] 5 | name = "github.com/davecgh/go-spew" 6 | packages = ["spew"] 7 | revision = "346938d642f2ec3594ed81d874461961cd0faa76" 8 | version = "v1.1.0" 9 | 10 | [[projects]] 11 | name = "github.com/pmezard/go-difflib" 12 | packages = ["difflib"] 13 | revision = "792786c7400a136282c1664665ae0a8db921c6c2" 14 | version = "v1.0.0" 15 | 16 | [[projects]] 17 | name = "github.com/stretchr/objx" 18 | packages = ["."] 19 | revision = "facf9a85c22f48d2f52f2380e4efce1768749a89" 20 | version = "v0.1" 21 | 22 | [solve-meta] 23 | analyzer-name = "dep" 24 | analyzer-version = 1 25 | inputs-digest = "448ddae4702c6aded2555faafd390c537789bb1c483f70b0431e6634f73f2090" 26 | solver-name = "gps-cdcl" 27 | solver-version = 1 28 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/Gopkg.toml: -------------------------------------------------------------------------------- 1 | [prune] 2 | unused-packages = true 3 | non-go = true 4 | go-tests = true 5 | 6 | [[constraint]] 7 | name = "github.com/davecgh/go-spew" 8 | version = "~1.1.0" 9 | 10 | [[constraint]] 11 | name = "github.com/pmezard/go-difflib" 12 | version = "~1.0.0" 13 | 14 | [[constraint]] 15 | name = "github.com/stretchr/objx" 16 | version = "~0.1.0" 17 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2012-2018 Mat Ryer and Tyler Bunnell 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 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentFormat}} 2 | func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool { 3 | if h, ok := t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}}) 5 | } 6 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentWithoutT "a"}} 2 | func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool { 3 | if h, ok := a.t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) 5 | } 6 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/assert/errors.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // AnError is an error instance useful for testing. If the code does not care 8 | // about error specifics, and only needs to return the error for example, this 9 | // error should be used to make the test code more readable. 10 | var AnError = errors.New("assert.AnError general error for testing") 11 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/assert/forward_assertions.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | // Assertions provides assertion methods around the 4 | // TestingT interface. 5 | type Assertions struct { 6 | t TestingT 7 | } 8 | 9 | // New makes a new Assertions object for the specified TestingT. 10 | func New(t TestingT) *Assertions { 11 | return &Assertions{ 12 | t: t, 13 | } 14 | } 15 | 16 | //go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs 17 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/doc.go: -------------------------------------------------------------------------------- 1 | // Package testify is a set of packages that provide many tools for testifying that your code will behave as you intend. 2 | // 3 | // testify contains the following packages: 4 | // 5 | // The assert package provides a comprehensive set of assertion functions that tie in to the Go testing system. 6 | // 7 | // The http package contains tools to make it easier to test http activity using the Go testing system. 8 | // 9 | // The mock package provides a system by which it is possible to mock your objects and verify calls are happening as expected. 10 | // 11 | // The suite package provides a basic structure for using structs as testing suites, and methods on those structs as tests. It includes setup/teardown functionality in the way of interfaces. 12 | package testify 13 | 14 | // blank imports help docs. 15 | import ( 16 | // assert package 17 | _ "github.com/stretchr/testify/assert" 18 | // http package 19 | _ "github.com/stretchr/testify/http" 20 | // mock package 21 | _ "github.com/stretchr/testify/mock" 22 | ) 23 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/stretchr/testify 2 | 3 | require ( 4 | github.com/davecgh/go-spew v1.1.0 5 | github.com/pmezard/go-difflib v1.0.0 6 | github.com/stretchr/objx v0.1.0 7 | ) 8 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/go.sum: -------------------------------------------------------------------------------- 1 | github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= 2 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 3 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 4 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 5 | github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= 6 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= 7 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/http/doc.go: -------------------------------------------------------------------------------- 1 | // Package http DEPRECATED USE net/http/httptest 2 | package http 3 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/http/test_round_tripper.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "github.com/stretchr/testify/mock" 5 | "net/http" 6 | ) 7 | 8 | // TestRoundTripper DEPRECATED USE net/http/httptest 9 | type TestRoundTripper struct { 10 | mock.Mock 11 | } 12 | 13 | // RoundTrip DEPRECATED USE net/http/httptest 14 | func (t *TestRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) { 15 | args := t.Called(req) 16 | return args.Get(0).(*http.Response), args.Error(1) 17 | } 18 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/package_test.go: -------------------------------------------------------------------------------- 1 | package testify 2 | 3 | import ( 4 | "github.com/stretchr/testify/assert" 5 | "testing" 6 | ) 7 | 8 | func TestImports(t *testing.T) { 9 | if assert.Equal(t, 1, 1) != true { 10 | t.Error("Something is wrong.") 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/require/doc.go: -------------------------------------------------------------------------------- 1 | // Package require implements the same assertions as the `assert` package but 2 | // stops test execution when a test fails. 3 | // 4 | // Example Usage 5 | // 6 | // The following is a complete example using require in a standard test function: 7 | // import ( 8 | // "testing" 9 | // "github.com/stretchr/testify/require" 10 | // ) 11 | // 12 | // func TestSomething(t *testing.T) { 13 | // 14 | // var a string = "Hello" 15 | // var b string = "Hello" 16 | // 17 | // require.Equal(t, a, b, "The two words should be the same.") 18 | // 19 | // } 20 | // 21 | // Assertions 22 | // 23 | // The `require` package have same global functions as in the `assert` package, 24 | // but instead of returning a boolean result they call `t.FailNow()`. 25 | // 26 | // Every assertion function also takes an optional string message as the final argument, 27 | // allowing custom error messages to be appended to the message the assertion method outputs. 28 | package require 29 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/require/forward_requirements.go: -------------------------------------------------------------------------------- 1 | package require 2 | 3 | // Assertions provides assertion methods around the 4 | // TestingT interface. 5 | type Assertions struct { 6 | t TestingT 7 | } 8 | 9 | // New makes a new Assertions object for the specified TestingT. 10 | func New(t TestingT) *Assertions { 11 | return &Assertions{ 12 | t: t, 13 | } 14 | } 15 | 16 | //go:generate go run ../_codegen/main.go -output-package=require -template=require_forward.go.tmpl -include-format-funcs 17 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/require/require.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.Comment}} 2 | func {{.DocInfo.Name}}(t TestingT, {{.Params}}) { 3 | if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return } 4 | if h, ok := t.(tHelper); ok { h.Helper() } 5 | t.FailNow() 6 | } 7 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/require/require_forward.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentWithoutT "a"}} 2 | func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) { 3 | if h, ok := a.t.(tHelper); ok { h.Helper() } 4 | {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) 5 | } 6 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/require/requirements.go: -------------------------------------------------------------------------------- 1 | package require 2 | 3 | // TestingT is an interface wrapper around *testing.T 4 | type TestingT interface { 5 | Errorf(format string, args ...interface{}) 6 | FailNow() 7 | } 8 | 9 | type tHelper interface { 10 | Helper() 11 | } 12 | 13 | // ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful 14 | // for table driven tests. 15 | type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) 16 | 17 | // ValueAssertionFunc is a common function prototype when validating a single value. Can be useful 18 | // for table driven tests. 19 | type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) 20 | 21 | // BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful 22 | // for table driven tests. 23 | type BoolAssertionFunc func(TestingT, bool, ...interface{}) 24 | 25 | // ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful 26 | // for table driven tests. 27 | type ErrorAssertionFunc func(TestingT, error, ...interface{}) 28 | 29 | //go:generate go run ../_codegen/main.go -output-package=require -template=require.go.tmpl -include-format-funcs 30 | -------------------------------------------------------------------------------- /coreos/nvidia-container-runtime/vendor/github.com/stretchr/testify/suite/interfaces.go: -------------------------------------------------------------------------------- 1 | package suite 2 | 3 | import "testing" 4 | 5 | // TestingSuite can store and return the current *testing.T context 6 | // generated by 'go test'. 7 | type TestingSuite interface { 8 | T() *testing.T 9 | SetT(*testing.T) 10 | } 11 | 12 | // SetupAllSuite has a SetupSuite method, which will run before the 13 | // tests in the suite are run. 14 | type SetupAllSuite interface { 15 | SetupSuite() 16 | } 17 | 18 | // SetupTestSuite has a SetupTest method, which will run before each 19 | // test in the suite. 20 | type SetupTestSuite interface { 21 | SetupTest() 22 | } 23 | 24 | // TearDownAllSuite has a TearDownSuite method, which will run after 25 | // all the tests in the suite have been run. 26 | type TearDownAllSuite interface { 27 | TearDownSuite() 28 | } 29 | 30 | // TearDownTestSuite has a TearDownTest method, which will run after 31 | // each test in the suite. 32 | type TearDownTestSuite interface { 33 | TearDownTest() 34 | } 35 | 36 | // BeforeTest has a function to be executed right before the test 37 | // starts and receives the suite and test names as input 38 | type BeforeTest interface { 39 | BeforeTest(suiteName, testName string) 40 | } 41 | 42 | // AfterTest has a function to be executed right after the test 43 | // finishes and receives the suite and test names as input 44 | type AfterTest interface { 45 | AfterTest(suiteName, testName string) 46 | } 47 | -------------------------------------------------------------------------------- /fedora/common.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright (c) 2018-2022, NVIDIA CORPORATION. All rights reserved. 3 | 4 | GPU_DIRECT_RDMA_ENABLED="${GPU_DIRECT_RDMA_ENABLED:-false}" 5 | 6 | _mellanox_devices_present() { 7 | devices_found=0 8 | for dev in /sys/bus/pci/devices/*; do 9 | read vendor < $dev/vendor 10 | if [ "$vendor" = "0x15b3" ]; then 11 | echo "Mellanox device found at $(basename $dev)" 12 | return 0 13 | fi 14 | done 15 | echo "No Mellanox devices were found..." 16 | return 1 17 | } 18 | 19 | _gpu_direct_rdma_enabled() { 20 | if [ "${GPU_DIRECT_RDMA_ENABLED}" = "true" ]; then 21 | # check if mellanox cards are present 22 | if _mellanox_devices_present; then 23 | return 0 24 | fi 25 | fi 26 | return 1 27 | } -------------------------------------------------------------------------------- /fedora/drivers/README.md: -------------------------------------------------------------------------------- 1 | # Folder for downloading vGPU drivers and dependent metadata files -------------------------------------------------------------------------------- /fedora/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/fedora/empty -------------------------------------------------------------------------------- /flatcar/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/flatcar/empty -------------------------------------------------------------------------------- /native-only.mk: -------------------------------------------------------------------------------- 1 | # Copyright (c) 2022, 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 | DOCKER_BUILD_PLATFORM_OPTIONS = --platform=linux/amd64 16 | 17 | $(DRIVER_PUSH_TARGETS): push-%: 18 | $(DOCKER) tag "$(IMAGE)" "$(OUT_IMAGE)" 19 | $(DOCKER) push "$(OUT_IMAGE)" 20 | 21 | $(VGPU_GUEST_DRIVER_PUSH_TARGETS): push-vgpuguest-%: 22 | $(DOCKER) tag "$(IMAGE)" "$(OUT_IMAGE)" 23 | $(DOCKER) push "$(OUT_IMAGE)" 24 | -------------------------------------------------------------------------------- /photon3.0/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/photon3.0/README.md -------------------------------------------------------------------------------- /photon3.0/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/photon3.0/empty -------------------------------------------------------------------------------- /rhel7/README.md: -------------------------------------------------------------------------------- 1 | # Centos7 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | See https://github.com/NVIDIA/nvidia-docker/wiki/Driver-containers-(Beta) 4 | -------------------------------------------------------------------------------- /rhel7/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/rhel7/empty -------------------------------------------------------------------------------- /rhel8/README.md: -------------------------------------------------------------------------------- 1 | # Centos7 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | See https://github.com/NVIDIA/nvidia-docker/wiki/Driver-containers-(Beta) 4 | -------------------------------------------------------------------------------- /rhel8/common.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright (c) 2018-2023, NVIDIA CORPORATION. All rights reserved. 3 | 4 | GPU_DIRECT_RDMA_ENABLED="${GPU_DIRECT_RDMA_ENABLED:-false}" 5 | GDS_ENABLED="${GDS_ENABLED:-false}" 6 | GDRCOPY_ENABLED="${GDRCOPY_ENABLED:-false}" 7 | 8 | # Check if mellanox devices are present 9 | _mellanox_devices_present() { 10 | devices_found=0 11 | for dev in /sys/bus/pci/devices/*; do 12 | read vendor < $dev/vendor 13 | if [ "$vendor" = "0x15b3" ]; then 14 | echo "Mellanox device found at $(basename $dev)" 15 | return 0 16 | fi 17 | done 18 | echo "No Mellanox devices were found..." 19 | return 1 20 | } 21 | 22 | # Check if GPU Direct RDMA is enabled 23 | _gpu_direct_rdma_enabled() { 24 | if [ "${GPU_DIRECT_RDMA_ENABLED}" = "true" ]; then 25 | # check if mellanox cards are present 26 | if _mellanox_devices_present; then 27 | return 0 28 | fi 29 | fi 30 | return 1 31 | } 32 | 33 | # Check if GDS is enabled 34 | _gpu_direct_storage_enabled() { 35 | if [ "${GDS_ENABLED}" = "true" ]; then 36 | return 0 37 | fi 38 | return 1 39 | } 40 | 41 | # Check if GDRCopy is enabled 42 | _gdrcopy_enabled() { 43 | if [ "${GDRCOPY_ENABLED}" = "true" ]; then 44 | return 0 45 | fi 46 | return 1 47 | } 48 | -------------------------------------------------------------------------------- /rhel8/drivers/README.md: -------------------------------------------------------------------------------- 1 | # Folder for downloading vGPU drivers and dependent metadata files -------------------------------------------------------------------------------- /rhel8/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/rhel8/empty -------------------------------------------------------------------------------- /rhel8/precompiled/.gitignore: -------------------------------------------------------------------------------- 1 | .tmp/config.json -------------------------------------------------------------------------------- /rhel8/precompiled/common.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright (c) 2018-2022, NVIDIA CORPORATION. All rights reserved. 3 | 4 | GPU_DIRECT_RDMA_ENABLED="${GPU_DIRECT_RDMA_ENABLED:-false}" 5 | 6 | _mellanox_devices_present() { 7 | devices_found=0 8 | for dev in /sys/bus/pci/devices/*; do 9 | read vendor < $dev/vendor 10 | if [ "$vendor" = "0x15b3" ]; then 11 | echo "Mellanox device found at $(basename $dev)" 12 | return 0 13 | fi 14 | done 15 | echo "No Mellanox devices were found..." 16 | return 1 17 | } 18 | 19 | _gpu_direct_rdma_enabled() { 20 | if [ "${GPU_DIRECT_RDMA_ENABLED}" = "true" ]; then 21 | # check if mellanox cards are present 22 | if _mellanox_devices_present; then 23 | return 0 24 | fi 25 | fi 26 | return 1 27 | } -------------------------------------------------------------------------------- /rhel8/precompiled/rhsm-register: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | 5 | RHSM_ORG=$(cat /run/secrets/RHSM_ORG) 6 | RHSM_ACTIVATIONKEY=$(cat /run/secrets/RHSM_ACTIVATIONKEY) 7 | subscription-manager register --name=rhcos-driver-builder --org=${RHSM_ORG} --activationkey=${RHSM_ACTIVATIONKEY} -------------------------------------------------------------------------------- /rhel8/precompiled/x509-configuration.ini: -------------------------------------------------------------------------------- 1 | [ req ] 2 | default_bits = 4096 3 | distinguished_name = req_distinguished_name 4 | prompt = no 5 | string_mask = utf8only 6 | x509_extensions = myexts 7 | 8 | [ req_distinguished_name ] 9 | O = $USER 10 | CN = $USER 11 | emailAddress = $EMAIL 12 | 13 | [ myexts ] 14 | basicConstraints=critical,CA:FALSE 15 | keyUsage=digitalSignature 16 | subjectKeyIdentifier=hash 17 | authorityKeyIdentifier=keyid 18 | -------------------------------------------------------------------------------- /rhel9/README.md: -------------------------------------------------------------------------------- 1 | # RHEL9 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | See https://github.com/NVIDIA/nvidia-docker/wiki/Driver-containers-(Beta) 4 | -------------------------------------------------------------------------------- /rhel9/common.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright (c) 2018-2023, NVIDIA CORPORATION. All rights reserved. 3 | 4 | GPU_DIRECT_RDMA_ENABLED="${GPU_DIRECT_RDMA_ENABLED:-false}" 5 | GDS_ENABLED="${GDS_ENABLED:-false}" 6 | GDRCOPY_ENABLED="${GDRCOPY_ENABLED:-false}" 7 | 8 | # Check if mellanox devices are present 9 | _mellanox_devices_present() { 10 | devices_found=0 11 | for dev in /sys/bus/pci/devices/*; do 12 | read vendor < $dev/vendor 13 | if [ "$vendor" = "0x15b3" ]; then 14 | echo "Mellanox device found at $(basename $dev)" 15 | return 0 16 | fi 17 | done 18 | echo "No Mellanox devices were found..." 19 | return 1 20 | } 21 | 22 | # Check if GPU Direct RDMA is enabled 23 | _gpu_direct_rdma_enabled() { 24 | if [ "${GPU_DIRECT_RDMA_ENABLED}" = "true" ]; then 25 | # check if mellanox cards are present 26 | if _mellanox_devices_present; then 27 | return 0 28 | fi 29 | fi 30 | return 1 31 | } 32 | 33 | # Check if GDS is enabled 34 | _gpu_direct_storage_enabled() { 35 | if [ "${GDS_ENABLED}" = "true" ]; then 36 | return 0 37 | fi 38 | return 1 39 | } 40 | 41 | # Check if GDRCopy is enabled 42 | _gdrcopy_enabled() { 43 | if [ "${GDRCOPY_ENABLED}" = "true" ]; then 44 | return 0 45 | fi 46 | return 1 47 | } 48 | -------------------------------------------------------------------------------- /rhel9/drivers/README.md: -------------------------------------------------------------------------------- 1 | # Folder for downloading vGPU drivers and dependent metadata files -------------------------------------------------------------------------------- /rhel9/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/rhel9/empty -------------------------------------------------------------------------------- /rhel9/precompiled/.gitignore: -------------------------------------------------------------------------------- 1 | .tmp/config.json -------------------------------------------------------------------------------- /rhel9/precompiled/common.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright (c) 2018-2022, NVIDIA CORPORATION. All rights reserved. 3 | 4 | GPU_DIRECT_RDMA_ENABLED="${GPU_DIRECT_RDMA_ENABLED:-false}" 5 | 6 | _mellanox_devices_present() { 7 | devices_found=0 8 | for dev in /sys/bus/pci/devices/*; do 9 | read vendor < $dev/vendor 10 | if [ "$vendor" = "0x15b3" ]; then 11 | echo "Mellanox device found at $(basename $dev)" 12 | return 0 13 | fi 14 | done 15 | echo "No Mellanox devices were found..." 16 | return 1 17 | } 18 | 19 | _gpu_direct_rdma_enabled() { 20 | if [ "${GPU_DIRECT_RDMA_ENABLED}" = "true" ]; then 21 | # check if mellanox cards are present 22 | if _mellanox_devices_present; then 23 | return 0 24 | fi 25 | fi 26 | return 1 27 | } -------------------------------------------------------------------------------- /rhel9/precompiled/nvidiadriver.json: -------------------------------------------------------------------------------- 1 | { 2 | "apiVersion": "nvidia.com/v1alpha1", 3 | "kind": "NVIDIADriver", 4 | "metadata": { 5 | "name": "gpu-driver" 6 | }, 7 | "spec": { 8 | "driverType": "gpu", 9 | "usePrecompiled": true, 10 | "repository": "quay.io/fabiendupont", 11 | "image": "nvidia-gpu-driver", 12 | "version": "550.163.01", 13 | "imagePullPolicy": "Always", 14 | "nodeSelector": {}, 15 | "manager": {}, 16 | "repoConfig": { 17 | "name": "" 18 | }, 19 | "certConfig": { 20 | "name": "" 21 | }, 22 | "licensingConfig": { 23 | "nlsEnabled": true, 24 | "name": "" 25 | }, 26 | "virtualTopologyConfig": { 27 | "name": "" 28 | }, 29 | "kernelModuleConfig": { 30 | "name": "" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /rhel9/precompiled/rhsm-register: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | 5 | RHSM_ORG=$(cat /run/secrets/RHSM_ORG) 6 | RHSM_ACTIVATIONKEY=$(cat /run/secrets/RHSM_ACTIVATIONKEY) 7 | subscription-manager register --name=rhcos-driver-builder --org=${RHSM_ORG} --activationkey=${RHSM_ACTIVATIONKEY} -------------------------------------------------------------------------------- /rhel9/precompiled/x509-configuration.ini: -------------------------------------------------------------------------------- 1 | [ req ] 2 | default_bits = 4096 3 | distinguished_name = req_distinguished_name 4 | prompt = no 5 | string_mask = utf8only 6 | x509_extensions = myexts 7 | 8 | [ req_distinguished_name ] 9 | O = $USER 10 | CN = $USER 11 | emailAddress = $EMAIL 12 | 13 | [ myexts ] 14 | basicConstraints=critical,CA:FALSE 15 | keyUsage=digitalSignature 16 | subjectKeyIdentifier=hash 17 | authorityKeyIdentifier=keyid 18 | -------------------------------------------------------------------------------- /sle15/README.md: -------------------------------------------------------------------------------- 1 | ## Build 2 | 3 | ``` 4 | docker build -t mydriver \ 5 | --build-arg DRIVER_VERSION="510.85.02" \ 6 | --build-arg CUDA_VERSION="11.7.1" \ 7 | --build-arg SLES_VERSION="15.3" \ 8 | . 9 | ``` 10 | -------------------------------------------------------------------------------- /sle15/drivers/README.md: -------------------------------------------------------------------------------- 1 | # Folder for downloading vGPU drivers and dependent metadata files -------------------------------------------------------------------------------- /sle15/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/sle15/empty -------------------------------------------------------------------------------- /tests/cases/nvidia-driver.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | # This test case runs the operator installation / test case with the default options. 3 | 4 | if [[ $# -lt 1 ]]; then 5 | echo "Error: $0 must be called with driver options" 6 | exit 1 7 | fi 8 | 9 | # export gpu-operator options 10 | export TEST_CASE_ARGS="$1" 11 | if [[ $# -eq 2 ]]; then 12 | export IMAGE_PATH="$2" 13 | sudo ctr -n k8s.io images import "$IMAGE_PATH" 14 | fi 15 | 16 | SCRIPTS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )"/../scripts && pwd )" 17 | source "${SCRIPTS_DIR}"/.definitions.sh 18 | 19 | # Run an end-to-end test cycle 20 | "${SCRIPTS_DIR}"/end-to-end-nvidia-driver.sh 21 | -------------------------------------------------------------------------------- /tests/ci-remote-exec.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -xe 4 | 5 | if [[ $# -lt 1 ]]; then 6 | echo "Error:$0 must be called with 1(REMOTE_EXEC) or more than 1 args (REMOTE_EXEC, ARGS1 ARGS2 etc)" 7 | exit 1 8 | fi 9 | 10 | TEST_DIR="$(pwd)/tests" 11 | 12 | ${TEST_DIR}/remote-exec-local.sh "$@" 13 | -------------------------------------------------------------------------------- /tests/ci-run-e2e.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -xe 4 | 5 | if [[ $# -lt 2 ]]; then 6 | echo "TEST_CASE TEST_CASE_ARGS are required" 7 | exit 1 8 | fi 9 | 10 | TEST_DIR="$(pwd)/tests" 11 | 12 | ${TEST_DIR}/local.sh "$@" 13 | -------------------------------------------------------------------------------- /tests/holodeck_ubuntu22.04.yaml: -------------------------------------------------------------------------------- 1 | apiVersion: holodeck.nvidia.com/v1alpha1 2 | kind: Environment 3 | metadata: 4 | name: HOLODECK_NAME 5 | description: "end-to-end test infrastructure" 6 | spec: 7 | provider: aws 8 | auth: 9 | keyName: cnt-ci 10 | privateKey: HOLODECK_PRIVATE_KEY 11 | instance: 12 | type: g4dn.xlarge 13 | region: us-west-1 14 | ingressIpRanges: 15 | - 18.190.12.32/32 16 | - 3.143.46.93/32 17 | - 52.15.119.136/32 18 | - 35.155.108.162/32 19 | - 35.162.190.51/32 20 | - 54.201.61.24/32 21 | - 52.24.205.48/32 22 | - 44.235.4.62/32 23 | - 44.230.241.223/32 24 | image: 25 | architecture: amd64 26 | imageId: ami-0ce2cb35386fc22e9 27 | containerRuntime: 28 | install: true 29 | name: containerd 30 | kubernetes: 31 | install: true 32 | installer: kubeadm 33 | version: v1.28.5 34 | crictlVersion: v1.28.0 35 | -------------------------------------------------------------------------------- /tests/holodeck_ubuntu24.04.yaml: -------------------------------------------------------------------------------- 1 | apiVersion: holodeck.nvidia.com/v1alpha1 2 | kind: Environment 3 | metadata: 4 | name: HOLODECK_NAME 5 | description: "end-to-end test infrastructure" 6 | spec: 7 | provider: aws 8 | auth: 9 | keyName: cnt-ci 10 | privateKey: HOLODECK_PRIVATE_KEY 11 | instance: 12 | type: g4dn.xlarge 13 | region: us-west-1 14 | ingressIpRanges: 15 | - 18.190.12.32/32 16 | - 3.143.46.93/32 17 | - 52.15.119.136/32 18 | - 35.155.108.162/32 19 | - 35.162.190.51/32 20 | - 54.201.61.24/32 21 | - 52.24.205.48/32 22 | - 44.235.4.62/32 23 | - 44.230.241.223/32 24 | image: 25 | architecture: amd64 26 | imageId: ami-0da424eb883458071 27 | containerRuntime: 28 | install: true 29 | name: containerd 30 | version: 1.7.22 31 | kubernetes: 32 | install: true 33 | installer: kubeadm 34 | version: v1.30.0 35 | crictlVersion: v1.30.0 36 | -------------------------------------------------------------------------------- /tests/local.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | if [[ $# -ge 1 ]]; then 4 | TEST_CASE=${1} 5 | test -n "${TEST_CASE}" 6 | fi 7 | test -f ${PROJECT_DIR}/${TEST_CASE} 8 | 9 | export PROJECT="gpu-driver-container" 10 | 11 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )"/scripts && pwd )" 12 | source ${SCRIPT_DIR}/.definitions.sh 13 | source ${SCRIPT_DIR}/.local.sh 14 | 15 | # Sync the project folder to the remote 16 | ${SCRIPT_DIR}/push.sh 17 | 18 | # We trigger the installation of prerequisites on the remote instance 19 | remote SKIP_PREREQUISITES="${SKIP_PREREQUISITES}" ./tests/scripts/prerequisites.sh 20 | 21 | # We trigger the specified test case on the remote instance. 22 | # Note: We need to ensure that the required environment variables 23 | # are forwarded to the remote shell. 24 | remote \ 25 | PROJECT="${PROJECT}" \ 26 | "$@" 27 | -------------------------------------------------------------------------------- /tests/remote-exec-local.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | if [[ $# -ge 1 ]]; then 4 | REMOTE_EXEC=${1} 5 | test -n "${REMOTE_EXEC}" 6 | fi 7 | test -f ${PROJECT_DIR}/${REMOTE_EXEC} 8 | 9 | export PROJECT="gpu-driver-container" 10 | 11 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )"/scripts && pwd )" 12 | source ${SCRIPT_DIR}/.definitions.sh 13 | source ${SCRIPT_DIR}/.local.sh 14 | 15 | # Sync the project folder to the remote 16 | ${SCRIPT_DIR}/push.sh 17 | 18 | # We trigger the specified script on the remote instance. 19 | remote \ 20 | PROJECT="${PROJECT}" \ 21 | "$@" 22 | -------------------------------------------------------------------------------- /tests/scripts/.definitions.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -e 3 | 4 | [[ -z "${DEBUG}" ]] || set -x 5 | 6 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 7 | TEST_DIR="$( cd "${SCRIPT_DIR}/.." && pwd )" 8 | PROJECT_DIR="$( cd "${TEST_DIR}/.." && pwd )" 9 | CASES_DIR="$( cd "${TEST_DIR}/cases" && pwd )" 10 | 11 | # Set default values if not defined 12 | : ${HELM:="helm"} 13 | : ${PROJECT:="$(basename "${PROJECT_DIR}")"} 14 | 15 | : ${TEST_NAMESPACE:="test-operator"} 16 | 17 | : ${HELM_NVIDIA_REPO:="https://helm.ngc.nvidia.com/nvidia"} 18 | 19 | : ${DAEMON_POD_STATUS_TIME_OUT:="15m"} 20 | : ${POD_STATUS_TIME_OUT:="2m"} 21 | 22 | : ${LOG_DIR:="/tmp/logs"} 23 | 24 | : ${SYSTEM_ONLINE_CHECK_TIMEOUT:="900"} 25 | 26 | : ${BASE_TARGET:="jammy"} 27 | -------------------------------------------------------------------------------- /tests/scripts/.local.sh: -------------------------------------------------------------------------------- 1 | #!/usr/env bash 2 | 3 | function remote() { 4 | ${SCRIPT_DIR}/remote.sh "cd ${PROJECT} && "$@"" 5 | } 6 | 7 | function remote_retry() { 8 | ${SCRIPT_DIR}/remote_retry.sh 9 | } 10 | -------------------------------------------------------------------------------- /tests/scripts/.rsync-includes: -------------------------------------------------------------------------------- 1 | tests/ 2 | tests/*** 3 | -------------------------------------------------------------------------------- /tests/scripts/checks.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | check_pod_ready() { 4 | local pod_label=$1 5 | local pod_status_time_out=$2 6 | 7 | echo "Checking $pod_label pod" 8 | 9 | kubectl get pods -lapp=$pod_label -n ${TEST_NAMESPACE} 10 | 11 | echo "Checking $pod_label pod readiness" 12 | 13 | if kubectl wait -n ${TEST_NAMESPACE} --for=condition=Ready pod -l app=$pod_label --timeout ${pod_status_time_out}; then 14 | return 0 15 | else 16 | # print status of pod 17 | kubectl get pods -n ${TEST_NAMESPACE} 18 | fi 19 | 20 | return 1 21 | } 22 | -------------------------------------------------------------------------------- /tests/scripts/ci-precompiled-helpers.sh: -------------------------------------------------------------------------------- 1 | get_kernel_versions_to_test() { 2 | if [[ "$#" -ne 4 ]]; then 3 | echo " Error:$0 must be called with KERNEL_FLAVORS DRIVER_BRANCHES DIST LTS_KERNEL" >&2 4 | exit 1 5 | fi 6 | 7 | local -a KERNEL_FLAVORS=("${!1}") 8 | local -a DRIVER_BRANCHES=("${!2}") 9 | local DIST="$3" 10 | local LTS_KERNEL="$4" 11 | 12 | kernel_versions=() 13 | for kernel_flavor in "${KERNEL_FLAVORS[@]}"; do 14 | for DRIVER_BRANCH in "${DRIVER_BRANCHES[@]}"; do 15 | source ./tests/scripts/findkernelversion.sh "${kernel_flavor}" "$DRIVER_BRANCH" "$DIST" "$LTS_KERNEL" >&2 16 | if [[ "$should_continue" == true ]]; then 17 | break 18 | fi 19 | done 20 | if [[ "$should_continue" == true ]]; then 21 | KERNEL_VERSION=$(echo "$KERNEL_VERSION" | tr -d ' \n') 22 | kernel_versions+=("$KERNEL_VERSION") 23 | fi 24 | done 25 | # Remove duplicates 26 | kernel_versions=($(printf "%s\n" "${kernel_versions[@]}" | sort -u)) 27 | for i in "${!kernel_versions[@]}"; do 28 | kernel_versions[$i]="${kernel_versions[$i]}-$DIST" 29 | done 30 | echo "${kernel_versions[@]}" 31 | } 32 | -------------------------------------------------------------------------------- /tests/scripts/end-to-end-nvidia-driver.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 4 | source "${SCRIPT_DIR}"/.definitions.sh 5 | 6 | echo "" 7 | echo "" 8 | echo "--------------Installing the GPU Operator--------------" 9 | 10 | ${SCRIPT_DIR}/install-operator.sh 11 | 12 | "${SCRIPT_DIR}"/verify-operator.sh 13 | 14 | echo "--------------Verification completed for GPU Operator, uninstalling the GPU operator--------------" 15 | 16 | ${SCRIPT_DIR}/uninstall-operator.sh ${TEST_NAMESPACE} "gpu-operator" 17 | 18 | echo "--------------Verification completed for GPU Operator--------------" 19 | -------------------------------------------------------------------------------- /tests/scripts/install-operator.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [[ "${SKIP_INSTALL}" == "true" ]]; then 4 | echo "Skipping install: SKIP_INSTALL=${SKIP_INSTALL}" 5 | exit 0 6 | fi 7 | 8 | echo "Checking current kernel version..." 9 | CURRENT_KERNEL=$(uname -r) 10 | echo "Current kernel version: $CURRENT_KERNEL" 11 | 12 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 13 | source ${SCRIPT_DIR}/.definitions.sh 14 | 15 | OPERATOR_OPTIONS="${TEST_CASE_ARGS}" 16 | 17 | # add helm driver repo 18 | helm repo add nvidia ${HELM_NVIDIA_REPO} && helm repo update 19 | 20 | # Create the test namespace 21 | kubectl create namespace "${TEST_NAMESPACE}" 22 | 23 | # Run the helm install command 24 | echo "OPERATOR_OPTIONS: ${OPERATOR_OPTIONS}" 25 | eval ${HELM} install gpu-operator nvidia/gpu-operator \ 26 | -n "${TEST_NAMESPACE}" \ 27 | "${OPERATOR_OPTIONS}" \ 28 | --wait 29 | -------------------------------------------------------------------------------- /tests/scripts/prerequisites.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [[ "${SKIP_PREREQUISITES}" == "true" ]]; then 4 | echo "Skipping prerequisites: SKIP_PREREQUISITES=${SKIP_PREREQUISITES}" 5 | exit 0 6 | fi 7 | 8 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 9 | source "${SCRIPT_DIR}"/.definitions.sh 10 | 11 | echo "Create log dir ${LOG_DIR}" 12 | mkdir -p "${LOG_DIR}" 13 | 14 | export DEBIAN_FRONTEND=noninteractive 15 | 16 | echo "Load kernel modules i2c_core and ipmi_msghandler" 17 | sudo modprobe -a i2c_core ipmi_msghandler 18 | 19 | echo "Install dependencies" 20 | sudo apt update && sudo apt install -y jq 21 | 22 | echo "Install Helm" 23 | curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash 24 | -------------------------------------------------------------------------------- /tests/scripts/pull.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [[ $# -ne 2 ]]; then 4 | echo "Pull requires a source and destination" 5 | exit 1 6 | fi 7 | 8 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 9 | source ${SCRIPT_DIR}/.definitions.sh 10 | source ${SCRIPT_DIR}/.local.sh 11 | 12 | ${SCRIPT_DIR}/sync.sh ${instance_hostname}:${1} ${2} 13 | -------------------------------------------------------------------------------- /tests/scripts/push.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 4 | source ${SCRIPT_DIR}/.definitions.sh 5 | source ${SCRIPT_DIR}/.local.sh 6 | 7 | REMOTE_PROJECT_FOLDER="~/${PROJECT}" 8 | 9 | # Copy over the contents of the project folder 10 | ${SCRIPT_DIR}/sync.sh \ 11 | "${PROJECT_DIR}/" \ 12 | "${instance_hostname}:${REMOTE_PROJECT_FOLDER}" 13 | -------------------------------------------------------------------------------- /tests/scripts/remote.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 4 | source ${SCRIPT_DIR}/.definitions.sh 5 | source ${SCRIPT_DIR}/.local.sh 6 | 7 | # keep alive 60sec and timeout after 30 tries 8 | ssh -o ServerAliveInterval=60 -o ServerAliveCountMax=30 -i ${private_key} ${instance_hostname} "${@}" 9 | -------------------------------------------------------------------------------- /tests/scripts/remote_retry.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 4 | source ${SCRIPT_DIR}/.definitions.sh 5 | INTERVAL=30 6 | SECONDS_ELAPSED=0 7 | 8 | set +e 9 | # Function to handle timeout exit 10 | handle_timeout() { 11 | echo "Failed to connect within the timeout period of $SYSTEM_ONLINE_CHECK_TIMEOUT seconds." 12 | exit 1 13 | } 14 | 15 | # Set trap for timeout 16 | trap handle_timeout EXIT 17 | 18 | # sleep before to handle restart of the system 19 | sleep 60; 20 | 21 | while [ $SECONDS_ELAPSED -lt $SYSTEM_ONLINE_CHECK_TIMEOUT ]; do 22 | # Attempt to connect via SSH and ignore errors 23 | status=0 24 | ( 25 | ssh -o ConnectTimeout=5 -i ${private_key} ${instance_hostname} "exit" 26 | ) >/dev/null 2>&1 27 | status=$? 28 | if [ $status -eq 0 ]; then 29 | echo "Successfully connected to ${instance_hostname}." 30 | trap - EXIT # Disable the timeout trap since the connection was successful 31 | exit 0 32 | fi 33 | sleep $INTERVAL 34 | SECONDS_ELAPSED=$((SECONDS_ELAPSED + INTERVAL)) 35 | echo "ssh retry...elpased time $SECONDS_ELAPSED" 36 | done 37 | -------------------------------------------------------------------------------- /tests/scripts/sync.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [[ "${SKIP_SYNC}" == "true" ]]; then 4 | echo "Skipping sync: SKIP_SYNC=${SKIP_SYNC}" 5 | exit 0 6 | fi 7 | 8 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 9 | source ${SCRIPT_DIR}/.definitions.sh 10 | 11 | source ${SCRIPT_DIR}/.local.sh 12 | 13 | rsync -e "ssh -i ${private_key} -o StrictHostKeyChecking=no" \ 14 | -avz --delete \ 15 | --include-from="${SCRIPT_DIR}/.rsync-includes" \ 16 | --exclude='*' \ 17 | ${@} 18 | 19 | -------------------------------------------------------------------------------- /tests/scripts/uninstall-operator.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [[ "${SKIP_INSTALL}" == "true" ]]; then 4 | echo "Skipping install: SKIP_INSTALL=${SKIP_INSTALL}" 5 | exit 0 6 | fi 7 | 8 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 9 | source ${SCRIPT_DIR}/.definitions.sh 10 | 11 | namespace=$1 12 | release_name=$2 13 | helm uninstall $release_name --namespace $namespace || true 14 | kubectl delete namespace $namespace || true 15 | -------------------------------------------------------------------------------- /tests/scripts/upgrade-kernel.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | # This test case runs the operator installation / test case with the default options. 3 | 4 | if [[ $# -ne 1 ]]; then 5 | echo "Error: $0 must be called with kernel_version" 6 | exit 1 7 | fi 8 | 9 | SCRIPTS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )"/../scripts && pwd )" 10 | source "${SCRIPTS_DIR}"/.definitions.sh 11 | 12 | # export kernel version and Run an end-to-end test cycle 13 | export KERNEL_VERSION="$1" 14 | "${SCRIPTS_DIR}"/kernel-upgrade-helper.sh 15 | -------------------------------------------------------------------------------- /tests/scripts/verify-operator.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [[ "${SKIP_VERIFY}" == "true" ]]; then 4 | echo "Skipping verify: SKIP_VERIFY=${SKIP_VERIFY}" 5 | exit 0 6 | fi 7 | 8 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 9 | source ${SCRIPT_DIR}/.definitions.sh 10 | 11 | # Import the check definitions 12 | source ${SCRIPT_DIR}/checks.sh 13 | 14 | # wait for the nvidia-driver pod to be ready 15 | # If successful, then wait for the validator pod to be ready (this means that the rest of the pods are healthy) 16 | # collect log in case of failure 17 | check_pod_ready "nvidia-driver-daemonset" ${DAEMON_POD_STATUS_TIME_OUT} && \ 18 | check_pod_ready "nvidia-operator-validator" ${POD_STATUS_TIME_OUT}; exit_status=$? 19 | if [ $exit_status -ne 0 ]; then 20 | curl -o ${SCRIPT_DIR}/must-gather.sh "https://raw.githubusercontent.com/NVIDIA/gpu-operator/main/hack/must-gather.sh" 21 | chmod +x ${SCRIPT_DIR}/must-gather.sh 22 | ARTIFACT_DIR="${LOG_DIR}" ${SCRIPT_DIR}/must-gather.sh 23 | ${SCRIPT_DIR}/uninstall-operator.sh ${TEST_NAMESPACE} "gpu-operator" 24 | exit 1 25 | else 26 | echo "All gpu-operator pods are ready." 27 | fi 28 | -------------------------------------------------------------------------------- /ubuntu16.04/README.md: -------------------------------------------------------------------------------- 1 | # Ubuntu 16.04 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | ## 396.37 4 | - [`396.37-ubuntu16.04`, `396.37-4.4.0-131-ubuntu16.04` (*Dockerfile*)](https://gitlab.com/nvidia/driver/blob/master/ubuntu16.04/Dockerfile) 5 | - [`396.37-ubuntu16.04-hwe`, `396.37-4.15.0-29-ubuntu16.04-hwe` (*Dockerfile*)](https://gitlab.com/nvidia/driver/blob/master/ubuntu16.04/Dockerfile) 6 | - [`396.37-ubuntu16.04-aws`, `396.37-4.4.0-1063-ubuntu16.04-aws` (*Dockerfile*)](https://gitlab.com/nvidia/driver/blob/master/ubuntu16.04/Dockerfile) 7 | -------------------------------------------------------------------------------- /ubuntu16.04/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/ubuntu16.04/empty -------------------------------------------------------------------------------- /ubuntu18.04/README.md: -------------------------------------------------------------------------------- 1 | # Ubuntu 18.04 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | See https://github.com/NVIDIA/nvidia-docker/wiki/Driver-containers-(Beta) 4 | -------------------------------------------------------------------------------- /ubuntu18.04/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/ubuntu18.04/empty -------------------------------------------------------------------------------- /ubuntu20.04/README.md: -------------------------------------------------------------------------------- 1 | # Ubuntu 20.04 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | See https://github.com/NVIDIA/nvidia-docker/wiki/Driver-containers-(Beta) 4 | -------------------------------------------------------------------------------- /ubuntu20.04/drivers/README.md: -------------------------------------------------------------------------------- 1 | # Folder for downloading vGPU drivers and dependent metadata files -------------------------------------------------------------------------------- /ubuntu20.04/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/ubuntu20.04/empty -------------------------------------------------------------------------------- /ubuntu22.04/README.md: -------------------------------------------------------------------------------- 1 | # Ubuntu 20.04 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | See https://github.com/NVIDIA/nvidia-docker/wiki/Driver-containers-(Beta) 4 | -------------------------------------------------------------------------------- /ubuntu22.04/drivers/README.md: -------------------------------------------------------------------------------- 1 | # Folder for downloading vGPU drivers and dependent metadata files -------------------------------------------------------------------------------- /ubuntu22.04/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/ubuntu22.04/empty -------------------------------------------------------------------------------- /ubuntu24.04/README.md: -------------------------------------------------------------------------------- 1 | # Ubuntu 20.04 [![build status](https://gitlab.com/nvidia/driver/badges/master/build.svg)](https://gitlab.com/nvidia/driver/commits/master) 2 | 3 | See https://github.com/NVIDIA/nvidia-docker/wiki/Driver-containers-(Beta) 4 | -------------------------------------------------------------------------------- /ubuntu24.04/drivers/README.md: -------------------------------------------------------------------------------- 1 | # Folder for downloading vGPU drivers and dependent metadata files -------------------------------------------------------------------------------- /ubuntu24.04/empty: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NVIDIA/gpu-driver-container/8f0912c3a69270b0f0f75e7d82c664395b65983c/ubuntu24.04/empty -------------------------------------------------------------------------------- /versions.mk: -------------------------------------------------------------------------------- 1 | # Copyright (c) 2022, 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 | # DRIVER_VERSIONS contains latest version in all active datacenter branches 16 | DRIVER_VERSIONS ?= 535.247.01 550.163.01 570.148.08 17 | 18 | GOLANG_VERSION := 1.24.3 19 | -------------------------------------------------------------------------------- /vgpu-manager/rhel8/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM nvcr.io/nvidia/cuda:12.9.0-base-ubi8 2 | 3 | ARG DRIVER_VERSION 4 | ENV DRIVER_VERSION=$DRIVER_VERSION 5 | ARG DRIVER_ARCH=x86_64 6 | ENV DRIVER_ARCH=$DRIVER_ARCH 7 | 8 | RUN mkdir -p /driver 9 | WORKDIR /driver 10 | COPY NVIDIA-Linux-${DRIVER_ARCH}-${DRIVER_VERSION}-vgpu-kvm.run . 11 | RUN chmod +x NVIDIA-Linux-${DRIVER_ARCH}-${DRIVER_VERSION}-vgpu-kvm.run 12 | 13 | COPY nvidia-driver /usr/local/bin 14 | COPY ocp_dtk_entrypoint /usr/local/bin 15 | 16 | LABEL io.k8s.display-name="NVIDIA vGPU Manager Container" 17 | LABEL name="NVIDIA vGPU Manager Container" 18 | LABEL vendor="NVIDIA" 19 | LABEL version="${DRIVER_VERSION}" 20 | LABEL release="N/A" 21 | LABEL summary="Provision the NVIDIA vGPU Manager through containers" 22 | LABEL description="See summary" 23 | 24 | # Install / upgrade packages here that are required to resolve CVEs 25 | ARG CVE_UPDATES 26 | RUN if [ -n "${CVE_UPDATES}" ]; then \ 27 | yum update -y ${CVE_UPDATES} && \ 28 | rm -rf /var/cache/yum/*; \ 29 | fi 30 | 31 | # Add NGC DL license from the CUDA image 32 | RUN mkdir /licenses && mv /NGC-DL-CONTAINER-LICENSE /licenses/NGC-DL-CONTAINER-LICENSE 33 | 34 | ENTRYPOINT ["nvidia-driver", "init"] 35 | -------------------------------------------------------------------------------- /vgpu/Dockerfile: -------------------------------------------------------------------------------- 1 | # Copyright (c) 2019, 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 | FROM ubuntu:20.04 as builder 16 | 17 | ARG GOLANG_VERSION=1.20 18 | ENV GOLANG_VERSION=${GOLANG_VERSION} 19 | 20 | RUN apt-get update && \ 21 | apt-get install -y --no-install-recommends golang-${GOLANG_VERSION} && \ 22 | apt-get clean 23 | ENV PATH=/usr/lib/go-${GOLANG_VERSION}/bin:${PATH} 24 | 25 | WORKDIR /work 26 | COPY src/. . 27 | RUN go build -o vgpu-util 28 | 29 | FROM ubuntu:20.04 30 | COPY --from=builder /work/vgpu-util /usr/local/bin/vgpu-util 31 | ARG VERSION 32 | 33 | ENTRYPOINT ["/usr/bin/sleep", "infinity"] 34 | -------------------------------------------------------------------------------- /vgpu/src/go.mod: -------------------------------------------------------------------------------- 1 | module vgpu-util 2 | 3 | go 1.22.2 4 | 5 | require ( 6 | github.com/sirupsen/logrus v1.9.3 7 | github.com/urfave/cli/v2 v2.25.5 8 | gopkg.in/yaml.v2 v2.4.0 9 | ) 10 | 11 | require ( 12 | github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect 13 | github.com/russross/blackfriday/v2 v2.1.0 // indirect 14 | github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect 15 | golang.org/x/sys v0.8.0 // indirect 16 | ) 17 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/cpuguy83/go-md2man/v2/LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014 Brian Goff 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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/cpuguy83/go-md2man/v2/md2man/md2man.go: -------------------------------------------------------------------------------- 1 | package md2man 2 | 3 | import ( 4 | "github.com/russross/blackfriday/v2" 5 | ) 6 | 7 | // Render converts a markdown document into a roff formatted document. 8 | func Render(doc []byte) []byte { 9 | renderer := NewRoffRenderer() 10 | 11 | return blackfriday.Run(doc, 12 | []blackfriday.Option{blackfriday.WithRenderer(renderer), 13 | blackfriday.WithExtensions(renderer.GetExtensions())}...) 14 | } 15 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/russross/blackfriday/v2/.gitignore: -------------------------------------------------------------------------------- 1 | *.out 2 | *.swp 3 | *.8 4 | *.6 5 | _obj 6 | _test* 7 | markdown 8 | tags 9 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/russross/blackfriday/v2/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | go: 4 | - "1.10.x" 5 | - "1.11.x" 6 | - tip 7 | matrix: 8 | fast_finish: true 9 | allow_failures: 10 | - go: tip 11 | install: 12 | - # Do nothing. This is needed to prevent default install action "go get -t -v ./..." from happening here (we want it to happen inside script step). 13 | script: 14 | - go get -t -v ./... 15 | - diff -u <(echo -n) <(gofmt -d -s .) 16 | - go tool vet . 17 | - go test -v ./... 18 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/sirupsen/logrus/.gitignore: -------------------------------------------------------------------------------- 1 | logrus 2 | vendor 3 | 4 | .idea/ 5 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/sirupsen/logrus/.golangci.yml: -------------------------------------------------------------------------------- 1 | run: 2 | # do not run on test files yet 3 | tests: false 4 | 5 | # all available settings of specific linters 6 | linters-settings: 7 | errcheck: 8 | # report about not checking of errors in type assetions: `a := b.(MyStruct)`; 9 | # default is false: such cases aren't reported by default. 10 | check-type-assertions: false 11 | 12 | # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`; 13 | # default is false: such cases aren't reported by default. 14 | check-blank: false 15 | 16 | lll: 17 | line-length: 100 18 | tab-width: 4 19 | 20 | prealloc: 21 | simple: false 22 | range-loops: false 23 | for-loops: false 24 | 25 | whitespace: 26 | multi-if: false # Enforces newlines (or comments) after every multi-line if statement 27 | multi-func: false # Enforces newlines (or comments) after every multi-line function signature 28 | 29 | linters: 30 | enable: 31 | - megacheck 32 | - govet 33 | disable: 34 | - maligned 35 | - prealloc 36 | disable-all: false 37 | presets: 38 | - bugs 39 | - unused 40 | fast: false 41 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/sirupsen/logrus/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014 Simon Eskildsen 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 13 | all 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 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/sirupsen/logrus/hooks.go: -------------------------------------------------------------------------------- 1 | package logrus 2 | 3 | // A hook to be fired when logging on the logging levels returned from 4 | // `Levels()` on your implementation of the interface. Note that this is not 5 | // fired in a goroutine or a channel with workers, you should handle such 6 | // functionality yourself if your call is non-blocking and you don't wish for 7 | // the logging calls for levels returned from `Levels()` to block. 8 | type Hook interface { 9 | Levels() []Level 10 | Fire(*Entry) error 11 | } 12 | 13 | // Internal type for storing the hooks on a logger instance. 14 | type LevelHooks map[Level][]Hook 15 | 16 | // Add a hook to an instance of logger. This is called with 17 | // `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface. 18 | func (hooks LevelHooks) Add(hook Hook) { 19 | for _, level := range hook.Levels() { 20 | hooks[level] = append(hooks[level], hook) 21 | } 22 | } 23 | 24 | // Fire all the hooks for the passed level. Used by `entry.log` to fire 25 | // appropriate hooks for a log entry. 26 | func (hooks LevelHooks) Fire(level Level, entry *Entry) error { 27 | for _, hook := range hooks[level] { 28 | if err := hook.Fire(entry); err != nil { 29 | return err 30 | } 31 | } 32 | 33 | return nil 34 | } 35 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/.flake8: -------------------------------------------------------------------------------- 1 | [flake8] 2 | max-line-length = 120 3 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/.gitignore: -------------------------------------------------------------------------------- 1 | *.coverprofile 2 | *.exe 3 | *.orig 4 | .*envrc 5 | .envrc 6 | .idea 7 | /.local/ 8 | /site/ 9 | coverage.txt 10 | internal/*/built-example 11 | vendor 12 | /cmd/urfave-cli-genflags/urfave-cli-genflags 13 | *.exe 14 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2022 urfave/cli maintainers 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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/Makefile: -------------------------------------------------------------------------------- 1 | # NOTE: this Makefile is meant to provide a simplified entry point for humans to 2 | # run all of the critical steps to verify one's changes are harmonious in 3 | # nature. Keeping target bodies to one line each and abstaining from make magic 4 | # are very important so that maintainers and contributors can focus their 5 | # attention on files that are primarily Go. 6 | 7 | GO_RUN_BUILD := go run internal/build/build.go 8 | 9 | .PHONY: all 10 | all: generate vet test check-binary-size gfmrun yamlfmt v2diff 11 | 12 | # NOTE: this is a special catch-all rule to run any of the commands 13 | # defined in internal/build/build.go with optional arguments passed 14 | # via GFLAGS (global flags) and FLAGS (command-specific flags), e.g.: 15 | # 16 | # $ make test GFLAGS='--packages cli' 17 | %: 18 | $(GO_RUN_BUILD) $(GFLAGS) $* $(FLAGS) 19 | 20 | .PHONY: docs 21 | docs: 22 | mkdocs build 23 | 24 | .PHONY: serve-docs 25 | serve-docs: 26 | mkdocs serve 27 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/README.md: -------------------------------------------------------------------------------- 1 | # cli 2 | 3 | [![Run Tests](https://github.com/urfave/cli/actions/workflows/cli.yml/badge.svg?branch=v2-maint)](https://github.com/urfave/cli/actions/workflows/cli.yml) 4 | [![Go Reference](https://pkg.go.dev/badge/github.com/urfave/cli/v2.svg)](https://pkg.go.dev/github.com/urfave/cli/v2) 5 | [![Go Report Card](https://goreportcard.com/badge/github.com/urfave/cli/v2)](https://goreportcard.com/report/github.com/urfave/cli/v2) 6 | [![codecov](https://codecov.io/gh/urfave/cli/branch/v2-maint/graph/badge.svg?token=t9YGWLh05g)](https://app.codecov.io/gh/urfave/cli/tree/v2-maint) 7 | 8 | cli is a simple, fast, and fun package for building command line apps in Go. The 9 | goal is to enable developers to write fast and distributable command line 10 | applications in an expressive way. 11 | 12 | ## Documentation 13 | 14 | More documentation is available in [`./docs`](./docs) or the hosted 15 | documentation site at . 16 | 17 | ## License 18 | 19 | See [`LICENSE`](./LICENSE) 20 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/args.go: -------------------------------------------------------------------------------- 1 | package cli 2 | 3 | type Args interface { 4 | // Get returns the nth argument, or else a blank string 5 | Get(n int) string 6 | // First returns the first argument, or else a blank string 7 | First() string 8 | // Tail returns the rest of the arguments (not the first one) 9 | // or else an empty string slice 10 | Tail() []string 11 | // Len returns the length of the wrapped slice 12 | Len() int 13 | // Present checks if there are any arguments present 14 | Present() bool 15 | // Slice returns a copy of the internal slice 16 | Slice() []string 17 | } 18 | 19 | type args []string 20 | 21 | func (a *args) Get(n int) string { 22 | if len(*a) > n { 23 | return (*a)[n] 24 | } 25 | return "" 26 | } 27 | 28 | func (a *args) First() string { 29 | return a.Get(0) 30 | } 31 | 32 | func (a *args) Tail() []string { 33 | if a.Len() >= 2 { 34 | tail := []string((*a)[1:]) 35 | ret := make([]string, len(tail)) 36 | copy(ret, tail) 37 | return ret 38 | } 39 | return []string{} 40 | } 41 | 42 | func (a *args) Len() int { 43 | return len(*a) 44 | } 45 | 46 | func (a *args) Present() bool { 47 | return a.Len() != 0 48 | } 49 | 50 | func (a *args) Slice() []string { 51 | ret := make([]string, len(*a)) 52 | copy(ret, *a) 53 | return ret 54 | } 55 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/cli.go: -------------------------------------------------------------------------------- 1 | // Package cli provides a minimal framework for creating and organizing command line 2 | // Go applications. cli is designed to be easy to understand and write, the most simple 3 | // cli application can be written as follows: 4 | // 5 | // func main() { 6 | // (&cli.App{}).Run(os.Args) 7 | // } 8 | // 9 | // Of course this application does not do much, so let's make this an actual application: 10 | // 11 | // func main() { 12 | // app := &cli.App{ 13 | // Name: "greet", 14 | // Usage: "say a greeting", 15 | // Action: func(c *cli.Context) error { 16 | // fmt.Println("Greetings") 17 | // return nil 18 | // }, 19 | // } 20 | // 21 | // app.Run(os.Args) 22 | // } 23 | package cli 24 | 25 | //go:generate make -C cmd/urfave-cli-genflags run 26 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/flag_ext.go: -------------------------------------------------------------------------------- 1 | package cli 2 | 3 | import "flag" 4 | 5 | type extFlag struct { 6 | f *flag.Flag 7 | } 8 | 9 | func (e *extFlag) Apply(fs *flag.FlagSet) error { 10 | fs.Var(e.f.Value, e.f.Name, e.f.Usage) 11 | return nil 12 | } 13 | 14 | func (e *extFlag) Names() []string { 15 | return []string{e.f.Name} 16 | } 17 | 18 | func (e *extFlag) IsSet() bool { 19 | return false 20 | } 21 | 22 | func (e *extFlag) String() string { 23 | return FlagStringer(e) 24 | } 25 | 26 | func (e *extFlag) IsVisible() bool { 27 | return true 28 | } 29 | 30 | func (e *extFlag) TakesValue() bool { 31 | return false 32 | } 33 | 34 | func (e *extFlag) GetUsage() string { 35 | return e.f.Usage 36 | } 37 | 38 | func (e *extFlag) GetValue() string { 39 | return e.f.Value.String() 40 | } 41 | 42 | func (e *extFlag) GetDefaultText() string { 43 | return e.f.DefValue 44 | } 45 | 46 | func (e *extFlag) GetEnvVars() []string { 47 | return nil 48 | } 49 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/mkdocs-requirements.txt: -------------------------------------------------------------------------------- 1 | mkdocs-git-revision-date-localized-plugin~=1.0 2 | mkdocs-material-extensions~=1.0 3 | mkdocs-material~=8.2 4 | mkdocs~=1.3 5 | pygments~=2.12 6 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/urfave/cli/v2/sort.go: -------------------------------------------------------------------------------- 1 | package cli 2 | 3 | import "unicode" 4 | 5 | // lexicographicLess compares strings alphabetically considering case. 6 | func lexicographicLess(i, j string) bool { 7 | iRunes := []rune(i) 8 | jRunes := []rune(j) 9 | 10 | lenShared := len(iRunes) 11 | if lenShared > len(jRunes) { 12 | lenShared = len(jRunes) 13 | } 14 | 15 | for index := 0; index < lenShared; index++ { 16 | ir := iRunes[index] 17 | jr := jRunes[index] 18 | 19 | if lir, ljr := unicode.ToLower(ir), unicode.ToLower(jr); lir != ljr { 20 | return lir < ljr 21 | } 22 | 23 | if ir != jr { 24 | return ir < jr 25 | } 26 | } 27 | 28 | return i < j 29 | } 30 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/xrash/smetrics/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - 1.11 4 | - 1.12 5 | - 1.13 6 | - 1.14.x 7 | - master 8 | script: 9 | - cd tests && make 10 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/xrash/smetrics/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (C) 2016 Felipe da Cunha Gonçalves 2 | All Rights Reserved. 3 | 4 | MIT LICENSE 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy of 7 | this software and associated documentation files (the "Software"), to deal in 8 | the Software without restriction, including without limitation the rights to 9 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 10 | the Software, and to permit persons to whom the Software is furnished to do so, 11 | subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in all 14 | copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 18 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 19 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 20 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 21 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/xrash/smetrics/README.md: -------------------------------------------------------------------------------- 1 | [![Build Status](https://travis-ci.org/xrash/smetrics.svg?branch=master)](http://travis-ci.org/xrash/smetrics) 2 | 3 | # smetrics 4 | 5 | `smetrics` is "string metrics". 6 | 7 | Package smetrics provides a bunch of algorithms for calculating the distance between strings. 8 | 9 | There are implementations for calculating the popular Levenshtein distance (aka Edit Distance or Wagner-Fischer), as well as the Jaro distance, the Jaro-Winkler distance, and more. 10 | 11 | # How to import 12 | 13 | ```go 14 | import "github.com/xrash/smetrics" 15 | ``` 16 | 17 | # Documentation 18 | 19 | Go to [https://pkg.go.dev/github.com/xrash/smetrics](https://pkg.go.dev/github.com/xrash/smetrics) for complete documentation. 20 | 21 | # Example 22 | 23 | ```go 24 | package main 25 | 26 | import ( 27 | "github.com/xrash/smetrics" 28 | ) 29 | 30 | func main() { 31 | smetrics.WagnerFischer("POTATO", "POTATTO", 1, 1, 2) 32 | smetrics.WagnerFischer("MOUSE", "HOUSE", 2, 2, 4) 33 | 34 | smetrics.Ukkonen("POTATO", "POTATTO", 1, 1, 2) 35 | smetrics.Ukkonen("MOUSE", "HOUSE", 2, 2, 4) 36 | 37 | smetrics.Jaro("AL", "AL") 38 | smetrics.Jaro("MARTHA", "MARHTA") 39 | 40 | smetrics.JaroWinkler("AL", "AL", 0.7, 4) 41 | smetrics.JaroWinkler("MARTHA", "MARHTA", 0.7, 4) 42 | 43 | smetrics.Soundex("Euler") 44 | smetrics.Soundex("Ellery") 45 | 46 | smetrics.Hamming("aaa", "aaa") 47 | smetrics.Hamming("aaa", "aab") 48 | } 49 | ``` 50 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/xrash/smetrics/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package smetrics provides a bunch of algorithms for calculating 3 | the distance between strings. 4 | 5 | There are implementations for calculating the popular Levenshtein 6 | distance (aka Edit Distance or Wagner-Fischer), as well as the Jaro 7 | distance, the Jaro-Winkler distance, and more. 8 | 9 | For the Levenshtein distance, you can use the functions WagnerFischer() 10 | and Ukkonen(). Read the documentation on these functions. 11 | 12 | For the Jaro and Jaro-Winkler algorithms, check the functions 13 | Jaro() and JaroWinkler(). Read the documentation on these functions. 14 | 15 | For the Soundex algorithm, check the function Soundex(). 16 | 17 | For the Hamming distance algorithm, check the function Hamming(). 18 | */ 19 | package smetrics 20 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/xrash/smetrics/hamming.go: -------------------------------------------------------------------------------- 1 | package smetrics 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // The Hamming distance is the minimum number of substitutions required to change string A into string B. Both strings must have the same size. If the strings have different sizes, the function returns an error. 8 | func Hamming(a, b string) (int, error) { 9 | al := len(a) 10 | bl := len(b) 11 | 12 | if al != bl { 13 | return -1, fmt.Errorf("strings are not equal (len(a)=%d, len(b)=%d)", al, bl) 14 | } 15 | 16 | var difference = 0 17 | 18 | for i := range a { 19 | if a[i] != b[i] { 20 | difference = difference + 1 21 | } 22 | } 23 | 24 | return difference, nil 25 | } 26 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/xrash/smetrics/jaro-winkler.go: -------------------------------------------------------------------------------- 1 | package smetrics 2 | 3 | import ( 4 | "math" 5 | ) 6 | 7 | // The Jaro-Winkler distance. The result is 1 for equal strings, and 0 for completely different strings. It is commonly used on Record Linkage stuff, thus it tries to be accurate for common typos when writing real names such as person names and street names. 8 | // Jaro-Winkler is a modification of the Jaro algorithm. It works by first running Jaro, then boosting the score of exact matches at the beginning of the strings. Because of that, it introduces two more parameters: the boostThreshold and the prefixSize. These are commonly set to 0.7 and 4, respectively. 9 | func JaroWinkler(a, b string, boostThreshold float64, prefixSize int) float64 { 10 | j := Jaro(a, b) 11 | 12 | if j <= boostThreshold { 13 | return j 14 | } 15 | 16 | prefixSize = int(math.Min(float64(len(a)), math.Min(float64(prefixSize), float64(len(b))))) 17 | 18 | var prefixMatch float64 19 | for i := 0; i < prefixSize; i++ { 20 | if a[i] == b[i] { 21 | prefixMatch++ 22 | } else { 23 | break 24 | } 25 | } 26 | 27 | return j + 0.1*prefixMatch*(1.0-j) 28 | } 29 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/xrash/smetrics/soundex.go: -------------------------------------------------------------------------------- 1 | package smetrics 2 | 3 | import ( 4 | "strings" 5 | ) 6 | 7 | // The Soundex encoding. It is a phonetic algorithm that considers how the words sound in English. Soundex maps a string to a 4-byte code consisting of the first letter of the original string and three numbers. Strings that sound similar should map to the same code. 8 | func Soundex(s string) string { 9 | m := map[byte]string{ 10 | 'B': "1", 'P': "1", 'F': "1", 'V': "1", 11 | 'C': "2", 'S': "2", 'K': "2", 'G': "2", 'J': "2", 'Q': "2", 'X': "2", 'Z': "2", 12 | 'D': "3", 'T': "3", 13 | 'L': "4", 14 | 'M': "5", 'N': "5", 15 | 'R': "6", 16 | } 17 | 18 | s = strings.ToUpper(s) 19 | 20 | r := string(s[0]) 21 | p := s[0] 22 | for i := 1; i < len(s) && len(r) < 4; i++ { 23 | c := s[i] 24 | 25 | if (c < 'A' || c > 'Z') || (c == p) { 26 | continue 27 | } 28 | 29 | p = c 30 | 31 | if n, ok := m[c]; ok { 32 | r += n 33 | } 34 | } 35 | 36 | for i := len(r); i < 4; i++ { 37 | r += "0" 38 | } 39 | 40 | return r 41 | } 42 | -------------------------------------------------------------------------------- /vgpu/src/vendor/github.com/xrash/smetrics/wagner-fischer.go: -------------------------------------------------------------------------------- 1 | package smetrics 2 | 3 | // The Wagner-Fischer algorithm for calculating the Levenshtein distance. 4 | // The first two parameters are the two strings to be compared. The last three parameters are the insertion cost, the deletion cost and the substitution cost. These are normally defined as 1, 1 and 2 respectively. 5 | func WagnerFischer(a, b string, icost, dcost, scost int) int { 6 | 7 | // Allocate both rows. 8 | row1 := make([]int, len(b)+1) 9 | row2 := make([]int, len(b)+1) 10 | var tmp []int 11 | 12 | // Initialize the first row. 13 | for i := 1; i <= len(b); i++ { 14 | row1[i] = i * icost 15 | } 16 | 17 | // For each row... 18 | for i := 1; i <= len(a); i++ { 19 | row2[0] = i * dcost 20 | 21 | // For each column... 22 | for j := 1; j <= len(b); j++ { 23 | if a[i-1] == b[j-1] { 24 | row2[j] = row1[j-1] 25 | } else { 26 | ins := row2[j-1] + icost 27 | del := row1[j] + dcost 28 | sub := row1[j-1] + scost 29 | 30 | if ins < del && ins < sub { 31 | row2[j] = ins 32 | } else if del < sub { 33 | row2[j] = del 34 | } else { 35 | row2[j] = sub 36 | } 37 | } 38 | } 39 | 40 | // Swap the rows at the end of each row. 41 | tmp = row1 42 | row1 = row2 43 | row2 = tmp 44 | } 45 | 46 | // Because we swapped the rows, the final result is in row1 instead of row2. 47 | return row1[len(row1)-1] 48 | } 49 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/PATENTS: -------------------------------------------------------------------------------- 1 | Additional IP Rights Grant (Patents) 2 | 3 | "This implementation" means the copyrightable works distributed by 4 | Google as part of the Go project. 5 | 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive, 7 | no-charge, royalty-free, irrevocable (except as stated in this section) 8 | patent license to make, have made, use, offer to sell, sell, import, 9 | transfer and otherwise run, modify and propagate the contents of this 10 | implementation of Go, where such license applies only to those patent 11 | claims, both currently owned or controlled by Google and acquired in 12 | the future, licensable by Google that are necessarily infringed by this 13 | implementation of Go. This grant does not include claims that would be 14 | infringed only as a consequence of further modification of this 15 | implementation. If you or your agent or exclusive licensee institute or 16 | order or agree to the institution of patent litigation against any 17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging 18 | that this implementation of Go or any code incorporated within this 19 | implementation of Go constitutes direct or contributory patent 20 | infringement, or inducement of patent infringement, then any patent 21 | rights granted to you under this License for this implementation of Go 22 | shall terminate as of the date such litigation is filed. 23 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/internal/unsafeheader/unsafeheader.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 | // Package unsafeheader contains header declarations for the Go runtime's 6 | // slice and string implementations. 7 | // 8 | // This package allows x/sys to use types equivalent to 9 | // reflect.SliceHeader and reflect.StringHeader without introducing 10 | // a dependency on the (relatively heavy) "reflect" package. 11 | package unsafeheader 12 | 13 | import ( 14 | "unsafe" 15 | ) 16 | 17 | // Slice is the runtime representation of a slice. 18 | // It cannot be used safely or portably and its representation may change in a later release. 19 | type Slice struct { 20 | Data unsafe.Pointer 21 | Len int 22 | Cap int 23 | } 24 | 25 | // String is the runtime representation of a string. 26 | // It cannot be used safely or portably and its representation may change in a later release. 27 | type String struct { 28 | Data unsafe.Pointer 29 | Len int 30 | } 31 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/.gitignore: -------------------------------------------------------------------------------- 1 | _obj/ 2 | unix.test 3 | -------------------------------------------------------------------------------- /vgpu/src/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) && go1.9 6 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos 7 | // +build go1.9 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | type Signal = syscall.Signal 14 | type Errno = syscall.Errno 15 | type SysProcAttr = syscall.SysProcAttr 16 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 12 | // 13 | 14 | TEXT ·syscall6(SB),NOSPLIT,$0-88 15 | JMP syscall·syscall6(SB) 16 | 17 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 18 | JMP syscall·rawSyscall6(SB) 19 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for 386 BSD 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-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build darwin dragonfly freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for AMD64 BSD 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 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for ARM BSD 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-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build darwin freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for ARM64 BSD 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 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build darwin freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // 12 | // System call support for ppc64, BSD 13 | // 14 | 15 | // Just jump to package syscall's implementation for all these functions. 16 | // The runtime may know about them. 17 | 18 | TEXT ·Syscall(SB),NOSPLIT,$0-56 19 | JMP syscall·Syscall(SB) 20 | 21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 22 | JMP syscall·Syscall6(SB) 23 | 24 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 25 | JMP syscall·Syscall9(SB) 26 | 27 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 28 | JMP syscall·RawSyscall(SB) 29 | 30 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 31 | JMP syscall·RawSyscall6(SB) 32 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build darwin freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for RISCV64 BSD 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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/asm_linux_arm.s: -------------------------------------------------------------------------------- 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 gc 6 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System calls for arm, Linux 12 | // 13 | 14 | // Just jump to package syscall's implementation for all these functions. 15 | // The runtime may know about them. 16 | 17 | TEXT ·Syscall(SB),NOSPLIT,$0-28 18 | B syscall·Syscall(SB) 19 | 20 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 21 | B syscall·Syscall6(SB) 22 | 23 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-24 24 | BL runtime·entersyscall(SB) 25 | MOVW trap+0(FP), R7 26 | MOVW a1+4(FP), R0 27 | MOVW a2+8(FP), R1 28 | MOVW a3+12(FP), R2 29 | MOVW $0, R3 30 | MOVW $0, R4 31 | MOVW $0, R5 32 | SWI $0 33 | MOVW R0, r1+16(FP) 34 | MOVW $0, R0 35 | MOVW R0, r2+20(FP) 36 | BL runtime·exitsyscall(SB) 37 | RET 38 | 39 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 40 | B syscall·RawSyscall(SB) 41 | 42 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 43 | B syscall·RawSyscall6(SB) 44 | 45 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24 46 | MOVW trap+0(FP), R7 // syscall entry 47 | MOVW a1+4(FP), R0 48 | MOVW a2+8(FP), R1 49 | MOVW a3+12(FP), R2 50 | SWI $0 51 | MOVW R0, r1+16(FP) 52 | MOVW $0, R0 53 | MOVW R0, r2+20(FP) 54 | RET 55 | 56 | TEXT ·seek(SB),NOSPLIT,$0-28 57 | B syscall·seek(SB) 58 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/asm_linux_arm64.s: -------------------------------------------------------------------------------- 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 linux && arm64 && gc 6 | // +build linux 7 | // +build arm64 8 | // +build gc 9 | 10 | #include "textflag.h" 11 | 12 | // Just jump to package syscall's implementation for all these functions. 13 | // The runtime may know about them. 14 | 15 | TEXT ·Syscall(SB),NOSPLIT,$0-56 16 | B syscall·Syscall(SB) 17 | 18 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 19 | B syscall·Syscall6(SB) 20 | 21 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 22 | BL runtime·entersyscall(SB) 23 | MOVD a1+8(FP), R0 24 | MOVD a2+16(FP), R1 25 | MOVD a3+24(FP), R2 26 | MOVD $0, R3 27 | MOVD $0, R4 28 | MOVD $0, R5 29 | MOVD trap+0(FP), R8 // syscall entry 30 | SVC 31 | MOVD R0, r1+32(FP) // r1 32 | MOVD R1, r2+40(FP) // r2 33 | BL runtime·exitsyscall(SB) 34 | RET 35 | 36 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 37 | B syscall·RawSyscall(SB) 38 | 39 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 40 | B syscall·RawSyscall6(SB) 41 | 42 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 43 | MOVD a1+8(FP), R0 44 | MOVD a2+16(FP), R1 45 | MOVD a3+24(FP), R2 46 | MOVD $0, R3 47 | MOVD $0, R4 48 | MOVD $0, R5 49 | MOVD trap+0(FP), R8 // syscall entry 50 | SVC 51 | MOVD R0, r1+32(FP) 52 | MOVD R1, r2+40(FP) 53 | RET 54 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build linux 7 | // +build ppc64 ppc64le 8 | // +build gc 9 | 10 | #include "textflag.h" 11 | 12 | // 13 | // System calls for ppc64, Linux 14 | // 15 | 16 | // Just jump to package syscall's implementation for all these functions. 17 | // The runtime may know about them. 18 | 19 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 20 | BL runtime·entersyscall(SB) 21 | MOVD a1+8(FP), R3 22 | MOVD a2+16(FP), R4 23 | MOVD a3+24(FP), R5 24 | MOVD R0, R6 25 | MOVD R0, R7 26 | MOVD R0, R8 27 | MOVD trap+0(FP), R9 // syscall entry 28 | SYSCALL R9 29 | MOVD R3, r1+32(FP) 30 | MOVD R4, r2+40(FP) 31 | BL runtime·exitsyscall(SB) 32 | RET 33 | 34 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 35 | MOVD a1+8(FP), R3 36 | MOVD a2+16(FP), R4 37 | MOVD a3+24(FP), R5 38 | MOVD R0, R6 39 | MOVD R0, R7 40 | MOVD R0, R8 41 | MOVD trap+0(FP), R9 // syscall entry 42 | SYSCALL R9 43 | MOVD R3, r1+32(FP) 44 | MOVD R4, r2+40(FP) 45 | RET 46 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/asm_linux_riscv64.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 riscv64 && gc 6 | // +build riscv64 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // 12 | // System calls for linux/riscv64. 13 | // 14 | // Where available, just jump to package syscall's implementation of 15 | // these functions. 16 | 17 | TEXT ·Syscall(SB),NOSPLIT,$0-56 18 | JMP syscall·Syscall(SB) 19 | 20 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 21 | JMP syscall·Syscall6(SB) 22 | 23 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 24 | CALL runtime·entersyscall(SB) 25 | MOV a1+8(FP), A0 26 | MOV a2+16(FP), A1 27 | MOV a3+24(FP), A2 28 | MOV trap+0(FP), A7 // syscall entry 29 | ECALL 30 | MOV A0, r1+32(FP) // r1 31 | MOV A1, r2+40(FP) // r2 32 | CALL runtime·exitsyscall(SB) 33 | RET 34 | 35 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 36 | JMP syscall·RawSyscall(SB) 37 | 38 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 39 | JMP syscall·RawSyscall6(SB) 40 | 41 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 42 | MOV a1+8(FP), A0 43 | MOV a2+16(FP), A1 44 | MOV a3+24(FP), A2 45 | MOV trap+0(FP), A7 // syscall entry 46 | ECALL 47 | MOV A0, r1+32(FP) 48 | MOV A1, r2+40(FP) 49 | RET 50 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System call support for mips64, OpenBSD 12 | // 13 | 14 | // Just jump to package syscall's implementation for all these functions. 15 | // The runtime may know about them. 16 | 17 | TEXT ·Syscall(SB),NOSPLIT,$0-56 18 | JMP syscall·Syscall(SB) 19 | 20 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 21 | JMP syscall·Syscall6(SB) 22 | 23 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 24 | JMP syscall·Syscall9(SB) 25 | 26 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 27 | JMP syscall·RawSyscall(SB) 28 | 29 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 30 | JMP syscall·RawSyscall6(SB) 31 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go 12 | // 13 | 14 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88 15 | JMP syscall·sysvicall6(SB) 16 | 17 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 18 | JMP syscall·rawSysvicall6(SB) 19 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos 7 | 8 | package unix 9 | 10 | const ( 11 | R_OK = 0x4 12 | W_OK = 0x2 13 | X_OK = 0x1 14 | ) 15 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build aix,ppc 7 | 8 | // Functions to access/create device major and minor numbers matching the 9 | // encoding used by AIX. 10 | 11 | package unix 12 | 13 | // Major returns the major component of a Linux device number. 14 | func Major(dev uint64) uint32 { 15 | return uint32((dev >> 16) & 0xffff) 16 | } 17 | 18 | // Minor returns the minor component of a Linux device number. 19 | func Minor(dev uint64) uint32 { 20 | return uint32(dev & 0xffff) 21 | } 22 | 23 | // Mkdev returns a Linux device number generated from the given major and minor 24 | // components. 25 | func Mkdev(major, minor uint32) uint64 { 26 | return uint64(((major) << 16) | (minor)) 27 | } 28 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build aix,ppc64 7 | 8 | // Functions to access/create device major and minor numbers matching the 9 | // encoding used AIX. 10 | 11 | package unix 12 | 13 | // Major returns the major component of a Linux device number. 14 | func Major(dev uint64) uint32 { 15 | return uint32((dev & 0x3fffffff00000000) >> 32) 16 | } 17 | 18 | // Minor returns the minor component of a Linux device number. 19 | func Minor(dev uint64) uint32 { 20 | return uint32((dev & 0x00000000ffffffff) >> 0) 21 | } 22 | 23 | // Mkdev returns a Linux device number generated from the given major and minor 24 | // components. 25 | func Mkdev(major, minor uint32) uint64 { 26 | var DEVNO64 uint64 27 | DEVNO64 = 0x8000000000000000 28 | return ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64) 29 | } 30 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/dev_dragonfly.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 Dragonfly'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 DragonFlyBSD device number. 17 | func Major(dev uint64) uint32 { 18 | return uint32((dev >> 8) & 0xff) 19 | } 20 | 21 | // Minor returns the minor component of a DragonFlyBSD device number. 22 | func Minor(dev uint64) uint32 { 23 | return uint32(dev & 0xffff00ff) 24 | } 25 | 26 | // Mkdev returns a DragonFlyBSD 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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build zos,s390x 7 | 8 | // Functions to access/create device major and minor numbers matching the 9 | // encoding used by z/OS. 10 | // 11 | // The information below is extracted and adapted from macros. 12 | 13 | package unix 14 | 15 | // Major returns the major component of a z/OS device number. 16 | func Major(dev uint64) uint32 { 17 | return uint32((dev >> 16) & 0x0000FFFF) 18 | } 19 | 20 | // Minor returns the minor component of a z/OS device number. 21 | func Minor(dev uint64) uint32 { 22 | return uint32(dev & 0x0000FFFF) 23 | } 24 | 25 | // Mkdev returns a z/OS device number generated from the given major and minor 26 | // components. 27 | func Mkdev(major, minor uint32) uint64 { 28 | return (uint64(major) << 16) | uint64(minor) 29 | } 30 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build armbe arm64be m68k mips mips64 mips64p32 ppc ppc64 s390 s390x shbe sparc sparc64 7 | 8 | package unix 9 | 10 | const isBigEndian = true 11 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build 386 amd64 amd64p32 alpha arm arm64 loong64 mipsle mips64le mips64p32le nios2 ppc64le riscv riscv64 sh 7 | 8 | package unix 9 | 10 | const isBigEndian = false 11 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos 7 | 8 | // Unix environment variables. 9 | 10 | package unix 11 | 12 | import "syscall" 13 | 14 | func Getenv(key string) (value string, found bool) { 15 | return syscall.Getenv(key) 16 | } 17 | 18 | func Setenv(key, value string) error { 19 | return syscall.Setenv(key, value) 20 | } 21 | 22 | func Clearenv() { 23 | syscall.Clearenv() 24 | } 25 | 26 | func Environ() []string { 27 | return syscall.Environ() 28 | } 29 | 30 | func Unsetenv(key string) error { 31 | return syscall.Unsetenv(key) 32 | } 33 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/fcntl.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 dragonfly || freebsd || linux || netbsd || openbsd 6 | // +build dragonfly freebsd linux netbsd openbsd 7 | 8 | package unix 9 | 10 | import "unsafe" 11 | 12 | // fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux 13 | // systems by fcntl_linux_32bit.go to be SYS_FCNTL64. 14 | var fcntl64Syscall uintptr = SYS_FCNTL 15 | 16 | func fcntl(fd int, cmd, arg int) (int, error) { 17 | valptr, _, errno := Syscall(fcntl64Syscall, uintptr(fd), uintptr(cmd), uintptr(arg)) 18 | var err error 19 | if errno != 0 { 20 | err = errno 21 | } 22 | return int(valptr), err 23 | } 24 | 25 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument. 26 | func FcntlInt(fd uintptr, cmd, arg int) (int, error) { 27 | return fcntl(int(fd), cmd, arg) 28 | } 29 | 30 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. 31 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { 32 | _, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk))) 33 | if errno == 0 { 34 | return nil 35 | } 36 | return errno 37 | } 38 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build linux,386 linux,arm linux,mips linux,mipsle linux,ppc 7 | 8 | package unix 9 | 10 | func init() { 11 | // On 32-bit Linux systems, the fcntl syscall that matches Go's 12 | // Flock_t type is SYS_FCNTL64, not SYS_FCNTL. 13 | fcntl64Syscall = SYS_FCNTL64 14 | } 15 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos 7 | 8 | package unix 9 | 10 | // Set adds fd to the set fds. 11 | func (fds *FdSet) Set(fd int) { 12 | fds.Bits[fd/NFDBITS] |= (1 << (uintptr(fd) % NFDBITS)) 13 | } 14 | 15 | // Clear removes fd from the set fds. 16 | func (fds *FdSet) Clear(fd int) { 17 | fds.Bits[fd/NFDBITS] &^= (1 << (uintptr(fd) % NFDBITS)) 18 | } 19 | 20 | // IsSet returns whether fd is in the set fds. 21 | func (fds *FdSet) IsSet(fd int) bool { 22 | return fds.Bits[fd/NFDBITS]&(1<<(uintptr(fd)%NFDBITS)) != 0 23 | } 24 | 25 | // Zero clears the set fds. 26 | func (fds *FdSet) Zero() { 27 | for i := range fds.Bits { 28 | fds.Bits[i] = 0 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build gccgo,linux,amd64 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | //extern gettimeofday 13 | func realGettimeofday(*Timeval, *byte) int32 14 | 15 | func gettimeofday(tv *Timeval) (err syscall.Errno) { 16 | r := realGettimeofday(tv, nil) 17 | if r < 0 { 18 | return syscall.GetErrno() 19 | } 20 | return 0 21 | } 22 | -------------------------------------------------------------------------------- /vgpu/src/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 6 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris 7 | 8 | // For Unix, get the pagesize from the runtime. 9 | 10 | package unix 11 | 12 | import "syscall" 13 | 14 | func Getpagesize() int { 15 | return syscall.Getpagesize() 16 | } 17 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build darwin,!ios 7 | 8 | package unix 9 | 10 | import "unsafe" 11 | 12 | func ptrace(request int, pid int, addr uintptr, data uintptr) error { 13 | return ptrace1(request, pid, addr, data) 14 | } 15 | 16 | func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) error { 17 | return ptrace1Ptr(request, pid, addr, data) 18 | } 19 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build ios 7 | 8 | package unix 9 | 10 | import "unsafe" 11 | 12 | func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) { 13 | return ENOTSUP 14 | } 15 | 16 | func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) { 17 | return ENOTSUP 18 | } 19 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build darwin,race linux,race freebsd,race 7 | 8 | package unix 9 | 10 | import ( 11 | "runtime" 12 | "unsafe" 13 | ) 14 | 15 | const raceenabled = true 16 | 17 | func raceAcquire(addr unsafe.Pointer) { 18 | runtime.RaceAcquire(addr) 19 | } 20 | 21 | func raceReleaseMerge(addr unsafe.Pointer) { 22 | runtime.RaceReleaseMerge(addr) 23 | } 24 | 25 | func raceReadRange(addr unsafe.Pointer, len int) { 26 | runtime.RaceReadRange(addr, len) 27 | } 28 | 29 | func raceWriteRange(addr unsafe.Pointer, len int) { 30 | runtime.RaceWriteRange(addr, len) 31 | } 32 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build aix darwin,!race linux,!race freebsd,!race netbsd openbsd solaris dragonfly zos 7 | 8 | package unix 9 | 10 | import ( 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = false 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | } 18 | 19 | func raceReleaseMerge(addr unsafe.Pointer) { 20 | } 21 | 22 | func raceReadRange(addr unsafe.Pointer, len int) { 23 | } 24 | 25 | func raceWriteRange(addr unsafe.Pointer, len int) { 26 | } 27 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build aix dragonfly freebsd linux netbsd openbsd 7 | 8 | package unix 9 | 10 | // ReadDirent reads directory entries from fd and writes them into buf. 11 | func ReadDirent(fd int, buf []byte) (n int, err error) { 12 | return Getdents(fd, buf) 13 | } 14 | -------------------------------------------------------------------------------- /vgpu/src/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 6 | // +build darwin 7 | 8 | package unix 9 | 10 | import "unsafe" 11 | 12 | // ReadDirent reads directory entries from fd and writes them into buf. 13 | func ReadDirent(fd int, buf []byte) (n int, err error) { 14 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. 15 | // 64 bits should be enough. (32 bits isn't even on 386). Since the 16 | // actual system call is getdirentries64, 64 is a good guess. 17 | // TODO(rsc): Can we use a single global basep for all calls? 18 | var base = (*uintptr)(unsafe.Pointer(new(uint64))) 19 | return Getdirentries(fd, buf, base) 20 | } 21 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.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 darwin && go1.12 6 | // +build darwin,go1.12 7 | 8 | package unix 9 | 10 | import _ "unsafe" 11 | 12 | // Implemented in the runtime package (runtime/sys_darwin.go) 13 | func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 14 | func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 15 | func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 16 | func syscall_syscall9(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) // 32-bit only 17 | func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 18 | func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 19 | func syscall_syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 20 | 21 | //go:linkname syscall_syscall syscall.syscall 22 | //go:linkname syscall_syscall6 syscall.syscall6 23 | //go:linkname syscall_syscall6X syscall.syscall6X 24 | //go:linkname syscall_syscall9 syscall.syscall9 25 | //go:linkname syscall_rawSyscall syscall.rawSyscall 26 | //go:linkname syscall_rawSyscall6 syscall.rawSyscall6 27 | //go:linkname syscall_syscallPtr syscall.syscallPtr 28 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build hurd 7 | 8 | package unix 9 | 10 | /* 11 | #include 12 | int ioctl(int, unsigned long int, uintptr_t); 13 | */ 14 | import "C" 15 | 16 | func ioctl(fd int, req uint, arg uintptr) (err error) { 17 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) 18 | if r0 == -1 && er != nil { 19 | err = er 20 | } 21 | return 22 | } 23 | 24 | func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { 25 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(uintptr(arg))) 26 | if r0 == -1 && er != nil { 27 | err = er 28 | } 29 | return 30 | } 31 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build 386,hurd 7 | 8 | package unix 9 | 10 | const ( 11 | TIOCGETA = 0x62251713 12 | ) 13 | 14 | type Winsize struct { 15 | Row uint16 16 | Col uint16 17 | Xpixel uint16 18 | Ypixel uint16 19 | } 20 | 21 | type Termios struct { 22 | Iflag uint32 23 | Oflag uint32 24 | Cflag uint32 25 | Lflag uint32 26 | Cc [20]uint8 27 | Ispeed int32 28 | Ospeed int32 29 | } 30 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build linux 7 | // +build 386 amd64 mips mipsle mips64 mipsle ppc64 ppc64le ppc s390x sparc64 8 | 9 | package unix 10 | 11 | // SYS_ALARM is not defined on arm or riscv, but is available for other GOARCH 12 | // values. 13 | 14 | //sys Alarm(seconds uint) (remaining uint, err error) 15 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build amd64,linux,gc 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | //go:noescape 13 | func gettimeofday(tv *Timeval) (err syscall.Errno) 14 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build linux,gc 7 | 8 | package unix 9 | 10 | // SyscallNoError may be used instead of Syscall for syscalls that don't fail. 11 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 12 | 13 | // RawSyscallNoError may be used instead of RawSyscall for syscalls that don't 14 | // fail. 15 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 16 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build linux,gc,386 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | // Underlying system call writes to newoffset via pointer. 13 | // Implemented in assembly to avoid allocation. 14 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 15 | 16 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 17 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 18 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build arm,gc,linux 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | // Underlying system call writes to newoffset via pointer. 13 | // Implemented in assembly to avoid allocation. 14 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 15 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build linux,gccgo,386 7 | 8 | package unix 9 | 10 | import ( 11 | "syscall" 12 | "unsafe" 13 | ) 14 | 15 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 16 | var newoffset int64 17 | offsetLow := uint32(offset & 0xffffffff) 18 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 19 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 20 | return newoffset, err 21 | } 22 | 23 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) { 24 | fd, _, err := Syscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0) 25 | return int(fd), err 26 | } 27 | 28 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) { 29 | fd, _, err := RawSyscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0) 30 | return int(fd), err 31 | } 32 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build linux,gccgo,arm 7 | 8 | package unix 9 | 10 | import ( 11 | "syscall" 12 | "unsafe" 13 | ) 14 | 15 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 16 | var newoffset int64 17 | offsetLow := uint32(offset & 0xffffffff) 18 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 19 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 20 | return newoffset, err 21 | } 22 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build 386,netbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: int32(nsec)} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint32(fd) 20 | k.Filter = uint32(mode) 21 | k.Flags = uint32(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint32(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = int32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build amd64,netbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint64(fd) 20 | k.Filter = uint32(mode) 21 | k.Flags = uint32(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint64(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = int32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build arm,netbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: int32(nsec)} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint32(fd) 20 | k.Filter = uint32(mode) 21 | k.Flags = uint32(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint32(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = int32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build arm64,netbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint64(fd) 20 | k.Filter = uint32(mode) 21 | k.Flags = uint32(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint64(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = int32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/syscall_openbsd_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 && openbsd 6 | // +build 386,openbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: int32(nsec)} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint32(fd) 20 | k.Filter = int16(mode) 21 | k.Flags = uint16(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint32(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = uint32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | 40 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 41 | // of openbsd/386 the syscall is called sysctl instead of __sysctl. 42 | const SYS___SYSCTL = SYS_SYSCTL 43 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/syscall_openbsd_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 && openbsd 6 | // +build amd64,openbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: usec} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint64(fd) 20 | k.Filter = int16(mode) 21 | k.Flags = uint16(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint64(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = uint32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | 40 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 41 | // of openbsd/amd64 the syscall is called sysctl instead of __sysctl. 42 | const SYS___SYSCTL = SYS_SYSCTL 43 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/syscall_openbsd_arm.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 arm && openbsd 6 | // +build arm,openbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: int32(nsec)} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint32(fd) 20 | k.Filter = int16(mode) 21 | k.Flags = uint16(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint32(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = uint32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | 40 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 41 | // of openbsd/arm the syscall is called sysctl instead of __sysctl. 42 | const SYS___SYSCTL = SYS_SYSCTL 43 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/syscall_openbsd_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 && openbsd 6 | // +build arm64,openbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: usec} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint64(fd) 20 | k.Filter = int16(mode) 21 | k.Flags = uint16(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint64(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = uint32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | 40 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 41 | // of openbsd/amd64 the syscall is called sysctl instead of __sysctl. 42 | const SYS___SYSCTL = SYS_SYSCTL 43 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/syscall_openbsd_libc.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 openbsd 6 | // +build openbsd 7 | 8 | package unix 9 | 10 | import _ "unsafe" 11 | 12 | // Implemented in the runtime package (runtime/sys_openbsd3.go) 13 | func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 14 | func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 15 | func syscall_syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2 uintptr, err Errno) 16 | func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 17 | func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 18 | 19 | //go:linkname syscall_syscall syscall.syscall 20 | //go:linkname syscall_syscall6 syscall.syscall6 21 | //go:linkname syscall_syscall10 syscall.syscall10 22 | //go:linkname syscall_rawSyscall syscall.rawSyscall 23 | //go:linkname syscall_rawSyscall6 syscall.rawSyscall6 24 | 25 | func syscall_syscall9(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) { 26 | return syscall_syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, 0) 27 | } 28 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/syscall_openbsd_ppc64.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 ppc64 && openbsd 6 | // +build ppc64,openbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: usec} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint64(fd) 20 | k.Filter = int16(mode) 21 | k.Flags = uint16(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint64(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = uint32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | 40 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 41 | // of openbsd/ppc64 the syscall is called sysctl instead of __sysctl. 42 | const SYS___SYSCTL = SYS_SYSCTL 43 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/syscall_openbsd_riscv64.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 riscv64 && openbsd 6 | // +build riscv64,openbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: usec} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint64(fd) 20 | k.Filter = int16(mode) 21 | k.Flags = uint16(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint64(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = uint32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | 40 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 41 | // of openbsd/riscv64 the syscall is called sysctl instead of __sysctl. 42 | const SYS___SYSCTL = SYS_SYSCTL 43 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build amd64,solaris 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: usec} 16 | } 17 | 18 | func (iov *Iovec) SetLen(length int) { 19 | iov.Len = uint64(length) 20 | } 21 | 22 | func (msghdr *Msghdr) SetIovlen(length int) { 23 | msghdr.Iovlen = int32(length) 24 | } 25 | 26 | func (cmsg *Cmsghdr) SetLen(length int) { 27 | cmsg.Len = uint32(length) 28 | } 29 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build darwin dragonfly freebsd linux,!ppc64,!ppc64le netbsd openbsd solaris 7 | // +build gc 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 16 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 17 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build linux 7 | // +build ppc64le ppc64 8 | // +build gc 9 | 10 | package unix 11 | 12 | import "syscall" 13 | 14 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 15 | return syscall.Syscall(trap, a1, a2, a3) 16 | } 17 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 18 | return syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6) 19 | } 20 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 21 | return syscall.RawSyscall(trap, a1, a2, a3) 22 | } 23 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 24 | return syscall.RawSyscall6(trap, a1, a2, a3, a4, a5, a6) 25 | } 26 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build linux 7 | 8 | package unix 9 | 10 | import "runtime" 11 | 12 | // SysvShmCtl performs control operations on the shared memory segment 13 | // specified by id. 14 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 15 | if runtime.GOARCH == "arm" || 16 | runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le" { 17 | cmd |= ipc_64 18 | } 19 | 20 | return shmctl(id, cmd, desc) 21 | } 22 | -------------------------------------------------------------------------------- /vgpu/src/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 6 | // +build darwin,!ios 7 | 8 | package unix 9 | 10 | // SysvShmCtl performs control operations on the shared memory segment 11 | // specified by id. 12 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 13 | return shmctl(id, cmd, desc) 14 | } 15 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/unveil_openbsd.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 unix 6 | 7 | import ( 8 | "syscall" 9 | "unsafe" 10 | ) 11 | 12 | // Unveil implements the unveil syscall. 13 | // For more information see unveil(2). 14 | // Note that the special case of blocking further 15 | // unveil calls is handled by UnveilBlock. 16 | func Unveil(path string, flags string) error { 17 | pathPtr, err := syscall.BytePtrFromString(path) 18 | if err != nil { 19 | return err 20 | } 21 | flagsPtr, err := syscall.BytePtrFromString(flags) 22 | if err != nil { 23 | return err 24 | } 25 | _, _, e := syscall.Syscall(SYS_UNVEIL, uintptr(unsafe.Pointer(pathPtr)), uintptr(unsafe.Pointer(flagsPtr)), 0) 26 | if e != 0 { 27 | return e 28 | } 29 | return nil 30 | } 31 | 32 | // UnveilBlock blocks future unveil calls. 33 | // For more information see unveil(2). 34 | func UnveilBlock() error { 35 | // Both pointers must be nil. 36 | var pathUnsafe, flagsUnsafe unsafe.Pointer 37 | _, _, e := syscall.Syscall(SYS_UNVEIL, uintptr(pathUnsafe), uintptr(flagsUnsafe), 0) 38 | if e != 0 { 39 | return e 40 | } 41 | return nil 42 | } 43 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/unix/zptrace_armnn_linux.go: -------------------------------------------------------------------------------- 1 | // Code generated by linux/mkall.go generatePtracePair("arm", "arm64"). DO NOT EDIT. 2 | 3 | //go:build linux && (arm || arm64) 4 | // +build linux 5 | // +build arm arm64 6 | 7 | package unix 8 | 9 | import "unsafe" 10 | 11 | // PtraceRegsArm is the registers used by arm binaries. 12 | type PtraceRegsArm struct { 13 | Uregs [18]uint32 14 | } 15 | 16 | // PtraceGetRegsArm fetches the registers used by arm binaries. 17 | func PtraceGetRegsArm(pid int, regsout *PtraceRegsArm) error { 18 | return ptracePtr(PTRACE_GETREGS, pid, 0, unsafe.Pointer(regsout)) 19 | } 20 | 21 | // PtraceSetRegsArm sets the registers used by arm binaries. 22 | func PtraceSetRegsArm(pid int, regs *PtraceRegsArm) error { 23 | return ptracePtr(PTRACE_SETREGS, pid, 0, unsafe.Pointer(regs)) 24 | } 25 | 26 | // PtraceRegsArm64 is the registers used by arm64 binaries. 27 | type PtraceRegsArm64 struct { 28 | Regs [31]uint64 29 | Sp uint64 30 | Pc uint64 31 | Pstate uint64 32 | } 33 | 34 | // PtraceGetRegsArm64 fetches the registers used by arm64 binaries. 35 | func PtraceGetRegsArm64(pid int, regsout *PtraceRegsArm64) error { 36 | return ptracePtr(PTRACE_GETREGS, pid, 0, unsafe.Pointer(regsout)) 37 | } 38 | 39 | // PtraceSetRegsArm64 sets the registers used by arm64 binaries. 40 | func PtraceSetRegsArm64(pid int, regs *PtraceRegsArm64) error { 41 | return ptracePtr(PTRACE_SETREGS, pid, 0, unsafe.Pointer(regs)) 42 | } 43 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 && go1.9 6 | // +build windows,go1.9 7 | 8 | package windows 9 | 10 | import "syscall" 11 | 12 | type Errno = syscall.Errno 13 | type SysProcAttr = syscall.SysProcAttr 14 | -------------------------------------------------------------------------------- /vgpu/src/vendor/golang.org/x/sys/windows/empty.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 !go1.12 6 | // +build !go1.12 7 | 8 | // This file is here to allow bodyless functions with go:linkname for Go 1.11 9 | // and earlier (see https://golang.org/issue/23311). 10 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build windows 7 | 8 | package windows 9 | 10 | const ( 11 | EVENTLOG_SUCCESS = 0 12 | EVENTLOG_ERROR_TYPE = 1 13 | EVENTLOG_WARNING_TYPE = 2 14 | EVENTLOG_INFORMATION_TYPE = 4 15 | EVENTLOG_AUDIT_SUCCESS = 8 16 | EVENTLOG_AUDIT_FAILURE = 16 17 | ) 18 | 19 | //sys RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW 20 | //sys DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource 21 | //sys ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW 22 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build generate 7 | 8 | package windows 9 | 10 | //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 11 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build windows,race 7 | 8 | package windows 9 | 10 | import ( 11 | "runtime" 12 | "unsafe" 13 | ) 14 | 15 | const raceenabled = true 16 | 17 | func raceAcquire(addr unsafe.Pointer) { 18 | runtime.RaceAcquire(addr) 19 | } 20 | 21 | func raceReleaseMerge(addr unsafe.Pointer) { 22 | runtime.RaceReleaseMerge(addr) 23 | } 24 | 25 | func raceReadRange(addr unsafe.Pointer, len int) { 26 | runtime.RaceReadRange(addr, len) 27 | } 28 | 29 | func raceWriteRange(addr unsafe.Pointer, len int) { 30 | runtime.RaceWriteRange(addr, len) 31 | } 32 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build windows,!race 7 | 8 | package windows 9 | 10 | import ( 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = false 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | } 18 | 19 | func raceReleaseMerge(addr unsafe.Pointer) { 20 | } 21 | 22 | func raceReadRange(addr unsafe.Pointer, len int) { 23 | } 24 | 25 | func raceWriteRange(addr unsafe.Pointer, len int) { 26 | } 27 | -------------------------------------------------------------------------------- /vgpu/src/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 | // +build windows 7 | 8 | package windows 9 | 10 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 11 | if val < 0 { 12 | return "-" + itoa(-val) 13 | } 14 | var buf [32]byte // big enough for int64 15 | i := len(buf) - 1 16 | for val >= 10 { 17 | buf[i] = byte(val%10 + '0') 18 | i-- 19 | val /= 10 20 | } 21 | buf[i] = byte(val + '0') 22 | return string(buf[i:]) 23 | } 24 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/gopkg.in/yaml.v2/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - "1.4.x" 5 | - "1.5.x" 6 | - "1.6.x" 7 | - "1.7.x" 8 | - "1.8.x" 9 | - "1.9.x" 10 | - "1.10.x" 11 | - "1.11.x" 12 | - "1.12.x" 13 | - "1.13.x" 14 | - "1.14.x" 15 | - "tip" 16 | 17 | go_import_path: gopkg.in/yaml.v2 18 | -------------------------------------------------------------------------------- /vgpu/src/vendor/gopkg.in/yaml.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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/gopkg.in/yaml.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 | -------------------------------------------------------------------------------- /vgpu/src/vendor/modules.txt: -------------------------------------------------------------------------------- 1 | # github.com/cpuguy83/go-md2man/v2 v2.0.2 2 | ## explicit; go 1.11 3 | github.com/cpuguy83/go-md2man/v2/md2man 4 | # github.com/russross/blackfriday/v2 v2.1.0 5 | ## explicit 6 | github.com/russross/blackfriday/v2 7 | # github.com/sirupsen/logrus v1.9.3 8 | ## explicit; go 1.13 9 | github.com/sirupsen/logrus 10 | # github.com/urfave/cli/v2 v2.25.5 11 | ## explicit; go 1.18 12 | github.com/urfave/cli/v2 13 | # github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 14 | ## explicit 15 | github.com/xrash/smetrics 16 | # golang.org/x/sys v0.8.0 17 | ## explicit; go 1.17 18 | golang.org/x/sys/internal/unsafeheader 19 | golang.org/x/sys/unix 20 | golang.org/x/sys/windows 21 | # gopkg.in/yaml.v2 v2.4.0 22 | ## explicit; go 1.15 23 | gopkg.in/yaml.v2 24 | --------------------------------------------------------------------------------