From 5d2f48cd4286055a46f7290d043ba8807ae26bbc Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Fri, 28 Feb 2025 14:15:37 +0200 Subject: [PATCH] Use oci.ContainerRoot from enable-cuda-compat This change updates the enable-cuda-compat implementation to also use oci.ContainerRoot. Signed-off-by: Evan Lezar --- .../cudacompat/container-root.go | 76 ------------------- cmd/nvidia-cdi-hook/cudacompat/cudacompat.go | 34 +++++---- .../cudacompat/cudacompat_test.go | 6 +- internal/oci/container-root.go | 14 ++++ 4 files changed, 38 insertions(+), 92 deletions(-) delete mode 100644 cmd/nvidia-cdi-hook/cudacompat/container-root.go diff --git a/cmd/nvidia-cdi-hook/cudacompat/container-root.go b/cmd/nvidia-cdi-hook/cudacompat/container-root.go deleted file mode 100644 index 8bb3b3c8..00000000 --- a/cmd/nvidia-cdi-hook/cudacompat/container-root.go +++ /dev/null @@ -1,76 +0,0 @@ -/** -# Copyright (c) 2025, 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 cudacompat - -import ( - "os" - "path/filepath" - - "github.com/moby/sys/symlink" -) - -// A containerRoot represents the root filesystem of a container. -type containerRoot string - -// hasPath checks whether the specified path exists in the root. -func (r containerRoot) hasPath(path string) bool { - resolved, err := r.resolve(path) - if err != nil { - return false - } - if _, err := os.Stat(resolved); err != nil && os.IsNotExist(err) { - return false - } - return true -} - -// globFiles matches the specified pattern in the root. -// The files that match must be regular files. -func (r containerRoot) globFiles(pattern string) ([]string, error) { - patternPath, err := r.resolve(pattern) - if err != nil { - return nil, err - } - matches, err := filepath.Glob(patternPath) - if err != nil { - return nil, err - } - var files []string - for _, match := range matches { - info, err := os.Lstat(match) - if err != nil { - return nil, err - } - // Ignore symlinks. - if info.Mode()&os.ModeSymlink != 0 { - continue - } - // Ignore directories. - if info.IsDir() { - continue - } - files = append(files, match) - } - return files, nil -} - -// resolve returns the absolute path including root path. -// Symlinks are resolved, but are guaranteed to resolve in the root. -func (r containerRoot) resolve(path string) (string, error) { - absolute := filepath.Clean(filepath.Join(string(r), path)) - return symlink.FollowSymlinkInScope(absolute, string(r)) -} diff --git a/cmd/nvidia-cdi-hook/cudacompat/cudacompat.go b/cmd/nvidia-cdi-hook/cudacompat/cudacompat.go index be1bb642..f149d2bd 100644 --- a/cmd/nvidia-cdi-hook/cudacompat/cudacompat.go +++ b/cmd/nvidia-cdi-hook/cudacompat/cudacompat.go @@ -108,7 +108,7 @@ func (m command) run(_ *cli.Context, cfg *options) error { return fmt.Errorf("failed to determined container root: %w", err) } - containerForwardCompatDir, err := m.getContainerForwardCompatDir(containerRoot(containerRootDirPath), cfg.hostDriverVersion) + containerForwardCompatDir, err := m.getContainerForwardCompatDirPathInContainer(containerRootDirPath, cfg.hostDriverVersion) if err != nil { return fmt.Errorf("failed to get container forward compat directory: %w", err) } @@ -116,40 +116,44 @@ func (m command) run(_ *cli.Context, cfg *options) error { return nil } - return m.createLdsoconfdFile(containerRoot(containerRootDirPath), cudaCompatLdsoconfdFilenamePattern, containerForwardCompatDir) + return m.createLdsoconfdFile(containerRootDirPath, cudaCompatLdsoconfdFilenamePattern, containerForwardCompatDir) } -func (m command) getContainerForwardCompatDir(containerRoot containerRoot, hostDriverVersion string) (string, error) { +// getContainerForwardCompatDirPathInContainer returns the path to the directory containing +// the CUDA Forward Compatibility libraries in the container. +func (m command) getContainerForwardCompatDirPathInContainer(containerRootDirPath oci.ContainerRoot, hostDriverVersion string) (string, error) { if hostDriverVersion == "" { m.logger.Debugf("Host driver version not specified") return "", nil } - if !containerRoot.hasPath(cudaCompatPath) { + if !containerRootDirPath.HasPath(cudaCompatPath) { m.logger.Debugf("No CUDA forward compatibility libraries directory in container") return "", nil } - if !containerRoot.hasPath("/etc/ld.so.cache") { + if !containerRootDirPath.HasPath("/etc/ld.so.cache") { m.logger.Debugf("The container does not have an LDCache") return "", nil } - libs, err := containerRoot.globFiles(filepath.Join(cudaCompatPath, "libcuda.so.*.*")) + cudaForwardCompatLibPaths, err := containerRootDirPath.GlobFiles(filepath.Join(cudaCompatPath, "libcuda.so.*.*")) if err != nil { m.logger.Warningf("Failed to find CUDA compat library: %w", err) return "", nil } - if len(libs) == 0 { + if len(cudaForwardCompatLibPaths) == 0 { m.logger.Debugf("No CUDA forward compatibility libraries container") return "", nil } - if len(libs) != 1 { - m.logger.Warningf("Unexpected number of CUDA compat libraries in container: %v", libs) + if len(cudaForwardCompatLibPaths) != 1 { + m.logger.Warningf("Unexpected number of CUDA compat libraries in container: %v", cudaForwardCompatLibPaths) return "", nil } - compatDriverVersion := strings.TrimPrefix(filepath.Base(libs[0]), "libcuda.so.") + cudaForwardCompatLibPath := cudaForwardCompatLibPaths[0] + + compatDriverVersion := strings.TrimPrefix(filepath.Base(cudaForwardCompatLibPath), "libcuda.so.") compatMajor, err := extractMajorVersion(compatDriverVersion) if err != nil { return "", fmt.Errorf("failed to extract major version from %q: %v", compatDriverVersion, err) @@ -165,20 +169,22 @@ func (m command) getContainerForwardCompatDir(containerRoot containerRoot, hostD return "", nil } - resolvedCompatDir := strings.TrimPrefix(filepath.Dir(libs[0]), string(containerRoot)) - return resolvedCompatDir, nil + cudaForwardCompatLibDirPath := filepath.Dir(cudaForwardCompatLibPath) + resolvedCompatDirPathInContainer := containerRootDirPath.ToContainerPath(cudaForwardCompatLibDirPath) + + return resolvedCompatDirPathInContainer, nil } // createLdsoconfdFile creates a file at /etc/ld.so.conf.d/ in the specified root. // The file is created at /etc/ld.so.conf.d/{{ .pattern }} using `CreateTemp` and // contains the specified directories on each line. -func (m command) createLdsoconfdFile(in containerRoot, pattern string, dirs ...string) error { +func (m command) createLdsoconfdFile(in oci.ContainerRoot, pattern string, dirs ...string) error { if len(dirs) == 0 { m.logger.Debugf("No directories to add to /etc/ld.so.conf") return nil } - ldsoconfdDir, err := in.resolve("/etc/ld.so.conf.d") + ldsoconfdDir, err := in.Resolve("/etc/ld.so.conf.d") if err != nil { return err } diff --git a/cmd/nvidia-cdi-hook/cudacompat/cudacompat_test.go b/cmd/nvidia-cdi-hook/cudacompat/cudacompat_test.go index 0422fe76..a795a3d5 100644 --- a/cmd/nvidia-cdi-hook/cudacompat/cudacompat_test.go +++ b/cmd/nvidia-cdi-hook/cudacompat/cudacompat_test.go @@ -24,6 +24,8 @@ import ( testlog "github.com/sirupsen/logrus/hooks/test" "github.com/stretchr/testify/require" + + "github.com/NVIDIA/nvidia-container-toolkit/internal/oci" ) func TestCompatLibs(t *testing.T) { @@ -130,7 +132,7 @@ func TestCompatLibs(t *testing.T) { c := command{ logger: logger, } - containerForwardCompatDir, err := c.getContainerForwardCompatDir(containerRoot(containerRootDir), tc.hostDriverVersion) + containerForwardCompatDir, err := c.getContainerForwardCompatDirPathInContainer(oci.ContainerRoot(containerRootDir), tc.hostDriverVersion) require.NoError(t, err) require.EqualValues(t, tc.expectedContainerForwardCompatDir, containerForwardCompatDir) }) @@ -160,7 +162,7 @@ func TestUpdateLdconfig(t *testing.T) { c := command{ logger: logger, } - err := c.createLdsoconfdFile(containerRoot(containerRootDir), cudaCompatLdsoconfdFilenamePattern, tc.folders...) + err := c.createLdsoconfdFile(oci.ContainerRoot(containerRootDir), cudaCompatLdsoconfdFilenamePattern, tc.folders...) require.NoError(t, err) matches, err := filepath.Glob(filepath.Join(containerRootDir, "/etc/ld.so.conf.d/00-compat-*.conf")) diff --git a/internal/oci/container-root.go b/internal/oci/container-root.go index 13703ff5..2613fab5 100644 --- a/internal/oci/container-root.go +++ b/internal/oci/container-root.go @@ -20,6 +20,7 @@ package oci import ( "os" "path/filepath" + "strings" "github.com/moby/sys/symlink" ) @@ -75,3 +76,16 @@ func (r ContainerRoot) Resolve(path string) (string, error) { absolute := filepath.Clean(filepath.Join(string(r), path)) return symlink.FollowSymlinkInScope(absolute, string(r)) } + +// ToContainerPath converts the specified path to a path in the container. +// Relative paths and absolute paths that are in the container root are returned as is. +func (r ContainerRoot) ToContainerPath(path string) string { + if !filepath.IsAbs(path) { + return path + } + if !strings.HasPrefix(path, string(r)) { + return path + } + + return strings.TrimPrefix(path, string(r)) +}