diff --git a/internal/nvsandboxutils/gen/nvsandboxutils/nvsandboxutils.yml b/internal/nvsandboxutils/gen/nvsandboxutils/nvsandboxutils.yml index 851db7436..760616dc9 100644 --- a/internal/nvsandboxutils/gen/nvsandboxutils/nvsandboxutils.yml +++ b/internal/nvsandboxutils/gen/nvsandboxutils/nvsandboxutils.yml @@ -49,6 +49,7 @@ TRANSLATOR: const: - {action: accept, from: "^NVSANDBOXUTILS_"} - {action: accept, from: "^nvSandboxUtils"} + - {action: replace, from: "^NVSANDBOXUTILS_255_MASK_", to: "MASK255_" } - {action: replace, from: "^NVSANDBOXUTILS_"} - {action: replace, from: "^nvSandboxUtils"} - {action: accept, from: "^NV"} diff --git a/pkg/nvcdi/driver-nvml.go b/internal/platform-support/dgpu/driver-nvml.go similarity index 66% rename from pkg/nvcdi/driver-nvml.go rename to internal/platform-support/dgpu/driver-nvml.go index 519c6c36f..2761e4457 100644 --- a/pkg/nvcdi/driver-nvml.go +++ b/internal/platform-support/dgpu/driver-nvml.go @@ -14,7 +14,7 @@ # limitations under the License. **/ -package nvcdi +package dgpu import ( "fmt" @@ -31,33 +31,22 @@ import ( "github.com/NVIDIA/nvidia-container-toolkit/internal/lookup/root" ) -// NewDriverDiscoverer creates a discoverer for the libraries and binaries associated with a driver installation. -// The supplied NVML Library is used to query the expected driver version. -func NewDriverDiscoverer(logger logger.Interface, driver *root.Driver, nvidiaCDIHookPath string, ldconfigPath string, version string) (discover.Discover, error) { - return newDriverVersionDiscoverer(logger, driver, nvidiaCDIHookPath, ldconfigPath, version) -} - -func newDriverVersionDiscoverer(logger logger.Interface, driver *root.Driver, nvidiaCDIHookPath, ldconfigPath, version string) (discover.Discover, error) { - libraries, err := NewDriverLibraryDiscoverer(logger, driver, nvidiaCDIHookPath, ldconfigPath, version) +// newNvmlDriverDiscoverer constructs a discoverer from the specified NVML library. +func (o *options) newNvmlDriverDiscoverer() (discover.Discover, error) { + libraries, err := o.newNvmlDriverLibraryDiscoverer() if err != nil { return nil, fmt.Errorf("failed to create discoverer for driver libraries: %v", err) } - ipcs, err := discover.NewIPCDiscoverer(logger, driver.Root) - if err != nil { - return nil, fmt.Errorf("failed to create discoverer for IPC sockets: %v", err) - } - - firmwares, err := NewDriverFirmwareDiscoverer(logger, driver.Root, version) + firmwares, err := o.newNvmlDriverFirmwareDiscoverer() if err != nil { return nil, fmt.Errorf("failed to create discoverer for GSP firmware: %v", err) } - binaries := NewDriverBinariesDiscoverer(logger, driver.Root) + binaries := o.newNvmlDriverBinariesDiscoverer() d := discover.Merge( libraries, - ipcs, firmwares, binaries, ) @@ -65,32 +54,27 @@ func newDriverVersionDiscoverer(logger logger.Interface, driver *root.Driver, nv return d, nil } -// NewDriverLibraryDiscoverer creates a discoverer for the libraries associated with the specified driver version. -func NewDriverLibraryDiscoverer(logger logger.Interface, driver *root.Driver, nvidiaCDIHookPath, ldconfigPath, version string) (discover.Discover, error) { - libraryPaths, err := getVersionLibs(logger, driver, version) +// newNvmlDriverLibraryDiscoverer creates a discoverer for the libraries associated with the specified driver version. +func (o *options) newNvmlDriverLibraryDiscoverer() (discover.Discover, error) { + libraryPaths, err := getVersionLibs(o.logger, o.driver, o.version) if err != nil { return nil, fmt.Errorf("failed to get libraries for driver version: %v", err) } libraries := discover.NewMounts( - logger, + o.logger, lookup.NewFileLocator( - lookup.WithLogger(logger), - lookup.WithRoot(driver.Root), + lookup.WithLogger(o.logger), + lookup.WithRoot(o.driver.Root), ), - driver.Root, + o.driver.Root, libraryPaths, ) - updateLDCache, _ := discover.NewLDCacheUpdateHook(logger, libraries, nvidiaCDIHookPath, ldconfigPath) - - d := discover.Merge( - discover.WithDriverDotSoSymlinks( - libraries, - version, - nvidiaCDIHookPath, - ), - updateLDCache, + d := discover.WithDriverDotSoSymlinks( + libraries, + o.version, + o.nvidiaCDIHookPath, ) return d, nil @@ -138,31 +122,31 @@ func getCustomFirmwareClassPath(logger logger.Interface) string { return strings.TrimSpace(string(customFirmwareClassPath)) } -// NewDriverFirmwareDiscoverer creates a discoverer for GSP firmware associated with the specified driver version. -func NewDriverFirmwareDiscoverer(logger logger.Interface, driverRoot string, version string) (discover.Discover, error) { - gspFirmwareSearchPaths, err := getFirmwareSearchPaths(logger) +// newNvmlDriverFirmwareDiscoverer creates a discoverer for GSP firmware associated with the specified driver version. +func (o *options) newNvmlDriverFirmwareDiscoverer() (discover.Discover, error) { + gspFirmwareSearchPaths, err := getFirmwareSearchPaths(o.logger) if err != nil { return nil, fmt.Errorf("failed to get firmware search paths: %v", err) } - gspFirmwarePaths := filepath.Join("nvidia", version, "gsp*.bin") + gspFirmwarePaths := filepath.Join("nvidia", o.version, "gsp*.bin") return discover.NewMounts( - logger, + o.logger, lookup.NewFileLocator( - lookup.WithLogger(logger), - lookup.WithRoot(driverRoot), + lookup.WithLogger(o.logger), + lookup.WithRoot(o.driver.Root), lookup.WithSearchPaths(gspFirmwareSearchPaths...), ), - driverRoot, + o.driver.Root, []string{gspFirmwarePaths}, ), nil } -// NewDriverBinariesDiscoverer creates a discoverer for GSP firmware associated with the GPU driver. -func NewDriverBinariesDiscoverer(logger logger.Interface, driverRoot string) discover.Discover { +// newNvmlDriverBinariesDiscoverer creates a discoverer for binaries associated with the specified driver version. +func (o *options) newNvmlDriverBinariesDiscoverer() discover.Discover { return discover.NewMounts( - logger, - lookup.NewExecutableLocator(logger, driverRoot), - driverRoot, + o.logger, + lookup.NewExecutableLocator(o.logger, o.driver.Root), + o.driver.Root, []string{ "nvidia-smi", /* System management interface */ "nvidia-debugdump", /* GPU coredump utility */ diff --git a/internal/platform-support/dgpu/driver-nvsandboxutils.go b/internal/platform-support/dgpu/driver-nvsandboxutils.go new file mode 100644 index 000000000..713260833 --- /dev/null +++ b/internal/platform-support/dgpu/driver-nvsandboxutils.go @@ -0,0 +1,31 @@ +/** +# Copyright (c) NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +**/ + +package dgpu + +import ( + "fmt" + + "github.com/NVIDIA/nvidia-container-toolkit/internal/discover" +) + +// newNvsandboxutilsDriverDiscoverer constructs a discoverer from the specified nvsandboxutils library. +func (o *options) newNvsandboxutilsDriverDiscoverer() (discover.Discover, error) { + if o.nvsandboxutilslib == nil { + return nil, nil + } + return nil, fmt.Errorf("nvsandboxutils driver discovery is not implemented") +} diff --git a/internal/platform-support/dgpu/driver.go b/internal/platform-support/dgpu/driver.go new file mode 100644 index 000000000..2533edfb6 --- /dev/null +++ b/internal/platform-support/dgpu/driver.go @@ -0,0 +1,74 @@ +/** +# Copyright (c) NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +**/ + +package dgpu + +import ( + "errors" + "fmt" + + "github.com/NVIDIA/nvidia-container-toolkit/internal/discover" +) + +// NewDriverDiscoverer creates a discoverer for the libraries and binaries associated with a driver installation. +func NewDriverDiscoverer(opts ...Option) (discover.Discover, error) { + o := new(opts...) + + if o.version == "" { + return nil, fmt.Errorf("a version must be specified") + } + + var discoverers []discover.Discover + var errs error + + nvsandboxutilsDiscoverer, err := o.newNvsandboxutilsDriverDiscoverer() + if err != nil { + // TODO: Log a warning + errs = errors.Join(errs, err) + } else if nvsandboxutilsDiscoverer != nil { + discoverers = append(discoverers, nvsandboxutilsDiscoverer) + } + + nvmlDiscoverer, err := o.newNvmlDriverDiscoverer() + if err != nil { + // TODO: Log a warning + errs = errors.Join(errs, err) + } else if nvmlDiscoverer != nil { + discoverers = append(discoverers, nvmlDiscoverer) + } + + if len(discoverers) == 0 { + return nil, errs + } + + cached := discover.WithCache( + discover.FirstValid( + discoverers..., + ), + ) + updateLDCache, _ := discover.NewLDCacheUpdateHook(o.logger, cached, o.nvidiaCDIHookPath, o.ldconfigPath) + + ipcs, err := discover.NewIPCDiscoverer(o.logger, o.driver.Root) + if err != nil { + return nil, fmt.Errorf("failed to create discoverer for IPC sockets: %v", err) + } + + return discover.Merge( + cached, + updateLDCache, + ipcs, + ), nil +} diff --git a/internal/platform-support/dgpu/options.go b/internal/platform-support/dgpu/options.go index 2fd1c01bd..e8e3bac36 100644 --- a/internal/platform-support/dgpu/options.go +++ b/internal/platform-support/dgpu/options.go @@ -18,13 +18,16 @@ package dgpu import ( "github.com/NVIDIA/nvidia-container-toolkit/internal/logger" + "github.com/NVIDIA/nvidia-container-toolkit/internal/lookup/root" "github.com/NVIDIA/nvidia-container-toolkit/internal/nvcaps" "github.com/NVIDIA/nvidia-container-toolkit/internal/nvsandboxutils" ) type options struct { logger logger.Interface + driver *root.Driver devRoot string + ldconfigPath string nvidiaCDIHookPath string isMigDevice bool @@ -33,6 +36,9 @@ type options struct { migCaps nvcaps.MigCaps migCapsError error + // version stores the driver version. + version string + nvsandboxutilslib nvsandboxutils.Interface } @@ -45,6 +51,19 @@ func WithDevRoot(root string) Option { } } +func WithDriver(driver *root.Driver) Option { + return func(l *options) { + l.driver = driver + } +} + +// WithLdconfigPath sets the path to the ldconfig program +func WithLdconfigPath(path string) Option { + return func(l *options) { + l.ldconfigPath = path + } +} + // WithLogger sets the logger for the library func WithLogger(logger logger.Interface) Option { return func(l *options) { @@ -72,3 +91,9 @@ func WithNvsandboxuitilsLib(nvsandboxutilslib nvsandboxutils.Interface) Option { l.nvsandboxutilslib = nvsandboxutilslib } } + +func WithVersion(version string) Option { + return func(l *options) { + l.version = version + } +} diff --git a/pkg/nvcdi/common-nvml.go b/pkg/nvcdi/common-nvml.go index 1acb309aa..17ac87769 100644 --- a/pkg/nvcdi/common-nvml.go +++ b/pkg/nvcdi/common-nvml.go @@ -20,6 +20,7 @@ import ( "fmt" "github.com/NVIDIA/nvidia-container-toolkit/internal/discover" + "github.com/NVIDIA/nvidia-container-toolkit/internal/platform-support/dgpu" ) // newCommonNVMLDiscoverer returns a discoverer for entities that are not associated with a specific CDI device. @@ -41,7 +42,15 @@ func (l *nvmllib) newCommonNVMLDiscoverer(version string) (discover.Discover, er l.logger.Warningf("failed to create discoverer for graphics mounts: %v", err) } - driverFiles, err := NewDriverDiscoverer(l.logger, l.driver, l.nvidiaCDIHookPath, l.ldconfigPath, version) + driverFiles, err := dgpu.NewDriverDiscoverer( + dgpu.WithDevRoot(l.devRoot), + dgpu.WithDriver(l.driver), + dgpu.WithLdconfigPath(l.ldconfigPath), + dgpu.WithLogger(l.logger), + dgpu.WithNVIDIACDIHookPath(l.nvidiaCDIHookPath), + dgpu.WithNvsandboxuitilsLib(l.nvsandboxutilslib), + dgpu.WithVersion(version), + ) if err != nil { return nil, fmt.Errorf("failed to create discoverer for driver files: %v", err) } diff --git a/pkg/nvcdi/management.go b/pkg/nvcdi/management.go index b11f43103..38fbae475 100644 --- a/pkg/nvcdi/management.go +++ b/pkg/nvcdi/management.go @@ -28,6 +28,7 @@ import ( "github.com/NVIDIA/nvidia-container-toolkit/internal/discover" "github.com/NVIDIA/nvidia-container-toolkit/internal/edits" "github.com/NVIDIA/nvidia-container-toolkit/internal/nvsandboxutils" + "github.com/NVIDIA/nvidia-container-toolkit/internal/platform-support/dgpu" "github.com/NVIDIA/nvidia-container-toolkit/pkg/nvcdi/spec" ) @@ -76,10 +77,18 @@ func (m *managementlib) GetCommonEdits() (*cdi.ContainerEdits, error) { version, err := (*nvcdilib)(m).getDriverVersion() if err != nil { - return nil, fmt.Errorf("failed to get CUDA version: %v", err) + return nil, fmt.Errorf("failed to get driver version: %v", err) } - driver, err := newDriverVersionDiscoverer(m.logger, m.driver, m.nvidiaCDIHookPath, m.ldconfigPath, version) + driver, err := dgpu.NewDriverDiscoverer( + dgpu.WithDevRoot(m.devRoot), + dgpu.WithDriver(m.driver), + dgpu.WithLdconfigPath(m.ldconfigPath), + dgpu.WithLogger(m.logger), + dgpu.WithNVIDIACDIHookPath(m.nvidiaCDIHookPath), + dgpu.WithNvsandboxuitilsLib(m.nvsandboxutilslib), + dgpu.WithVersion(version), + ) if err != nil { return nil, fmt.Errorf("failed to create driver library discoverer: %v", err) }