kernel: GR context-promote bisection modes 4-17 and server-managed-ctxbuf registry variant; complete vgsp rename; docs/tooling refresh

- gsp_phys_booter: GR promote bisection modes 4-17 (two-phase zero-field VA,
  batched entries, hVirtMemory, bare VA, KMD SKIP_CTXBUFFER_ALLOC channel,
  old-interface GPU_INITIALIZE_CTX, FBMEM context buffer, UVM-faithful PA-only,
  PATCH/PM auxiliary promotes, server-managed no-promote path); PATCH/PM
  geometry queries and buffers; pre-boot SET_REGISTRY profile selection
- gsp_phys_gpu: gsp_phys_rmcall_gr_promote clamp 0..17 and gsp_phys_srv_ctxbuf
  parameter; registry image variant with RMSetClientRMAllocatedCtxBuffer=0
- vgsp rename across kernel, scripts, tools and docs (module vgsp.ko,
  /sys/kernel/debug/vgsp/, vgsp-<subsystem>: log prefixes)
- risc-v-gsp-rm-debugger user-facing rename and docs/CI refresh; guest-diag
  tool updates; README/SBOM/install/Makefile sync

Live status: CE ladder and P6 guest-copy forwarding green; GR engine context
commit still open (all promote shapes accepted or cleanly refused; the channel
stays CTXNOTVALID) - see Handoff-vGPU-IO.md Addendum 21 (local).

1 files changed, 134 insertions, 134 deletions

diff --git a/kernel/main.c b/kernel/main.c
index fbeb7e3..39c71c3 100644
--- a/kernel/main.c
+++ b/kernel/main.c
@@ -175,7 +175,7 @@ static NV_STATUS nv_vgpu_create_callback(struct pci_dev *pdev, const NvU8 *uuid,
                                          NvU32 type_id, NvU16 *vgpu_id,
                                          NvU32 *gpu_pci_id, NvU32 gpu_pci_bdf)
 {
-	pr_info("gsp-resman-vfio: vgpu_create callback: type_id=%u\n", type_id);
+	pr_info("vgsp: vgpu_create callback: type_id=%u\n", type_id);
 	if (vgpu_id)
 		*vgpu_id = 1;
 	if (gpu_pci_id)
@@ -185,14 +185,14 @@ static NV_STATUS nv_vgpu_create_callback(struct pci_dev *pdev, const NvU8 *uuid,
 
 static NV_STATUS nv_vgpu_delete_callback(const NvU8 *uuid, NvU16 vgpu_id)
 {
-	pr_info("gsp-resman-vfio: vgpu_delete callback: vgpu_id=%u\n", vgpu_id);
+	pr_info("vgsp: vgpu_delete callback: vgpu_id=%u\n", vgpu_id);
 	return NV_OK;
 }
 
 static NV_STATUS nv_vgpu_bar_info_callback(struct pci_dev *pdev, const NvU8 *uuid,
                                            NvU64 *size, NvU32 bar_index, void *vgpu_dev)
 {
-	pr_info("gsp-resman-vfio: vgpu_bar_info callback: bar_index=%u\n", bar_index);
+	pr_info("vgsp: vgpu_bar_info callback: bar_index=%u\n", bar_index);
 	if (size) {
 		switch (bar_index) {
 		case 0:
@@ -217,7 +217,7 @@ static NV_STATUS nv_vgpu_bar_info_callback(struct pci_dev *pdev, const NvU8 *uui
 
 static NV_STATUS nv_vgpu_get_name_callback(struct pci_dev *pdev, NvU32 type_id, char *buf)
 {
-	pr_info("gsp-resman-vfio: get_name callback: type_id=%u\n", type_id);
+	pr_info("vgsp: get_name callback: type_id=%u\n", type_id);
 	if (buf) {
 		switch (type_id) {
 		case 0: /* Ampere */
@@ -242,7 +242,7 @@ static NV_STATUS nv_vgpu_get_name_callback(struct pci_dev *pdev, NvU32 type_id,
 
 static NV_STATUS nv_vgpu_get_description_callback(struct pci_dev *pdev, NvU32 type_id, char *buf)
 {
-	pr_info("gsp-resman-vfio: get_description callback: type_id=%u\n", type_id);
+	pr_info("vgsp: get_description callback: type_id=%u\n", type_id);
 	if (buf) {
 		switch (type_id) {
 		case 0:
@@ -267,7 +267,7 @@ static NV_STATUS nv_vgpu_get_description_callback(struct pci_dev *pdev, NvU32 ty
 
 static NV_STATUS nv_vgpu_get_instances_callback(struct pci_dev *pdev, NvU32 type_id, char *buf)
 {
-	pr_info("gsp-resman-vfio: get_instances callback: type_id=%u\n", type_id);
+	pr_info("vgsp: get_instances callback: type_id=%u\n", type_id);
 	if (buf)
 		strcpy(buf, "1");
 	return NV_OK;
@@ -277,13 +277,13 @@ static void nv_vgpu_update_request_callback(const NvU8 *uuid, NvU64 *vgpu_dev,
                                             NvU64 *vgpu_vm, VGPU_DEVICE_STATE device_state,
                                             const char *params)
 {
-	pr_info("gsp-resman-vfio: update_request callback: state=%u\n", device_state);
+	pr_info("vgsp: update_request callback: state=%u\n", device_state);
 }
 
 static NV_STATUS nv_vgpu_start_callback(const NvU8 *uuid, void *wait_queue, NvS32 *return_status,
                                         NvU8 *vm_name, NvU32 qemu_pid)
 {
-	pr_info("gsp-resman-vfio: vgpu_start callback: qemu_pid=%u\n", qemu_pid);
+	pr_info("vgsp: vgpu_start callback: qemu_pid=%u\n", qemu_pid);
 	if (return_status)
 		*return_status = 0;
 	return NV_OK;
@@ -292,7 +292,7 @@ static NV_STATUS nv_vgpu_start_callback(const NvU8 *uuid, void *wait_queue, NvS3
 static NV_STATUS nv_vgpu_sparse_mmap_callback(struct pci_dev *pdev, const NvU8 *uuid,
                                               NvU64 **pages, NvU64 **offsets, NvU32 *count)
 {
-	pr_info("gsp-resman-vfio: sparse_mmap callback\n");
+	pr_info("vgsp: sparse_mmap callback\n");
 	if (count)
 		*count = 0;
 	return NV_OK;
@@ -345,7 +345,7 @@ int nv_vgpu_register_type_info(struct nv_vgpu_type_info *info)
     
     mutex_unlock(&g_vgpu_type_lock);
     
-    pr_info("Registered vGPU type: name='%s', vdev=0x%llx, pdev=0x%llx, max_inst=%u\n",
+    pr_info("vgsp: Registered vGPU type: name='%s', vdev=0x%llx, pdev=0x%llx, max_inst=%u\n",
             info->name, info->vdev_id, info->pdev_id, info->max_instances);
     return 0;
 }
@@ -436,7 +436,7 @@ NV_STATUS nvidia_vgpu_vfio_get_ops(rm_vgpu_vfio_ops_t *ops)
 	
 	populate_rm_ops();
 	memcpy(ops, &g_rm_vgpu_vfio_ops, sizeof(rm_vgpu_vfio_ops_t));
-	pr_info("gsp-resman-vfio: get_ops provided RM ops\n");
+	pr_info("vgsp: get_ops provided RM ops\n");
 	return NV_OK;
 }
 EXPORT_SYMBOL(nvidia_vgpu_vfio_get_ops);
@@ -448,7 +448,7 @@ NV_STATUS nvidia_vgpu_vfio_set_ops(vgpu_vfio_ops_t *ops)
 		return NV_ERR_INVALID_ARGUMENT;
 	
 	g_vgpu_vfio_ops = ops;
-	pr_info("gsp-resman-vfio: set_ops received VFIO ops\n");
+	pr_info("vgsp: set_ops received VFIO ops\n");
 	return NV_OK;
 }
 EXPORT_SYMBOL(nvidia_vgpu_vfio_set_ops);
@@ -456,14 +456,14 @@ EXPORT_SYMBOL(nvidia_vgpu_vfio_set_ops);
 /* mdev driver registration - called by nvidia.ko */
 int nv_vgpu_mdev_driver_register(void)
 {
-	pr_info("gsp-resman-vfio: mdev driver register\n");
+	pr_info("vgsp: mdev driver register\n");
 	return mdev_register_driver(&nv_vgpu_mdev_driver);
 }
 EXPORT_SYMBOL(nv_vgpu_mdev_driver_register);
 
 void nv_vgpu_mdev_driver_unregister(void)
 {
-	pr_info("gsp-resman-vfio: mdev driver unregister\n");
+	pr_info("vgsp: mdev driver unregister\n");
 	mdev_unregister_driver(&nv_vgpu_mdev_driver);
 }
 EXPORT_SYMBOL(nv_vgpu_mdev_driver_unregister);
@@ -475,10 +475,10 @@ int nv_vgpu_mdev_register_parent(struct pci_dev *pdev)
 	struct mdev_parent *parent;
 	int ret;
 
-	pr_info("gsp-resman-vfio: mdev parent register for %s\n", pci_name(pdev));
+	pr_info("vgsp: mdev parent register for %s\n", pci_name(pdev));
 
 	if (g_mdev_parent) {
-		pr_warn("mdev parent already registered\n");
+		pr_warn("vgsp: mdev parent already registered\n");
 		return 0;
 	}
 
@@ -491,25 +491,25 @@ int nv_vgpu_mdev_register_parent(struct pci_dev *pdev)
 	ret = mdev_register_parent(parent, &pdev->dev, &nv_vgpu_mdev_driver,
 				   nv_vgpu_mdev_types, g_num_vgpu_types);
 	if (ret) {
-		pr_err("Failed to register mdev parent: %d\n", ret);
+		pr_err("vgsp: Failed to register mdev parent: %d\n", ret);
 		kfree(parent);
 		return ret;
 	}
 
 	g_mdev_parent = parent;
-	pr_info("mdev parent registered successfully with %d types\n", g_num_vgpu_types);
+	pr_info("vgsp: mdev parent registered successfully with %d types\n", g_num_vgpu_types);
 	return 0;
 }
 EXPORT_SYMBOL(nv_vgpu_mdev_register_parent);
 
 void nv_vgpu_mdev_unregister_parent(struct pci_dev *pdev)
 {
-	pr_info("gsp-resman-vfio: mdev parent unregister for %s\n", pci_name(pdev));
+	pr_info("vgsp: mdev parent unregister for %s\n", pci_name(pdev));
 
 	if (g_mdev_parent) {
-		pr_info("gsp-resman-vfio: mdev_unregister_parent: entering\n");
+		pr_info("vgsp: mdev_unregister_parent: entering\n");
 		mdev_unregister_parent(g_mdev_parent);
-		pr_info("gsp-resman-vfio: mdev_unregister_parent: returned\n");
+		pr_info("vgsp: mdev_unregister_parent: returned\n");
 		kfree(g_mdev_parent);
 		g_mdev_parent = NULL;
 	}
@@ -519,12 +519,12 @@ EXPORT_SYMBOL(nv_vgpu_mdev_unregister_parent);
 /* NOTE: No MODULE_SOFTDEP on nvidia - this module is fully standalone.
  * It exports the nvidia_vgpu_vfio_* interface (nvidia.ko imports it when
  * present) and registers the mdev parent on the physical GPU directly.
- * Load order for the matched stack: open-iov-vfio.ko BEFORE nvidia.ko. */
+ * Load order for the matched stack: vgsp.ko BEFORE nvidia.ko. */
 
 MODULE_AUTHOR("Open-IOV Project");
 MODULE_DESCRIPTION("Open-IOV vGPU VFIO Mediated Device Driver");
 MODULE_LICENSE("GPL v2");
-MODULE_VERSION(OPEN_IOV_VFIO_VERSION);
+MODULE_VERSION(VGSP_VERSION);
 
 struct nv_vgpu_driver_data nv_vgpu_driver = {
 	.lock = __MUTEX_INITIALIZER(nv_vgpu_driver.lock),
@@ -620,12 +620,12 @@ static void nv_vgpu_mdev_remove(struct mdev_device *mdev)
 	long timeout;
 
 	if (!vgpu) {
-		printk(KERN_ERR "gsp-resman-vfio: No vGPU device data found for mdev %s\n",
+		printk(KERN_ERR "vgsp: No vGPU device data found for mdev %s\n",
 		       dev_name(&mdev->dev));
 		return;
 	}
 
-	pr_info("gsp-resman-vfio: mdev remove started for %s\n", dev_name(&mdev->dev));
+	pr_info("vgsp: mdev remove started for %s\n", dev_name(&mdev->dev));
 
 	/* Cancel pending/running init work first */
 	cancel_work_sync(&vgpu->init_work);
@@ -635,17 +635,17 @@ static void nv_vgpu_mdev_remove(struct mdev_device *mdev)
 	 * otherwise vfio_device_group_unregister can crash with NULL pointer deref.
 	 * vfio_unregister_group_dev() itself blocks until fds drain, so this
 	 * pre-wait exists to surface a clear warning if userspace is stuck. */
-	pr_info("gsp-resman-vfio: waiting for vfio_dev_open_count to reach 0 (current: %d)\n",
+	pr_info("vgsp: waiting for vfio_dev_open_count to reach 0 (current: %d)\n",
 		atomic_read(&vgpu->vfio_dev_open_count));
 
 	timeout = wait_event_timeout(vgpu->vfio_dev_close_wait,
 				     atomic_read(&vgpu->vfio_dev_open_count) == 0,
 				     msecs_to_jiffies(5000));
 	if (timeout == 0) {
-		pr_warn("gsp-resman-vfio: timeout waiting for vfio device close (open_count=%d), proceeding anyway\n",
+		pr_warn("vgsp: timeout waiting for vfio device close (open_count=%d), proceeding anyway\n",
 			atomic_read(&vgpu->vfio_dev_open_count));
 	} else {
-		pr_info("gsp-resman-vfio: all vfio device file descriptors closed\n");
+		pr_info("vgsp: all vfio device file descriptors closed\n");
 	}
 
 	/* Unregister the VFIO device. This removes it from its IOMMU group,
@@ -674,26 +674,26 @@ static void nv_vgpu_mdev_remove(struct mdev_device *mdev)
 	 * the vfio_device refcount drops to zero (ops->release fires first). */
 	vfio_put_device(&vgpu->vfio_dev);
 
-	pr_info("gsp-resman-vfio: mdev remove callback completed for %s\n", dev_name(&mdev->dev));
+	pr_info("vgsp: mdev remove callback completed for %s\n", dev_name(&mdev->dev));
 }
 
 /* VFIO device operations implementations */
 static int nv_vgpu_vfio_dev_init(struct vfio_device *vdev)
 {
-	pr_info("gsp-resman-vfio: VFIO device init\n");
+	pr_info("vgsp: VFIO device init\n");
 	return 0;
 }
 
 static void nv_vgpu_vfio_dev_release(struct vfio_device *vdev)
 {
-	pr_info("gsp-resman-vfio: VFIO device release\n");
+	pr_info("vgsp: VFIO device release\n");
 }
 
 static int nv_vgpu_vfio_dev_open(struct vfio_device *vdev)
 {
 	struct nv_vgpu_device *vgpu = container_of(vdev, struct nv_vgpu_device, vfio_dev);
 	
-	pr_info("gsp-resman-vfio: VFIO device open\n");
+	pr_info("vgsp: VFIO device open\n");
 	atomic_inc(&vgpu->vfio_dev_open_count);
 	return 0;
 }
@@ -703,7 +703,7 @@ static void nv_vgpu_vfio_dev_close(struct vfio_device *vdev)
 	struct nv_vgpu_device *vgpu = container_of(vdev, struct nv_vgpu_device, vfio_dev);
 	int i;
 
-	pr_info("gsp-resman-vfio: VFIO device close\n");
+	pr_info("vgsp: VFIO device close\n");
 
 	/* Release eventfd trigger references wired via SET_IRQS; the next
 	 * opener re-wires its own. Prevents fd/ctx leaks across VM restarts. */
@@ -725,7 +725,7 @@ static ssize_t nv_vgpu_vfio_dev_read(struct vfio_device *vdev, char __user *buf,
 	loff_t pos = *ppos;
 	
 	if (gsp_sema_dbg)
-		pr_info("gsp-resman-vfio: VFIO device read count=%zu pos=%lld (0x%llx)\n",
+		pr_info("vgsp: VFIO device read count=%zu pos=%lld (0x%llx)\n",
 			count, pos, pos);
 
 	/* Config space region: VFIO_PCI_INDEX_TO_OFFSET(VFIO_PCI_CONFIG_REGION_INDEX) = 0x70000000000 */
@@ -782,7 +782,7 @@ static ssize_t nv_vgpu_vfio_dev_write(struct vfio_device *vdev, const char __use
 	loff_t pos = *ppos;
 	
 	if (gsp_sema_dbg)
-		pr_info_ratelimited("gsp-resman-vfio: VFIO device write count=%zu pos=%lld (0x%llx)\n",
+		pr_info_ratelimited("vgsp: VFIO device write count=%zu pos=%lld (0x%llx)\n",
 				    count, pos, pos);
 
 	/* Config space region - route through the per-register filter so the
@@ -821,14 +821,14 @@ static ssize_t nv_vgpu_vfio_dev_write(struct vfio_device *vdev, const char __use
 
 			if ((u64)pos == 0x88704) {
 				if (gsp_sema_dbg && db_log < 512) {
-					pr_info("gsp-resman-vfio: DOORBELL write pos=0x%llx size=%zu val=0x%llx\n",
+					pr_info("vgsp: DOORBELL write pos=0x%llx size=%zu val=0x%llx\n",
 						(u64)pos, count, v);
 					db_log++;
 				}
 				if (count == 4)
 					gsp_sema_service_doorbell((u32)v);
 			} else {
-				pr_info("gsp-resman-vfio: BAR0 write pos=0x%llx size=%zu val=0x%llx\n",
+				pr_info("vgsp: BAR0 write pos=0x%llx size=%zu val=0x%llx\n",
 					(u64)pos, count, v);
 				bar0_log++;
 			}
@@ -853,7 +853,7 @@ static ssize_t nv_vgpu_vfio_dev_write(struct vfio_device *vdev, const char __use
 
 			memcpy(&v, buf, count);
 
-			pr_info("gsp-resman-vfio: BAR1 write off=0x%llx size=%zu val=0x%llx\n",
+			pr_info("vgsp: BAR1 write off=0x%llx size=%zu val=0x%llx\n",
 				bar1_off, count, v);
 			bar1_log++;
 		}
@@ -874,24 +874,24 @@ static long nv_vgpu_vfio_dev_ioctl(struct vfio_device *vdev, unsigned int cmd,
 	unsigned long minsz;
 	int ret;
 	
-	pr_info("gsp-resman-vfio: VFIO device ioctl cmd=0x%x\n", cmd);
+	pr_info("vgsp: VFIO device ioctl cmd=0x%x\n", cmd);
 
 	if (cmd == VFIO_DEVICE_GET_INFO) {
 		struct vfio_device_info info;
 
 		minsz = offsetofend(struct vfio_device_info, num_irqs);
 
-		pr_info("gsp-resman-vfio: VFIO_DEVICE_GET_INFO minsz=%lu argsz=%u\n", minsz, info.argsz);
+		pr_info("vgsp: VFIO_DEVICE_GET_INFO minsz=%lu argsz=%u\n", minsz, info.argsz);
 
 		if (copy_from_user(&info, (void __user *)arg, minsz)) {
-			pr_err("gsp-resman-vfio: VFIO_DEVICE_GET_INFO copy_from_user failed\n");
+			pr_err("vgsp: VFIO_DEVICE_GET_INFO copy_from_user failed\n");
 			return -EFAULT;
 		}
 
-		pr_info("gsp-resman-vfio: VFIO_DEVICE_GET_INFO argsz=%u minsz=%lu\n", info.argsz, minsz);
+		pr_info("vgsp: VFIO_DEVICE_GET_INFO argsz=%u minsz=%lu\n", info.argsz, minsz);
 
 		if (info.argsz < minsz) {
-			pr_err("gsp-resman-vfio: VFIO_DEVICE_GET_INFO argsz too small\n");
+			pr_err("vgsp: VFIO_DEVICE_GET_INFO argsz too small\n");
 			return -EINVAL;
 		}
 
@@ -899,11 +899,11 @@ static long nv_vgpu_vfio_dev_ioctl(struct vfio_device *vdev, unsigned int cmd,
 		info.num_regions = VFIO_PCI_NUM_REGIONS;
 		info.num_irqs = VFIO_PCI_NUM_IRQS;
 
-		pr_info("gsp-resman-vfio: VFIO_DEVICE_GET_INFO returning flags=0x%x num_regions=%u num_irqs=%u\n",
+		pr_info("vgsp: VFIO_DEVICE_GET_INFO returning flags=0x%x num_regions=%u num_irqs=%u\n",
 			info.flags, info.num_regions, info.num_irqs);
 
 		ret = copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
-		pr_info("gsp-resman-vfio: VFIO_DEVICE_GET_INFO copy_to_user ret=%d\n", ret);
+		pr_info("vgsp: VFIO_DEVICE_GET_INFO copy_to_user ret=%d\n", ret);
 		return ret;
 	}
 
@@ -1061,42 +1061,42 @@ static long nv_vgpu_vfio_dev_ioctl(struct vfio_device *vdev, unsigned int cmd,
 		unsigned long minsz = offsetof(struct vfio_irq_set, data);
 		int *fds = NULL;
 
-		pr_info("gsp-resman-vfio: VFIO_DEVICE_SET_IRQS\n");
+		pr_info("vgsp: VFIO_DEVICE_SET_IRQS\n");
 
 		/* First copy the fixed part to get argsz */
 		if (copy_from_user(&irq_set_hdr, (void __user *)arg, minsz)) {
-			pr_err("gsp-resman-vfio: SET_IRQS copy_from_user hdr failed\n");
+			pr_err("vgsp: SET_IRQS copy_from_user hdr failed\n");
 			return -EFAULT;
 		}
 
-		pr_info("gsp-resman-vfio: SET_IRQS hdr: argsz=%u flags=0x%x index=%u start=%u count=%u\n",
+		pr_info("vgsp: SET_IRQS hdr: argsz=%u flags=0x%x index=%u start=%u count=%u\n",
 			irq_set_hdr.argsz, irq_set_hdr.flags, irq_set_hdr.index, irq_set_hdr.start, irq_set_hdr.count);
 
 		if (irq_set_hdr.argsz < minsz) {
-			pr_err("gsp-resman-vfio: SET_IRQS argsz too small: %u < %lu\n", irq_set_hdr.argsz, minsz);
+			pr_err("vgsp: SET_IRQS argsz too small: %u < %lu\n", irq_set_hdr.argsz, minsz);
 			return -EINVAL;
 		}
 
 		/* Allocate buffer for full struct including data array */
 		irq_set_ptr = kmalloc(irq_set_hdr.argsz, GFP_KERNEL);
 		if (!irq_set_ptr) {
-			pr_err("gsp-resman-vfio: SET_IRQS kmalloc failed\n");
+			pr_err("vgsp: SET_IRQS kmalloc failed\n");
 			return -ENOMEM;
 		}
 
 		if (copy_from_user(irq_set_ptr, (void __user *)arg, irq_set_hdr.argsz)) {
-			pr_err("gsp-resman-vfio: SET_IRQS copy_from_user full failed\n");
+			pr_err("vgsp: SET_IRQS copy_from_user full failed\n");
 			kfree(irq_set_ptr);
 			return -EFAULT;
 		}
 
-		pr_info("gsp-resman-vfio: SET_IRQS full: argsz=%u flags=0x%x index=%u start=%u count=%u\n",
+		pr_info("vgsp: SET_IRQS full: argsz=%u flags=0x%x index=%u start=%u count=%u\n",
 			irq_set_ptr->argsz, irq_set_ptr->flags, irq_set_ptr->index, irq_set_ptr->start, irq_set_ptr->count);
 
 		/* Validate data type */
 		if ((irq_set_ptr->flags & VFIO_IRQ_SET_DATA_TYPE_MASK) == 0 ||
 		    (irq_set_ptr->flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) == 0) {
-			pr_err("gsp-resman-vfio: SET_IRQS invalid flags\n");
+			pr_err("vgsp: SET_IRQS invalid flags\n");
 			kfree(irq_set_ptr);
 			return -EINVAL;
 		}
@@ -1112,7 +1112,7 @@ static long nv_vgpu_vfio_dev_ioctl(struct vfio_device *vdev, unsigned int cmd,
 
 			if (irq_set_ptr->index > VFIO_PCI_REQ_IRQ_INDEX ||
 			    irq_set_ptr->start + irq_set_ptr->count > NV_VGPU_MAX_IRQS) {
-				pr_err("gsp-resman-vfio: SET_IRQS out of range: index=%u start=%u count=%u\n",
+				pr_err("vgsp: SET_IRQS out of range: index=%u start=%u count=%u\n",
 				       irq_set_ptr->index, irq_set_ptr->start, irq_set_ptr->count);
 				kfree(irq_set_ptr);
 				return -EINVAL;
@@ -1126,7 +1126,7 @@ static long nv_vgpu_vfio_dev_ioctl(struct vfio_device *vdev, unsigned int cmd,
 
 			/* Copy eventfds directly from userspace (after the fixed header) */
 			if (copy_from_user(fds, (void __user *)arg + minsz, irq_set_ptr->count * sizeof(int))) {
-				pr_err("gsp-resman-vfio: SET_IRQS copy_from_user data failed\n");
+				pr_err("vgsp: SET_IRQS copy_from_user data failed\n");
 				kfree(fds);
 				kfree(irq_set_ptr);
 				return -EFAULT;
@@ -1144,7 +1144,7 @@ static long nv_vgpu_vfio_dev_ioctl(struct vfio_device *vdev, unsigned int cmd,
 
 					trigger = eventfd_ctx_fdget(fds[i]);
 					if (IS_ERR(trigger)) {
-						pr_err("gsp-resman-vfio: SET_IRQS bad eventfd %d for vector %d\n",
+						pr_err("vgsp: SET_IRQS bad eventfd %d for vector %d\n",
 						       fds[i], idx);
 						continue;
 					}
@@ -1161,7 +1161,7 @@ static long nv_vgpu_vfio_dev_ioctl(struct vfio_device *vdev, unsigned int cmd,
 				}
 			}
 
-			pr_info("gsp-resman-vfio: SET_IRQS wired %d/%d eventfds (index=%d start=%d)\n",
+			pr_info("vgsp: SET_IRQS wired %d/%d eventfds (index=%d start=%d)\n",
 				wired, irq_set_ptr->count, irq_set_ptr->index, irq_set_ptr->start);
 
 			kfree(fds);
@@ -1171,7 +1171,7 @@ static long nv_vgpu_vfio_dev_ioctl(struct vfio_device *vdev, unsigned int cmd,
 
 		/* Handle DATA_NONE (mask/unmask) */
 		if (irq_set_ptr->flags & VFIO_IRQ_SET_DATA_NONE) {
-			pr_info("gsp-resman-vfio: SET_IRQS DATA_NONE index=%d start=%d count=%d action=%x\n",
+			pr_info("vgsp: SET_IRQS DATA_NONE index=%d start=%d count=%d action=%x\n",
 				irq_set_ptr->index, irq_set_ptr->start, irq_set_ptr->count, irq_set_ptr->flags & VFIO_IRQ_SET_ACTION_TYPE_MASK);
 			kfree(irq_set_ptr);
 			return 0;
@@ -1179,7 +1179,7 @@ static long nv_vgpu_vfio_dev_ioctl(struct vfio_device *vdev, unsigned int cmd,
 
 		/* Handle DATA_BOOL */
 		if (irq_set_ptr->flags & VFIO_IRQ_SET_DATA_BOOL) {
-			pr_info("gsp-resman-vfio: SET_IRQS DATA_BOOL index=%d start=%d count=%d\n",
+			pr_info("vgsp: SET_IRQS DATA_BOOL index=%d start=%d count=%d\n",
 				irq_set_ptr->index, irq_set_ptr->start, irq_set_ptr->count);
 			kfree(irq_set_ptr);
 			return 0;
@@ -1216,7 +1216,7 @@ static int nv_vgpu_vfio_dev_mmap(struct vfio_device *vdev, struct vm_area_struct
 	unsigned long region_base;
 	unsigned long region_size;
 
-	pr_info("gsp-resman-vfio: VFIO device mmap offset=0x%lx size=0x%lx\n", offset, size);
+	pr_info("vgsp: VFIO device mmap offset=0x%lx size=0x%lx\n", offset, size);
 
 	/* Config space region */
 	region_base = VFIO_PCI_INDEX_TO_OFFSET(VFIO_PCI_CONFIG_REGION_INDEX);
@@ -1253,7 +1253,7 @@ static int nv_vgpu_vfio_dev_mmap(struct vfio_device *vdev, struct vm_area_struct
 		}
 		/* Debug: log PRAMIN window mapping for BAR2 verify debugging */
 		if (shadow_off <= 0x70e000 && shadow_off + size > 0x70e000) {
-			pr_info("gsp-resman-vfio: BAR0 mmap covers PRAMIN[0xe000] shadow_off=0x%lx size=0x%lx\n",
+			pr_info("vgsp: BAR0 mmap covers PRAMIN[0xe000] shadow_off=0x%lx size=0x%lx\n",
 				shadow_off, size);
 		}
 		return 0;
@@ -1362,13 +1362,13 @@ static int nv_vgpu_vfio_dev_mmap(struct vfio_device *vdev, struct vm_area_struct
 		return -EINVAL;
 	}
 
-	pr_err("gsp-resman-vfio: mmap failed for unknown offset 0x%lx\n", offset);
+	pr_err("vgsp: mmap failed for unknown offset 0x%lx\n", offset);
 	return -EINVAL;
 }
 
 static void nv_vgpu_vfio_dev_dma_unmap(struct vfio_device *vdev, u64 iova, u64 length)
 {
-	pr_info("gsp-resman-vfio: VFIO device dma_unmap iova=0x%llx len=0x%llx\n", iova, length);
+	pr_info("vgsp: VFIO device dma_unmap iova=0x%llx len=0x%llx\n", iova, length);
 }
 
 static int nv_vgpu_vfio_dev_match(struct vfio_device *vdev, char *buf)
@@ -1393,51 +1393,51 @@ static int __init nv_vgpu_init(void)
 	int ret;
 	struct pci_dev *pdev = NULL;
 
-	pr_info("gsp-resman-vfio: init started\n");
+	pr_info("vgsp: init started\n");
 
 	nv_vgpu_driver.class = class_create("nvidia-vgpu");
 	if (IS_ERR(nv_vgpu_driver.class)) {
 		ret = PTR_ERR(nv_vgpu_driver.class);
-		pr_err("Failed to create nvidia-vgpu class: %d\n", ret);
+		pr_err("vgsp: Failed to create nvidia-vgpu class: %d\n", ret);
 		return ret;
 	}
-	pr_info("gsp-resman-vfio: class created\n");
+	pr_info("vgsp: class created\n");
 
 	/* Create static vGPU types as fallback (userspace can override via ioctl) */
 	nv_vgpu_create_static_types();
-	pr_info("gsp-resman-vfio: static types created\n");
+	pr_info("vgsp: static types created\n");
 
 	/* Create mdev types from registered vGPU types */
 	ret = nv_vgpu_create_mdev_types();
 	if (ret) {
-		pr_err("Failed to create mdev types: %d\n", ret);
+		pr_err("vgsp: Failed to create mdev types: %d\n", ret);
 		goto err_class;
 	}
-	pr_info("gsp-resman-vfio: mdev types created\n");
+	pr_info("vgsp: mdev types created\n");
 
 	/* Find the parent PCI device to register mdev parent */
 	pdev = pci_get_device(0x10de, 0x1ed3, NULL);
 	if (!pdev) {
-		pr_err("Failed to find NVIDIA GPU (10de:1ed3) for mdev parent registration\n");
+		pr_err("vgsp: Failed to find NVIDIA GPU (10de:1ed3) for mdev parent registration\n");
 		ret = -ENODEV;
 		goto err_types;
 	}
-	pr_info("gsp-resman-vfio: found GPU %s\n", pci_name(pdev));
+	pr_info("vgsp: found GPU %s\n", pci_name(pdev));
 
 	/* Register mdev parent via nvidia.ko */
 	ret = nv_vgpu_mdev_register_parent(pdev);
 	if (ret) {
-		pr_err("Failed to register mdev parent: %d\n", ret);
+		pr_err("vgsp: Failed to register mdev parent: %d\n", ret);
 		goto err_put_pdev;
 	}
-	pr_info("gsp-resman-vfio: mdev parent registered\n");
+	pr_info("vgsp: mdev parent registered\n");
 
 	ret = mdev_register_driver(&nv_vgpu_mdev_driver);
 	if (ret) {
-		pr_err("Failed to register mdev driver: %d\n", ret);
+		pr_err("vgsp: Failed to register mdev driver: %d\n", ret);
 		goto err_types;
 	}
-	pr_info("gsp-resman-vfio: mdev driver registered\n");
+	pr_info("vgsp: mdev driver registered\n");
 
 	pci_dev_put(pdev);
 	pdev = NULL;
@@ -1445,15 +1445,15 @@ static int __init nv_vgpu_init(void)
 	/* Provide VFIO ops to host driver (nvidia.ko) */
 	ret = nvidia_vgpu_vfio_set_ops(&nv_vgpu_vfio_ops);
 	if (ret) {
-		pr_err("Failed to set VFIO ops: %d\n", ret);
+		pr_err("vgsp: Failed to set VFIO ops: %d\n", ret);
 		goto err_driver;
 	}
-	pr_info("gsp-resman-vfio: VFIO ops set\n");
+	pr_info("vgsp: VFIO ops set\n");
 
 	if (gsp_phys_gpu_param && !gsp_phys_mdev_owned_enabled()) {
 		ret = gsp_phys_gpu_claim();
 		if (ret) {
-			pr_warn("gsp-resman-vfio: physical GPU claim failed: %d\n",
+			pr_warn("vgsp: physical GPU claim failed: %d\n",
 				ret);
 		} else {
 			/*
@@ -1466,13 +1466,13 @@ static int __init nv_vgpu_init(void)
 			 */
 			ret = gsp_phys_backend_start();
 			if (ret)
-				pr_warn("gsp-resman-vfio: physical backend start failed: %d\n",
+				pr_warn("vgsp: physical backend start failed: %d\n",
 					ret);
 		}
 	} else if (gsp_phys_gpu_param) {
-		pr_info("gsp-resman-vfio: gsp_phys_mdev_owned=1: physical GPU claim+boot deferred to the first mdev create\n");
+		pr_info("vgsp: gsp_phys_mdev_owned=1: physical GPU claim+boot deferred to the first mdev create\n");
 	} else if (gsp_phys_mdev_owned_enabled()) {
-		pr_warn("gsp-resman-vfio: gsp_phys_mdev_owned=1 requires gsp_phys_gpu=1; physical backend stays off\n");
+		pr_warn("vgsp: gsp_phys_mdev_owned=1 requires gsp_phys_gpu=1; physical backend stays off\n");
 	}
 
 	/* Test-enabling trigger for the GSP-RM unload RPC plus the read-only
@@ -1480,17 +1480,17 @@ static int __init nv_vgpu_init(void)
 	 * (gsp_phys_boot=1). Removed on module exit. Creation failure is
 	 * non-fatal. */
 	if (gsp_phys_boot_debugfs_init())
-		pr_warn("gsp-resman-vfio: gsp-phys debugfs files unavailable\n");
+		pr_warn("vgsp: gsp-phys debugfs files unavailable\n");
 
-	pr_info("NVIDIA vGPU VFIO driver loaded (version %s)\n", NVIDIA_VGPU_VFIO_VERSION);
+	pr_info("vgsp: NVIDIA vGPU VFIO driver loaded (version %s)\n", NVIDIA_VGPU_VFIO_VERSION);
 	/* Start the emulated-GPU progress service: it discovers the guest's
 	 * GPU-VA -> guest-PA map and applies copy-engine semaphore releases so
 	 * the guest's UVM waits complete. Idle until a VM opens a device. */
 	ret = gsp_sema_service_start();
 	if (ret)
-		pr_warn("gsp-resman-vfio: sema service start failed: %d\n", ret);
+		pr_warn("vgsp: sema service start failed: %d\n", ret);
 
-	pr_info("gsp-resman-vfio: init complete\n");
+	pr_info("vgsp: init complete\n");
 	return 0;
 
 err_driver:
@@ -1510,12 +1510,12 @@ static void __exit nv_vgpu_exit(void)
 	struct pci_dev *pdev = NULL;
 	bool mdev_owned = gsp_phys_mdev_owned_enabled();
 
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: starting cleanup\n");
+	pr_info("vgsp: nv_vgpu_exit: starting cleanup\n");
 
 	/* Break circular dependency with nvidia.ko FIRST
 	 * by clearing the VFIO ops pointer. This signals nvidia.ko
 	 * to release its references to our module. */
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: clearing VFIO ops to break circular dependency\n");
+	pr_info("vgsp: nv_vgpu_exit: clearing VFIO ops to break circular dependency\n");
 	g_vgpu_vfio_ops = NULL;
 
 	gsp_phys_boot_debugfs_fini();
@@ -1563,15 +1563,15 @@ static void __exit nv_vgpu_exit(void)
 		pdev = pci_get_device(0x10de, 0x1ed3, NULL);
 	}
 
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: stopping sema service\n");
+	pr_info("vgsp: nv_vgpu_exit: stopping sema service\n");
 	gsp_sema_service_stop();
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: sema service stopped\n");
+	pr_info("vgsp: nv_vgpu_exit: sema service stopped\n");
 
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: unregistering mdev driver\n");
+	pr_info("vgsp: nv_vgpu_exit: unregistering mdev driver\n");
 	/* Unregister mdev driver FIRST, then mdev parent. This drains the
 	 * mdev remove callbacks, hence the emulation threads. */
 	mdev_unregister_driver(&nv_vgpu_mdev_driver);
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: mdev driver unregistered\n");
+	pr_info("vgsp: nv_vgpu_exit: mdev driver unregistered\n");
 
 	if (mdev_owned) {
 		/* Drain complete: release the mdev-owned claim (no-op when
@@ -1581,22 +1581,22 @@ static void __exit nv_vgpu_exit(void)
 
 	/* Unregister mdev parent via nvidia.ko */
 	if (pdev) {
-		pr_info("gsp-resman-vfio: nv_vgpu_exit: unregistering mdev parent\n");
+		pr_info("vgsp: nv_vgpu_exit: unregistering mdev parent\n");
 		nv_vgpu_mdev_unregister_parent(pdev);
-		pr_info("gsp-resman-vfio: mdev parent unregistered for %s\n", dev_name(&pdev->dev));
+		pr_info("vgsp: mdev parent unregistered for %s\n", dev_name(&pdev->dev));
 		pci_dev_put(pdev);
 		pdev = NULL;
 	}
 
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: destroying class\n");
+	pr_info("vgsp: nv_vgpu_exit: destroying class\n");
 	class_destroy(nv_vgpu_driver.class);
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: class destroyed\n");
+	pr_info("vgsp: nv_vgpu_exit: class destroyed\n");
 
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: freeing type info\n");
+	pr_info("vgsp: nv_vgpu_exit: freeing type info\n");
 	nv_vgpu_free_type_info();
-	pr_info("gsp-resman-vfio: nv_vgpu_exit: type info freed\n");
+	pr_info("vgsp: nv_vgpu_exit: type info freed\n");
 
-	pr_info("NVIDIA vGPU VFIO driver unloaded\n");
+	pr_info("vgsp: NVIDIA vGPU VFIO driver unloaded\n");
 }
 
 static void nv_vgpu_device_init_work(struct work_struct *work)
@@ -1708,20 +1708,20 @@ static void nv_vgpu_device_cleanup_work(struct work_struct *work)
 
 static NV_STATUS nv_vgpu_vfio_probe(struct pci_dev *pdev, NvU32 vgpu_type_id, NvU32 *vgpu_id)
 {
-	pr_info("gsp-resman-vfio: VFIO probe called for vGPU type %u\n", vgpu_type_id);
+	pr_info("vgsp: VFIO probe called for vGPU type %u\n", vgpu_type_id);
 	return NV_OK;
 }
 
 static void nv_vgpu_vfio_remove(struct pci_dev *pdev)
 {
-	pr_info("gsp-resman-vfio: VFIO remove called\n");
+	pr_info("vgsp: VFIO remove called\n");
 	/* Clear VFIO ops to break circular dependency with nvidia.ko */
 	g_vgpu_vfio_ops = NULL;
 }
 
 static NV_STATUS nv_vgpu_vfio_inject_interrupt(void *vgpu_dev)
 {
-	pr_info("gsp-resman-vfio: VFIO inject interrupt called\n");
+	pr_info("vgsp: VFIO inject interrupt called\n");
 	return NV_OK;
 }
 
@@ -2106,14 +2106,14 @@ static ssize_t nv_vgpu_config_write(struct nv_vgpu_device *vgpu, const char __us
 
 NV_STATUS nvidia_vgpu_vfio_probe(struct pci_dev *pdev)
 {
-	pr_info("gsp-resman-vfio: nvidia_vgpu_vfio_probe called for %s\n", pci_name(pdev));
+	pr_info("vgsp: nvidia_vgpu_vfio_probe called for %s\n", pci_name(pdev));
 	return NV_OK;
 }
 EXPORT_SYMBOL(nvidia_vgpu_vfio_probe);
 
 void nvidia_vgpu_vfio_remove(struct pci_dev *pdev, NvBool remove_device)
 {
-	pr_info("gsp-resman-vfio: nvidia_vgpu_vfio_remove called for %s, remove_device=%d\n",
+	pr_info("vgsp: nvidia_vgpu_vfio_remove called for %s, remove_device=%d\n",
 		pci_name(pdev), remove_device);
 }
 EXPORT_SYMBOL(nvidia_vgpu_vfio_remove);
@@ -2121,7 +2121,7 @@ EXPORT_SYMBOL(nvidia_vgpu_vfio_remove);
 /*
  * Debug: scan the guest's RAM for a 64-bit value to locate guest structures
  * without knowing the guest's GPU page tables (see handoff PART 6).
- *   echo 0x121000000 > /sys/module/open_iov_vfio/parameters/scan_guest_ram
+ *   echo 0x121000000 > /sys/module/vgsp/parameters/scan_guest_ram
  * Scans 0..8GB of guest physical address space, 4KB at a time.
  *
  * The scan MUST run in a kthread: vfio_iommu_type1_dma_rw only works when
@@ -2181,7 +2181,7 @@ MODULE_PARM_DESC(scan_guest_ram, "Scan guest RAM for a 64-bit value (hex)");
  * Debug: scan the emulated vidmem (BAR1 shadow, 256MB host buffer) for a
  * 32/64-bit value. Used to find guest page tables / channel structures that
  * the guest writes into its vidmem aperture.
- *   echo 0x21000000 > /sys/module/open_iov_vfio/parameters/scan_vidmem
+ *   echo 0x21000000 > /sys/module/vgsp/parameters/scan_vidmem
  */
 static int nv_vgpu_scan_vidmem_set(const char *val, const struct kernel_param *kp)
 {
@@ -2210,17 +2210,17 @@ static int nv_vgpu_scan_vidmem_set(const char *val, const struct kernel_param *k
 			memcpy(&v64, base + off, 8);
 			memcpy(&v32, base + off, 4);
 			if (v64 == needle) {
-				pr_info("gsp-resman-vfio: vidmem scan: u64 0x%llx at vidmem off 0x%zx\n",
+				pr_info("vgsp: vidmem scan: u64 0x%llx at vidmem off 0x%zx\n",
 					needle, off);
 				hits++;
 			}
 			if (v32 == (u32)needle) {
-				pr_info("gsp-resman-vfio: vidmem scan: u32 0x%x at vidmem off 0x%zx\n",
+				pr_info("vgsp: vidmem scan: u32 0x%x at vidmem off 0x%zx\n",
 					(u32)needle, off);
 				hits++;
 			}
 		}
-		pr_info("gsp-resman-vfio: vidmem scan: needle=0x%llx size=0x%zx hits=%u\n",
+		pr_info("vgsp: vidmem scan: needle=0x%llx size=0x%zx hits=%u\n",
 			needle, size, hits);
 	}
 	mutex_unlock(&nv_vgpu_driver.lock);
@@ -2313,12 +2313,12 @@ static int nv_vgpu_scan_seq_set(const char *val, const struct kernel_param *kp)
 					}
 				}
 				if (ok && hits < 8) {
-					pr_info("gsp-resman-vfio: seq scan: hit in vidmem at off 0x%zx\n",
+					pr_info("vgsp: seq scan: hit in vidmem at off 0x%zx\n",
 						off);
 					hits++;
 				}
 			}
-			pr_info("gsp-resman-vfio: seq scan: vidmem hits=%u\n", hits);
+			pr_info("vgsp: seq scan: vidmem hits=%u\n", hits);
 		}
 	}
 	mutex_unlock(&nv_vgpu_driver.lock);
@@ -2369,7 +2369,7 @@ static int nv_vgpu_shadow_dump_set(const char *val, const struct kernel_param *k
 		u32 i;
 
 		if (!base || off + (u64)n * 4 > size) {
-			pr_info("gsp-resman-vfio: shadow dump: bar%u bad (base=%p size=0x%llx)\n",
+			pr_info("vgsp: shadow dump: bar%u bad (base=%p size=0x%llx)\n",
 				bar, base, size);
 			continue;
 		}
@@ -2377,7 +2377,7 @@ static int nv_vgpu_shadow_dump_set(const char *val, const struct kernel_param *k
 			u32 v;
 
 			memcpy(&v, base + off + i * 4, 4);
-			pr_info("gsp-resman-vfio: shadow bar%u[0x%llx+%u] = 0x%08x\n",
+			pr_info("vgsp: shadow bar%u[0x%llx+%u] = 0x%08x\n",
 				bar, off, i, v);
 		}
 	}
@@ -2436,13 +2436,13 @@ static int nv_vgpu_shadow_scan_set(const char *val, const struct kernel_param *k
 					}
 				}
 				if (ok && hits < 8) {
-					pr_info("gsp-resman-vfio: shadow scan: bar%u hit at 0x%llx\n",
+					pr_info("vgsp: shadow scan: bar%u hit at 0x%llx\n",
 						b, off);
 					hits++;
 				}
 			}
 			if (hits)
-				pr_info("gsp-resman-vfio: shadow scan: bar%u hits=%u\n",
+				pr_info("vgsp: shadow scan: bar%u hits=%u\n",
 					b, hits);
 		}
 	}
@@ -2837,19 +2837,19 @@ static int nv_vgpu_scan_pt_set(const char *val, const struct kernel_param *kp)
 				memcpy(&v64, base + off, 8);
 				memcpy(&v32, base + off, 4);
 				if ((v64 & 0xfffffffffffff000ULL) == pa_page) {
-					pr_info("gsp-resman-vfio: pt scan: vidmem u64 pte 0x%llx at off 0x%zx\n",
+					pr_info("vgsp: pt scan: vidmem u64 pte 0x%llx at off 0x%zx\n",
 						v64, off);
 					if (++hits >= 16)
 						break;
 				}
 				if ((v32 & 0xfffff000U) == (u32)pa_page) {
-					pr_info("gsp-resman-vfio: pt scan: vidmem u32 pte 0x%x at off 0x%zx\n",
+					pr_info("vgsp: pt scan: vidmem u32 pte 0x%x at off 0x%zx\n",
 						v32, off);
 					if (++hits >= 16)
 						break;
 				}
 			}
-			pr_info("gsp-resman-vfio: pt scan: vidmem pa=0x%llx hits=%u\n",
+			pr_info("vgsp: pt scan: vidmem pa=0x%llx hits=%u\n",
 				pa, hits);
 		}
 	}
@@ -2947,7 +2947,7 @@ static int nv_vgpu_fill_vidmem_set(const char *val, const struct kernel_param *k
 			continue;
 		for (o = 0; o + 4 <= size; o += 4)
 			memcpy(base + o, &value, 4);
-		pr_info("gsp-resman-vfio: fill_vidmem value=0x%x size=0x%zx done\n",
+		pr_info("vgsp: fill_vidmem value=0x%x size=0x%zx done\n",
 			value, size);
 	}
 	mutex_unlock(&nv_vgpu_driver.lock);
@@ -2986,7 +2986,7 @@ static int nv_vgpu_poke_thread(void *arg)
 		}
 		req->rc = vfio_dma_rw(&vgpu->vfio_dev, req->gpa, &req->value,
 				      sizeof(req->value), true);
-		pr_info("gsp-resman-vfio: poke gpa=0x%llx value=0x%x rc=%d\n",
+		pr_info("vgsp: poke gpa=0x%llx value=0x%x rc=%d\n",
 			req->gpa, req->value, req->rc);
 	}
 	mutex_unlock(&nv_vgpu_driver.lock);
@@ -3048,7 +3048,7 @@ static int nv_vgpu_poke_fill_thread(void *arg)
 		req->rc = vfio_dma_rw(&vgpu->vfio_dev, req->gpa,
 				      nv_vgpu_fill_buf,
 				      nv_vgpu_fill_count * sizeof(u32), true);
-		pr_info("gsp-resman-vfio: poke_fill gpa=0x%llx count=%u rc=%d\n",
+		pr_info("vgsp: poke_fill gpa=0x%llx count=%u rc=%d\n",
 			req->gpa, nv_vgpu_fill_count, req->rc);
 	}
 	mutex_unlock(&nv_vgpu_driver.lock);
@@ -3138,12 +3138,12 @@ static int nv_vgpu_dump_vidmem_set(const char *val, const struct kernel_param *k
 				memcpy(&v, base + o, 4);
 				if (v) {
 					if (nz < 32)
-						pr_info("gsp-resman-vfio: vidmem nz[0x%zx]=0x%x\n",
+						pr_info("vgsp: vidmem nz[0x%zx]=0x%x\n",
 							o, v);
 					nz++;
 				}
 			}
-			pr_info("gsp-resman-vfio: vidmem summary: size=0x%zx nonzero_dwords=%u\n",
+			pr_info("vgsp: vidmem summary: size=0x%zx nonzero_dwords=%u\n",
 				size, nz);
 		}
 		mutex_unlock(&nv_vgpu_driver.lock);
@@ -3173,7 +3173,7 @@ static int nv_vgpu_dump_vidmem_set(const char *val, const struct kernel_param *k
 		for (o = 0; o < len; o += 64) {
 			u32 n = min_t(unsigned long, len - o, 64);
 
-			pr_info("gsp-resman-vfio: vidmem[0x%lx..0x%lx]=%*phN\n",
+			pr_info("vgsp: vidmem[0x%lx..0x%lx]=%*phN\n",
 				off + o, off + o + n, (int)n, base + off + o);
 		}
 	}
@@ -3231,7 +3231,7 @@ static int nv_vgpu_dump_bar0_set(const char *val, const struct kernel_param *kp)
 		for (o = 0; o < len; o += 64) {
 			u32 n = min_t(unsigned long, len - o, 64);
 
-			pr_info("gsp-resman-vfio: bar0[0x%lx..0x%lx]=%*phN\n",
+			pr_info("vgsp: bar0[0x%lx..0x%lx]=%*phN\n",
 				off + o, off + o + n, (int)n, base + off + o);
 		}
 	}
@@ -3271,12 +3271,12 @@ static int nv_vgpu_scan_bar0_set(const char *val, const struct kernel_param *kp)
 
 			memcpy(&v, base + o, 4);
 			if (v == (u32)needle) {
-				pr_info("gsp-resman-vfio: bar0 scan: 0x%x at off 0x%zx\n",
+				pr_info("vgsp: bar0 scan: 0x%x at off 0x%zx\n",
 					v, o);
 				hits++;
 			}
 		}
-		pr_info("gsp-resman-vfio: bar0 scan: needle=0x%lx hits=%u\n",
+		pr_info("vgsp: bar0 scan: needle=0x%lx hits=%u\n",
 			needle, hits);
 	}
 	mutex_unlock(&nv_vgpu_driver.lock);
@@ -3321,11 +3321,11 @@ static int nv_vgpu_find_userd_set(const char *val, const struct kernel_param *kp
 			if (get > put)
 				continue;
 			if (shown < 32)
-				pr_info("gsp-resman-vfio: userd cand off=0x%zx get=%u put=%u\n",
+				pr_info("vgsp: userd cand off=0x%zx get=%u put=%u\n",
 					off, get, put);
 			shown++;
 		}
-		pr_info("gsp-resman-vfio: userd scan: candidates=%d\n", shown);
+		pr_info("vgsp: userd scan: candidates=%d\n", shown);
 	}
 	mutex_unlock(&nv_vgpu_driver.lock);
 	return 0;
@@ -3361,7 +3361,7 @@ static int nv_vgpu_poke_vidmem_set(const char *val, const struct kernel_param *k
 			break;
 		}
 		memcpy(vgpu->bars[1].vaddr + off, &value, 4);
-		pr_info("poke_vidmem: [0x%llx] = 0x%llx\n", off, value);
+		pr_info("vgsp-poke-vidmem: [0x%llx] = 0x%llx\n", off, value);
 		break;
 	}
 	mutex_unlock(&nv_vgpu_driver.lock);
@@ -3403,7 +3403,7 @@ static int nv_vgpu_dump_guest_thread(void *arg)
 
 		if (atomic_read(&vgpu->vfio_dev_open_count) <= 0)
 			continue;
-		pr_info("gsp-resman-vfio: guest dump 0x%llx..0x%llx\n",
+		pr_info("vgsp: guest dump 0x%llx..0x%llx\n",
 			req->gpa, req->gpa + req->len);
 		for (o = 0; o < req->len; o += 256) {
 			unsigned long chunk = min_t(unsigned long, 256,
@@ -3411,12 +3411,12 @@ static int nv_vgpu_dump_guest_thread(void *arg)
 
 			if (vfio_dma_rw(&vgpu->vfio_dev, req->gpa + o, buf,
 					chunk, false)) {
-				pr_info("gsp-resman-vfio: guest dump read failed at 0x%llx\n",
+				pr_info("vgsp: guest dump read failed at 0x%llx\n",
 					req->gpa + o);
 				break;
 			}
 			for (i = 0; i < chunk / 4; i += 4)
-				pr_info("gsp-resman-vfio: 0x%llx: %08x %08x %08x %08x\n",
+				pr_info("vgsp: 0x%llx: %08x %08x %08x %08x\n",
 					req->gpa + o + i * 4, buf[i], buf[i + 1],
 					buf[i + 2], buf[i + 3]);
 		}
@@ -3501,7 +3501,7 @@ static int nv_vgpu_inject_irq_set(const char *val, const struct kernel_param *kp
 		trigger = vgpu->irqs[idx].trigger;
 		if (trigger)
 			eventfd_signal(trigger);
-		pr_info("gsp-resman-vfio: inject_irq %lu (trigger %s)\n",
+		pr_info("vgsp: inject_irq %lu (trigger %s)\n",
 			idx, trigger ? "fired" : "missing");
 		ret = 0;
 	}
@@ -3581,7 +3581,7 @@ static int nv_vgpu_rmpost_thread(void *arg)
 		if (atomic_read(&vgpu->vfio_dev_open_count) <= 0)
 			continue;
 		req->rc = gsp_rm_force_post(vgpu, req->idx);
-		pr_info("gsp-resman-vfio: rmpost idx=%u -> %d\n",
+		pr_info("vgsp: rmpost idx=%u -> %d\n",
 			req->idx, req->rc);
 	}
 	mutex_unlock(&nv_vgpu_driver.lock);