595.80

Author: mmaneetsingh

README.md

@@ -1,7 +1,7 @@
 # NVIDIA Linux Open GPU Kernel Module Source
 
 This is the source release of the NVIDIA Linux open GPU kernel modules,
-version 595.71.05.
+version 595.80.
 
 
 ## How to Build
@@ -17,7 +17,7 @@ as root:
 
 Note that the kernel modules built here must be used with GSP
 firmware and user-space NVIDIA GPU driver components from a corresponding
-595.71.05 driver release.  This can be achieved by installing
+595.80 driver release.  This can be achieved by installing
 the NVIDIA GPU driver from the .run file using the `--no-kernel-modules`
 option.  E.g.,
 
@@ -185,7 +185,7 @@ table below).
 For details on feature support and limitations, see the NVIDIA GPU driver
 end user README here:
 
-https://us.download.nvidia.com/XFree86/Linux-x86_64/595.71.05/README/kernel_open.html
+https://us.download.nvidia.com/XFree86/Linux-x86_64/595.80/README/kernel_open.html
 
 For vGPU support, please refer to the README.vgpu packaged in the vGPU Host
 Package for more details.
@@ -1020,6 +1020,7 @@ Subsystem Device ID.
 | NVIDIA RTX PRO 500 Blackwell Embedded GPU               | 2DF9           |
 | NVIDIA GB10                                             | 2E12 10DE 21EC |
 | NVIDIA GeForce RTX 5070                                 | 2F04           |
+| NVIDIA GeForce RTX 5060                                 | 2F06           |
 | NVIDIA GeForce RTX 5070 Ti Laptop GPU                   | 2F18           |
 | NVIDIA RTX PRO 3000 Blackwell Generation Laptop GPU     | 2F38           |
 | NVIDIA GeForce RTX 5070 Ti Laptop GPU                   | 2F58           |

kernel-open/Kbuild

@@ -79,7 +79,7 @@ ccflags-y += -I$(src)/common/inc
 ccflags-y += -I$(src)
 ccflags-y += -Wall $(DEFINES) $(INCLUDES) -Wno-cast-qual -Wno-format-extra-args
 ccflags-y += -D__KERNEL__ -DMODULE -DNVRM
-ccflags-y += -DNV_VERSION_STRING=\"595.71.05\"
+ccflags-y += -DNV_VERSION_STRING=\"595.80\"
 
 # Include and link Tegra out-of-tree modules.
 ifneq ($(wildcard /usr/src/nvidia/nvidia-public),)

kernel-open/common/inc/nv-proto.h

@@ -49,6 +49,7 @@ void        nv_revoke_gpu_mappings_locked(nv_state_t *);
 
 NvUPtr      nv_vm_map_pages             (struct page **, NvU32, NvBool, NvBool);
 void        nv_vm_unmap_pages           (NvUPtr, NvU32);
+NvU64       nv_get_reclaimable_memory_usage(void);
 
 NV_STATUS   nv_alloc_contig_pages       (nv_state_t *, nv_alloc_t *);
 void        nv_free_contig_pages        (nv_alloc_t *);

kernel-open/common/inc/nv.h

@@ -359,7 +359,7 @@ typedef struct nv_event_s
     NvU16               info16;
     nv_file_private_t  *nvfp;  /* per file-descriptor data pointer */
     NvU32               fd;
-    NvBool              active; /* whether the event should be signaled */
+    PORT_ATOMIC NvS32   active; /* whether the event should be signaled */
     NvU32               refcount; /* count of associated RM events */
     struct nv_event_s  *next;
 } nv_event_t;

kernel-open/common/inc/os-interface.h

@@ -224,6 +224,7 @@ enum os_pci_req_atomics_type {
 };
 NV_STATUS   NV_API_CALL  os_enable_pci_req_atomics   (void *, enum os_pci_req_atomics_type);
 void        NV_API_CALL  os_pci_trigger_flr(void *handle);
+NvU64       NV_API_CALL  os_get_reclaimable_memory_usage(void);
 NV_STATUS   NV_API_CALL  os_get_numa_node_memory_usage (NvS32, NvU64 *, NvU64 *);
 NV_STATUS   NV_API_CALL  os_numa_add_gpu_memory      (void *, NvU64, NvU64, NvU32 *);
 NV_STATUS   NV_API_CALL  os_numa_remove_gpu_memory   (void *, NvU64, NvU64, NvU32); 

kernel-open/conftest.sh

@@ -5085,6 +5085,25 @@ compile_test() {
             compile_check_conftest "$CODE" "NV_SHRINKER_ALLOC_PRESENT" "" "functions"
         ;;
 
+        nr_kernel_misc_reclaimable)
+            #
+            # Determine if NR_KERNEL_MISC_RECLAIMABLE is present in
+            # enum node_stat_item.
+            #
+            # Added by commit a4a33ef5657a ("mm: add NR_KERNEL_MISC_RECLAIMABLE
+            # node stat for misc reclaimable kernel memory") in v5.9.
+            #
+            CODE="
+            #include <linux/mmzone.h>
+
+            void conftest_nr_kernel_misc_reclaimable(void) {
+                enum node_stat_item x = NR_KERNEL_MISC_RECLAIMABLE;
+                (void)x;
+            }"
+
+            compile_check_conftest "$CODE" "NV_NR_KERNEL_MISC_RECLAIMABLE_PRESENT" "" "types"
+        ;;
+
         memory_device_coherent_present)
             #
             # Determine if MEMORY_DEVICE_COHERENT support is present or not
@@ -5138,6 +5157,22 @@ compile_test() {
             compile_check_conftest "$CODE" "NV_IS_VMA_WRITE_LOCKED_HAS_MM_LOCK_SEQ_ARG" "" "types"
         ;;
 
+        drm_atomic_commit_struct_present)
+            #
+            # Determine if 'struct drm_atomic_state' has been renamed to
+            # 'struct drm_atomic_commit'.
+            #
+            # Renamed by commit 5164f7e7ff8e ("drm: Rename struct
+            # drm_atomic_state to drm_atomic_commit"), expected in Linux v7.2.
+            #
+            CODE="
+            #include <drm/drm_atomic.h>
+
+            struct drm_atomic_commit state;"
+
+            compile_check_conftest "$CODE" "NV_DRM_ATOMIC_COMMIT_STRUCT_PRESENT" "" "types"
+        ;;
+
         # When adding a new conftest entry, please use the correct format for
         # specifying the relevant upstream Linux kernel commit.  Please
         # avoid specifying -rc kernels, and only use SHAs that actually exist

kernel-open/nvidia-uvm/uvm_pmm_gpu.c

@@ -3062,10 +3062,12 @@ static void devmem_page_free(struct page *page)
                                  &gpu->pmm.root_chunks.va_block_lazy_free_q_item);
 }
 
+#if defined(NV_PAGEMAP_OPS_HAS_FOLIO_FREE)
 static void devmem_folio_free(struct folio *folio)
 {
     devmem_page_free(&folio->page);
 }
+#endif
 
 // This is called by HMM when the CPU faults on a ZONE_DEVICE private entry.
 static vm_fault_t devmem_fault(struct vm_fault *vmf)
@@ -3279,22 +3281,26 @@ static void device_p2p_page_free(struct page *page)
     nv_kref_put(&p2p_mem->refcount, device_p2p_page_free_wake);
 }
 
+#if defined(NV_PAGEMAP_OPS_HAS_FOLIO_FREE)
 static void device_p2p_folio_free(struct folio *folio)
 {
     device_p2p_page_free(&folio->page);
 }
 #endif
+#endif
 
 #if UVM_CDMM_PAGES_SUPPORTED()
 static void device_coherent_page_free(struct page *page)
 {
     device_p2p_page_free(page);
 }
 
+#if defined(NV_PAGEMAP_OPS_HAS_FOLIO_FREE)
 static void device_coherent_folio_free(struct folio *folio)
 {
     device_p2p_page_free(&folio->page);
 }
+#endif
 
 static const struct dev_pagemap_ops uvm_device_coherent_pgmap_ops =
 {

kernel-open/nvidia/nv-pci.c

@@ -78,7 +78,6 @@
 #include <linux/pci-ats.h>
 #endif
 
-extern int NVreg_GrdmaPciTopoCheckOverride;
 extern int NVreg_ExcludeAllGpus;
 
 static void
@@ -1485,6 +1484,14 @@ nv_pci_tegra_devfreq_remove(struct nv_pci_tegra_devfreq_dev *tdev)
     struct thermal_zone_device *tzdev;
 #endif
 
+#if defined(NV_UPDATE_DEVFREQ_PRESENT)
+    if (tdev->boost_enabled)
+    {
+        tdev->boost_enabled = 0;
+        cancel_delayed_work_sync(&tdev->boost_disable);
+    }
+#endif
+
     if (tdev->devfreq != NULL)
     {
 #if NV_HAS_COOLING_SUPPORTED
@@ -1499,8 +1506,8 @@ nv_pci_tegra_devfreq_remove(struct nv_pci_tegra_devfreq_dev *tdev)
             thermal_unbind_cdev_from_trip(tzdev, data->passive_trip, tdev->devfreq->cdev);
         }
 #endif
-        devm_devfreq_remove_device(&tdev->dev, tdev->devfreq);
         nv_pci_tegra_devfreq_remove_opps(tdev);
+        devm_devfreq_remove_device(&tdev->dev, tdev->devfreq);
         tdev->devfreq = NULL;
     }
 
@@ -1539,7 +1546,7 @@ nv_pci_tegra_devfreq_remove(struct nv_pci_tegra_devfreq_dev *tdev)
 
     if (tdev->clk != NULL)
     {
-        devm_clk_put(tdev->dev.parent, tptr->clk);
+        devm_clk_put(tdev->dev.parent, tdev->clk);
         tdev->clk = NULL;
         device_unregister(&tdev->dev);
     }
@@ -2660,7 +2667,9 @@ nv_pci_count_devices(void)
 /*
  * On coherent platforms that support BAR1 mappings for GPUDirect RDMA,
  * dma-buf and nv-p2p subsystems need to ensure the 2 devices belong to
- * the same IOMMU group.
+ * the same IOMMU group. If the importer device doesn't have an IOMMU
+ * group assigned, at least check if the GPU and importer are under the same
+ * root port.
  */
 NvBool nv_pci_is_valid_topology_for_direct_pci(
     nv_state_t     *nv,
@@ -2675,7 +2684,13 @@ NvBool nv_pci_is_valid_topology_for_direct_pci(
         return NV_FALSE;
     }
 
-    return (pdev0->dev.iommu_group == pdev1->dev.iommu_group);
+    if (pdev0->dev.iommu_group == pdev1->dev.iommu_group)
+        return NV_TRUE;
+
+    if (pdev1->dev.iommu_group == NULL)
+        return nv_pci_has_common_pci_switch(nv, peer);
+
+    return NV_FALSE;
 }
 
 NvBool nv_pci_has_common_pci_switch(
@@ -2719,16 +2734,6 @@ NvBool NV_API_CALL nv_grdma_pci_topology_supported(
         return NV_TRUE;
     }
 
-    switch (NVreg_GrdmaPciTopoCheckOverride)
-    {
-        case NV_REG_GRDMA_PCI_TOPO_CHECK_OVERRIDE_ALLOW_ACCESS:
-            return NV_TRUE;
-        case NV_REG_GRDMA_PCI_TOPO_CHECK_OVERRIDE_DENY_ACCESS:
-            return NV_FALSE;
-        default:
-            break;
-    }
-
     // Allow RDMA by default on passthrough VMs.
     if ((nv->flags & NV_FLAG_PASSTHRU) != 0)
         return NV_TRUE;

kernel-open/nvidia/nv-reg.h

@@ -975,25 +975,6 @@
 #define __NV_CREATE_IMEX_CHANNEL_0 CreateImexChannel0
 #define NV_CREATE_IMEX_CHANNEL_0 NV_REG_STRING(__CREATE_IMEX_CHANNEL_0)
 
-/*
- * Option: NVreg_GrdmaPciTopoCheckOverride
- *
- * Description:
- *
- * This option allows users to override the PCI topology validation enforced by
- * the GPU driver's dma-buf and nv-p2p subsystems.
- *
- * Possible values:
- * 0 - Driver's topology check to allow or deny access (default).
- * 1 - Override driver's topology check to allow access.
- * 2 - Override driver's topology check to deny access.
- */
-#define __NV_GRDMA_PCI_TOPO_CHECK_OVERRIDE GrdmaPciTopoCheckOverride
-#define NV_GRDMA_PCI_TOPO_CHECK_OVERRIDE NV_REG_STRING(__NV_GRDMA_PCI_TOPO_CHECK_OVERRIDE)
-#define NV_REG_GRDMA_PCI_TOPO_CHECK_OVERRIDE_DEFAULT       0
-#define NV_REG_GRDMA_PCI_TOPO_CHECK_OVERRIDE_ALLOW_ACCESS  1
-#define NV_REG_GRDMA_PCI_TOPO_CHECK_OVERRIDE_DENY_ACCESS   2
-
 /*
  * Option: NVreg_EnableSystemMemoryPools
  *
@@ -1084,8 +1065,6 @@ NV_DEFINE_REG_STRING_ENTRY(__NV_RM_NVLINK_BW, NULL);
 NV_DEFINE_REG_ENTRY(__NV_RM_NVLINK_BW_LINK_COUNT, 0);
 NV_DEFINE_REG_ENTRY_GLOBAL(__NV_IMEX_CHANNEL_COUNT, 2048);
 NV_DEFINE_REG_ENTRY_GLOBAL(__NV_CREATE_IMEX_CHANNEL_0, 0);
-NV_DEFINE_REG_ENTRY_GLOBAL(__NV_GRDMA_PCI_TOPO_CHECK_OVERRIDE,
-                           NV_REG_GRDMA_PCI_TOPO_CHECK_OVERRIDE_DEFAULT);
 NV_DEFINE_REG_ENTRY_GLOBAL(__NV_ENABLE_SYSTEM_MEMORY_POOLS, NV_ENABLE_SYSTEM_MEMORY_POOLS_DEFAULT);
 NV_DEFINE_REG_ENTRY_GLOBAL(__NV_USE_KERNEL_SUSPEND_NOTIFIERS, 0);
 
@@ -1138,7 +1117,6 @@ nv_parm_t nv_parms[] = {
     NV_DEFINE_PARAMS_TABLE_ENTRY(__NV_DMA_REMAP_PEER_MMIO),
     NV_DEFINE_PARAMS_TABLE_ENTRY(__NV_IMEX_CHANNEL_COUNT),
     NV_DEFINE_PARAMS_TABLE_ENTRY(__NV_CREATE_IMEX_CHANNEL_0),
-    NV_DEFINE_PARAMS_TABLE_ENTRY(__NV_GRDMA_PCI_TOPO_CHECK_OVERRIDE),
     NV_DEFINE_PARAMS_TABLE_ENTRY(__NV_ENABLE_SYSTEM_MEMORY_POOLS),
     {NULL, NULL}
 };

kernel-open/nvidia/nv-vm.c

@@ -464,6 +464,20 @@ static void nv_mem_pool_shrinker_register(nv_page_pool_t *mem_pool, struct shrin
 }
 #endif // NV_SHRINKER_ALLOC_PRESENT
 
+// Pages in the pool are reclaimable non-slab kernel memory.  Tracking them
+// with NR_KERNEL_MISC_RECLAIMABLE lets si_mem_available() include them in
+// MemAvailable (/proc/meminfo), giving the kernel an accurate picture of how
+// much memory can be recovered under pressure via the registered shrinker.
+static void nv_mem_pool_mod_misc_reclaimable(nv_page_pool_t *mem_pool, long delta_compound_pages)
+{
+#if defined(NV_NR_KERNEL_MISC_RECLAIMABLE_PRESENT)
+    if (delta_compound_pages != 0)
+        mod_node_page_state(NODE_DATA(mem_pool->node_id),
+                            NR_KERNEL_MISC_RECLAIMABLE,
+                            delta_compound_pages << mem_pool->order);
+#endif
+}
+
 static unsigned long
 nv_mem_pool_move_pages
 (
@@ -561,6 +575,8 @@ nv_mem_pool_shrinker_scan
     mem_pool->pages_owned -= pages_freed;
     os_release_mutex(mem_pool->lock);
 
+    nv_mem_pool_mod_misc_reclaimable(mem_pool, -(long)pages_freed);
+
     nv_mem_pool_free_page_list(&reclaim_list, mem_pool->order);
 
     nv_printf(NV_DBG_MEMINFO, "NVRM: VM: %s: node=%d order=%u: %lu/%lu pages freed\n",
@@ -619,6 +635,8 @@ nv_mem_pool_alloc_pages
     pages_owned = mem_pool->pages_owned;
     os_release_mutex(mem_pool->lock);
 
+    nv_mem_pool_mod_misc_reclaimable(mem_pool, -(long)pages_allocated);
+
     while ((pool_entry = NV_MEM_POOL_LIST_HEAD(&alloc_clean_pages)))
     {
         nv_alloc_set_page(at, i, pool_entry->virt_addr);
@@ -691,9 +709,12 @@ void
 nv_mem_pool_destroy(nv_page_pool_t *mem_pool)
 {
     NV_STATUS status;
+    unsigned long saved_pages_owned;
 
     status = os_acquire_mutex(mem_pool->lock);
     WARN_ON(status != NV_OK);
+    // Snapshot before freeing: counts dirty + in-flight + clean pages.
+    saved_pages_owned = mem_pool->pages_owned;
     nv_mem_pool_free_page_list(&mem_pool->dirty_list, mem_pool->order);
     os_release_mutex(mem_pool->lock);
 
@@ -706,6 +727,8 @@ nv_mem_pool_destroy(nv_page_pool_t *mem_pool)
     nv_mem_pool_free_page_list(&mem_pool->clean_list, mem_pool->order);
     os_release_mutex(mem_pool->lock);
 
+    nv_mem_pool_mod_misc_reclaimable(mem_pool, -(long)saved_pages_owned);
+
     nv_mem_pool_shrinker_free(mem_pool);
 
     os_free_mutex(mem_pool->lock);
@@ -832,8 +855,12 @@ nv_mem_pool_free_pages
     pages_owned = mem_pool->pages_owned;
     os_release_mutex(mem_pool->lock);
 
-    nv_printf(NV_DBG_MEMINFO, "NVRM: VM: %s: node=%d order=%u: %lu/%lu pages added to pool (%lu now in pool)\n",
-              __FUNCTION__, mem_pool->node_id, mem_pool->order, num_added_pages, num_pages, pages_owned);
+    nv_mem_pool_mod_misc_reclaimable(mem_pool, (long)num_added_pages);
+
+    nv_printf(NV_DBG_MEMINFO, "NVRM: VM: %s: at = %lx, at->order = %u, at->num_pages = %u, \
+                pool_order = %u: %lu/%lu pages added to pool (%lu now in pool)\n", \
+              __FUNCTION__, (long int) at, at->order, at->num_pages, mem_pool->order, \
+              num_added_pages, num_pages, pages_owned);
 
     if (queue_worker)
     {
@@ -1122,6 +1149,35 @@ static NvUPtr nv_vmap(struct page **pages, NvU32 page_count,
     return (NvUPtr)ptr;
 }
 
+NvU64 nv_get_reclaimable_memory_usage(void)
+{
+    int node_id;
+    unsigned int order;
+    NvU64 reclaimable_memory_bytes = 0;
+
+    for_each_node(node_id)
+    {
+        for (order = 0; order <= NV_MAX_PAGE_ORDER; order++)
+        {
+            if (sysmem_page_pools[node_id][order])
+            {
+                nv_printf(NV_DBG_MEMINFO, "NVRM: VM: %s: node_id = %u, pool_order = %u: %lu pages in pool\n", \
+                    __FUNCTION__, node_id, sysmem_page_pools[node_id][order]->order, \
+                    sysmem_page_pools[node_id][order]->pages_owned);
+
+                reclaimable_memory_bytes += (sysmem_page_pools[node_id][order]->pages_owned \
+                                                << sysmem_page_pools[node_id][order]->order) \
+                                                * PAGE_SIZE;
+
+                nv_printf(NV_DBG_MEMINFO, "NVRM: VM: %s: reclaimable_memory_bytes = %d\n", \
+                                            __FUNCTION__, reclaimable_memory_bytes);
+            }
+        }
+    }
+
+    return reclaimable_memory_bytes;
+}
+
 static void nv_vunmap(NvUPtr vaddr, NvU32 page_count)
 {
     vunmap((void *)vaddr);