diff -ru usr/src/nv/Makefile.kbuild usr/src/nv.2305230/Makefile.kbuild
--- usr/src/nv/Makefile.kbuild 2008-01-21 11:48:11.000000000 -0800
+++ usr/src/nv.2305230/Makefile.kbuild 2008-03-18 12:55:25.461856977 -0700
@@ -176,6 +176,7 @@
vmap \
signal_struct \
agp_backend_acquire \
+ set_pages_uc \
change_page_attr \
pci_get_class \
sysctl_max_map_count \
diff -ru usr/src/nv/conftest.sh usr/src/nv.2305230/conftest.sh
--- usr/src/nv/conftest.sh 2008-01-21 11:48:11.000000000 -0800
+++ usr/src/nv.2305230/conftest.sh 2008-03-18 12:55:28.782046180 -0700
@@ -100,6 +100,32 @@
fi
;;
+ set_pages_uc)
+ #
+ # Determine if the set_pages_uc() function is present.
+ #
+ echo "#include <linux/autoconf.h>
+ #include <asm/cacheflush.h>
+ void conftest_set_pages_uc(void) {
+ set_pages_uc();
+ }" > conftest$$.c
+
+ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1
+ rm -f conftest$$.c
+
+ if [ -f conftest$$.o ]; then
+ rm -f conftest$$.o
+ echo "#undef NV_SET_PAGES_UC_PRESENT" >> conftest.h
+ return
+ else
+ echo "#ifdef NV_CHANGE_PAGE_ATTR_PRESENT" >> conftest.h
+ echo "#undef NV_CHANGE_PAGE_ATTR_PRESENT" >> conftest.h
+ echo "#endif" >> conftest.h
+ echo "#define NV_SET_PAGES_UC_PRESENT" >> conftest.h
+ return
+ fi
+ ;;
+
change_page_attr)
#
# Determine if the change_page_attr() function is
@@ -124,7 +150,9 @@
rm -f conftest$$.o
return
else
+ echo "#ifndef NV_SET_PAGES_UC_PRESENT" >> conftest.h
echo "#define NV_CHANGE_PAGE_ATTR_PRESENT" >> conftest.h
+ echo "#endif" >> conftest.h
return
fi
;;
@@ -501,6 +529,8 @@
return
fi
+ rm -f conftest$$.o
+
echo "#include <linux/autoconf.h>
#include <linux/interrupt.h>
irq_handler_t conftest_isr;
diff -ru usr/src/nv/nv-linux.h usr/src/nv.2305230/nv-linux.h
--- usr/src/nv/nv-linux.h 2008-01-21 11:48:11.000000000 -0800
+++ usr/src/nv.2305230/nv-linux.h 2008-03-18 12:57:26.340745475 -0700
@@ -19,8 +19,8 @@
#include <linux/utsname.h>
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)
-# error This driver does not support pre-2.4 kernels!
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 7)
+# error This driver does not support 2.4 kernels older than 2.4.7!
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
# define KERNEL_2_4
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
@@ -51,6 +51,10 @@
#include <linux/modversions.h>
#endif
+#if defined(KERNEL_2_4) && !defined(EXPORT_SYMTAB)
+#define EXPORT_SYMTAB
+#endif
+
#include <linux/kernel.h>
#include <linux/module.h>
@@ -98,6 +102,7 @@
#include <linux/spinlock.h>
#include <asm/semaphore.h>
+#include <linux/completion.h>
#include <linux/highmem.h>
#ifdef CONFIG_PROC_FS
@@ -118,8 +123,12 @@
#endif
#if defined(CONFIG_KGDB)
+#if defined(NV_OLD_MM_KGDB_BREAKPOINT_PRESENT)
+#include <asm/kgdb.h>
+#else
#include <linux/kgdb.h>
#endif
+#endif
#if defined (CONFIG_AGP) || defined (CONFIG_AGP_MODULE)
#define AGPGART
@@ -516,19 +525,16 @@
#define NV_KMEM_CACHE_ALLOC(ptr, kmem_cache, type) \
{ \
(ptr) = kmem_cache_alloc(kmem_cache, GFP_KERNEL); \
- KM_ALLOC_RECORD(ptr, sizeof(type), "km_cache_alloc"); \
}
#define NV_KMEM_CACHE_FREE(ptr, type, kmem_cache) \
{ \
- KM_FREE_RECORD(ptr, sizeof(type), "km_cache_free"); \
kmem_cache_free(kmem_cache, ptr); \
}
-#if defined(NV_SG_MAP_BUFFERS) /* Linux/x86-64, only */
#if defined(NV_VMAP_PRESENT)
#if (NV_VMAP_ARGUMENT_COUNT == 2)
-#define NV_VMAP(ptr, pages, count, cached) \
+#define NV_VMAP_KERNEL(ptr, pages, count, prot) \
{ \
(ptr) = (unsigned long)vmap(pages, count); \
VM_ALLOC_RECORD((void *)ptr, (count) * PAGE_SIZE, "vm_vmap"); \
@@ -537,26 +543,35 @@
#ifndef VM_MAP
#define VM_MAP 0
#endif
-#define NV_VMAP(ptr, pages, count, cached) \
+#define NV_VMAP_KERNEL(ptr, pages, count, prot) \
{ \
- pgprot_t __prot = (cached) ? PAGE_KERNEL : PAGE_KERNEL_NOCACHE; \
- (ptr) = (unsigned long)vmap(pages, count, VM_MAP, __prot); \
+ (ptr) = (unsigned long)vmap(pages, count, VM_MAP, prot); \
VM_ALLOC_RECORD((void *)ptr, (count) * PAGE_SIZE, "vm_vmap"); \
}
#else
#error "NV_VMAP_ARGUMENT_COUNT value unrecognized!"
#endif
#else
+#if defined(NV_SG_MAP_BUFFERS)
#error "NV_VMAP() undefined (vmap() unavailable)!"
+#endif
#endif /* NV_VMAP_PRESENT */
-#define NV_VUNMAP(ptr, count) \
+#define NV_VUNMAP_KERNEL(ptr, count) \
{ \
- VM_FREE_RECORD((void *)ptr, (count) * PAGE_SIZE, "vm_vmap"); \
+ VM_FREE_RECORD((void *)ptr, (count) * PAGE_SIZE, "vm_vunmap"); \
vunmap((void *)(ptr)); \
}
-#endif /* NV_SG_MAP_BUFFERS */
+#define NV_VMAP(addr, pages, count, cached) \
+ { \
+ pgprot_t __prot = (cached) ? PAGE_KERNEL : PAGE_KERNEL_NOCACHE; \
+ void *__ptr = nv_vmap(pages, count, __prot); \
+ (addr) = (unsigned long)__ptr; \
+ }
+
+#define NV_VUNMAP(addr, count) nv_vunmap((void *)addr, count)
+
#endif /* !defined NVWATCH */
@@ -764,9 +779,10 @@
#define NV_PGD_OFFSET(address, kernel, mm) \
({ \
+ struct mm_struct *__mm = (mm); \
pgd_t *__pgd; \
if (!kernel) \
- __pgd = pgd_offset(mm, address); \
+ __pgd = pgd_offset(__mm, address); \
else \
__pgd = pgd_offset_k(address); \
__pgd; \
@@ -968,9 +984,7 @@
#define NV_ALLOC_TYPE_PCI (1<<0)
#define NV_ALLOC_TYPE_AGP (1<<1)
#define NV_ALLOC_TYPE_CONTIG (1<<2)
-#define NV_ALLOC_TYPE_KERNEL (1<<3)
-#define NV_ALLOC_TYPE_VMALLOC (1<<4)
-#define NV_ALLOC_TYPE_VMAP (1<<5)
+#define NV_ALLOC_TYPE_VMAP (1<<3)
#define NV_ALLOC_MAPPING_SHIFT 16
#define NV_ALLOC_MAPPING(flags) (((flags)>>NV_ALLOC_MAPPING_SHIFT)&0xff)
@@ -980,7 +994,6 @@
#define NV_ALLOC_MAPPING_AGP(flags) ((flags) & NV_ALLOC_TYPE_AGP)
#define NV_ALLOC_MAPPING_CONTIG(flags) ((flags) & NV_ALLOC_TYPE_CONTIG)
-#define NV_ALLOC_MAPPING_VMALLOC(flags) ((flags) & NV_ALLOC_TYPE_VMALLOC)
#define NV_ALLOC_MAPPING_VMAP(flags) ((flags) & NV_ALLOC_TYPE_VMAP)
static inline U032 nv_alloc_init_flags(int cached, int agp, int contig, int kernel)
@@ -988,12 +1001,7 @@
U032 flags = NV_ALLOC_ENC_MAPPING(cached);
if (agp) flags |= NV_ALLOC_TYPE_AGP;
else flags |= NV_ALLOC_TYPE_PCI;
- if (kernel) flags |= NV_ALLOC_TYPE_KERNEL;
-#if defined(NV_SG_MAP_BUFFERS)
if (kernel && !contig) flags |= NV_ALLOC_TYPE_VMAP;
-#else
- if (kernel && !contig) flags |= NV_ALLOC_TYPE_VMALLOC;
-#endif
if (contig && !agp) flags |= NV_ALLOC_TYPE_CONTIG;
return flags;
}
@@ -1067,21 +1075,24 @@
#define NV_ATOMIC_DEC_AND_TEST(data) atomic_dec_and_test(&(data))
#define NV_ATOMIC_READ(data) atomic_read(&(data))
+extern int nv_update_memory_types;
+
/*
- * a BUG() is triggered on early 2.6 x86_64 kernels. the underlying
- * problem actually exists on many architectures and kernels, but
- * these are the only kernels that check the condition and trigger
- * a BUG(). note that this is a problem of the core kernel, not an
- * nvidia bug (and can still be triggered by agpgart). let's avoid
- * change_page_attr on those kernels.
+ * Using change_page_attr() on early Linux/x86-64 2.6 kernels may
+ * result in a BUG() being triggered. The underlying problem
+ * actually exists on multiple architectures and kernels, but only
+ * the above check for the condition and trigger a BUG().
+ *
+ * Note that this is a due to a bug in the Linux kernel, not an
+ * NVIDIA driver bug (it can also be triggered by AGPGART).
+ *
+ * We therefore need to determine at runtime if change_page_attr()
+ * can be used safely on these kernels.
*/
-#if defined(NV_CHANGE_PAGE_ATTR_PRESENT)
-extern int nv_use_cpa;
-
-#if defined(NVCPU_X86_64) && !defined(KERNEL_2_4) && \
- (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11))
-#define NV_CHANGE_PAGE_ATTR_BUG_PRESENT 1
-#endif
+#if defined(NV_CHANGE_PAGE_ATTR_PRESENT) && defined(NVCPU_X86_64) && \
+ !defined(KERNEL_2_4) && \
+ (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11))
+#define NV_CHANGE_PAGE_ATTR_BUG_PRESENT
#endif
#if defined(NVCPU_X86) || defined(NVCPU_X86_64)
@@ -1093,7 +1104,7 @@
*
* We need to be careful to mask out _PAGE_NX when the host system
* doesn't support this feature or when it's disabled: the kernel
- * may not do this in its implementation of the change_page_attr()
+ * may not do this in its implementation of the change_page_attr()
* interface.
*/
#ifndef X86_FEATURE_NX
diff -ru usr/src/nv/nv-vm.c usr/src/nv.2305230/nv-vm.c
--- usr/src/nv/nv-vm.c 2008-01-21 11:48:11.000000000 -0800
+++ usr/src/nv.2305230/nv-vm.c 2008-03-18 12:55:58.755754293 -0700
@@ -43,42 +43,40 @@
}
#endif
-/*
- * AMD Athlon processors expose a subtle bug in the Linux
- * kernel, that may lead to AGP memory corruption. Recent
- * kernel versions had a workaround for this problem, but
- * 2.4.20 is the first kernel to address it properly. The
- * page_attr API provides the means to solve the problem.
- */
-
static inline void nv_set_page_attrib_uncached(nv_pte_t *page_ptr)
{
-#if defined(NV_CHANGE_PAGE_ATTR_PRESENT)
- if (nv_use_cpa)
+ if (nv_update_memory_types)
{
- struct page *page = virt_to_page(__va(page_ptr->phys_addr));
+#if defined(NV_SET_PAGES_UC_PRESENT)
+ struct page *page = NV_GET_PAGE_STRUCT(page_ptr->phys_addr);
+ set_pages_uc(page, 1);
+#elif defined(NV_CHANGE_PAGE_ATTR_PRESENT)
+ struct page *page = NV_GET_PAGE_STRUCT(page_ptr->phys_addr);
pgprot_t prot = PAGE_KERNEL_NOCACHE;
#if defined(NVCPU_X86) || defined(NVCPU_X86_64)
pgprot_val(prot) &= __nv_supported_pte_mask;
#endif
change_page_attr(page, 1, prot);
- }
#endif
+ }
}
static inline void nv_set_page_attrib_cached(nv_pte_t *page_ptr)
{
-#if defined(NV_CHANGE_PAGE_ATTR_PRESENT)
- if (nv_use_cpa)
+ if (nv_update_memory_types)
{
- struct page *page = virt_to_page(__va(page_ptr->phys_addr));
+#if defined(NV_SET_PAGES_UC_PRESENT)
+ struct page *page = NV_GET_PAGE_STRUCT(page_ptr->phys_addr);
+ set_pages_wb(page, 1);
+#elif defined(NV_CHANGE_PAGE_ATTR_PRESENT)
+ struct page *page = NV_GET_PAGE_STRUCT(page_ptr->phys_addr);
pgprot_t prot = PAGE_KERNEL;
#if defined(NVCPU_X86) || defined(NVCPU_X86_64)
pgprot_val(prot) &= __nv_supported_pte_mask;
#endif
change_page_attr(page, 1, prot);
+#endif
}
-#endif /* NV_CHANGE_PAGE_ATTR_PRESENT */
}
static inline void nv_lock_page(nv_pte_t *page_ptr)
@@ -360,8 +358,11 @@
#if defined(NV_CPA_NEEDS_FLUSHING)
nv_execute_on_all_cpus(cache_flush, NULL);
#endif
+#if (defined(NVCPU_X86) || defined(NVCPU_X86_64)) && \
+ defined(NV_CHANGE_PAGE_ATTR_PRESENT)
global_flush_tlb();
#endif
+#endif
}
/*
@@ -409,11 +410,11 @@
nv_pte_t *page_ptr = *at->page_table;
unsigned int i, j, gfp_mask;
unsigned long virt_addr = 0, phys_addr;
+ struct page **pages = 0;
#if defined(NV_SG_MAP_BUFFERS)
int ret = -1;
nv_linux_state_t *nvl = NV_GET_NVL_FROM_NV_STATE(nv);
struct pci_dev *dev = nvl->dev;
- struct page **pages = 0;
#endif
nv_printf(NV_DBG_MEMINFO, "NVRM: VM: nv_vm_malloc_pages: %d pages\n",
@@ -462,22 +463,7 @@
}
#endif
}
- else if (NV_ALLOC_MAPPING_VMALLOC(at->flags))
- {
- void *virt_kptr = NULL;
- at->size = at->num_pages * PAGE_SIZE;
- nv_printf(NV_DBG_MEMINFO, "NVRM: VM: vmalloc, size 0x%x\n", at->size);
- NV_VMALLOC(virt_kptr, at->size, NV_ALLOC_MAPPING_CACHED(at->flags));
- virt_addr = (unsigned long) virt_kptr;
- if (virt_addr == 0)
- {
- nv_printf(NV_DBG_ERRORS,
- "NVRM: nv_vm_malloc failed to allocate vmalloc memory\n");
- return -1;
- }
- }
-#if defined(NV_SG_MAP_BUFFERS)
if (NV_ALLOC_MAPPING_VMAP(at->flags))
{
NV_KMALLOC(pages, sizeof(struct page *) * at->num_pages);
@@ -488,11 +474,10 @@
return -1;
}
}
-#endif
for (i = 0; i < at->num_pages; i++)
{
- if (!NV_ALLOC_MAPPING_CONTIG(at->flags) && !NV_ALLOC_MAPPING_VMALLOC(at->flags))
+ if (!NV_ALLOC_MAPPING_CONTIG(at->flags))
{
NV_GET_FREE_PAGES(virt_addr, 0, gfp_mask);
if (virt_addr == 0)
@@ -553,10 +538,10 @@
}
}
nv_sg_load(&page_ptr->sg_list, page_ptr);
+#endif
if (NV_ALLOC_MAPPING_VMAP(at->flags))
pages[i] = NV_GET_PAGE_STRUCT(page_ptr->phys_addr);
-#endif
if (!NV_ALLOC_MAPPING_CACHED(at->flags))
nv_set_page_attrib_uncached(page_ptr);
@@ -565,41 +550,21 @@
virt_addr += PAGE_SIZE;
}
-#if defined(NV_SG_MAP_BUFFERS)
if (NV_ALLOC_MAPPING_VMAP(at->flags))
{
NV_VMAP(virt_addr, pages, at->num_pages, NV_ALLOC_MAPPING_CACHED(at->flags));
-#if defined(KERNEL_2_4)
- if (virt_addr != 0)
- {
- unsigned int i;
- /*
- * XXX Linux 2.4's vmap() increments the pages' reference counts
- * in preparation for vfree(); the latter skips the calls to
- * __free_page() if the pages are marked reserved, however, so
- * that the underlying memory is effectively leaked when we free
- * it later. Decrement the count here to avoid this leak.
- */
- for (i = 0; i < at->num_pages; i++)
- {
- if (PageReserved(pages[i]))
- atomic_dec(&pages[i]->count);
- }
- }
-#endif
- NV_KFREE((void *)pages, sizeof(struct page *) * at->num_pages);
if (virt_addr == 0)
{
nv_printf(NV_DBG_ERRORS,
"NVRM: VM: nv_vm_malloc_pages: failed to vmap pages\n");
goto failed;
}
+ NV_KFREE((void *)pages, sizeof(struct page *) * at->num_pages);
for (i = 0; i < at->num_pages; i++)
{
at->page_table[i]->virt_addr = virt_addr + i * PAGE_SIZE;
}
}
-#endif /* NV_SG_MAP_BUFFERS */
nv_vm_list_page_count(at->page_table, at->num_pages);
@@ -624,7 +589,7 @@
nv_sg_unmap_buffer(dev, &page_ptr->sg_list, page_ptr);
#endif
nv_unlock_page(page_ptr);
- if (!NV_ALLOC_MAPPING_CONTIG(at->flags) && !NV_ALLOC_MAPPING_VMALLOC(at->flags))
+ if (!NV_ALLOC_MAPPING_CONTIG(at->flags))
NV_FREE_PAGES(page_ptr->virt_addr, 0);
}
}
@@ -638,16 +603,9 @@
#endif
NV_FREE_PAGES(page_ptr->virt_addr, at->order);
}
- else if (NV_ALLOC_MAPPING_VMALLOC(at->flags))
- {
- page_ptr = *at->page_table;
- NV_VFREE((void *) page_ptr->virt_addr, at->size);
- }
-#if defined(NV_SG_MAP_BUFFERS)
if (NV_ALLOC_MAPPING_VMAP(at->flags) && pages != 0)
- NV_VFREE((void *)pages, sizeof(struct page *) * at->num_pages);
-#endif
+ NV_KFREE((void *)pages, sizeof(struct page *) * at->num_pages);
return -1;
}
@@ -674,19 +632,17 @@
}
nv_vm_list_page_count(at->page_table, at->num_pages);
-#if defined(NV_SG_MAP_BUFFERS)
if (NV_ALLOC_MAPPING_VMAP(at->flags))
NV_VUNMAP((void *)at->page_table[0]->virt_addr, at->num_pages); // undo vmap()
-#endif
for (i = 0; i < at->num_pages; i++)
{
page_ptr = at->page_table[i];
if (!NV_ALLOC_MAPPING_CACHED(at->flags))
nv_set_page_attrib_cached(page_ptr);
-#if defined(NV_SG_MAP_BUFFERS)
if (NV_ALLOC_MAPPING_VMAP(at->flags))
page_ptr->virt_addr = (unsigned long) __va(page_ptr->phys_addr);
+#if defined(NV_SG_MAP_BUFFERS)
if (!NV_ALLOC_MAPPING_CONTIG(at->flags))
nv_sg_unmap_buffer(dev, &page_ptr->sg_list, page_ptr);
#endif
@@ -701,7 +657,7 @@
}
}
nv_unlock_page(page_ptr);
- if (!NV_ALLOC_MAPPING_CONTIG(at->flags) && !NV_ALLOC_MAPPING_VMALLOC(at->flags))
+ if (!NV_ALLOC_MAPPING_CONTIG(at->flags))
NV_FREE_PAGES(page_ptr->virt_addr, 0);
}
nv_flush_caches();
@@ -714,9 +670,136 @@
#endif
NV_FREE_PAGES(page_ptr->virt_addr, at->order);
}
- else if (NV_ALLOC_MAPPING_VMALLOC(at->flags))
+}
+
+#if defined(NV_VMAP_PRESENT) && defined(KERNEL_2_4) && defined(NVCPU_X86)
+static unsigned long
+nv_vmap_vmalloc(
+ int count,
+ struct page **pages,
+ pgprot_t prot
+)
+{
+ void *virt_addr = NULL;
+ unsigned int i, size = count * PAGE_SIZE;
+
+ NV_VMALLOC(virt_addr, size, TRUE);
+ if (virt_addr == NULL)
+ {
+ nv_printf(NV_DBG_ERRORS,
+ "NVRM: vmalloc() failed to allocate vmap() scratch pages!\n");
+ return 0;
+ }
+
+ for (i = 0; i < (unsigned int)count; i++)
{
- page_ptr = *at->page_table;
- NV_VFREE((void *) page_ptr->virt_addr, at->size);
+ pgd_t *pgd = NULL;
+ pmd_t *pmd = NULL;
+ pte_t *pte = NULL;
+ unsigned long address;
+ struct page *page;
+
+ address = (unsigned long)virt_addr + i * PAGE_SIZE;
+
+ pgd = NV_PGD_OFFSET(address, 1, NULL);
+ if (!NV_PGD_PRESENT(pgd))
+ goto failed;
+
+ pmd = NV_PMD_OFFSET(address, pgd);
+ if (!NV_PMD_PRESENT(pmd))
+ goto failed;
+
+ pte = NV_PTE_OFFSET(address, pmd);
+ if (!NV_PTE_PRESENT(pte))
+ goto failed;
+
+ page = NV_GET_PAGE_STRUCT(pte_val(*pte) & PAGE_MASK);
+ get_page(pages[i]);
+ set_pte(pte, mk_pte(pages[i], prot));
+ put_page(page);
+ NV_PTE_UNMAP(pte);
+ }
+ nv_flush_caches();
+
+ return (unsigned long)virt_addr;
+
+failed:
+ NV_VFREE(virt_addr, size);
+
+ return 0;
+}
+
+static void
+nv_vunmap_vmalloc(
+ void *address,
+ int count
+)
+{
+ NV_VFREE(address, count * PAGE_SIZE);
+}
+#endif /* NV_VMAP_PRESENT && KERNEL_2_4 && NVCPU_X86 */
+
+void *nv_vmap(
+ struct page **pages,
+ int count,
+ pgprot_t prot
+)
+{
+ unsigned long virt_addr = 0;
+#if defined(NV_VMAP_PRESENT)
+#if defined(KERNEL_2_4) && defined(NVCPU_X86)
+ /*
+ * XXX Linux 2.4's vmap() checks the requested mapping's size against
+ * the value of (max_mapnr << PAGESHIFT); since 'map_nr' is a 32-bit
+ * symbol, the checks fails given enough physical memory. We can't solve
+ * this problem by adjusting the value of 'map_nr', but we can avoid
+ * vmap() by going through vmalloc().
+ */
+ if (max_mapnr >= 0x100000)
+ virt_addr = nv_vmap_vmalloc(count, pages, prot);
+ else
+#endif
+ NV_VMAP_KERNEL(virt_addr, pages, count, prot);
+#if defined(KERNEL_2_4)
+ if (virt_addr)
+ {
+ int i;
+ /*
+ * XXX Linux 2.4's vmap() increments the pages' reference counts
+ * in preparation for vfree(); the latter skips the calls to
+ * __free_page() if the pages are marked reserved, however, so
+ * that the underlying memory is effectively leaked when we free
+ * it later. Decrement the count here to avoid this leak.
+ */
+ for (i = 0; i < count; i++)
+ {
+ if (PageReserved(pages[i]))
+ atomic_dec(&pages[i]->count);
+ }
}
+#endif
+#endif /* NV_VMAP_PRESENT */
+ return (void *)virt_addr;
+}
+
+void nv_vunmap(
+ void *address,
+ int count
+)
+{
+#if defined(NV_VMAP_PRESENT)
+#if defined(KERNEL_2_4) && defined(NVCPU_X86)
+ /*
+ * XXX Linux 2.4's vmap() checks the requested mapping's size against
+ * the value of (max_mapnr << PAGESHIFT); since 'map_nr' is a 32-bit
+ * symbol, the checks fails given enough physical memory. We can't solve
+ * this problem by adjusting the value of 'map_nr', but we can avoid
+ * vmap() by going through vmalloc().
+ */
+ if (max_mapnr >= 0x100000)
+ nv_vunmap_vmalloc(address, count);
+ else
+#endif
+ NV_VUNMAP_KERNEL(address, count);
+#endif /* NV_VMAP_PRESENT */
}
diff -ru usr/src/nv/nv-vm.h usr/src/nv.2305230/nv-vm.h
--- usr/src/nv/nv-vm.h 2008-01-21 11:48:11.000000000 -0800
+++ usr/src/nv.2305230/nv-vm.h 2008-03-18 12:55:54.643519951 -0700
@@ -11,6 +11,9 @@
#ifndef _NV_VM_H_
#define _NV_VM_H_
+void * nv_vmap(struct page **, int, pgprot_t);
+void nv_vunmap(void *, int);
+
int nv_vm_malloc_pages(nv_state_t *, nv_alloc_t *);
void nv_vm_free_pages(nv_state_t *, nv_alloc_t *);
diff -ru usr/src/nv/nv.c usr/src/nv.2305230/nv.c
--- usr/src/nv/nv.c 2008-01-21 11:48:11.000000000 -0800
+++ usr/src/nv.2305230/nv.c 2008-03-18 12:56:01.123889244 -0700
@@ -97,9 +97,7 @@
unsigned int nv_remap_limit;
#endif
-#if defined(NV_CHANGE_PAGE_ATTR_PRESENT)
-int nv_use_cpa = 1;
-#endif
+int nv_update_memory_types = 1;
static void *nv_pte_t_cache = NULL;
@@ -850,16 +848,13 @@
for (i = 0; i < 4; i++)
{
- if (NV_PAT_ENTRY(pat1, i) == 1)
+ if ((i != 1) && NV_PAT_ENTRY(pat1, i) == 1)
{
nv_printf(NV_DBG_ERRORS, "NVRM: PAT index %d already configured for Write-Combining!\n", i);
nv_printf(NV_DBG_ERRORS, "NVRM: Aborting, due to PAT already being configured\n");
return 0;
}
- }
- for (i = 0; i < 4; i++)
- {
if (NV_PAT_ENTRY(pat2, i) == 1)
{
nv_printf(NV_DBG_ERRORS, "NVRM: PAT index %d already configured for Write-Combining!\n", i + 4);
@@ -969,30 +964,26 @@
#endif /* defined(NV_BUILD_NV_PAT_SUPPORT) */
}
-
#if defined(NV_CHANGE_PAGE_ATTR_BUG_PRESENT)
-
-/* nv_verify_cpa_interface - determine if the change_page_attr bug is fixed
- * in this kernel.
+/*
+ * nv_verify_cpa_interface() - determine if the change_page_attr() large page
+ * management accounting bug known to exist in early Linux/x86-64 kernels
+ * is present in this kernel.
*
- * there's really not a good way to determine if change_page_attr is fixed.
- * we can't really use cpa on 2.6 x86_64 kernels < 2.6.11, as if we run into
- * the accounting bug, the kernel will throw a BUG. this isn't 100% accurate,
- * as it doesn't throw a bug until we try to restore the caching attributes
- * of the page. so if we can track down a 4M allocation, we can mark it
- * uncached and see if the accounting was done correctly.
- *
- * this is a little ugly, but the most accurate approach to determining if
- * this kernel is good.
+ * There's really no good way to determine if change_page_attr() is working
+ * correctly. We can't reliably use change_page_attr() on Linux/x86-64 2.6
+ * kernels < 2.6.11: if we run into the accounting bug, the Linux kernel will
+ * trigger a BUG() if we attempt to restore the WB memory type of a page
+ * originally part of a large page.
*
- * why do we even bother? some distributions have back-ported the cpa fix to
- * kernels < 2.6.11. we want to use change_page_attr to avoid random corruption
- * and hangs, but need to make sure it's safe to do so.
+ * So if we can successfully allocate such a page, change its memory type to
+ * UC and check if the accounting was done correctly, we can determine if
+ * the change_page_attr() interface can be used safely.
*
- * return values:
- * 0 - test passed, interface works
- * 1 - test failed, status unclear
- * -1 - test failed, interface broken
+ * Return values:
+ * 0 - test passed, the change_page_attr() interface works
+ * 1 - test failed, the status is unclear
+ * -1 - test failed, the change_page_attr() interface is broken
*/
static inline pte_t *check_large_page(unsigned long vaddr)
@@ -1000,7 +991,7 @@
pgd_t *pgd = NULL;
pmd_t *pmd = NULL;
- pgd = NV_PGD_OFFSET(vaddr, 1, &init_mm);
+ pgd = NV_PGD_OFFSET(vaddr, 1, NULL);
if (!NV_PGD_PRESENT(pgd))
return NULL;
@@ -1110,35 +1101,42 @@
return 1;
}
-
#endif /* defined(NV_CHANGE_PAGE_ATTR_BUG_PRESENT) */
-
-// verify that the kernel's mapping matches the requested type
-// this is to protect against accidental cache aliasing problems
+/*
+ * nv_verify_page_mappings() - verify that the kernel mapping of the specified
+ * page matches the specified type. This is to help detect bugs in the Linux
+ * kernel's change_page_attr() interface, early.
+ *
+ * This function relies on the ability to perform kernel virtul address to PFN
+ * translations and therefore on 'init_mm'. Unfortunately, the latter is no
+ * longer exported in recent Linux/x86 2.6 kernels. The export was removed at
+ * roughtly the same time as the set_pages_{uc,wb}() change_page_attr()
+ * replacement interfaces were introduced; hopefully, it will be sufficient to
+ * check for their presence.
+ */
int nv_verify_page_mappings(
nv_pte_t *page_ptr,
unsigned int cachetype
)
{
- struct mm_struct *mm;
+#if defined(NV_CHANGE_PAGE_ATTR_PRESENT) || \
+ (defined(NV_SET_PAGES_UC_PRESENT) && !defined(NVCPU_X86))
+ unsigned long retval = -1;
+#if defined(NVCPU_X86) || defined(NVCPU_X86_64)
pgd_t *pgd = NULL;
pmd_t *pmd = NULL;
pte_t *pte = NULL;
- unsigned long retval = -1;
unsigned int flags, expected;
unsigned long address;
static int count = 0;
-#if defined(NV_CHANGE_PAGE_ATTR_PRESENT)
- if (!nv_use_cpa)
+ if (!nv_update_memory_types)
return 0;
-#endif
address = (unsigned long)__va(page_ptr->phys_addr);
- mm = &init_mm; // always a kernel page
- pgd = NV_PGD_OFFSET(address, 1, mm);
+ pgd = NV_PGD_OFFSET(address, 1, NULL);
if (!NV_PGD_PRESENT(pgd))
{
nv_printf(NV_DBG_ERRORS, "NVRM: pgd not present for addr 0x%lx\n", address);
@@ -1204,7 +1202,11 @@
}
failed:
+#endif /* defined(NVCPU_X86) || defined(NVCPU_X86_64) */
return retval;
+#else
+ return 0;
+#endif
}
#if defined(NV_BUILD_NV_PAT_SUPPORT) && defined(CONFIG_HOTPLUG_CPU)
@@ -1250,7 +1252,8 @@
static int __init nvidia_init_module(void)
{
int rc;
- U032 i, count;
+ U032 i, count, data;
+ nv_state_t *nv = NV_STATE_PTR(&nv_ctl_device);
#if defined(VM_CHECKER)
nv_init_lock(vm_lock);
@@ -1266,11 +1269,18 @@
return -ENODEV;
}
+ if (!rm_init_rm())
+ {
+ nv_printf(NV_DBG_ERRORS, "NVRM: rm_init_rm() failed!\n");
+ return -EIO;
+ }
+
memset(nv_linux_devices, 0, sizeof(nv_linux_devices));
if (pci_register_driver(&nv_pci_driver) < 0)
{
pci_unregister_driver(&nv_pci_driver); // XXX ???
+ rm_shutdown_rm();
nv_printf(NV_DBG_ERRORS, "NVRM: No NVIDIA graphics adapter found!\n");
return -ENODEV;
}
@@ -1293,6 +1303,7 @@
if (num_probed_nv_devices == 0)
{
pci_unregister_driver(&nv_pci_driver);
+ rm_shutdown_rm();
nv_printf(NV_DBG_ERRORS, "NVRM: No NVIDIA graphics adapter probed!\n");
return -ENODEV;
}
@@ -1307,6 +1318,7 @@
if (num_nv_devices == 0)
{
pci_unregister_driver(&nv_pci_driver);
+ rm_shutdown_rm();
nv_printf(NV_DBG_ERRORS,
"NVRM: None of the NVIDIA graphics adapters were initialized!\n");
return -ENODEV;
@@ -1317,8 +1329,9 @@
rc = register_chrdev(nv_major, "nvidia", &nv_fops);
if (rc < 0)
{
- nv_printf(NV_DBG_ERRORS, "NVRM: register chrdev failed\n");
pci_unregister_driver(&nv_pci_driver);
+ rm_shutdown_rm();
+ nv_printf(NV_DBG_ERRORS, "NVRM: register_chrdev() failed!\n");
return rc;
}
@@ -1367,14 +1380,6 @@
}
#endif
- // Init the resource manager
- if (!rm_init_rm())
- {
- nv_printf(NV_DBG_ERRORS, "NVRM: rm_init_rm() failed\n");
- rc = -EIO;
- goto failed;
- }
-
#if defined(NV_SG_MAP_BUFFERS)
rm_read_registry_dword(NV_STATE_PTR(&nv_ctl_device), "NVreg", "RemapLimit", &nv_remap_limit);
@@ -1407,48 +1412,41 @@
/* create /proc/driver/nvidia */
nvos_proc_create();
-#if defined(NV_CHANGE_PAGE_ATTR_PRESENT)
+ /*
+ * Give users an opportunity to disable the driver's use of
+ * the change_page_attr() and set_pages_{uc,wb}() kernel
+ * interfaces.
+ */
+ rc = rm_read_registry_dword(nv, "NVreg", "UpdateMemoryTypes", &data);
+ if ((rc == 0) && ((int)data != ~0))
{
- int data;
-
- // allow the user to override us with a registry key
- rc = rm_read_registry_dword(NV_STATE_PTR(&nv_ctl_device), "NVreg", "UseCPA", &data);
- if ((rc == 0) && (data != -1))
- {
- nv_use_cpa = data;
- }
+ nv_update_memory_types = data;
+ }
#if defined(NV_CHANGE_PAGE_ATTR_BUG_PRESENT)
- else
+ /*
+ * Unless we explicitely detect that the change_page_attr()
+ * inteface is fixed, disable usage of the interface on
+ * this kernel. Notify the user of this problem using the
+ * driver's /proc warnings interface (read by the installer
+ * and the bug report script).
+ */
+ else
+ {
+ rc = nv_verify_cpa_interface();
+ if (rc < 0)
{
- /*
- * Unless we explicitely detect that the change_page_attr()
- * inteface is fixed, disable usage of the interface on
- * this kernel. Notify the user of this problem using the
- * driver's /proc warnings interface (read by the installer
- * and the bug report script).
- */
- rc = nv_verify_cpa_interface();
- if (rc < 0)
- {
- nv_prints(NV_DBG_ERRORS, __cpgattr_warning);
- nvos_proc_add_warning_file("change_page_attr", __cpgattr_warning);
- nv_use_cpa = 0;
- }
- else if (rc != 0)
- {
- nv_prints(NV_DBG_ERRORS, __cpgattr_warning_2);
- nvos_proc_add_warning_file("change_page_attr", __cpgattr_warning_2);
- nv_use_cpa = 0;
- }
+ nv_prints(NV_DBG_ERRORS, __cpgattr_warning);
+ nvos_proc_add_warning_file("change_page_attr", __cpgattr_warning);
+ nv_update_memory_types = 0;
+ }
+ else if (rc != 0)
+ {
+ nv_prints(NV_DBG_ERRORS, __cpgattr_warning_2);
+ nvos_proc_add_warning_file("change_page_attr", __cpgattr_warning_2);
+ nv_update_memory_types = 0;
}
-#endif
}
-#endif
-
-
-#if defined(DEBUG)
- inter_module_register("nv_linux_devices", THIS_MODULE, nv_linux_devices);
-#endif
+#endif /* defined(NV_CHANGE_PAGE_ATTR_BUG_PRESENT) */
#if defined(NVCPU_X86_64) && defined(CONFIG_IA32_EMULATION) && !defined(HAVE_COMPAT_IOCTL)
/* Register ioctl conversions for 32 bit clients */
@@ -1501,6 +1499,8 @@
}
pci_unregister_driver(&nv_pci_driver);
+ rm_shutdown_rm();
+
return rc;
}
@@ -1532,10 +1532,6 @@
/* remove /proc/driver/nvidia */
nvos_proc_remove();
-#if defined(DEBUG)
- inter_module_unregister("nv_linux_devices");
-#endif
-
#if defined(NV_PM_SUPPORT_OLD_STYLE_APM)
for (i = 0; i < num_nv_devices; i++)
{
@@ -2112,6 +2108,8 @@
if (rm_validate_pfn_range(file, NV_VMA_PGOFF(vma),
NV_VMA_SIZE(vma)) == RM_OK)
{
+ if (vma->vm_flags & VM_WRITE)
+ return -EACCES;
vma->vm_flags |= (VM_IO | VM_LOCKED);
#if defined(NV_VM_INSERT_PAGE_PRESENT)
if (NV_VM_INSERT_PAGE(vma, vma->vm_start, pfn_to_page(NV_VMA_PGOFF(vma))))
@@ -2240,6 +2238,8 @@
if (rm_validate_pfn_range(file, NV_VMA_PGOFF(vma),
NV_VMA_SIZE(vma)) == RM_OK)
{
+ if (vma->vm_flags & VM_WRITE)
+ return -EACCES;
vma->vm_flags |= (VM_IO | VM_LOCKED);
#if defined(NV_VM_INSERT_PAGE_PRESENT)
if (NV_VM_INSERT_PAGE(vma, vma->vm_start, pfn_to_page(NV_VMA_PGOFF(vma))))
@@ -3266,8 +3266,21 @@
pte_t *pte = NULL;
unsigned long retval;
- mm = (kern) ? &init_mm : current->mm;
- if (!kern) down_read(¤t->mm->mmap_sem);
+ if (!kern)
+ {
+ mm = current->mm;
+ down_read(&mm->mmap_sem);
+ }
+ else
+ {
+#if defined(NV_SET_PAGES_UC_PRESENT) && defined(NVCPU_X86)
+ /* nv_printf(NV_DBG_ERRORS,
+ "NVRM: can't translate KVA in nv_get_phys_address()!\n"); */
+ return 0;
+#else
+ mm = NULL;
+#endif
+ }
pgd = NV_PGD_OFFSET(address, kern, mm);
if (!NV_PGD_PRESENT(pgd))
@@ -3288,11 +3301,13 @@
retval &= ~_PAGE_NX;
#endif
- if (!kern) up_read(¤t->mm->mmap_sem);
+ if (!kern)
+ up_read(&mm->mmap_sem);
return retval;
failed:
- if (!kern) up_read(¤t->mm->mmap_sem);
+ if (!kern)
+ up_read(&mm->mmap_sem);
return 0;
}
@@ -3300,12 +3315,19 @@
unsigned long address
)
{
- // make sure this address is a kernel pointer
+#if defined(NV_SET_PAGES_UC_PRESENT) && defined(NVCPU_X86)
+ nv_linux_state_t *nvl;
+ nv_alloc_t *at;
+ unsigned long virt_addr;
+ U032 i, j;
+#endif
+
+ /* make sure this address is a kernel virtual address */
#if defined(DEBUG) && !defined(CONFIG_X86_4G)
if (address < PAGE_OFFSET)
{
nv_printf(NV_DBG_WARNINGS,
- "NVRM: user address passed to get_kern_phys_address: 0x%lx\n",
+ "NVRM: user address passed to get_kern_phys_address: 0x%llx!\n",
address);
return 0;
}
@@ -3315,6 +3337,30 @@
if ((address > PAGE_OFFSET) && (address < VMALLOC_START))
return __pa(address);
+#if defined(NV_SET_PAGES_UC_PRESENT) && defined(NVCPU_X86)
+ for (i = 0; i < num_nv_devices; i++)
+ {
+ nvl = &nv_linux_devices[i];
+
+ for (at = nvl->alloc_queue; (at != NULL); at = at->next)
+ {
+ if (!NV_ALLOC_MAPPING_VMAP(at->flags))
+ continue;
+
+ for (j = 0; j < at->num_pages; j++)
+ {
+ virt_addr = at->page_table[j]->virt_addr;
+ if ((address >= virt_addr) &&
+ (address < (virt_addr + PAGE_SIZE)))
+ {
+ return (at->page_table[j]->phys_addr +
+ (address & ~PAGE_MASK));
+ }
+ }
+ }
+ }
+#endif
+
return _get_phys_address(address, 1);
}
@@ -3322,12 +3368,12 @@
unsigned long address
)
{
- // make sure this address is not a kernel pointer
+ /* make sure this address is not a kernel virtual address */
#if defined(DEBUG) && !defined(CONFIG_X86_4G)
if (address >= PAGE_OFFSET)
{
nv_printf(NV_DBG_WARNINGS,
- "NVRM: kernel address passed to get_user_phys_address: 0x%lx\n",
+ "NVRM: kernel address passed to get_user_phys_address: 0x%llx!\n",
address);
return 0;
}
@@ -3396,8 +3442,6 @@
if (nv_vm_malloc_pages(nv, at))
goto failed;
- at->class = class;
-
// set our 'key' to the page_table. rm_alloc_agp_pages will call
// nv_translate_address below, which will look up pages using
// the value of *pAddress as a key, then index into the page_table
@@ -3952,7 +3996,8 @@
if (num_nv_devices == NV_MAX_DEVICES)
{
- nv_printf(NV_DBG_ERRORS, "NVRM: maximum device number (%d) reached!\n", num_nv_devices);
+ nv_printf(NV_DBG_ERRORS, "NVRM: maximum device number (%d) exceeded!\n",
+ (NV_MAX_DEVICES - 1));
return -1;
}
@@ -4085,13 +4130,10 @@
return -1;
}
-int NV_API_CALL nv_no_incoherent_mappings
-(
- void
-)
+int NV_API_CALL nv_no_incoherent_mappings(void)
{
-#if defined(NV_CHANGE_PAGE_ATTR_PRESENT)
- return 1;
+#if defined(NV_CHANGE_PAGE_ATTR_PRESENT) || defined(NV_SET_PAGES_UC_PRESENT)
+ return (nv_update_memory_types);
#else
return 0;
#endif
diff -ru usr/src/nv/nv.h usr/src/nv.2305230/nv.h
--- usr/src/nv/nv.h 2008-01-21 11:48:11.000000000 -0800
+++ usr/src/nv.2305230/nv.h 2008-03-18 12:55:56.919649651 -0700
@@ -335,15 +332,39 @@
#define NV_DEVICE_NAME_LENGTH 40
+#define NV_MAX_ISR_DELAY_US 20000
+#define NV_MAX_ISR_DELAY_MS (NV_MAX_ISR_DELAY_US / 1000)
+
+#define NV_TIMERCMP(a, b, CMP) \
+ (((a)->tv_sec == (b)->tv_sec) ? \
+ ((a)->tv_usec CMP (b)->tv_usec) : ((a)->tv_sec CMP (b)->tv_sec))
+
+#define NV_TIMERADD(a, b, result) \
+ { \
+ (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \
+ (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \
+ if ((result)->tv_usec >= 1000000) \
+ { \
+ ++(result)->tv_sec; \
+ (result)->tv_usec -= 1000000; \
+ } \
+ }
+
+#define NV_TIMERSUB(a, b, result) \
+ { \
+ (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
+ (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
+ if ((result)->tv_usec < 0) \
+ { \
+ --(result)->tv_sec; \
+ (result)->tv_usec += 1000000; \
+ } \
+ }
/*
* driver internal interfaces
*/
-/* need a fake device number for control device; just to flag it for msgs */
-#define NV_CONTROL_DEVICE_NUMBER 100
-
-
#ifndef NVWATCH
/*
diff -ru usr/src/nv/os-interface.c usr/src/nv.2305230/os-interface.c
--- usr/src/nv/os-interface.c 2008-01-21 11:48:11.000000000 -0800
+++ usr/src/nv.2305230/os-interface.c 2008-03-18 12:56:04.288069559 -0700
@@ -25,7 +25,6 @@
#include "os-interface.h"
#include "nv-linux.h"
-
static volatile int os_block_on_smp_barrier;
#ifdef CONFIG_SMP
@@ -63,7 +62,7 @@
//
typedef struct os_sema_s
{
- struct semaphore wait;
+ struct completion completion;
spinlock_t lock;
S032 count;
} os_sema_t;
@@ -86,7 +85,7 @@
return rmStatus;
os_sema = (os_sema_t *)*ppSema;
- sema_init(&os_sema->wait, 0);
+ init_completion(&os_sema->completion);
spin_lock_init(&os_sema->lock);
os_sema->count = 1;
@@ -131,7 +130,7 @@
{
os_sema->count--;
spin_unlock_irqrestore(&os_sema->lock, old_irq);
- down(&os_sema->wait);
+ wait_for_completion(&os_sema->completion);
}
else
{
@@ -208,7 +207,7 @@
spin_unlock_irqrestore(&os_sema->lock, old_irq);
if (doWakeup)
- up(&os_sema->wait);
+ complete(&os_sema->completion);
return RM_OK;
}
@@ -448,8 +447,6 @@
//
//---------------------------------------------------------------------------
-#define NV_MAX_ISR_UDELAY 20000
-#define NV_MAX_ISR_MDELAY (NV_MAX_ISR_UDELAY / 1000)
#define NV_MSECS_PER_JIFFIE (1000 / HZ)
#define NV_MSECS_TO_JIFFIES(msec) ((msec) * HZ / 1000)
#define NV_USECS_PER_JIFFIE (1000000 / HZ)
@@ -474,7 +471,7 @@
do_gettimeofday(&tm1);
#endif
- if (in_irq() && MicroSeconds > NV_MAX_ISR_UDELAY)
+ if (in_irq() && (MicroSeconds > NV_MAX_ISR_DELAY_US))
return RM_ERROR;
mdelay_safe_msec = MicroSeconds / 1000;
@@ -494,36 +491,6 @@
return RM_OK;
}
-#ifndef timercmp
-# define timercmp(a, b, CMP) \
- (((a)->tv_sec == (b)->tv_sec) ? \
- ((a)->tv_usec CMP (b)->tv_usec) : \
- ((a)->tv_sec CMP (b)->tv_sec))
-#endif
-#ifndef timeradd
-# define timeradd(a, b, result) \
- do { \
- (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \
- (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \
- if ((result)->tv_usec >= 1000000) \
- { \
- ++(result)->tv_sec; \
- (result)->tv_usec -= 1000000; \
- } \
- } while (0)
-#endif
-#ifndef timersub
-# define timersub(a, b, result) \
- do { \
- (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
- (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
- if ((result)->tv_usec < 0) { \
- --(result)->tv_sec; \
- (result)->tv_usec += 1000000; \
- } \
- } while (0)
-#endif
-
/*
* On Linux, a jiffie represents the time passed in between two timer
* interrupts. The number of jiffies per second (HZ) varies across the
@@ -549,7 +516,7 @@
tm_start = tm_aux;
#endif
- if (in_irq() && MilliSeconds > NV_MAX_ISR_MDELAY)
+ if (in_irq() && (MilliSeconds > NV_MAX_ISR_DELAY_MS))
return RM_ERROR;
if (!NV_MAY_SLEEP())
@@ -561,7 +528,7 @@
MicroSeconds = MilliSeconds * 1000;
tm_end.tv_usec = MicroSeconds;
tm_end.tv_sec = 0;
- timeradd(&tm_aux, &tm_end, &tm_end);
+ NV_TIMERADD(&tm_aux, &tm_end, &tm_end);
/* do we have a full jiffie to wait? */
jiffies = NV_USECS_TO_JIFFIES(MicroSeconds);
@@ -590,9 +557,9 @@
schedule_timeout(jiffies);
/* catch the remainder, if any */
do_gettimeofday(&tm_aux);
- if (timercmp(&tm_aux, &tm_end, <))
+ if (NV_TIMERCMP(&tm_aux, &tm_end, <))
{
- timersub(&tm_end, &tm_aux, &tm_aux); // tm_aux = tm_end - tm_aux
+ NV_TIMERSUB(&tm_end, &tm_aux, &tm_aux); // tm_aux = tm_end - tm_aux
MicroSeconds = tm_aux.tv_usec + tm_aux.tv_sec * 1000000;
} else
MicroSeconds = 0;
@@ -1109,6 +1076,18 @@
{
void *vaddr;
+ if (start == 0)
+ {
+ if (mode != NV_MEMORY_CACHED)
+ {
+ nv_printf(NV_DBG_ERRORS,
+ "NVRM: os_map_kernel_space: won't map address 0x%0llx UC!\n", start);
+ return NULL;
+ }
+ else
+ return (void *)PAGE_OFFSET;
+ }
+
if (!NV_MAY_SLEEP())
{
nv_printf(NV_DBG_ERRORS,
@@ -1131,6 +1110,9 @@
U032 size_bytes
)
{
+ if (addr == (void *)PAGE_OFFSET)
+ return;
+
NV_IOUNMAP(addr, size_bytes);
}
@@ -1176,7 +1158,11 @@
#if defined(CONFIG_X86_REMOTE_DEBUG)
__asm__ __volatile__ ("int $3");
#elif defined(CONFIG_KGDB)
+#if defined(NV_OLD_MM_KGDB_BREAKPOINT_PRESENT)
+ BREAKPOINT;
+#else
BREAKPOINT();
+#endif
#elif defined(CONFIG_KDB)
KDB_ENTER();
#else
diff -ru usr/src/nv/os-registry.c usr/src/nv.2305230/os-registry.c
--- usr/src/nv/os-registry.c 2008-01-21 11:48:11.000000000 -0800
+++ usr/src/nv.2305230/os-registry.c 2008-03-18 12:56:07.492252151 -0700
@@ -48,24 +48,6 @@
* This could be changed to work on a per-device basis.
*/
-/*
- * The 2nd argument to MODULE_PARM is used to verify parameters passed
- * to the module at load time. It should be a string in the following
- * format:
- *
- * [min[-max]]{b,h,i,l,s}
- *
- * The MIN and MAX specifiers delimit the length of the array. If MAX
- * is omitted, it defaults to MIN; if both are omitted, the default is
- * 1. The final character is a type specifier.
- *
- * b byte
- * h short
- * i int
- * l long
- * s string
- */
-
/*
* Option: VideoMemoryTypeOverride
*
@@ -360,9 +342,6 @@
static int NVreg_DevicesConnected = 0;
NV_MODULE_PARAMETER(NVreg_DevicesConnected);
-static int NVreg_VideoEnhancement = 0;
-NV_MODULE_PARAMETER(NVreg_VideoEnhancement);
-
static int NVreg_RmLogonRC = 1;
NV_MODULE_PARAMETER(NVreg_RmLogonRC);
@@ -402,34 +381,36 @@
NV_MODULE_PARAMETER(NVreg_RemapLimit);
/*
- * Option: UseCPA
+ * Option: UpdateMemoryTypes
*
* Description:
*
- * Many kernels have a broken implementation of change_page_attr that leads
- * to cache aliasing problems. x86_64 kernels between 2.6.0 and 2.6.10 will
- * force a kernel BUG_ON() when this condition is encountered. For this
- * reason, the NVIDIA driver is very careful about not using the CPA kernel
- * interface on these kernels.
+ * Many kernels have broken implementations of the change_page_attr()
+ * kernel interface that may cause cache aliasing problems. Linux/x86-64
+ * kernels between 2.6.0 and 2.6.10 may prompt kernel BUG()s due to
+ * improper accounting in the interface's large page management code, for
+ * example. For this reason, the NVIDIA Linux driver is very careful about
+ * not using the change_page_attr() kernel interface on these kernels.
+ *
+ * Due to the serious nature of the problems that can arise from bugs in
+ * the change_page_attr(), set_pages_{uc,wb}() and other kernel interfaces
+ * used to modify memory types, the NVIDIA driver implements a manual
+ * registry key override to allow forcibly enabling or disabling use of
+ * these APIs.
*
- * Some distributions have backported this fix to kernel versions that fall
- * within this version range. The NVIDIA driver attempts to automatically
- * detect these fixes and reenable usage of the change_page_attr interface.
+ * Possible values:
*
- * Due to the serious nature of the problems that can arise from this, the
- * NVIDIA driver implements a manual registry key to force usage of this API
- * to be enabled or disabled. This registry key can be used to force usage
- * of the API on a known fixed kernel if the NVIDIA driver fails to detect
- * the kernel as fixed. This registry key can also be used to disable usage
- * of the API on a bad kernel that is misdetected as a fixed kernel.
+ * ~0 = use the NVIDIA driver's default logic (default)
+ * 0 = enable use of change_page_attr(), etc.
+ * 1 = disable use of change_page_attr(), etc.
*
- * The default value is '-1' (use NVIDIA driver default logic)
- * A value of '0' will forcibly disable change_page_attr calls.
- * A value of '1' will forcibly enable change_page_attr calls.
+ * By default, the NVIDIA driver will attempt to auto-detect if it can
+ * safely use the change_page_attr() and other kernel interfaces to modify
+ * the memory types of kernel mappings.
*/
-static int NVreg_UseCPA = -1;
-NV_MODULE_PARAMETER(NVreg_UseCPA);
+static int NVreg_UpdateMemoryTypes = ~0;
+NV_MODULE_PARAMETER(NVreg_UpdateMemoryTypes);
// 1 - Force sourcing vbios from ROM
// 0 - business as usual
@@ -477,15 +458,14 @@
{ "NVreg", "ResmanDebugLevel", &NVreg_ResmanDebugLevel, 1 },
{ "NVreg", "FlatPanelMode", &NVreg_FlatPanelMode, 1 },
{ "NVreg", "DevicesConnected", &NVreg_DevicesConnected, 1 },
- { "NVreg", "VideoEnhancement", &NVreg_VideoEnhancement, 1 },
{ "NVreg", "RmLogonRC", &NVreg_RmLogonRC, 1 },
+ { "NVreg", "VbiosFromROM", &NVreg_VbiosFromROM, 1 },
{ "NVreg", "ModifyDeviceFiles", &NVreg_ModifyDeviceFiles, 1 },
{ "NVreg", "DeviceFileUID", &NVreg_DeviceFileUID, 1 },
{ "NVreg", "DeviceFileGID", &NVreg_DeviceFileGID, 1 },
{ "NVreg", "DeviceFileMode", &NVreg_DeviceFileMode, 1 },
- { "NVreg", "VbiosFromROM", &NVreg_VbiosFromROM, 1 },
{ "NVreg", "RemapLimit", &NVreg_RemapLimit, 1 },
- { "NVreg", "UseCPA", &NVreg_UseCPA, 1 },
+ { "NVreg", "UpdateMemoryTypes", &NVreg_UpdateMemoryTypes, 1 },
{ "NVreg", "RMEdgeIntrCheck", &NVreg_RMEdgeIntrCheck, 1 },
{ NULL, NULL, NULL, 0 }
};