fix: Fix device node issues related to Wayland in both CDI and legacy

Signed-off-by: Seungmin Kim <8457324+ehfd@users.noreply.github.com>

Author: ehfd

cmd/nvidia-ctk/cdi/generate/generate.go

@@ -35,6 +35,7 @@ import (
 	"github.com/NVIDIA/nvidia-container-toolkit/api/config/v1"
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/platform-support/tegra/csv"
+	"github.com/NVIDIA/nvidia-container-toolkit/internal/system/devicenodes"
 	"github.com/NVIDIA/nvidia-container-toolkit/pkg/nvcdi"
 	"github.com/NVIDIA/nvidia-container-toolkit/pkg/nvcdi/spec"
 	"github.com/NVIDIA/nvidia-container-toolkit/pkg/nvcdi/transform"
@@ -316,6 +317,10 @@ func (m command) validateFlags(c *cli.Command, opts *options) error {
 }
 
 func (m command) run(opts *options) error {
+	if err := devicenodes.CreateControlDeviceNodes(m.logger, opts.driverRoot, opts.devRoot); err != nil {
+		m.logger.Warningf("Failed to create missing NVIDIA control device nodes: %v", err)
+	}
+
 	specs, err := m.generateSpecs(opts)
 	if err != nil {
 		return fmt.Errorf("failed to generate CDI spec: %v", err)

internal/modifier/cdi.go

@@ -27,6 +27,7 @@ import (
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/modifier/cdi"
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/oci"
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/platform-support/tegra/csv"
+	"github.com/NVIDIA/nvidia-container-toolkit/internal/system/devicenodes"
 	"github.com/NVIDIA/nvidia-container-toolkit/pkg/nvcdi"
 )
 
@@ -183,6 +184,10 @@ func (f *Factory) newAutomaticCDISpecModifier(devices []string) (oci.SpecModifie
 		csvFiles = csv.BaseFilesOnly(csvFiles)
 	}
 
+	if err := devicenodes.CreateControlDeviceNodes(f.logger, f.driver.Root, f.driver.DevRoot); err != nil {
+		f.logger.Warningf("Failed to create missing NVIDIA control device nodes: %v", err)
+	}
+
 	cdiModeIdentifiers := cdiModeIdentfiersFromDevices(devices...)
 	f.logger.Debugf("Per-mode identifiers: %v", cdiModeIdentifiers)
 	var modifiers oci.SpecModifiers

internal/system/devicenodes/devicenodes.go

@@ -0,0 +1,136 @@
+/**
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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 devicenodes
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/NVIDIA/go-nvlib/pkg/nvlib/info"
+
+	"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
+	"github.com/NVIDIA/nvidia-container-toolkit/pkg/system/nvdevices"
+	"github.com/NVIDIA/nvidia-container-toolkit/pkg/system/nvmodules"
+)
+
+type moduleLoader interface {
+	LoadAll() error
+}
+
+type deviceCreator interface {
+	CreateNVIDIAControlDevices() error
+}
+
+// A creator creates NVIDIA control device nodes.
+type creator struct {
+	logger logger.Interface
+	// devRoot is the root under which the device nodes are created.
+	devRoot string
+
+	nodeExists      func(string) bool
+	resolvePlatform func() info.Platform
+	moduleLoader    moduleLoader
+	// newDeviceCreator constructs a device creator on demand. The device major
+	// numbers are read from /proc/devices at construction and only become
+	// available once the associated kernel modules have been loaded.
+	newDeviceCreator func() (deviceCreator, error)
+}
+
+// CreateControlDeviceNodes loads the NVIDIA kernel modules and creates the
+// NVIDIA control device nodes that do not exist. It is the programmatic
+// equivalent of running
+// `nvidia-ctk system create-device-nodes --control-devices --load-kernel-modules`.
+// The NVIDIA driver creates control device nodes such as /dev/nvidia-modeset
+// on demand and does not register them with devtmpfs, meaning that they may
+// not exist on a host even if the installed driver supports them.
+// The driverRoot is used to resolve the kernel modules of the NVIDIA driver
+// installation and devRoot is the root under which the device nodes are
+// created. If devRoot is empty, the driverRoot is assumed.
+// If all control device nodes already exist, this is a no-op. On platforms
+// that do not use NVIDIA device nodes, such as Tegra-based systems and WSL,
+// this is also a no-op. The kernel modules are loaded on a best-effort basis
+// so that device node creation is still attempted for modules that are
+// already loaded.
+func CreateControlDeviceNodes(logger logger.Interface, driverRoot string, devRoot string) error {
+	return newCreator(logger, driverRoot, devRoot).createControlDeviceNodes()
+}
+
+func newCreator(logger logger.Interface, driverRoot string, devRoot string) *creator {
+	if devRoot == "" {
+		devRoot = driverRoot
+	}
+	if devRoot == "" {
+		devRoot = "/"
+	}
+	return &creator{
+		logger:     logger,
+		devRoot:    devRoot,
+		nodeExists: nodeExists,
+		resolvePlatform: func() info.Platform {
+			return info.New(info.WithLogger(logger)).ResolvePlatform()
+		},
+		moduleLoader: nvmodules.New(
+			nvmodules.WithLogger(logger),
+			nvmodules.WithRoot(driverRoot),
+		),
+		newDeviceCreator: func() (deviceCreator, error) {
+			return nvdevices.New(
+				nvdevices.WithLogger(logger),
+				nvdevices.WithDevRoot(devRoot),
+			)
+		},
+	}
+}
+
+func (c *creator) createControlDeviceNodes() error {
+	if c.controlDeviceNodesExist() {
+		c.logger.Debugf("Skipping the creation of control device nodes: all control device nodes exist")
+		return nil
+	}
+	if c.resolvePlatform() != info.PlatformNVML {
+		c.logger.Debugf("Skipping the creation of control device nodes on a non-NVML platform")
+		return nil
+	}
+	if err := c.moduleLoader.LoadAll(); err != nil {
+		c.logger.Debugf("Failed to load the NVIDIA kernel modules: %v", err)
+	}
+	devices, err := c.newDeviceCreator()
+	if err != nil {
+		return fmt.Errorf("failed to query NVIDIA device majors: %w", err)
+	}
+	return devices.CreateNVIDIAControlDevices()
+}
+
+// controlDeviceNodesExist returns whether all NVIDIA control device nodes
+// exist at the configured device root.
+// Device nodes that cannot be checked are treated as missing so that their
+// creation is attempted.
+func (c *creator) controlDeviceNodesExist() bool {
+	for _, node := range nvdevices.ControlDeviceNodes() {
+		if !c.nodeExists(filepath.Join(c.devRoot, "dev", node)) {
+			return false
+		}
+	}
+	return true
+}
+
+func nodeExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}

internal/system/devicenodes/devicenodes_test.go

@@ -0,0 +1,183 @@
+/**
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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 devicenodes
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/NVIDIA/go-nvlib/pkg/nvlib/info"
+
+	"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
+)
+
+type fakeModuleLoader struct {
+	err   error
+	calls *[]string
+}
+
+func (f *fakeModuleLoader) LoadAll() error {
+	*f.calls = append(*f.calls, "load-modules")
+	return f.err
+}
+
+type fakeDeviceCreator struct {
+	err   error
+	calls *[]string
+}
+
+func (f *fakeDeviceCreator) CreateNVIDIAControlDevices() error {
+	*f.calls = append(*f.calls, "create-devices")
+	return f.err
+}
+
+func TestDevRootResolution(t *testing.T) {
+	testCases := []struct {
+		description     string
+		driverRoot      string
+		devRoot         string
+		expectedDevRoot string
+	}{
+		{
+			description:     "unspecified roots resolve to the filesystem root",
+			expectedDevRoot: "/",
+		},
+		{
+			description:     "an unspecified dev root assumes the driver root",
+			driverRoot:      "/driver-root",
+			expectedDevRoot: "/driver-root",
+		},
+		{
+			description:     "an explicit dev root is used",
+			driverRoot:      "/driver-root",
+			devRoot:         "/dev-root",
+			expectedDevRoot: "/dev-root",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.description, func(t *testing.T) {
+			c := newCreator(logger.New(), tc.driverRoot, tc.devRoot)
+			require.Equal(t, tc.expectedDevRoot, c.devRoot)
+		})
+	}
+}
+
+func TestCreateControlDeviceNodes(t *testing.T) {
+	errModuleLoad := errors.New("module load error")
+	errNewDeviceCreator := errors.New("device creator error")
+	errCreateDevices := errors.New("create devices error")
+
+	testCases := []struct {
+		description           string
+		nodesExist            bool
+		platform              info.Platform
+		moduleLoadError       error
+		newDeviceCreatorError error
+		createDevicesError    error
+		expectedError         error
+		expectedCalls         []string
+	}{
+		{
+			description: "existing control device nodes are not created",
+			nodesExist:  true,
+			platform:    info.PlatformNVML,
+		},
+		{
+			description:   "non-NVML platforms are skipped",
+			platform:      info.PlatformWSL,
+			expectedCalls: []string{"resolve-platform"},
+		},
+		{
+			description:   "kernel modules are loaded before device nodes are created",
+			platform:      info.PlatformNVML,
+			expectedCalls: []string{"resolve-platform", "load-modules", "new-device-creator", "create-devices"},
+		},
+		{
+			description:     "module load failures do not prevent device node creation",
+			platform:        info.PlatformNVML,
+			moduleLoadError: errModuleLoad,
+			expectedCalls:   []string{"resolve-platform", "load-modules", "new-device-creator", "create-devices"},
+		},
+		{
+			description:           "device creator construction errors are returned",
+			platform:              info.PlatformNVML,
+			newDeviceCreatorError: errNewDeviceCreator,
+			expectedError:         errNewDeviceCreator,
+			expectedCalls:         []string{"resolve-platform", "load-modules", "new-device-creator"},
+		},
+		{
+			description:        "device node creation errors are returned",
+			platform:           info.PlatformNVML,
+			createDevicesError: errCreateDevices,
+			expectedError:      errCreateDevices,
+			expectedCalls:      []string{"resolve-platform", "load-modules", "new-device-creator", "create-devices"},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.description, func(t *testing.T) {
+			var calls []string
+			var checkedNodes []string
+			c := &creator{
+				logger:  logger.New(),
+				devRoot: "/dev-root",
+				nodeExists: func(path string) bool {
+					checkedNodes = append(checkedNodes, path)
+					return tc.nodesExist
+				},
+				resolvePlatform: func() info.Platform {
+					calls = append(calls, "resolve-platform")
+					return tc.platform
+				},
+				moduleLoader: &fakeModuleLoader{
+					err:   tc.moduleLoadError,
+					calls: &calls,
+				},
+				newDeviceCreator: func() (deviceCreator, error) {
+					calls = append(calls, "new-device-creator")
+					if tc.newDeviceCreatorError != nil {
+						return nil, tc.newDeviceCreatorError
+					}
+					return &fakeDeviceCreator{
+						err:   tc.createDevicesError,
+						calls: &calls,
+					}, nil
+				},
+			}
+
+			err := c.createControlDeviceNodes()
+			if tc.expectedError != nil {
+				require.ErrorIs(t, err, tc.expectedError)
+			} else {
+				require.NoError(t, err)
+			}
+			require.Equal(t, tc.expectedCalls, calls)
+			// The control device nodes are checked at the configured device
+			// root before any other action is taken. The check is stopped as
+			// soon as a device node is found to be missing.
+			if tc.nodesExist {
+				require.Contains(t, checkedNodes, "/dev-root/dev/nvidia-modeset")
+			} else {
+				require.Equal(t, []string{"/dev-root/dev/nvidiactl"}, checkedNodes)
+			}
+		})
+	}
+}

pkg/system/nvdevices/devices.go

@@ -70,10 +70,15 @@ func New(opts ...Option) (*Interface, error) {
 	return i, nil
 }
 
+// ControlDeviceNodes returns the names of the NVIDIA control device nodes.
+// These are the device nodes that are not associated with a specific GPU.
+func ControlDeviceNodes() []string {
+	return []string{"nvidiactl", "nvidia-modeset", "nvidia-uvm", "nvidia-uvm-tools"}
+}
+
 // CreateNVIDIAControlDevices creates the NVIDIA control device nodes at the configured devRoot.
 func (m *Interface) CreateNVIDIAControlDevices() error {
-	controlNodes := []string{"nvidiactl", "nvidia-modeset", "nvidia-uvm", "nvidia-uvm-tools"}
-	for _, node := range controlNodes {
+	for _, node := range ControlDeviceNodes() {
 		err := m.CreateNVIDIADevice(node)
 		if err != nil {
 			return fmt.Errorf("failed to create device node %s: %w", node, err)