// module_main.c - Main module entry point
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include <linux/version.h>

#include "module_private.h"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Enterprise Systems Team");
MODULE_DESCRIPTION("Advanced Enterprise Kernel Module");
MODULE_VERSION("2.0.0");
MODULE_ALIAS("enterprise_module");

// Module parameters with validation
static int debug_level = 0;
module_param(debug_level, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug_level, "Debug level (0-3)");

static char *device_name = "enterprise_dev";
module_param(device_name, charp, S_IRUGO);
MODULE_PARM_DESC(device_name, "Device name for /dev/ entry");

static int max_devices = 4;
module_param(max_devices, int, S_IRUGO);
MODULE_PARM_DESC(max_devices, "Maximum number of devices (1-16)");

// Global module state
struct enterprise_module {
    dev_t devt;
    struct class *class;
    struct device *device;
    struct cdev cdev;
    struct mutex device_mutex;
    struct workqueue_struct *workqueue;
    atomic_t ref_count;
    
    // Statistics
    atomic_long_t operations_count;
    atomic_long_t error_count;
    unsigned long start_time;
    
    // Configuration
    struct enterprise_config config;
};

static struct enterprise_module *enterprise_mod = NULL;

// Forward declarations
static int enterprise_open(struct inode *inode, struct file *file);
static int enterprise_release(struct inode *inode, struct file *file);
static ssize_t enterprise_read(struct file *file, char __user *buf, 
                              size_t count, loff_t *ppos);
static ssize_t enterprise_write(struct file *file, const char __user *buf,
                               size_t count, loff_t *ppos);
static long enterprise_ioctl(struct file *file, unsigned int cmd, 
                            unsigned long arg);

// File operations structure
static const struct file_operations enterprise_fops = {
    .owner = THIS_MODULE,
    .open = enterprise_open,
    .release = enterprise_release,
    .read = enterprise_read,
    .write = enterprise_write,
    .unlocked_ioctl = enterprise_ioctl,
    .compat_ioctl = enterprise_ioctl,
};

// Parameter validation function
static int validate_module_params(void)
{
    if (debug_level < 0 || debug_level > 3) {
        pr_err("Invalid debug_level: %d (must be 0-3)\n", debug_level);
        return -EINVAL;
    }
    
    if (max_devices < 1 || max_devices > 16) {
        pr_err("Invalid max_devices: %d (must be 1-16)\n", max_devices);
        return -EINVAL;
    }
    
    if (!device_name || strlen(device_name) == 0) {
        pr_err("Invalid device_name\n");
        return -EINVAL;
    }
    
    return 0;
}

// Module initialization
static int __init enterprise_module_init(void)
{
    int ret;
    
    pr_info("Enterprise Module v%s initializing...\n", MODULE_VERSION(""));
    
    // Validate parameters
    ret = validate_module_params();
    if (ret)
        return ret;
    
    // Allocate module structure
    enterprise_mod = kzalloc(sizeof(*enterprise_mod), GFP_KERNEL);
    if (!enterprise_mod)
        return -ENOMEM;
    
    // Initialize synchronization primitives
    mutex_init(&enterprise_mod->device_mutex);
    atomic_set(&enterprise_mod->ref_count, 0);
    atomic_long_set(&enterprise_mod->operations_count, 0);
    atomic_long_set(&enterprise_mod->error_count, 0);
    enterprise_mod->start_time = jiffies;
    
    // Create workqueue
    enterprise_mod->workqueue = alloc_workqueue("enterprise_wq", 
                                               WQ_MEM_RECLAIM | WQ_HIGHPRI, 
                                               max_devices);
    if (!enterprise_mod->workqueue) {
        ret = -ENOMEM;
        goto err_free_module;
    }
    
    // Allocate device numbers
    ret = alloc_chrdev_region(&enterprise_mod->devt, 0, max_devices, 
                             "enterprise_module");
    if (ret) {
        pr_err("Failed to allocate device numbers: %d\n", ret);
        goto err_destroy_workqueue;
    }
    
    // Initialize character device
    cdev_init(&enterprise_mod->cdev, &enterprise_fops);
    enterprise_mod->cdev.owner = THIS_MODULE;
    
    ret = cdev_add(&enterprise_mod->cdev, enterprise_mod->devt, max_devices);
    if (ret) {
        pr_err("Failed to add character device: %d\n", ret);
        goto err_unregister_chrdev;
    }
    
    // Create device class
    enterprise_mod->class = class_create(THIS_MODULE, "enterprise_class");
    if (IS_ERR(enterprise_mod->class)) {
        ret = PTR_ERR(enterprise_mod->class);
        pr_err("Failed to create device class: %d\n", ret);
        goto err_del_cdev;
    }
    
    // Create device file
    enterprise_mod->device = device_create(enterprise_mod->class, NULL,
                                          enterprise_mod->devt, NULL,
                                          "%s", device_name);
    if (IS_ERR(enterprise_mod->device)) {
        ret = PTR_ERR(enterprise_mod->device);
        pr_err("Failed to create device: %d\n", ret);
        goto err_destroy_class;
    }
    
    // Initialize module-specific components
    ret = enterprise_hardware_init(&enterprise_mod->config);
    if (ret) {
        pr_err("Hardware initialization failed: %d\n", ret);
        goto err_destroy_device;
    }
    
    pr_info("Enterprise Module initialized successfully\n");
    return 0;

err_destroy_device:
    device_destroy(enterprise_mod->class, enterprise_mod->devt);
err_destroy_class:
    class_destroy(enterprise_mod->class);
err_del_cdev:
    cdev_del(&enterprise_mod->cdev);
err_unregister_chrdev:
    unregister_chrdev_region(enterprise_mod->devt, max_devices);
err_destroy_workqueue:
    destroy_workqueue(enterprise_mod->workqueue);
err_free_module:
    kfree(enterprise_mod);
    enterprise_mod = NULL;
    return ret;
}

// Module cleanup
static void __exit enterprise_module_exit(void)
{
    if (!enterprise_mod)
        return;
    
    pr_info("Enterprise Module shutting down...\n");
    
    // Cleanup hardware
    enterprise_hardware_cleanup(&enterprise_mod->config);
    
    // Remove device and class
    device_destroy(enterprise_mod->class, enterprise_mod->devt);
    class_destroy(enterprise_mod->class);
    
    // Remove character device
    cdev_del(&enterprise_mod->cdev);
    unregister_chrdev_region(enterprise_mod->devt, max_devices);
    
    // Cleanup workqueue
    flush_workqueue(enterprise_mod->workqueue);
    destroy_workqueue(enterprise_mod->workqueue);
    
    // Print statistics
    pr_info("Module statistics: operations=%ld, errors=%ld, uptime=%ld jiffies\n",
            atomic_long_read(&enterprise_mod->operations_count),
            atomic_long_read(&enterprise_mod->error_count),
            jiffies - enterprise_mod->start_time);
    
    // Free module structure
    kfree(enterprise_mod);
    enterprise_mod = NULL;
    
    pr_info("Enterprise Module shutdown complete\n");
}

module_init(enterprise_module_init);
module_exit(enterprise_module_exit);

# Makefile for Enterprise Kernel Module
obj-m += enterprise_module.o

enterprise_module-objs := module_main.o module_hardware.o module_utils.o module_proc.o

# Kernel build directory detection
KVER := $(shell uname -r)
KDIR := /lib/modules/$(KVER)/build

# Build flags for different kernel versions
EXTRA_CFLAGS += -DDEBUG -Wall -Wextra -Werror
EXTRA_CFLAGS += -DMODULE_VERSION_STRING=\"$(shell git describe --tags --dirty)\"

# Architecture-specific optimizations
ifeq ($(shell uname -m),x86_64)
    EXTRA_CFLAGS += -march=native -mtune=native
endif

# Build targets
all: modules

modules:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

modules_install:
	$(MAKE) -C $(KDIR) M=$(PWD) modules_install
	depmod -a

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean
	rm -f *.ur-safe

# DKMS integration
dkms-add:
	dkms add -m enterprise_module -v $(VERSION)

dkms-build:
	dkms build -m enterprise_module -v $(VERSION)

dkms-install:
	dkms install -m enterprise_module -v $(VERSION)

dkms-remove:
	dkms remove -m enterprise_module -v $(VERSION) --all

# Development targets
load: modules
	sudo insmod enterprise_module.ko debug_level=2

unload:
	sudo rmmod enterprise_module

reload: unload load

test: reload
	@echo "Running module tests..."
	./test_module.sh

# Static analysis
sparse:
	$(MAKE) -C $(KDIR) M=$(PWD) C=2 CF="-D__CHECK_ENDIAN__" modules

checkpatch:
	$(KDIR)/scripts/checkpatch.pl --no-tree -f *.c *.h

.PHONY: all modules modules_install clean load unload reload test sparse checkpatch

// module_memory.c - Advanced memory management
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/dma-mapping.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/pagemap.h>

// Memory pool for high-frequency allocations
struct memory_pool {
    struct kmem_cache *cache;
    spinlock_t lock;
    struct list_head free_list;
    atomic_t allocated_count;
    atomic_t total_allocated;
    size_t object_size;
    size_t pool_size;
    char name[32];
};

// DMA buffer management
struct dma_buffer {
    void *virt_addr;
    dma_addr_t dma_addr;
    size_t size;
    struct device *dev;
    struct list_head list;
};

struct dma_pool_manager {
    struct list_head buffer_list;
    struct mutex mutex;
    atomic_t buffer_count;
    size_t total_size;
};

static struct dma_pool_manager dma_mgr;

// Initialize memory pool
static int init_memory_pool(struct memory_pool *pool, const char *name,
                           size_t object_size, size_t pool_size)
{
    snprintf(pool->name, sizeof(pool->name), "%s", name);
    pool->object_size = object_size;
    pool->pool_size = pool_size;
    
    // Create slab cache
    pool->cache = kmem_cache_create(pool->name, object_size, 0,
                                   SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
    if (!pool->cache)
        return -ENOMEM;
    
    spin_lock_init(&pool->lock);
    INIT_LIST_HEAD(&pool->free_list);
    atomic_set(&pool->allocated_count, 0);
    atomic_set(&pool->total_allocated, 0);
    
    return 0;
}

// Allocate from memory pool
static void *pool_alloc(struct memory_pool *pool, gfp_t flags)
{
    void *obj;
    unsigned long irq_flags;
    
    // Try to get from free list first
    spin_lock_irqsave(&pool->lock, irq_flags);
    if (!list_empty(&pool->free_list)) {
        struct pool_object *pool_obj = list_first_entry(&pool->free_list,
                                                       struct pool_object, list);
        list_del(&pool_obj->list);
        spin_unlock_irqrestore(&pool->lock, irq_flags);
        
        atomic_inc(&pool->allocated_count);
        return pool_obj;
    }
    spin_unlock_irqrestore(&pool->lock, irq_flags);
    
    // Allocate new object
    obj = kmem_cache_alloc(pool->cache, flags);
    if (obj) {
        atomic_inc(&pool->allocated_count);
        atomic_inc(&pool->total_allocated);
    }
    
    return obj;
}

// Free to memory pool
static void pool_free(struct memory_pool *pool, void *obj)
{
    struct pool_object *pool_obj = (struct pool_object *)obj;
    unsigned long flags;
    
    if (!obj)
        return;
    
    atomic_dec(&pool->allocated_count);
    
    // Add to free list for reuse
    spin_lock_irqsave(&pool->lock, flags);
    list_add(&pool_obj->list, &pool->free_list);
    spin_unlock_irqrestore(&pool->lock, flags);
}

// DMA buffer allocation with scatter-gather support
static struct dma_buffer *alloc_dma_buffer(struct device *dev, size_t size,
                                          gfp_t flags)
{
    struct dma_buffer *buf;
    
    buf = kzalloc(sizeof(*buf), flags);
    if (!buf)
        return NULL;
    
    // Allocate coherent DMA memory
    buf->virt_addr = dma_alloc_coherent(dev, size, &buf->dma_addr, flags);
    if (!buf->virt_addr) {
        kfree(buf);
        return NULL;
    }
    
    buf->size = size;
    buf->dev = dev;
    INIT_LIST_HEAD(&buf->list);
    
    // Add to global list
    mutex_lock(&dma_mgr.mutex);
    list_add(&buf->list, &dma_mgr.buffer_list);
    atomic_inc(&dma_mgr.buffer_count);
    dma_mgr.total_size += size;
    mutex_unlock(&dma_mgr.mutex);
    
    return buf;
}

// Free DMA buffer
static void free_dma_buffer(struct dma_buffer *buf)
{
    if (!buf)
        return;
    
    // Remove from global list
    mutex_lock(&dma_mgr.mutex);
    list_del(&buf->list);
    atomic_dec(&dma_mgr.buffer_count);
    dma_mgr.total_size -= buf->size;
    mutex_unlock(&dma_mgr.mutex);
    
    // Free DMA memory
    dma_free_coherent(buf->dev, buf->size, buf->virt_addr, buf->dma_addr);
    kfree(buf);
}

// Memory mapping for userspace access
static int enterprise_mmap(struct file *file, struct vm_area_struct *vma)
{
    struct enterprise_device *dev = file->private_data;
    unsigned long size = vma->vm_end - vma->vm_start;
    unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
    
    // Validate mapping request
    if (offset + size > dev->buffer_size)
        return -EINVAL;
    
    // Set VM flags for proper memory mapping
    vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
    vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
    
    // Map DMA buffer to userspace
    if (remap_pfn_range(vma, vma->vm_start,
                       virt_to_phys(dev->dma_buffer->virt_addr + offset) >> PAGE_SHIFT,
                       size, vma->vm_page_prot)) {
        return -EAGAIN;
    }
    
    return 0;
}

// Zero-copy data transfer using get_user_pages
static int zero_copy_transfer(struct enterprise_device *dev,
                             unsigned long user_addr, size_t size,
                             int direction)
{
    struct page **pages;
    int nr_pages;
    int ret, i;
    struct sg_table sg_table;
    
    nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
    pages = kmalloc_array(nr_pages, sizeof(struct page *), GFP_KERNEL);
    if (!pages)
        return -ENOMEM;
    
    // Pin user pages in memory
    down_read(&current->mm->mmap_sem);
    ret = get_user_pages(user_addr, nr_pages,
                        direction == DMA_TO_DEVICE ? 0 : FOLL_WRITE,
                        pages, NULL);
    up_read(&current->mm->mmap_sem);
    
    if (ret != nr_pages) {
        if (ret > 0) {
            for (i = 0; i < ret; i++)
                put_page(pages[i]);
        }
        kfree(pages);
        return -EFAULT;
    }
    
    // Create scatter-gather table
    ret = sg_alloc_table_from_pages(&sg_table, pages, nr_pages,
                                   0, size, GFP_KERNEL);
    if (ret) {
        for (i = 0; i < nr_pages; i++)
            put_page(pages[i]);
        kfree(pages);
        return ret;
    }
    
    // Map for DMA
    ret = dma_map_sg(dev->device, sg_table.sgl, sg_table.nents, direction);
    if (ret == 0) {
        sg_free_table(&sg_table);
        for (i = 0; i < nr_pages; i++)
            put_page(pages[i]);
        kfree(pages);
        return -ENOMEM;
    }
    
    // Perform DMA transfer
    ret = perform_dma_transfer(dev, &sg_table, direction);
    
    // Cleanup
    dma_unmap_sg(dev->device, sg_table.sgl, sg_table.nents, direction);
    sg_free_table(&sg_table);
    
    for (i = 0; i < nr_pages; i++)
        put_page(pages[i]);
    kfree(pages);
    
    return ret;
}

// module_lockfree.c - Lock-free programming in kernel space
#include <linux/atomic.h>
#include <linux/rcu.h>
#include <linux/rcupdate.h>
#include <linux/compiler.h>

// Lock-free ring buffer for high-performance logging
struct lockfree_ringbuf {
    atomic_long_t head;
    atomic_long_t tail;
    size_t size;
    size_t mask;
    struct ringbuf_entry *entries;
};

struct ringbuf_entry {
    atomic_t state;  // 0=empty, 1=writing, 2=ready
    u64 timestamp;
    u32 cpu;
    u32 pid;
    char data[248];
};

#define ENTRY_EMPTY   0
#define ENTRY_WRITING 1
#define ENTRY_READY   2

// Initialize lock-free ring buffer
static int init_lockfree_ringbuf(struct lockfree_ringbuf *rb, size_t size)
{
    // Size must be power of 2
    if (!is_power_of_2(size))
        return -EINVAL;
    
    rb->entries = vzalloc(size * sizeof(struct ringbuf_entry));
    if (!rb->entries)
        return -ENOMEM;
    
    rb->size = size;
    rb->mask = size - 1;
    atomic_long_set(&rb->head, 0);
    atomic_long_set(&rb->tail, 0);
    
    return 0;
}

// Lock-free enqueue operation
static int ringbuf_enqueue(struct lockfree_ringbuf *rb, const char *data,
                          size_t len)
{
    long head, next_head;
    struct ringbuf_entry *entry;
    
    if (len > sizeof(entry->data))
        return -EINVAL;
    
    do {
        head = atomic_long_read(&rb->head);
        next_head = (head + 1) & rb->mask;
        
        // Check if buffer is full
        if (next_head == atomic_long_read(&rb->tail))
            return -ENOSPC;
        
        entry = &rb->entries[head];
        
        // Try to reserve this slot
        if (atomic_cmpxchg(&entry->state, ENTRY_EMPTY, ENTRY_WRITING) != ENTRY_EMPTY)
            continue;
        
        // Move head pointer
        if (atomic_long_cmpxchg(&rb->head, head, next_head) != head) {
            atomic_set(&entry->state, ENTRY_EMPTY);
            continue;
        }
        
        break;
    } while (1);
    
    // Fill entry data
    entry->timestamp = ktime_get_ns();
    entry->cpu = smp_processor_id();
    entry->pid = current->pid;
    memcpy(entry->data, data, len);
    
    // Make entry available
    smp_wmb();
    atomic_set(&entry->state, ENTRY_READY);
    
    return 0;
}

// Lock-free dequeue operation
static int ringbuf_dequeue(struct lockfree_ringbuf *rb, char *data,
                          size_t *len, u64 *timestamp)
{
    long tail;
    struct ringbuf_entry *entry;
    
    tail = atomic_long_read(&rb->tail);
    entry = &rb->entries[tail];
    
    // Check if entry is ready
    if (atomic_read(&entry->state) != ENTRY_READY)
        return -EAGAIN;
    
    // Copy data
    *len = strnlen(entry->data, sizeof(entry->data));
    memcpy(data, entry->data, *len);
    *timestamp = entry->timestamp;
    
    // Mark entry as empty
    atomic_set(&entry->state, ENTRY_EMPTY);
    smp_wmb();
    
    // Move tail pointer
    atomic_long_set(&rb->tail, (tail + 1) & rb->mask);
    
    return 0;
}

// RCU-protected hash table for fast lookups
struct rcu_hash_table {
    struct hlist_head *buckets;
    size_t bucket_count;
    size_t mask;
    atomic_t size;
    struct rcu_head rcu;
};

struct rcu_hash_node {
    struct hlist_node hnode;
    struct rcu_head rcu;
    atomic_t ref_count;
    u64 key;
    void *data;
    size_t data_size;
};

static struct rcu_hash_table *global_hash_table;

// Hash function (FNV-1a)
static u64 hash_function(u64 key)
{
    u64 hash = 14695981039346656037ULL;
    u8 *bytes = (u8 *)&key;
    
    for (int i = 0; i < sizeof(key); i++) {
        hash ^= bytes[i];
        hash *= 1099511628211ULL;
    }
    
    return hash;
}

// RCU-safe hash table lookup
static struct rcu_hash_node *rcu_hash_lookup(struct rcu_hash_table *table,
                                            u64 key)
{
    struct rcu_hash_node *node;
    struct hlist_head *bucket;
    u64 hash = hash_function(key);
    
    rcu_read_lock();
    bucket = &table->buckets[hash & table->mask];
    
    hlist_for_each_entry_rcu(node, bucket, hnode) {
        if (node->key == key) {
            if (atomic_inc_not_zero(&node->ref_count)) {
                rcu_read_unlock();
                return node;
            }
        }
    }
    
    rcu_read_unlock();
    return NULL;
}

// RCU-safe hash table insertion
static int rcu_hash_insert(struct rcu_hash_table *table, u64 key,
                          void *data, size_t data_size)
{
    struct rcu_hash_node *node, *existing;
    struct hlist_head *bucket;
    u64 hash = hash_function(key);
    
    // Check if key already exists
    existing = rcu_hash_lookup(table, key);
    if (existing) {
        rcu_hash_put(existing);
        return -EEXIST;
    }
    
    // Allocate new node
    node = kzalloc(sizeof(*node) + data_size, GFP_KERNEL);
    if (!node)
        return -ENOMEM;
    
    node->key = key;
    node->data = (char *)node + sizeof(*node);
    node->data_size = data_size;
    memcpy(node->data, data, data_size);
    atomic_set(&node->ref_count, 1);
    INIT_HLIST_NODE(&node->hnode);
    
    // Insert into table
    bucket = &table->buckets[hash & table->mask];
    hlist_add_head_rcu(&node->hnode, bucket);
    atomic_inc(&table->size);
    
    return 0;
}

// Reference counting with RCU
static void rcu_hash_put(struct rcu_hash_node *node)
{
    if (atomic_dec_and_test(&node->ref_count)) {
        call_rcu(&node->rcu, rcu_hash_free_node);
    }
}

static void rcu_hash_free_node(struct rcu_head *rcu)
{
    struct rcu_hash_node *node = container_of(rcu, struct rcu_hash_node, rcu);
    kfree(node);
}

// module_interrupts.c - Advanced interrupt and workqueue handling
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/kthread.h>
#include <linux/completion.h>

// High-performance interrupt handler structure
struct enterprise_irq_handler {
    int irq;
    unsigned long flags;
    struct tasklet_struct tasklet;
    struct work_struct work;
    struct workqueue_struct *workqueue;
    
    // Statistics
    atomic_long_t irq_count;
    atomic_long_t tasklet_count;
    atomic_long_t work_count;
    u64 last_irq_time;
    u64 max_irq_latency;
    u64 total_irq_time;
    
    // Rate limiting
    unsigned long last_rate_check;
    atomic_t rate_count;
    int rate_limit;
    
    void *private_data;
};

// Top-half interrupt handler (minimal processing)
static irqreturn_t enterprise_irq_handler(int irq, void *dev_id)
{
    struct enterprise_irq_handler *handler = 
        (struct enterprise_irq_handler *)dev_id;
    u64 start_time = ktime_get_ns();
    
    // Read hardware status quickly
    u32 status = readl(handler->private_data);
    if (!(status & IRQ_STATUS_MASK))
        return IRQ_NONE;
    
    // Clear interrupt source
    writel(status, handler->private_data + IRQ_CLEAR_REG);
    
    // Update statistics
    atomic_long_inc(&handler->irq_count);
    handler->last_irq_time = start_time;
    
    // Rate limiting check
    if (time_after(jiffies, handler->last_rate_check + HZ)) {
        int current_rate = atomic_read(&handler->rate_count);
        if (current_rate > handler->rate_limit) {
            pr_warn("IRQ rate limit exceeded: %d/sec\n", current_rate);
            // Could disable interrupt temporarily
        }
        atomic_set(&handler->rate_count, 0);
        handler->last_rate_check = jiffies;
    }
    atomic_inc(&handler->rate_count);
    
    // Schedule bottom-half processing
    tasklet_schedule(&handler->tasklet);
    
    // Calculate IRQ latency
    u64 irq_time = ktime_get_ns() - start_time;
    handler->total_irq_time += irq_time;
    if (irq_time > handler->max_irq_latency)
        handler->max_irq_latency = irq_time;
    
    return IRQ_HANDLED;
}

// Tasklet for time-critical processing
static void enterprise_tasklet_func(unsigned long data)
{
    struct enterprise_irq_handler *handler = 
        (struct enterprise_irq_handler *)data;
    
    atomic_long_inc(&handler->tasklet_count);
    
    // Time-critical processing here
    // - Update hardware registers
    // - Process high-priority data
    // - Schedule work for non-critical tasks
    
    // Queue work for longer processing
    queue_work(handler->workqueue, &handler->work);
}

// Work function for non-critical processing
static void enterprise_work_func(struct work_struct *work)
{
    struct enterprise_irq_handler *handler = 
        container_of(work, struct enterprise_irq_handler, work);
    
    atomic_long_inc(&handler->work_count);
    
    // Non-critical processing here
    // - Complex data processing
    // - Memory allocation
    // - User space communication
    
    // Example: Process data buffers
    process_interrupt_data(handler);
}

// Initialize interrupt handling
static int setup_enterprise_irq(struct enterprise_irq_handler *handler,
                               int irq, void *hw_base)
{
    int ret;
    
    handler->irq = irq;
    handler->flags = IRQF_SHARED;
    handler->private_data = hw_base;
    handler->rate_limit = 10000; // 10K IRQs per second limit
    
    // Initialize statistics
    atomic_long_set(&handler->irq_count, 0);
    atomic_long_set(&handler->tasklet_count, 0);
    atomic_long_set(&handler->work_count, 0);
    atomic_set(&handler->rate_count, 0);
    handler->last_rate_check = jiffies;
    
    // Create dedicated workqueue
    handler->workqueue = alloc_workqueue("enterprise_irq_wq",
                                        WQ_MEM_RECLAIM | WQ_HIGHPRI, 1);
    if (!handler->workqueue)
        return -ENOMEM;
    
    // Initialize tasklet
    tasklet_init(&handler->tasklet, enterprise_tasklet_func,
                (unsigned long)handler);
    
    // Initialize work
    INIT_WORK(&handler->work, enterprise_work_func);
    
    // Request IRQ
    ret = request_irq(irq, enterprise_irq_handler, handler->flags,
                     "enterprise_module", handler);
    if (ret) {
        destroy_workqueue(handler->workqueue);
        return ret;
    }
    
    return 0;
}

// Cleanup interrupt handling
static void cleanup_enterprise_irq(struct enterprise_irq_handler *handler)
{
    // Free IRQ
    free_irq(handler->irq, handler);
    
    // Kill tasklet
    tasklet_kill(&handler->tasklet);
    
    // Flush and destroy workqueue
    flush_workqueue(handler->workqueue);
    destroy_workqueue(handler->workqueue);
    
    // Print final statistics
    pr_info("IRQ Statistics: irqs=%ld, tasklets=%ld, works=%ld\n",
            atomic_long_read(&handler->irq_count),
            atomic_long_read(&handler->tasklet_count),
            atomic_long_read(&handler->work_count));
    
    if (handler->irq_count > 0) {
        u64 avg_latency = handler->total_irq_time / 
                         atomic_long_read(&handler->irq_count);
        pr_info("IRQ Latency: avg=%llu ns, max=%llu ns\n",
                avg_latency, handler->max_irq_latency);
    }
}

// module_chardev.c - Advanced character device implementation
#include <linux/fs.h>
#include <linux/poll.h>
#include <linux/select.h>
#include <linux/wait.h>
#include <linux/fasync.h>

// Device state management
enum device_state {
    DEVICE_STATE_IDLE,
    DEVICE_STATE_ACTIVE,
    DEVICE_STATE_ERROR,
    DEVICE_STATE_SUSPENDED
};

struct enterprise_char_device {
    struct cdev cdev;
    struct device *device;
    struct class *class;
    dev_t devt;
    
    // State management
    enum device_state state;
    struct mutex state_mutex;
    atomic_t open_count;
    
    // I/O buffers and queues
    struct circ_buf tx_buffer;
    struct circ_buf rx_buffer;
    wait_queue_head_t tx_wait;
    wait_queue_head_t rx_wait;
    spinlock_t buffer_lock;
    
    // Async notification
    struct fasync_struct *async_queue;
    
    // Statistics and diagnostics
    struct device_stats stats;
    struct proc_dir_entry *proc_entry;
    
    // Configuration
    struct device_config config;
    
    // Work for background processing
    struct delayed_work periodic_work;
    struct workqueue_struct *workqueue;
};

// File operation implementations
static int enterprise_open(struct inode *inode, struct file *file)
{
    struct enterprise_char_device *dev;
    int ret = 0;
    
    dev = container_of(inode->i_cdev, struct enterprise_char_device, cdev);
    
    // Check device state
    mutex_lock(&dev->state_mutex);
    if (dev->state == DEVICE_STATE_ERROR) {
        ret = -EIO;
        goto unlock;
    }
    
    if (dev->state == DEVICE_STATE_SUSPENDED) {
        ret = -EAGAIN;
        goto unlock;
    }
    
    // Check exclusive access if required
    if (dev->config.exclusive_access && atomic_read(&dev->open_count) > 0) {
        ret = -EBUSY;
        goto unlock;
    }
    
    atomic_inc(&dev->open_count);
    dev->state = DEVICE_STATE_ACTIVE;
    
    file->private_data = dev;
    
    // Initialize per-file state if needed
    if (file->f_flags & O_NONBLOCK) {
        // Set non-blocking mode
    }
    
    // Update statistics
    dev->stats.open_count++;
    dev->stats.last_open = ktime_get_real_seconds();
    
unlock:
    mutex_unlock(&dev->state_mutex);
    
    if (ret == 0)
        pr_debug("Device opened, open_count=%d\n", 
                atomic_read(&dev->open_count));
    
    return ret;
}

static int enterprise_release(struct inode *inode, struct file *file)
{
    struct enterprise_char_device *dev = file->private_data;
    
    mutex_lock(&dev->state_mutex);
    
    // Remove from async notification list
    fasync_helper(-1, file, 0, &dev->async_queue);
    
    atomic_dec(&dev->open_count);
    
    // If this was the last close, transition to idle
    if (atomic_read(&dev->open_count) == 0) {
        dev->state = DEVICE_STATE_IDLE;
        
        // Flush buffers if configured
        if (dev->config.flush_on_close) {
            unsigned long flags;
            spin_lock_irqsave(&dev->buffer_lock, flags);
            dev->tx_buffer.head = dev->tx_buffer.tail = 0;
            dev->rx_buffer.head = dev->rx_buffer.tail = 0;
            spin_unlock_irqrestore(&dev->buffer_lock, flags);
        }
    }
    
    // Update statistics
    dev->stats.close_count++;
    dev->stats.last_close = ktime_get_real_seconds();
    
    mutex_unlock(&dev->state_mutex);
    
    pr_debug("Device closed, open_count=%d\n", 
            atomic_read(&dev->open_count));
    
    return 0;
}

static ssize_t enterprise_read(struct file *file, char __user *buf,
                              size_t count, loff_t *ppos)
{
    struct enterprise_char_device *dev = file->private_data;
    ssize_t ret = 0;
    size_t bytes_read = 0;
    unsigned long flags;
    DEFINE_WAIT(wait);
    
    if (count == 0)
        return 0;
    
    while (bytes_read < count) {
        size_t available, to_read;
        
        spin_lock_irqsave(&dev->buffer_lock, flags);
        
        // Check available data in circular buffer
        available = CIRC_CNT(dev->rx_buffer.head, dev->rx_buffer.tail,
                           dev->config.buffer_size);
        
        if (available == 0) {
            spin_unlock_irqrestore(&dev->buffer_lock, flags);
            
            // No data available
            if (file->f_flags & O_NONBLOCK) {
                ret = bytes_read ? bytes_read : -EAGAIN;
                break;
            }
            
            // Block waiting for data
            prepare_to_wait(&dev->rx_wait, &wait, TASK_INTERRUPTIBLE);
            
            if (signal_pending(current)) {
                finish_wait(&dev->rx_wait, &wait);
                ret = bytes_read ? bytes_read : -ERESTARTSYS;
                break;
            }
            
            schedule();
            finish_wait(&dev->rx_wait, &wait);
            continue;
        }
        
        // Calculate how much to read
        to_read = min(available, count - bytes_read);
        to_read = min(to_read, CIRC_CNT_TO_END(dev->rx_buffer.head,
                                              dev->rx_buffer.tail,
                                              dev->config.buffer_size));
        
        spin_unlock_irqrestore(&dev->buffer_lock, flags);
        
        // Copy to user space
        if (copy_to_user(buf + bytes_read,
                        dev->rx_buffer.buf + dev->rx_buffer.tail,
                        to_read)) {
            ret = bytes_read ? bytes_read : -EFAULT;
            break;
        }
        
        // Update tail pointer
        spin_lock_irqsave(&dev->buffer_lock, flags);
        dev->rx_buffer.tail = (dev->rx_buffer.tail + to_read) & 
                             (dev->config.buffer_size - 1);
        spin_unlock_irqrestore(&dev->buffer_lock, flags);
        
        bytes_read += to_read;
        
        // Wake up writers if buffer was full
        wake_up_interruptible(&dev->tx_wait);
    }
    
    // Update statistics
    if (bytes_read > 0) {
        dev->stats.bytes_read += bytes_read;
        dev->stats.read_operations++;
    }
    
    return ret ? ret : bytes_read;
}

static ssize_t enterprise_write(struct file *file, const char __user *buf,
                               size_t count, loff_t *ppos)
{
    struct enterprise_char_device *dev = file->private_data;
    ssize_t ret = 0;
    size_t bytes_written = 0;
    unsigned long flags;
    DEFINE_WAIT(wait);
    
    if (count == 0)
        return 0;
    
    while (bytes_written < count) {
        size_t space, to_write;
        
        spin_lock_irqsave(&dev->buffer_lock, flags);
        
        // Check available space in circular buffer
        space = CIRC_SPACE(dev->tx_buffer.head, dev->tx_buffer.tail,
                          dev->config.buffer_size);
        
        if (space == 0) {
            spin_unlock_irqrestore(&dev->buffer_lock, flags);
            
            // No space available
            if (file->f_flags & O_NONBLOCK) {
                ret = bytes_written ? bytes_written : -EAGAIN;
                break;
            }
            
            // Block waiting for space
            prepare_to_wait(&dev->tx_wait, &wait, TASK_INTERRUPTIBLE);
            
            if (signal_pending(current)) {
                finish_wait(&dev->tx_wait, &wait);
                ret = bytes_written ? bytes_written : -ERESTARTSYS;
                break;
            }
            
            schedule();
            finish_wait(&dev->tx_wait, &wait);
            continue;
        }
        
        // Calculate how much to write
        to_write = min(space, count - bytes_written);
        to_write = min(to_write, CIRC_SPACE_TO_END(dev->tx_buffer.head,
                                                  dev->tx_buffer.tail,
                                                  dev->config.buffer_size));
        
        spin_unlock_irqrestore(&dev->buffer_lock, flags);
        
        // Copy from user space
        if (copy_from_user(dev->tx_buffer.buf + dev->tx_buffer.head,
                          buf + bytes_written, to_write)) {
            ret = bytes_written ? bytes_written : -EFAULT;
            break;
        }
        
        // Update head pointer
        spin_lock_irqsave(&dev->buffer_lock, flags);
        dev->tx_buffer.head = (dev->tx_buffer.head + to_write) & 
                             (dev->config.buffer_size - 1);
        spin_unlock_irqrestore(&dev->buffer_lock, flags);
        
        bytes_written += to_write;
        
        // Wake up readers
        wake_up_interruptible(&dev->rx_wait);
        
        // Send async notification
        kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
    }
    
    // Trigger background processing
    if (bytes_written > 0) {
        queue_delayed_work(dev->workqueue, &dev->periodic_work, 0);
        
        // Update statistics
        dev->stats.bytes_written += bytes_written;
        dev->stats.write_operations++;
    }
    
    return ret ? ret : bytes_written;
}

// Poll/select support
static __poll_t enterprise_poll(struct file *file, poll_table *wait)
{
    struct enterprise_char_device *dev = file->private_data;
    __poll_t mask = 0;
    unsigned long flags;
    
    poll_wait(file, &dev->rx_wait, wait);
    poll_wait(file, &dev->tx_wait, wait);
    
    spin_lock_irqsave(&dev->buffer_lock, flags);
    
    // Check for readable data
    if (CIRC_CNT(dev->rx_buffer.head, dev->rx_buffer.tail,
                dev->config.buffer_size) > 0) {
        mask |= EPOLLIN | EPOLLRDNORM;
    }
    
    // Check for writable space
    if (CIRC_SPACE(dev->tx_buffer.head, dev->tx_buffer.tail,
                  dev->config.buffer_size) > 0) {
        mask |= EPOLLOUT | EPOLLWRNORM;
    }
    
    spin_unlock_irqrestore(&dev->buffer_lock, flags);
    
    // Check error conditions
    if (dev->state == DEVICE_STATE_ERROR) {
        mask |= EPOLLERR;
    }
    
    return mask;
}

// Async notification support
static int enterprise_fasync(int fd, struct file *file, int on)
{
    struct enterprise_char_device *dev = file->private_data;
    return fasync_helper(fd, file, on, &dev->async_queue);
}

// module_debug.c - Advanced debugging and tracing
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/trace_events.h>
#include <linux/ftrace.h>

// Debug levels
#define DEBUG_LEVEL_NONE    0
#define DEBUG_LEVEL_ERROR   1
#define DEBUG_LEVEL_WARN    2
#define DEBUG_LEVEL_INFO    3
#define DEBUG_LEVEL_DEBUG   4
#define DEBUG_LEVEL_TRACE   5

extern int debug_level;

// Debug macros with rate limiting
#define enterprise_err(fmt, ...) \
    do { \
        if (debug_level >= DEBUG_LEVEL_ERROR) \
            pr_err_ratelimited("enterprise: " fmt, ##__VA_ARGS__); \
    } while (0)

#define enterprise_warn(fmt, ...) \
    do { \
        if (debug_level >= DEBUG_LEVEL_WARN) \
            pr_warn_ratelimited("enterprise: " fmt, ##__VA_ARGS__); \
    } while (0)

#define enterprise_info(fmt, ...) \
    do { \
        if (debug_level >= DEBUG_LEVEL_INFO) \
            pr_info("enterprise: " fmt, ##__VA_ARGS__); \
    } while (0)

#define enterprise_debug(fmt, ...) \
    do { \
        if (debug_level >= DEBUG_LEVEL_DEBUG) \
            pr_debug("enterprise: [%s:%d] " fmt, __func__, __LINE__, ##__VA_ARGS__); \
    } while (0)

// Function tracing
#define enterprise_trace_enter() \
    do { \
        if (debug_level >= DEBUG_LEVEL_TRACE) \
            pr_debug("enterprise: -> %s\n", __func__); \
    } while (0)

#define enterprise_trace_exit() \
    do { \
        if (debug_level >= DEBUG_LEVEL_TRACE) \
            pr_debug("enterprise: <- %s\n", __func__); \
    } while (0)

// Performance measurement
struct perf_measurement {
    u64 start_time;
    u64 end_time;
    const char *function;
    int line;
};

#define PERF_MEASURE_START(name) \
    struct perf_measurement name = { \
        .start_time = ktime_get_ns(), \
        .function = __func__, \
        .line = __LINE__ \
    }

#define PERF_MEASURE_END(name) \
    do { \
        name.end_time = ktime_get_ns(); \
        if (debug_level >= DEBUG_LEVEL_DEBUG) { \
            pr_debug("enterprise: PERF %s:%d took %llu ns\n", \
                    name.function, name.line, \
                    name.end_time - name.start_time); \
        } \
    } while (0)

// Statistics collection
struct debug_stats {
    atomic_long_t function_calls[32];  // Function call counters
    atomic_long_t error_counts[16];    // Error type counters
    atomic_long_t performance_buckets[8]; // Performance buckets
    u64 last_reset_time;
    struct mutex stats_mutex;
};

static struct debug_stats debug_stats;
static struct dentry *debug_dir;

// Function call tracking
enum function_id {
    FUNC_OPEN = 0,
    FUNC_CLOSE,
    FUNC_READ,
    FUNC_WRITE,
    FUNC_IOCTL,
    FUNC_IRQ_HANDLER,
    FUNC_TASKLET,
    FUNC_WORK,
    // Add more as needed
    FUNC_COUNT
};

#define TRACK_FUNCTION_CALL(func_id) \
    atomic_long_inc(&debug_stats.function_calls[func_id])

// Error tracking
enum error_id {
    ERROR_MEMORY_ALLOC = 0,
    ERROR_HARDWARE_FAIL,
    ERROR_INVALID_PARAM,
    ERROR_TIMEOUT,
    // Add more as needed
    ERROR_COUNT
};

#define TRACK_ERROR(error_id) \
    atomic_long_inc(&debug_stats.error_counts[error_id])

// DebugFS interface
static int debug_stats_show(struct seq_file *m, void *v)
{
    int i;
    
    seq_printf(m, "Enterprise Module Debug Statistics\n");
    seq_printf(m, "==================================\n\n");
    
    seq_printf(m, "Function Call Counts:\n");
    const char *func_names[] = {
        "open", "close", "read", "write", "ioctl",
        "irq_handler", "tasklet", "work"
    };
    
    for (i = 0; i < min(FUNC_COUNT, ARRAY_SIZE(func_names)); i++) {
        seq_printf(m, "  %-12s: %ld\n", func_names[i],
                  atomic_long_read(&debug_stats.function_calls[i]));
    }
    
    seq_printf(m, "\nError Counts:\n");
    const char *error_names[] = {
        "memory_alloc", "hardware_fail", "invalid_param", "timeout"
    };
    
    for (i = 0; i < min(ERROR_COUNT, ARRAY_SIZE(error_names)); i++) {
        seq_printf(m, "  %-12s: %ld\n", error_names[i],
                  atomic_long_read(&debug_stats.error_counts[i]));
    }
    
    seq_printf(m, "\nUptime: %llu seconds\n",
              (ktime_get_ns() - debug_stats.last_reset_time) / 1000000000ULL);
    
    return 0;
}

static int debug_stats_open(struct inode *inode, struct file *file)
{
    return single_open(file, debug_stats_show, NULL);
}

static ssize_t debug_stats_write(struct file *file, const char __user *buf,
                                 size_t count, loff_t *ppos)
{
    char command[32];
    int i;
    
    if (count >= sizeof(command))
        return -EINVAL;
    
    if (copy_from_user(command, buf, count))
        return -EFAULT;
    
    command[count] = '\0';
    
    if (strncmp(command, "reset", 5) == 0) {
        mutex_lock(&debug_stats.stats_mutex);
        
        // Reset all counters
        for (i = 0; i < FUNC_COUNT; i++)
            atomic_long_set(&debug_stats.function_calls[i], 0);
        
        for (i = 0; i < ERROR_COUNT; i++)
            atomic_long_set(&debug_stats.error_counts[i], 0);
        
        debug_stats.last_reset_time = ktime_get_ns();
        
        mutex_unlock(&debug_stats.stats_mutex);
        
        enterprise_info("Debug statistics reset\n");
    }
    
    return count;
}

static const struct proc_ops debug_stats_fops = {
    .proc_open    = debug_stats_open,
    .proc_read    = seq_read,
    .proc_write   = debug_stats_write,
    .proc_lseek   = seq_lseek,
    .proc_release = single_release,
};

// Memory leak detection
struct memory_tracker {
    struct list_head allocations;
    struct mutex mutex;
    atomic_t allocation_count;
    atomic_long_t total_allocated;
};

struct allocation_record {
    struct list_head list;
    void *ptr;
    size_t size;
    const char *function;
    int line;
    u64 timestamp;
};

static struct memory_tracker mem_tracker;

// Tracked memory allocation
static void *debug_kmalloc(size_t size, gfp_t flags, 
                          const char *func, int line)
{
    void *ptr;
    struct allocation_record *record;
    
    ptr = kmalloc(size, flags);
    if (!ptr)
        return NULL;
    
    if (debug_level >= DEBUG_LEVEL_DEBUG) {
        record = kmalloc(sizeof(*record), GFP_ATOMIC);
        if (record) {
            record->ptr = ptr;
            record->size = size;
            record->function = func;
            record->line = line;
            record->timestamp = ktime_get_ns();
            
            mutex_lock(&mem_tracker.mutex);
            list_add(&record->list, &mem_tracker.allocations);
            atomic_inc(&mem_tracker.allocation_count);
            atomic_long_add(size, &mem_tracker.total_allocated);
            mutex_unlock(&mem_tracker.mutex);
        }
    }
    
    return ptr;
}

// Tracked memory free
static void debug_kfree(void *ptr, const char *func, int line)
{
    struct allocation_record *record, *tmp;
    
    if (!ptr)
        return;
    
    if (debug_level >= DEBUG_LEVEL_DEBUG) {
        mutex_lock(&mem_tracker.mutex);
        list_for_each_entry_safe(record, tmp, &mem_tracker.allocations, list) {
            if (record->ptr == ptr) {
                list_del(&record->list);
                atomic_dec(&mem_tracker.allocation_count);
                atomic_long_sub(record->size, &mem_tracker.total_allocated);
                kfree(record);
                break;
            }
        }
        mutex_unlock(&mem_tracker.mutex);
    }
    
    kfree(ptr);
}

#define enterprise_kmalloc(size, flags) \
    debug_kmalloc(size, flags, __func__, __LINE__)

#define enterprise_kfree(ptr) \
    debug_kfree(ptr, __func__, __LINE__)

// Initialize debug subsystem
static int init_debug_subsystem(void)
{
    int i;
    
    // Initialize statistics
    for (i = 0; i < FUNC_COUNT; i++)
        atomic_long_set(&debug_stats.function_calls[i], 0);
    
    for (i = 0; i < ERROR_COUNT; i++)
        atomic_long_set(&debug_stats.error_counts[i], 0);
    
    debug_stats.last_reset_time = ktime_get_ns();
    mutex_init(&debug_stats.stats_mutex);
    
    // Initialize memory tracker
    INIT_LIST_HEAD(&mem_tracker.allocations);
    mutex_init(&mem_tracker.mutex);
    atomic_set(&mem_tracker.allocation_count, 0);
    atomic_long_set(&mem_tracker.total_allocated, 0);
    
    // Create debugfs entries
    debug_dir = debugfs_create_dir("enterprise_module", NULL);
    if (IS_ERR(debug_dir))
        return PTR_ERR(debug_dir);
    
    debugfs_create_file("stats", 0644, debug_dir, NULL, &debug_stats_fops);
    debugfs_create_atomic_t("debug_level", 0644, debug_dir, 
                           (atomic_t *)&debug_level);
    debugfs_create_atomic_t("allocation_count", 0444, debug_dir,
                           &mem_tracker.allocation_count);
    
    enterprise_info("Debug subsystem initialized\n");
    return 0;
}

// Cleanup debug subsystem
static void cleanup_debug_subsystem(void)
{
    struct allocation_record *record, *tmp;
    
    debugfs_remove_recursive(debug_dir);
    
    // Check for memory leaks
    mutex_lock(&mem_tracker.mutex);
    if (!list_empty(&mem_tracker.allocations)) {
        enterprise_warn("Memory leaks detected:\n");
        list_for_each_entry_safe(record, tmp, &mem_tracker.allocations, list) {
            enterprise_warn("  Leak: %zu bytes at %p (%s:%d)\n",
                          record->size, record->ptr,
                          record->function, record->line);
            list_del(&record->list);
            kfree(record);
        }
    }
    mutex_unlock(&mem_tracker.mutex);
    
    enterprise_info("Debug subsystem cleaned up\n");
}