570.86.16

2025-07-23 02:13:00 +02:00 · 2025-01-30 09:16:55 -08:00
parent 25ece5f9c3
commit c056e256a1
11 changed files with 151 additions and 23 deletions
--- a/files.c
+++ b/files.c
@@ -648,11 +648,20 @@ int set_destinations(Options *op, Package *p)
            break;

        case FILE_TYPE_GBM_BACKEND_LIB_SYMLINK:
-            p->entries[i].target = nvstrcat(op->utility_prefix, "/", op->utility_libdir, "/", p->entries[i].target, NULL);
+            if (p->entries[i].compat_arch == FILE_COMPAT_ARCH_COMPAT32) {
+                p->entries[i].target = nvstrcat(op->compat32_prefix, "/", op->compat32_libdir, "/", p->entries[i].target, NULL);
+            } else {
+                p->entries[i].target = nvstrcat(op->utility_prefix, "/", op->utility_libdir, "/", p->entries[i].target, NULL);
+            }
            /* fallthrough */
        case FILE_TYPE_GBM_BACKEND_LIB:
-            prefix = op->opengl_prefix;
-            dir = op->gbm_backend_dir;
+            if (p->entries[i].compat_arch == FILE_COMPAT_ARCH_COMPAT32) {
+                prefix = op->compat32_prefix;
+                dir = op->compat32_gbm_backend_dir;
+            } else {
+                prefix = op->opengl_prefix;
+                dir = op->gbm_backend_dir;
+            }
            path = "";
            break;

@@ -836,6 +845,11 @@ int set_destinations(Options *op, Package *p)
            dir = path = "";
            break;

+        case FILE_TYPE_SANDBOXUTILS_FILELIST_JSON:
+            prefix = "/usr/share/nvidia/files.d";
+            dir = path = "";
+            break;
+
        default:
            
            /* 
@@ -2549,6 +2563,10 @@ void get_compat32_path(Options *op)
        }
    }

+    if (!op->compat32_gbm_backend_dir)
+        op->compat32_gbm_backend_dir =
+            nvstrcat(op->compat32_libdir, "/", "gbm", NULL);
+
    nvfree(ldconfig_cache);
 #endif
 }
--- a/install-from-cwd.c
+++ b/install-from-cwd.c
@@ -811,7 +811,7 @@ static Package *parse_manifest (Options *op)
        struct module_type_info types;
        int num_types;

-        num_types = valid_kernel_module_types(op, &types);
+        num_types = valid_kernel_module_types(op, &types, FALSE);

        if (num_types > 0) {
            int selection;
--- a/kernel.c
+++ b/kernel.c
@@ -1418,6 +1418,7 @@ static int test_kernel_modules_helper(Options *op, Package *p, int pause_udev)
        "backlight",
        "vfio_pci_core",
        "ecc",
+        "nvgrace-egm",
    };

    if (pause_udev) {
@@ -2666,13 +2667,6 @@ static int kernel_configuration_conflict(Options *op, Package *p,
    return FALSE;
 }

-/* These values correspond to the initial letter which will be matched using the
- * --kernel-module-type command line option. */
-enum {
-    PROPRIETARY = 'p',
-    OPEN = 'o',
-};
-
 static struct {
    char type;
    char * const dir;
@@ -2682,7 +2676,7 @@ static struct {
    { .type = OPEN, .dir = "kernel-open", .license = "MIT/GPL" },
 };

-int valid_kernel_module_types(Options *op, struct module_type_info *info)
+int valid_kernel_module_types(Options *op, struct module_type_info *info, int allow_missing_directory)
 {
    int num_valid_types = 0, i;

@@ -2711,7 +2705,7 @@ int valid_kernel_module_types(Options *op, struct module_type_info *info)
            }
        }

-        if (directory_exists(kernel_module_types[i].dir)) {
+        if (directory_exists(kernel_module_types[i].dir) || allow_missing_directory) {
            info->types[num_valid_types] = kernel_module_types[i].type;
            info->dirs[num_valid_types] = kernel_module_types[i].dir;
            info->licenses[num_valid_types] = kernel_module_types[i].license;
@@ -2720,12 +2714,6 @@ int valid_kernel_module_types(Options *op, struct module_type_info *info)
        }
    }

-    if (num_valid_types == 0) {
-        ui_error(op, "This system requires a kernel module type which is "
-                 "not present in this installer package.");
-    }
-
-
    /* Return a default selection to the caller if multiple types are valid. */
    if (num_valid_types > 1) {
        char default_type = OPEN;
@@ -2744,6 +2732,17 @@ int valid_kernel_module_types(Options *op, struct module_type_info *info)
        }
    }

+    if (num_valid_types == 0 ||
+        (!directory_exists(info->dirs[info->default_entry]) && allow_missing_directory)) {
+        const char *msg = "This system requires a kernel module type which is "
+                          "not present in this installer package.";
+        if (num_valid_types == 0) {
+            ui_error(op, "%s", msg);
+        } else {
+            ui_warn(op, "%s", msg);
+        }
+    }
+
    return num_valid_types;
 }

@@ -2758,7 +2757,7 @@ int override_kernel_module_build_directory(Options *op, const char *directory)
        return FALSE;
    }

-    num_types = valid_kernel_module_types(op, &types);
+    num_types = valid_kernel_module_types(op, &types, FALSE);

    for (i = 0; i < num_types; i++) {
        if (strcmp(directory, types.dirs[i]) == 0) {
--- a/kernel.h
+++ b/kernel.h
@@ -29,6 +29,12 @@ typedef enum {
    KERNEL_CONFIG_OPTION_UNKNOWN
 } KernelConfigOptionStatus;

+/* These values correspond to the initial letter which will be matched using the
+ * --kernel-module-type command line option. */
+typedef enum {
+    PROPRIETARY = 'p',
+    OPEN = 'o',
+} KernelModuleType;
 #define NUM_KERNEL_MODULE_TYPES 2

 struct module_type_info {
@@ -67,7 +73,8 @@ int conftest_sanity_check                          (Options*, const char *,
                                                    const char *, const char *);
 char *precompiled_kernel_interface_path            (const Package*);
 int valid_kernel_module_types                      (Options*,
-                                                    struct module_type_info*);
+                                                    struct module_type_info*,
+                                                    int allow_missing_directory);
 int override_kernel_module_build_directory         (Options*, const char*);
 int override_kernel_module_type                    (Options*, const char*);

--- a/manifest.c
+++ b/manifest.c
@@ -134,6 +134,7 @@ static const struct {
    { ENTRY(SYSTEMD_SLEEP_SCRIPT,       F, T, F, F, F, F, F, F, F) },
    { ENTRY(OPENGL_DATA,                F, T, T, F, F, T, F, T, F) },
    { ENTRY(VULKANSC_ICD_JSON,          F, T, T, F, F, F, F, T, F) },
+    { ENTRY(SANDBOXUTILS_FILELIST_JSON, F, T, T, F, F, F, F, F, F) },
 };

 /*
--- a/nvGpus.h
+++ b/nvGpus.h
@@ -1653,6 +1653,7 @@ static const GPU_FLAGS GpuFlagList[] = {
    { 0x2882, GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x28a0, GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x28a1, GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x28a3, GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x28b0, GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x28b8, GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x28b9, GPU_FLAGS_PROPRIETARY_POSSIBLE },
@@ -2352,6 +2353,22 @@ static const GPU_SUBDEVICE_FLAGS GpuSubDeviceFlagList[] = {
    { 0x2331, 0x10de, 0x1798, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2331, 0x10de, 0x17f0, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2331, 0x10de, 0x1844, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x206e, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x206f, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2070, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2071, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2072, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2073, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2074, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2075, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2076, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2077, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2078, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x2079, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x207a, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x207b, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x207e, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2335, 0x10de, 0x207f, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2337, 0x10de, 0x18f2, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2337, 0x10de, 0x18f3, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2337, 0x10de, 0x18f4, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
@@ -2392,6 +2409,22 @@ static const GPU_SUBDEVICE_FLAGS GpuSubDeviceFlagList[] = {
    { 0x233a, 0x10de, 0x186c, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x233a, 0x10de, 0x186d, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x233a, 0x10de, 0x186e, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2081, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2082, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2083, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2084, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2085, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2086, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2087, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2088, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2089, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x208a, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x208b, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x208c, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x208d, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x208e, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x208f, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x233b, 0x10de, 0x2090, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2342, 0x10de, 0x18c2, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2342, 0x10de, 0x18c3, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2342, 0x10de, 0x18c4, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
@@ -2400,6 +2433,14 @@ static const GPU_SUBDEVICE_FLAGS GpuSubDeviceFlagList[] = {
    { 0x2342, 0x10de, 0x18c7, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2342, 0x10de, 0x18c8, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x2342, 0x10de, 0x18c9, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2348, 0x10de, 0x20c2, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2348, 0x10de, 0x20c3, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2348, 0x10de, 0x20c4, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2348, 0x10de, 0x20c5, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2348, 0x10de, 0x20c6, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2348, 0x10de, 0x20c7, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2348, 0x10de, 0x20c8, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
+    { 0x2348, 0x10de, 0x20c9, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x25b6, 0x10de, 0x159d, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x25b6, 0x10de, 0x159e, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE },
    { 0x25b6, 0x10de, 0x159f, GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE },
--- a/nvidia-installer.c
+++ b/nvidia-installer.c
@@ -49,6 +49,7 @@

 static void print_version(void);
 static void print_help(const char* name, int is_uninstall, int advanced);
+static void print_module_type(char module_type);



@@ -184,6 +185,33 @@ static int assign_file_type_override(Options *op, char *optarg)
    return TRUE;
 }

+static void print_module_type(char module_type)
+{
+    switch (module_type) {
+        case PROPRIETARY:
+            nv_info_msg(NULL, "proprietary");
+            break;
+        case OPEN:
+            nv_info_msg(NULL, "open");
+            break;
+    }
+}
+
+static int print_recommended_module_type_option(Options *op)
+{
+    int num_types;
+    struct module_type_info info;
+
+    num_types = valid_kernel_module_types(op, &info, TRUE);
+
+    if (num_types <= 0) {
+        ui_error(op, "Unable to determine recommended module type.");
+        return FALSE;
+    }
+
+    print_module_type(info.types[info.default_entry]);
+    return TRUE;
+}

 /*
 * parse_commandline() - Populate the Options structure with
@@ -198,6 +226,7 @@ static void parse_commandline(int argc, char *argv[], Options *op)
 {
    int c;
    int print_help_after = FALSE;
+    int print_recommended_kernel_module_after = FALSE;
    int print_help_args_only_after = FALSE;
    int print_advanced_help = FALSE;
    char *strval = NULL, *program_name = NULL;
@@ -533,6 +562,9 @@ static void parse_commandline(int argc, char *argv[], Options *op)
                goto fail;
            }
            break;
+        case PRINT_RECOMMENDED_MODULE_TYPE_OPTION:
+            print_recommended_kernel_module_after = TRUE;
+            break;
        case ALLOW_INSTALLATION_WITH_RUNNING_DRIVER_OPTION:
            op->allow_installation_with_running_driver = boolval;
            break;
@@ -543,6 +575,9 @@ static void parse_commandline(int argc, char *argv[], Options *op)
        case GBM_BACKEND_DIR_OPTION:
            op->gbm_backend_dir = strval;
            break;
+        case GBM_BACKEND_DIR32_OPTION:
+            op->compat32_gbm_backend_dir = strval;
+            break;
        default:
            goto fail;
        }
@@ -566,6 +601,12 @@ static void parse_commandline(int argc, char *argv[], Options *op)
        exit(0);
    }

+    if (print_recommended_kernel_module_after) {
+        if (!print_recommended_module_type_option(op)) {
+            goto fail;
+        }
+        exit(0);
+    }

    /*
     * if the installer prefix was not specified, default it to the
--- a/nvidia-installer.h
+++ b/nvidia-installer.h
@@ -164,6 +164,7 @@ typedef enum {
    FILE_TYPE_GBM_BACKEND_LIB_SYMLINK,
    FILE_TYPE_OPENGL_DATA,
    FILE_TYPE_VULKANSC_ICD_JSON,
+    FILE_TYPE_SANDBOXUTILS_FILELIST_JSON,
    FILE_TYPE_MAX
 } PackageEntryFileType;

@@ -253,6 +254,7 @@ typedef struct __options {
    char *compat32_chroot;
    char *compat32_prefix;
    char *compat32_libdir;
+    char *compat32_gbm_backend_dir;

    char *utility_prefix;
    char *utility_libdir;
--- a/option_table.h
+++ b/option_table.h
@@ -117,8 +117,10 @@ enum {
    SYSTEMD_SLEEP_PREFIX_OPTION,
    SYSTEMD_SYSCONF_PREFIX_OPTION,
    GBM_BACKEND_DIR_OPTION,
+    GBM_BACKEND_DIR32_OPTION,
    ALLOW_INSTALLATION_WITH_RUNNING_DRIVER_OPTION,
    REBUILD_INITRAMFS_OPTION,
+    PRINT_RECOMMENDED_MODULE_TYPE_OPTION,
 };

 static const NVGetoptOption __options[] = {
@@ -308,11 +310,19 @@ static const NVGetoptOption __options[] = {
    { "gbm-backend-dir", GBM_BACKEND_DIR_OPTION, NVGETOPT_STRING_ARGUMENT, NULL,
      "The path relative to the OpenGL library installation prefix under "
      "which the NVIDIA GBM backend library will be installed.  The "
-      "default is '$libdir/gbm', where '$libdir' is '" DEFAULT_64BIT_LIBDIR
+      "default is '<libdir>/gbm', where '<libdir>' is '" DEFAULT_64BIT_LIBDIR
      "' or '" DEFAULT_LIBDIR "', depending on the installed Linux "
      "distribution.  Only under very rare circumstances should this option be "
      "used." },

+    { "gbm-backend-dir32", GBM_BACKEND_DIR32_OPTION, NVGETOPT_STRING_ARGUMENT, NULL,
+      "The path relative to the 32-bit OpenGL library installation prefix under "
+      "which the 32-bit NVIDIA GBM backend library will be installed.  The "
+      "default is '<libdir>/gbm', where <libdir>' is '" DEFAULT_LIBDIR
+      "' or '" DEFAULT_32BIT_LIBDIR "', depending on the installed Linux "
+      "distribution.  Only under very rare circumstances should this option be "
+      "used." },
+
    { "documentation-prefix", DOCUMENTATION_PREFIX_OPTION,
      NVGETOPT_STRING_ARGUMENT,  NULL,
      "The prefix under which the documentation files for the NVIDIA "
@@ -728,6 +738,13 @@ static const NVGetoptOption __options[] = {
      "instead."
    },

+    { "print-recommended-kernel-module-type",
+      PRINT_RECOMMENDED_MODULE_TYPE_OPTION,  0, NULL,
+      "Print if \"open\" or \"proprietary\" modules should be used based on "
+      "currently attached GPUs and exit. NOTE: A kernel module type may be "
+      "recommended even if it is not included in this driver package."
+    },
+
    { "allow-installation-with-running-driver",
      ALLOW_INSTALLATION_WITH_RUNNING_DRIVER_OPTION, NVGETOPT_IS_BOOLEAN, NULL,
      "Proceed with installation even if an NVIDIA driver is already installed "
--- a/utils.mk
+++ b/utils.mk
@@ -541,6 +541,8 @@ NVIDSTRING = $(OUTPUTDIR)/g_nvid_string.c

 ifeq ($(DEBUG),1)
  NVIDSTRING_BUILD_TYPE_STRING = Debug Build
+else ifeq ($(DEVELOP),1)
+  NVIDSTRING_BUILD_TYPE_STRING = Develop Build
 else
  NVIDSTRING_BUILD_TYPE_STRING = Release Build
 endif
--- a/version.mk
+++ b/version.mk
@@ -1,4 +1,4 @@
-NVIDIA_VERSION = 565.77
+NVIDIA_VERSION = 570.86.16

 # This file.
 VERSION_MK_FILE := $(lastword $(MAKEFILE_LIST))