Merge pull request #63 from NVIDIA/2.26.6

GPUDirect Storage kernel driver (nvidia-fs) ver-2.26.6 commit

Author: sourabgupta3

ChangeLog

@@ -1,3 +1,7 @@
+nvidia-fs (2.26.6) RELEASE; urgency=low
+  * Fix issues for 6.11 kernel
+  * Fix compilation issues for 6.14 kernel
+  * Minor code cleanup
 nvidia-fs (2.25.7) RELEASE; urgency=low
   * fix configure script to export correct macro for access_ok
 

src/GDS_VERSION

@@ -1 +1 @@
-1.14.0.31
+1.15.0.42

src/configure

@@ -149,7 +149,6 @@ fi
 
 cat > $TEST_C <<EOF
 
-
 #include <linux/uaccess.h>
 #include "test.h"
 
@@ -534,6 +533,21 @@ if compile_prog "Checking if vma_flags are modifiable directly ..."; then
         output_sym "NVFS_VM_FLAGS_NOT_CONSTANT"
 fi
 
+cat > $TEST_C <<EOF
+#include <linux/blk-mq-pci.h>
+#include "test.h"
+
+int test (void)
+{
+        return 0;
+}
+
+EOF
+if compile_prog "Checking if blk-mq-pci.h is present..."; then
+        output_sym "HAVE_BLK_MQ_PCI_H"
+fi
+
+
 echo "#endif" >> $config_host_h
 rm -rf build
 

src/nvfs-batch.c

@@ -162,18 +162,16 @@ long nvfs_io_batch_submit(nvfs_batch_io_t *nvfs_batch)
 				 nvfs_batch->start_io),
 			 &nvfs_batch_submit_latency_per_sec);
 	 kfree(nvfs_batch);
-         return ret;;
+         return ret;
 
 cleanup:
-        if (nvfs_batch) {
-                for (i = 0; i < nvfs_batch->nents; i++) {
-                        if (nvfs_batch->nvfsio[i] && !IS_ERR(nvfs_batch->nvfsio[i]))
-                                nvfs_io_free(nvfs_batch->nvfsio[i], -EINVAL);
-                }
-                //XXX: wait for the ongoing ops, or cancel them.
-                kfree(nvfs_batch);
-        }
-        return ret;;
+	for (i = 0; i < nvfs_batch->nents; i++) {
+		if (nvfs_batch->nvfsio[i] && !IS_ERR(nvfs_batch->nvfsio[i]))
+			nvfs_io_free(nvfs_batch->nvfsio[i], -EINVAL);
+	}
+	//XXX: wait for the ongoing ops, or cancel them.
+	kfree(nvfs_batch);
+        return ret;
 
 }
 #endif

src/nvfs-core.c

@@ -1035,22 +1035,29 @@ nvfs_direct_io(int op, struct file *filp, char __user *buf,
 
         iov_iter_init(&iter, op, &iov, 1, len);
 
-//TODO: If the config is not present fallback to vfs_read/vfs_write
-#ifdef HAVE_CALL_READ_WRITE_ITER
         if(op == WRITE) {
                 set_write_flag(&nvfsio->common);
                 file_start_write(filp);
 
+#ifdef HAVE_CALL_READ_WRITE_ITER
                 ret = nvfs_io_ret(&nvfsio->common,
 				call_write_iter(filp, &nvfsio->common, &iter));
+#else
+		ret = nvfs_io_ret(&nvfsio->common,
+                                filp->f_op->write_iter(&nvfsio->common, &iter));
+#endif
                 if (S_ISREG(file_inode(filp)->i_mode))
                         __sb_writers_release(file_inode(filp)->i_sb,
 				SB_FREEZE_WRITE);
         } else {
+#ifdef HAVE_CALL_READ_WRITE_ITER
                 ret = nvfs_io_ret(&nvfsio->common,
 				call_read_iter(filp, &nvfsio->common, &iter));
-        }
+#else
+		ret = nvfs_io_ret(&nvfsio->common,
+                                filp->f_op->read_iter(&nvfsio->common, &iter));
 #endif
+        }
 
         nvfs_dbg("nvfs_direct_io : ret = %ld len = %lu\n" , ret, len);
         if (ret == -EIOCBQUEUED) {
@@ -1273,7 +1280,7 @@ static int nvfs_pin_gpu_pages(nvfs_ioctl_map_t *input_param,
         }
 
         if(gpu_buf_len < GPU_PAGE_SIZE &&
-		(input_param->sbuf_block * NVFS_BLOCK_SIZE) <
+		(input_param->sbuf_block * (unsigned long long)NVFS_BLOCK_SIZE) <
 		(gpuvaddr - gpu_virt_start + gpu_buf_len))
         {
 		nvfs_err("invalid shadow buf size provided %u, gpu_buf_len: %lld, gpuvaddr: %llx \n",
@@ -1504,7 +1511,7 @@ static int nvfs_map(nvfs_ioctl_map_t *input_param)
 	nvfs_get_ops();
 
         nvfs_mgroup = nvfs_mgroup_pin_shadow_pages(input_param->cpuvaddr,
-				input_param->sbuf_block * NVFS_BLOCK_SIZE);
+				input_param->sbuf_block * (unsigned long long)NVFS_BLOCK_SIZE);
 	if (!nvfs_mgroup) {
 		nvfs_err("%s:%d Error nvfs_setup_shadow_buffer\n",
 				__func__, __LINE__);
@@ -2462,7 +2469,7 @@ static int get_nvidia_driver_version(void){
 	char buf[NVIDIA_DRIVER_BUF_SIZE];
 	loff_t pos = 0;
 	ssize_t bytes_read;
-	int value;
+	int value = -1;
 
 	file = filp_open(NVIDIA_DRIVER_PATH, O_RDONLY, 0);
 	if (IS_ERR(file)) {

src/nvfs-dma.c

@@ -591,7 +591,6 @@ static int nvfs_dma_map_sg_attrs_internal(struct device *device,
 			}
 			// We do not handle dma mapping for CPU pages
 			nr_cpu_dma++;
-			continue;
                 } else {
 			// Cannot handle GPU/CPU pages
 			if (unlikely(nr_cpu_dma)) {

src/nvfs-dma.h

@@ -28,7 +28,9 @@
 #include <linux/types.h>
 #include <linux/blkdev.h>
 #include <linux/blk-mq.h>
+#ifdef HAVE_BLK_MQ_PCI_H
 #include <linux/blk-mq-pci.h>
+#endif
 #include <linux/scatterlist.h>
 #include <linux/page-flags.h>
 #include <linux/dma-direction.h>

src/nvfs-kernel-interface.h

@@ -26,7 +26,9 @@
 #include <linux/types.h>
 #include <linux/blkdev.h>
 #include <linux/blk-mq.h>
+#ifdef HAVE_BLK_MQ_PCI_H
 #include <linux/blk-mq-pci.h>
+#endif
 #include <linux/scatterlist.h>
 #include <linux/version.h>
 

src/nvfs-mmap.c

@@ -173,7 +173,6 @@ static void nvfs_mgroup_free(nvfs_mgroup_ptr_t nvfs_mgroup, bool from_dma)
         nvfs_dbg("freeing base_index %lx(ref:%d) found \n",
                   nvfs_mgroup->base_index, atomic_read(&nvfs_mgroup->ref));
         kfree(nvfs_mgroup);
-	nvfs_mgroup = NULL;
 }
 
 
@@ -225,7 +224,7 @@ void nvfs_mgroup_put_dma(nvfs_mgroup_ptr_t nvfs_mgroup) {
 
 static nvfs_mgroup_ptr_t nvfs_get_mgroup_from_vaddr_internal(u64 cpuvaddr)
 {
-	struct page *page;
+	struct page *page = NULL;
 	int ret;
 	unsigned long cur_base_index  = 0;
 	nvfs_mgroup_ptr_t nvfs_mgroup = NULL;
@@ -371,12 +370,12 @@ nvfs_mgroup_ptr_t nvfs_mgroup_pin_shadow_pages(u64 cpuvaddr, unsigned long lengt
 	count = DIV_ROUND_UP(length, PAGE_SIZE);
 	block_count = DIV_ROUND_UP(length, NVFS_BLOCK_SIZE);
 	pages = (struct page **) kmalloc(count * sizeof(struct page *), GFP_KERNEL);
-
 	if (!pages) {
 		nvfs_err("%s:%d shadow buffer pages allocation failed\n",
 				__func__, __LINE__);
 		goto out;
 	}
+	memset(pages, 0, count * sizeof(struct page *));
 
 #ifdef CONFIG_FAULT_INJECTION
         if (nvfs_fault_trigger(&nvfs_pin_shadow_pages_error)) {
@@ -625,7 +624,7 @@ static int nvfs_mgroup_mmap_internal(struct file *filp, struct vm_area_struct *v
         nvfs_mgroup_ptr_t nvfs_mgroup, nvfs_new_mgroup;
 	struct nvfs_gpu_args *gpu_info;
 	int os_pages_count;
-	vm_flags_t vm_flags;
+	vm_flags_t vm_flags, vm_flags_to_set;
 
 	nvfs_stat64(&nvfs_n_mmap);
         /* check length - do not allow larger mappings than the number of
@@ -668,11 +667,13 @@ static int nvfs_mgroup_mmap_internal(struct file *filp, struct vm_area_struct *v
                goto error;
         }
 
+ 
+	vm_flags_to_set = VM_MIXEDMAP | VM_DONTEXPAND | VM_DONTDUMP | VM_DONTCOPY;
         /* dont allow mremap to expand and dont allow copy on fork */
 #ifdef NVFS_VM_FLAGS_NOT_CONSTANT
-        vma->vm_flags |= VM_IO | VM_MIXEDMAP | VM_DONTEXPAND | VM_DONTDUMP | VM_DONTCOPY;
+        vma->vm_flags |= vm_flags_to_set;
 #else
-        vm_flags_set(vma, VM_IO | VM_MIXEDMAP | VM_DONTEXPAND | VM_DONTDUMP | VM_DONTCOPY);
+        vm_flags_set(vma, vm_flags_to_set);
 #endif
         vma->vm_ops = &nvfs_mmap_ops;
         nvfs_new_mgroup = (nvfs_mgroup_ptr_t)kzalloc(sizeof(struct nvfs_io_mgroup), GFP_KERNEL);
@@ -697,7 +698,6 @@ static int nvfs_mgroup_mmap_internal(struct file *filp, struct vm_area_struct *v
 		nvfs_mgroup = nvfs_mgroup_get_unlocked(base_index);
                 if (unlikely(nvfs_mgroup && tries--)) {
                         nvfs_mgroup_put(nvfs_mgroup);
-                        continue;
                 } else {
                         nvfs_new_mgroup->base_index = base_index;
                         atomic_set(&nvfs_new_mgroup->ref,1);
@@ -744,7 +744,6 @@ static int nvfs_mgroup_mmap_internal(struct file *filp, struct vm_area_struct *v
                 BUG_ON(vma->vm_private_data != NULL);
         }
 
-	j = 0;
         for (i = 0; i < nvfs_blocks_count; i++) {
 		j = i / nvfs_block_count_per_page;
 		if (nvfs_mgroup->nvfs_ppages[j] == NULL) {
@@ -1051,7 +1050,7 @@ int nvfs_mgroup_fill_mpages(nvfs_mgroup_ptr_t nvfs_mgroup, unsigned nr_blocks)
                 nvfs_mgroup_fill_mpage(nvfs_mgroup->nvfs_ppages[j/nvfs_block_count_per_page],
 			&nvfs_mgroup->nvfs_metadata[j], nvfsio);
         }
-        nvfsio->nvfs_active_blocks_end = j-1;
+        nvfsio->nvfs_active_blocks_end = (j > 0 ? j-1 : 0);
 
         // clear the state for unqueued pages
         for (; j < nvfs_mgroup->nvfs_blocks_count ; j++) {

src/nvfs-mod.c

@@ -135,11 +135,6 @@ void cleanup_module_list(void) {
 #ifdef HAVE_MODULE_MUTEX
 			mutex_unlock(&module_mutex);
 #endif
-
-			// initialized at compile time
-			if (!mod_entry->is_mod)
-				continue;
-
 		}
 	}
 }