kernel: Fix GSP emulation shadow binding, eventfd wiring, RPC livelocks + docs suite + repo reorg

CRITICAL FIXES (guest driver bring-up):
- gsp_emulation.c: emulation engine bound to the WRONG BAR0 - it polled the
  host physical BAR0 (bars[0].vaddr ioremap) for the doorbell and read RPCs
  from a local dma_alloc_wc buffer, while the guest writes land in the
  vzalloc'd bar0_shadow. The RPC path could never work; PBA writes even
  corrupted the host GPU's physical BAR0+0x3000. gsp_emu_init now binds
  exclusively to bar0_shadow (doorbell/mailbox/PBA aliases;
  shared_mem_dma==0 marks the alias so cleanup never dma_free's it).
- main.c SET_IRQS: DATA_EVENTFD eventfds were DISCARDED ('TODO' + kfree) -
  the guest never received MSI-X completions. Full wiring now:
  eventfd_ctx_fdget per vector, fd -1 clears, dev_close releases refs.
  gsp_emu_inject_completion_interrupt looks up vgpu->irqs[0].trigger LIVE
  (init-time copy was permanently NULL since QEMU wires after gsp_emu_init).
- gsp_rpc_client.c: BAR_TRAP/MIGRATE in emulation mode called
  gsp_rpc_submit_raw which rings the SAME doorbell the thread polls -
  self-triggered RPC livelock + multi-second stalls. Now fail fast with
  -ENOTSUPP + pr_warn_ratelimited (guest BAR access is direct MMIO).

MORE FIXES:
- main.c: nv_vgpu_config_write returned SIZE_MAX (while(count--) wrap) and
  was dead code while the VFIO write handler did unfiltered byte copies
  (guest could rewrite vendor ID/BARs). Return fixed; VFIO write handler
  now routes through the per-register filter.
- kernel/Makefile: M=$(PWD) used the env var which is stale when invoked
  via the top-level make (pointed at repo root -> kbuild silently built
  NOTHING; explains every 'stale .ko' incident). Now M=$(CURDIR).
- Warnings sweep: header prototypes for mdev/type functions, format casts
  in gsp_comm.c DRY-RUN logs, unused variable.

ROBUSTNESS (harness/tooling):
- vgpu_vm.py: run had no timeout (start could block forever);
  guest_shell recv could block forever on a wedged guest. Both now bounded;
  guest_shell pre-flights guest-ping and reports wedge diagnostics.
- stack_manager.sh: qemu/qemu-debug now launch via the vgpu_vm.py harness
  (workflow rule: never raw QEMU).

REPO REORGANIZATION:
- driver/ (legacy guest-side gsp-vgpu.ko) moved to legacy-driver-guest/
  (reference only, not built; README explains). 3 legacy un-buildable test
  files moved to legacy-driver-guest/kernel-tests/. Top-level Makefile
  cleaned of the dead DRIVER_DIR reference.

DOCUMENTATION SUITE (new):
- docs/GSP_EMULATION_ARCHITECTURE.md - emulator deep-dive: shadow BAR0
  model, doorbell protocol, dispatch table, MSI-X path, lifecycle, memory-
  model caveats
- docs/DEBUGGING.md - QEMU GDB stub workflow, serial console, QMP NMI,
  failure taxonomy, full bring-up validation checklist, EPT-livelock case
  study, version-matrix discipline
- docs/ONBOARDING.md - repo tour, coding standards (incl. virt_to_phys /
  dma_addr_t / get-put rules), first build & test
- docs/VERSION_UPGRADE.md - end-to-end new-driver-version procedure
  (firmware fetch, Ghidra analysis, configs, signatures, validation)
- docs/PERFORMANCE.md - bare-metal A/B methodology + targets
- README.md doc index; STATE.md refreshed; DEVELOPMENT_WORKFLOW.md corrected
  (load order: open-iov-vfio BEFORE nvidia; stock-driver blacklist note)

1 files changed, 0 insertions, 432 deletions

diff --git a/kernel/tests/gsp_vgpu_comprehensive_test.c b/kernel/tests/gsp_vgpu_comprehensive_test.c
deleted file mode 100644
index 7918beb..0000000
--- a/kernel/tests/gsp_vgpu_comprehensive_test.c
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
- * GSP vGPU-IO Driver - Comprehensive Test Suite
- * Tests all driver components: RPC, VF, BAR, WPR, Migration
- * Compiles against kernel headers only (no driver dependency)
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/errno.h>
-#include <linux/ktime.h>
-#include <linux/atomic.h>
-#include <linux/list.h>
-#include <linux/idr.h>
-#include <linux/mutex.h>
-#include <linux/kref.h>
-#include <linux/completion.h>
-#include <linux/wait.h>
-#include <linux/spinlock.h>
-#include <linux/debugfs.h>
-#include <linux/vmalloc.h>
-
-#include <gsp_core.h>
-
-static int test_count = 0;
-static int pass_count = 0;
-static int fail_count = 0;
-
-#define TEST_ASSERT(cond, msg) \
-    do { \
-        test_count++; \
-        if (cond) { \
-            pass_count++; \
-            pr_info("PASS: %s\n", msg); \
-        } else { \
-            fail_count++; \
-            pr_err("FAIL: %s\n", msg); \
-        } \
-    } while (0)
-
-#define TEST_ASSERT_EQ(a, b, msg) \
-    TEST_ASSERT((a) == (b), msg " (expected " #b ", got " #a ")")
-
-#define TEST_ASSERT_NE(a, b, msg) \
-    TEST_ASSERT((a) != (b), msg " (expected not " #b ", got " #a ")")
-
-/* ============================================================
- * Test: Kernel API Availability
- * ============================================================ */
-
-static int test_kernel_apis(void)
-{
-    pr_info("=== Testing Kernel API Availability ===\n");
-
-    /* Test kref */
-    struct kref *ref = kmalloc(sizeof(*ref), GFP_KERNEL);
-    TEST_ASSERT(ref != NULL, "kref allocation");
-    kref_init(ref);
-    TEST_ASSERT(kref_read(ref) == 1, "kref_init sets refcount to 1");
-    
-    kref_get(ref);
-    TEST_ASSERT(kref_read(ref) == 2, "kref_get increments refcount");
-    
-    kref_put(ref, (void (*)(struct kref *))kfree);
-    TEST_ASSERT(kref_read(ref) == 1, "kref_put decrements refcount");
-    
-    kref_put(ref, (void (*)(struct kref *))kfree);
-    TEST_ASSERT(kref_read(ref) == 0, "kref_put reaches zero");
-
-    /* Test completion */
-    struct completion comp;
-    init_completion(&comp);
-    TEST_ASSERT(!completion_done(&comp), "completion initially not done");
-    complete(&comp);
-    TEST_ASSERT(completion_done(&comp), "completion marked done");
-    
-    init_completion(&comp);
-    TEST_ASSERT(wait_for_completion_timeout(&comp, msecs_to_jiffies(100)) > 0,
-                "wait_for_completion_timeout works");
-
-    /* Test atomic64 */
-    atomic64_t a64 = ATOMIC64_INIT(0);
-    atomic64_inc(&a64);
-    TEST_ASSERT_EQ(atomic64_read(&a64), 1, "atomic64_inc");
-    atomic64_add(5, &a64);
-    TEST_ASSERT_EQ(atomic64_read(&a64), 6, "atomic64_add");
-    atomic64_sub(3, &a64);
-    TEST_ASSERT_EQ(atomic64_read(&a64), 3, "atomic64_sub");
-
-    /* Test mutex */
-    struct mutex mtx;
-    mutex_init(&mtx);
-    mutex_lock(&mtx);
-    TEST_ASSERT(mutex_is_locked(&mtx), "mutex_is_locked after lock");
-    mutex_unlock(&mtx);
-    TEST_ASSERT(!mutex_is_locked(&mtx), "mutex_is_locked after unlock");
-
-    /* Test spinlock */
-    spinlock_t sl = __SPIN_LOCK_UNLOCKED(sl);
-    unsigned long flags;
-    spin_lock_irqsave(&sl, flags);
-    TEST_ASSERT(spin_is_locked(&sl), "spin_is_locked after lock");
-    spin_unlock_irqrestore(&sl, flags);
-    TEST_ASSERT(!spin_is_locked(&sl), "spin_is_locked after unlock");
-
-    /* Test idr */
-    struct idr idr;
-    idr_init(&idr);
-    int id = idr_alloc(&idr, (void *)0xdeadbeef, 1, 100, GFP_KERNEL);
-    TEST_ASSERT(id >= 1 && id < 100, "idr_alloc returns valid id");
-    void *ptr = idr_find(&idr, id);
-    TEST_ASSERT(ptr == (void *)0xdeadbeef, "idr_find returns correct pointer");
-    idr_remove(&idr, id);
-    TEST_ASSERT(idr_find(&idr, id) == NULL, "idr_remove works");
-    idr_destroy(&idr);
-
-    /* Test list */
-    struct list_head head;
-    INIT_LIST_HEAD(&head);
-    TEST_ASSERT(list_empty(&head), "list_empty on new list");
-    
-    struct list_head item;
-    INIT_LIST_HEAD(&item);
-    list_add(&item, &head);
-    TEST_ASSERT(!list_empty(&head), "list not empty after add");
-    list_del(&item);
-    TEST_ASSERT(list_empty(&head), "list empty after del");
-
-    /* Test ktime */
-    ktime_t start = ktime_get();
-    ktime_t end = ktime_get();
-    s64 diff = ktime_to_ns(ktime_sub(end, start));
-    TEST_ASSERT(diff >= 0, "ktime_get and ktime_to_ns work");
-
-    return 0;
-}
-
-/* ============================================================
- * Test: Structure Sizes (from driver header)
- * ============================================================ */
-
-static int test_structure_sizes(void)
-{
-    pr_info("=== Testing Structure Sizes ===\n");
-
-    /* These sizes must match driver/include/gsp_core.h */
-    TEST_ASSERT_EQ(sizeof(struct gsp_rpc_header), 64, "gsp_rpc_header size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_rpc_message), 256, "gsp_rpc_message size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_rpc_response), 32, "gsp_rpc_response size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_alloc_payload), 40, "gsp_alloc_payload size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_alloc_response), 24, "gsp_alloc_response size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_pin_payload), 40, "gsp_pin_payload size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_pin_response), 8, "gsp_pin_response size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_bar_trap_payload), 40, "gsp_bar_trap_payload size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_bar_trap_response), 8, "gsp_bar_trap_response size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_migrate_payload), 56, "gsp_migrate_payload size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_subcmd_desc), 8, "gsp_subcmd_desc size");
-    TEST_ASSERT_EQ(sizeof(struct gsp_vf_config), 56, "gsp_vf_config size");
-
-    return 0;
-}
-
-/* ============================================================
- * Test: Enum Values (from driver header)
- * ============================================================ */
-
-static int test_enum_values(void)
-{
-    pr_info("=== Testing Enum Values ===\n");
-
-    TEST_ASSERT_EQ(GSP_RPC_ALLOC, 0x01, "RPC_ALLOC");
-    TEST_ASSERT_EQ(GSP_RPC_FREE, 0x02, "RPC_FREE");
-    TEST_ASSERT_EQ(GSP_RPC_MAP, 0x03, "RPC_MAP");
-    TEST_ASSERT_EQ(GSP_RPC_UNMAP, 0x04, "RPC_UNMAP");
-    TEST_ASSERT_EQ(GSP_RPC_PIN, 0x05, "RPC_PIN");
-    TEST_ASSERT_EQ(GSP_RPC_UNPIN, 0x06, "RPC_UNPIN");
-    TEST_ASSERT_EQ(GSP_RPC_SCHEDULE, 0x07, "RPC_SCHEDULE");
-    TEST_ASSERT_EQ(GSP_RPC_YIELD, 0x08, "RPC_YIELD");
-    TEST_ASSERT_EQ(GSP_RPC_NOTIFY, 0x09, "RPC_NOTIFY");
-    TEST_ASSERT_EQ(GSP_RPC_BAR_TRAP, 0x0A, "RPC_BAR_TRAP");
-    TEST_ASSERT_EQ(GSP_RPC_MIGRATE, 0x0B, "RPC_MIGRATE");
-    TEST_ASSERT_EQ(GSP_RPC_DEBUG, 0x0C, "RPC_DEBUG");
-
-    TEST_ASSERT_EQ(GSP_MEM_VRAM, 0, "MEM_VRAM");
-    TEST_ASSERT_EQ(GSP_MEM_SYSMEM, 1, "MEM_SYSMEM");
-    TEST_ASSERT_EQ(GSP_MEM_UNCACHED, 2, "MEM_UNCACHED");
-
-    TEST_ASSERT_EQ(GSP_PIN_READ, (1 << 0), "PIN_READ");
-    TEST_ASSERT_EQ(GSP_PIN_WRITE, (1 << 1), "PIN_WRITE");
-    TEST_ASSERT_EQ(GSP_PIN_LONGTERM, (1 << 2), "PIN_LONGTERM");
-
-    TEST_ASSERT_EQ(GSP_MIG_QUERY, 0, "MIG_QUERY");
-    TEST_ASSERT_EQ(GSP_MIG_PREPARE, 1, "MIG_PREPARE");
-    TEST_ASSERT_EQ(GSP_MIG_TRANSFER, 2, "MIG_TRANSFER");
-    TEST_ASSERT_EQ(GSP_MIG_COMMIT, 3, "MIG_COMMIT");
-    TEST_ASSERT_EQ(GSP_MIG_CLEANUP, 4, "MIG_CLEANUP");
-
-    TEST_ASSERT_EQ(GSP_MIG_LIVE, (1 << 0), "MIG_LIVE");
-    TEST_ASSERT_EQ(GSP_MIG_POSTCOPY, (1 << 1), "MIG_POSTCOPY");
-    TEST_ASSERT_EQ(GSP_MIG_AUTO_COMMIT, (1 << 2), "MIG_AUTO_COMMIT");
-    TEST_ASSERT_EQ(GSP_MIG_VERIFY, (1 << 3), "MIG_VERIFY");
-
-    TEST_ASSERT_EQ(GSP_VF_CREATING, 0, "VF_CREATING");
-    TEST_ASSERT_EQ(GSP_VF_ACTIVE, 1, "VF_ACTIVE");
-    TEST_ASSERT_EQ(GSP_VF_MIGRATING, 2, "VF_MIGRATING");
-    TEST_ASSERT_EQ(GSP_VF_SUSPENDED, 3, "VF_SUSPENDED");
-    TEST_ASSERT_EQ(GSP_VF_DESTROYING, 4, "VF_DESTROYING");
-
-    return 0;
-}
-
-/* ============================================================
- * Test: Error Code Mapping
- * ============================================================ */
-
-static int test_error_codes(void)
-{
-    pr_info("=== Testing Error Codes ===\n");
-
-    TEST_ASSERT_EQ(GSP_OK, 0, "GSP_OK");
-    TEST_ASSERT_EQ(GSP_EPERM, 0xFFFFFFFF, "GSP_EPERM");
-    TEST_ASSERT_EQ(GSP_ENOENT, 0xFFFFFFFE, "GSP_ENOENT");
-    TEST_ASSERT_EQ(GSP_EINVAL, 0xFFFFFFFD, "GSP_EINVAL");
-    TEST_ASSERT_EQ(GSP_ENODEV, 0xFFFFFFFA, "GSP_ENODEV");
-    TEST_ASSERT_EQ(GSP_ENOMEM, 0xFFFFFFF4, "GSP_ENOMEM");
-    TEST_ASSERT_EQ(GSP_EBUSY, 0xFFFFFFEE, "GSP_EBUSY");
-    TEST_ASSERT_EQ(GSP_ENOSPC, 0xFFFFFFE4, "GSP_ENOSPC");
-    TEST_ASSERT_EQ(GSP_ETIMEDOUT, 0x0000001E, "GSP_ETIMEDOUT");
-    TEST_ASSERT_EQ(GSP_EOVERFLOW, 0x00000025, "GSP_EOVERFLOW");
-    TEST_ASSERT_EQ(GSP_EDEV, 0x0000001F, "GSP_EDEV");
-
-    return 0;
-}
-
-/* ============================================================
- * Test: Firmware Constants
- * ============================================================ */
-
-static int test_firmware_constants(void)
-{
-    pr_info("=== Testing Firmware Constants ===\n");
-
-    TEST_ASSERT_EQ(GSP_FW_BASE_ADDR, 0x04000000ULL, "FW_BASE_ADDR");
-    TEST_ASSERT_EQ(GSP_FW_SIZE, 0x02000000ULL, "FW_SIZE");
-    TEST_ASSERT_EQ(GSP_ENTRY_POINT, 0x04009000ULL, "ENTRY_POINT");
-    TEST_ASSERT_EQ(GSP_PRIMARY_DISPATCHER, 0x057A1AC0ULL, "PRIMARY_DISPATCHER");
-    TEST_ASSERT_EQ(GSP_SECONDARY_DISPATCHER, 0x04ED39DCULL, "SECONDARY_DISPATCHER");
-    TEST_ASSERT_EQ(GSP_RPC_JUMP_TABLE, 0x059BFEB0ULL, "RPC_JUMP_TABLE");
-    TEST_ASSERT_EQ(GSP_BAR0_DOORBELL, 0x1000, "BAR0_DOORBELL");
-    TEST_ASSERT_EQ(GSP_BAR0_MSIX, 0x2000, "BAR0_MSIX");
-    TEST_ASSERT_EQ(GSP_MSG_RING_SIZE, 256, "MSG_RING_SIZE");
-    TEST_ASSERT_EQ(GSP_MSG_MAX_SIZE, 256, "MSG_MAX_SIZE");
-    TEST_ASSERT_EQ(GSP_MAX_PENDING, 64, "MAX_PENDING");
-
-    return 0;
-}
-
-/* ============================================================
- * Test: Migration State Enum (internal)
- * ============================================================ */
-
-static int test_migration_states(void)
-{
-    pr_info("=== Testing Migration States ===\n");
-
-    TEST_ASSERT_EQ(GSP_MIG_S_IDLE, 0, "MIG_S_IDLE");
-    TEST_ASSERT_EQ(GSP_MIG_S_QUERY, 1, "MIG_S_QUERY");
-    TEST_ASSERT_EQ(GSP_MIG_S_PREPARE, 2, "MIG_S_PREPARE");
-    TEST_ASSERT_EQ(GSP_MIG_S_TRANSFER, 3, "MIG_S_TRANSFER");
-    TEST_ASSERT_EQ(GSP_MIG_S_COMMIT, 4, "MIG_S_COMMIT");
-    TEST_ASSERT_EQ(GSP_MIG_S_CLEANUP, 5, "MIG_S_CLEANUP");
-    TEST_ASSERT_EQ(GSP_MIG_S_FAILED, 6, "MIG_S_FAILED");
-    TEST_ASSERT_EQ(GSP_MIG_S_COMPLETED, 7, "MIG_S_COMPLETED");
-
-    return 0;
-}
-
-/* ============================================================
- * Test: WPR Flags and Events
- * ============================================================ */
-
-static int test_wpr_flags(void)
-{
-    pr_info("=== Testing WPR Flags ===\n");
-
-    TEST_ASSERT_EQ(GSP_WPR_WRITE, (1 << 0), "WPR_WRITE");
-    TEST_ASSERT_EQ(GSP_WPR_READ, (1 << 1), "WPR_READ");
-    TEST_ASSERT_EQ(GSP_WPR_EXECUTE, (1 << 2), "WPR_EXECUTE");
-
-    TEST_ASSERT_EQ(GSP_WPR_WRITE_COMPLETE, 0, "WPR_WRITE_COMPLETE");
-    TEST_ASSERT_EQ(GSP_WPR_READ_COMPLETE, 1, "WPR_READ_COMPLETE");
-    TEST_ASSERT_EQ(GSP_WPR_WRITE_TIMEOUT, 2, "WPR_WRITE_TIMEOUT");
-    TEST_ASSERT_EQ(GSP_WPR_READ_TIMEOUT, 3, "WPR_READ_TIMEOUT");
-
-    return 0;
-}
-
-/* ============================================================
- * Test: Message Flags
- * ============================================================ */
-
-static int test_message_flags(void)
-{
-    pr_info("=== Testing Message Flags ===\n");
-
-    TEST_ASSERT_EQ(GSP_MSG_SYNC, (1 << 0), "MSG_SYNC");
-    TEST_ASSERT_EQ(GSP_MSG_ASYNC, (1 << 1), "MSG_ASYNC");
-    TEST_ASSERT_EQ(GSP_MSG_NOREPLY, (1 << 2), "MSG_NOREPLY");
-
-    return 0;
-}
-
-/* ============================================================
- * Test: BAR Trap Types
- * ============================================================ */
-
-static int test_bar_trap_types(void)
-{
-    pr_info("=== Testing BAR Trap Types ===\n");
-
-    TEST_ASSERT_EQ(GSP_BAR_READ, 0, "BAR_READ");
-    TEST_ASSERT_EQ(GSP_BAR_WRITE, 1, "BAR_WRITE");
-    TEST_ASSERT_EQ(GSP_BAR_ATOMIC, 2, "BAR_ATOMIC");
-
-    return 0;
-}
-
-/* ============================================================
- * Test: Memory Allocation Patterns
- * ============================================================ */
-
-static int test_memory_patterns(void)
-{
-    pr_info("=== Testing Memory Allocation Patterns ===\n");
-
-    /* Test vzalloc/vfree */
-    void *ptr = vzalloc(4096);
-    TEST_ASSERT(ptr != NULL, "vzalloc allocates memory");
-    vfree(ptr);
-
-    /* Test kmalloc/kfree */
-    ptr = kmalloc(1024, GFP_KERNEL);
-    TEST_ASSERT(ptr != NULL, "kmalloc allocates memory");
-    kfree(ptr);
-
-    /* Test kcalloc */
-    ptr = kcalloc(10, 64, GFP_KERNEL);
-    TEST_ASSERT(ptr != NULL, "kcalloc allocates zeroed memory");
-    kfree(ptr);
-
-    return 0;
-}
-
-/* ============================================================
- * Test: String Operations
- * ============================================================ */
-
-static int test_string_ops(void)
-{
-    pr_info("=== Testing String Operations ===\n");
-
-    char buf[64];
-    int len = snprintf(buf, sizeof(buf), "test_%d", 42);
-    TEST_ASSERT(len > 0 && len < sizeof(buf), "snprintf works");
-    TEST_ASSERT(strcmp(buf, "test_42") == 0, "snprintf formats correctly");
-
-    char *dup = kstrdup("test_string", GFP_KERNEL);
-    TEST_ASSERT(dup != NULL, "kstrdup works");
-    TEST_ASSERT(strcmp(dup, "test_string") == 0, "kstrdup copies correctly");
-    kfree(dup);
-
-    return 0;
-}
-
-/* ============================================================
- * Test Suite Runner
- * ============================================================ */
-
-static int run_all_tests(void)
-{
-    pr_info("\n============================================================\n");
-    pr_info("GSP vGPU-IO Comprehensive Test Suite Starting\n");
-    pr_info("============================================================\n\n");
-
-    test_kernel_apis();
-    test_structure_sizes();
-    test_enum_values();
-    test_error_codes();
-    test_firmware_constants();
-    test_migration_states();
-    test_wpr_flags();
-    test_message_flags();
-    test_bar_trap_types();
-    test_memory_patterns();
-    test_string_ops();
-
-    pr_info("\n============================================================\n");
-    pr_info("TEST RESULTS: %d total, %d passed, %d failed\n",
-            test_count, pass_count, fail_count);
-    pr_info("============================================================\n");
-
-    if (fail_count == 0) {
-        pr_info("TEST SUITE PASSED\n");
-        return 0;
-    } else {
-        pr_err("TEST SUITE FAILED\n");
-        return -1;
-    }
-}
-
-/* ============================================================
- * Module Init/Exit
- * ============================================================ */
-
-static int __init gsp_test_init(void)
-{
-    return run_all_tests();
-}
-
-static void __exit gsp_test_exit(void)
-{
-    pr_info("GSP vGPU-IO test module unloaded\n");
-}
-
-module_init(gsp_test_init);
-module_exit(gsp_test_exit);
-
-MODULE_LICENSE("GPL v2");
-MODULE_AUTHOR("NVIDIA vGPU-IO Team");
-MODULE_DESCRIPTION("GSP vGPU-IO Comprehensive Test Suite");
-MODULE_VERSION("1.0.0");
\ No newline at end of file