@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/examples/kernel/proc-file.c

@@ -0,0 +1,131 @@
+/**
+ * @file proc-file.c
+ * @brief Example Linux kernel /proc filesystem interface
+ * 
+ * This example demonstrates:
+ * - Creating /proc entries
+ * - Read/write operations in /proc
+ * - Kernel-user space data transfer
+ * - Sequence file interface
+ * 
+ * Build: make
+ * Load: sudo insmod proc-file.ko
+ * Test: cat /proc/example_proc
+ *       echo "value" > /proc/example_proc
+ * Unload: sudo rmmod proc-file
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <linux/uaccess.h>
+#include <linux/slab.h>
+
+#define PROC_NAME "example_proc"
+#define BUFFER_SIZE 256
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Example Author");
+MODULE_DESCRIPTION("Example /proc file interface");
+MODULE_VERSION("1.0");
+
+static struct proc_dir_entry *proc_entry = NULL;
+static char *proc_buffer = NULL;
+static size_t proc_buffer_size = 0;
+
+/**
+ * @brief Show function for seq_file
+ */
+static int proc_show(struct seq_file *m, void *v) {
+    if (proc_buffer_size > 0) {
+        seq_printf(m, "Stored data: %s\n", proc_buffer);
+        seq_printf(m, "Buffer size: %zu bytes\n", proc_buffer_size);
+    } else {
+        seq_printf(m, "No data stored\n");
+    }
+    
+    seq_printf(m, "Module loaded at: %s %s\n", __DATE__, __TIME__);
+    return 0;
+}
+
+/**
+ * @brief Open function for proc file
+ */
+static int proc_open(struct inode *inode, struct file *file) {
+    return single_open(file, proc_show, NULL);
+}
+
+/**
+ * @brief Write function for proc file
+ */
+static ssize_t proc_write(struct file *file, const char __user *user_buffer,
+                          size_t count, loff_t *offset) {
+    size_t to_copy;
+    
+    if (count > BUFFER_SIZE - 1) {
+        pr_warn("proc_file: Input too large, truncating\n");
+        to_copy = BUFFER_SIZE - 1;
+    } else {
+        to_copy = count;
+    }
+    
+    if (copy_from_user(proc_buffer, user_buffer, to_copy)) {
+        return -EFAULT;
+    }
+    
+    proc_buffer[to_copy] = '\0';  // Null-terminate
+    proc_buffer_size = to_copy;
+    
+    pr_info("proc_file: Received %zu bytes\n", to_copy);
+    return to_copy;
+}
+
+// File operations for proc file
+static const struct proc_ops proc_fops = {
+    .proc_open = proc_open,
+    .proc_read = seq_read,
+    .proc_write = proc_write,
+    .proc_lseek = seq_lseek,
+    .proc_release = single_release,
+};
+
+/**
+ * @brief Module initialization
+ */
+static int __init proc_file_init(void) {
+    pr_info("proc_file: Initializing module\n");
+    
+    // Allocate buffer
+    proc_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
+    if (!proc_buffer) {
+        pr_err("proc_file: Failed to allocate buffer\n");
+        return -ENOMEM;
+    }
+    
+    memset(proc_buffer, 0, BUFFER_SIZE);
+    
+    // Create proc entry
+    proc_entry = proc_create(PROC_NAME, 0666, NULL, &proc_fops);
+    if (!proc_entry) {
+        pr_err("proc_file: Failed to create /proc/%s\n", PROC_NAME);
+        kfree(proc_buffer);
+        return -ENOMEM;
+    }
+    
+    pr_info("proc_file: Created /proc/%s\n", PROC_NAME);
+    return 0;
+}
+
+/**
+ * @brief Module cleanup
+ */
+static void __exit proc_file_exit(void) {
+    proc_remove(proc_entry);
+    kfree(proc_buffer);
+    pr_info("proc_file: Module unloaded\n");
+}
+
+module_init(proc_file_init);
+module_exit(proc_file_exit);
+

package/augment-extensions/coding-standards/c/examples/kernel/simple-module.c

@@ -0,0 +1,111 @@
+/**
+ * @file simple-module.c
+ * @brief Example Linux kernel module demonstrating basic module structure
+ * 
+ * This example demonstrates:
+ * - Module initialization and cleanup
+ * - Module parameters
+ * - Kernel logging (printk)
+ * - Module metadata
+ * - Error handling in init
+ * 
+ * Build: make
+ * Load: sudo insmod simple-module.ko
+ * Load with param: sudo insmod simple-module.ko debug_level=2
+ * Check logs: dmesg | tail
+ * Unload: sudo rmmod simple-module
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Example Author <author@example.com>");
+MODULE_DESCRIPTION("Simple example kernel module");
+MODULE_VERSION("1.0");
+
+// Module parameters
+static int debug_level = 0;
+module_param(debug_level, int, 0644);
+MODULE_PARM_DESC(debug_level, "Debug level (0=off, 1=info, 2=verbose)");
+
+static char *message = "Hello";
+module_param(message, charp, 0644);
+MODULE_PARM_DESC(message, "Custom message to display");
+
+// Module data
+static void *module_data = NULL;
+
+/**
+ * @brief Helper function to demonstrate kernel logging
+ */
+static void log_message(int level, const char *msg) {
+    switch (level) {
+        case 0:
+            pr_err("simple_module: ERROR: %s\n", msg);
+            break;
+        case 1:
+            pr_info("simple_module: INFO: %s\n", msg);
+            break;
+        case 2:
+            pr_debug("simple_module: DEBUG: %s\n", msg);
+            break;
+        default:
+            pr_warn("simple_module: WARN: %s\n", msg);
+    }
+}
+
+/**
+ * @brief Module initialization function
+ * @return 0 on success, negative error code on failure
+ */
+static int __init simple_module_init(void) {
+    pr_info("simple_module: Initializing module\n");
+    pr_info("simple_module: Debug level: %d\n", debug_level);
+    pr_info("simple_module: Message: %s\n", message);
+    
+    // Allocate some memory (example)
+    module_data = kmalloc(1024, GFP_KERNEL);
+    if (!module_data) {
+        pr_err("simple_module: Failed to allocate memory\n");
+        return -ENOMEM;
+    }
+    
+    if (debug_level >= 1) {
+        log_message(1, "Module data allocated successfully");
+    }
+    
+    // Simulate initialization work
+    if (debug_level >= 2) {
+        log_message(2, "Performing detailed initialization");
+    }
+    
+    pr_info("simple_module: Module loaded successfully\n");
+    return 0;
+}
+
+/**
+ * @brief Module cleanup function
+ */
+static void __exit simple_module_exit(void) {
+    pr_info("simple_module: Cleaning up module\n");
+    
+    // Free allocated memory
+    if (module_data) {
+        kfree(module_data);
+        module_data = NULL;
+        
+        if (debug_level >= 1) {
+            log_message(1, "Module data freed");
+        }
+    }
+    
+    pr_info("simple_module: Module unloaded\n");
+}
+
+// Register init and exit functions
+module_init(simple_module_init);
+module_exit(simple_module_exit);
+

package/augment-extensions/coding-standards/c/examples/legacy/Makefile

@@ -0,0 +1,62 @@
+# Makefile for Legacy Maintenance Examples
+
+CC = gcc
+CFLAGS_C89 = -Wall -Wextra -std=c89 -pedantic -DUSE_C89
+CFLAGS_C99 = -Wall -Wextra -std=c99 -pedantic
+CFLAGS_C11 = -Wall -Wextra -std=c11 -pedantic
+
+.PHONY: all clean test compare
+
+all: migration-c89 migration-c11 compatibility
+
+# C89 version of migration example
+migration-c89: c89-to-c11-migration.c
+	$(CC) $(CFLAGS_C89) -o $@ $<
+
+# C11 version of migration example
+migration-c11: c89-to-c11-migration.c
+	$(CC) $(CFLAGS_C11) -o $@ $<
+
+# Compatibility layer
+compatibility: compatibility-layer.c
+	$(CC) $(CFLAGS_C11) -o $@ $<
+
+clean:
+	rm -f migration-c89 migration-c11 compatibility *.o
+
+test: all
+	@echo "=== Testing C89 Version ==="
+	./migration-c89
+	@echo ""
+	@echo "=== Testing C11 Version ==="
+	./migration-c11
+	@echo ""
+	@echo "=== Testing Compatibility Layer ==="
+	./compatibility
+
+compare: all
+	@echo "Comparing C89 vs C11 output:"
+	@echo ""
+	@echo "--- C89 Output ---"
+	@./migration-c89 > /tmp/c89-output.txt 2>&1
+	@cat /tmp/c89-output.txt
+	@echo ""
+	@echo "--- C11 Output ---"
+	@./migration-c11 > /tmp/c11-output.txt 2>&1
+	@cat /tmp/c11-output.txt
+	@echo ""
+	@echo "--- Differences ---"
+	@diff -u /tmp/c89-output.txt /tmp/c11-output.txt || true
+
+help:
+	@echo "Legacy Maintenance Examples Makefile"
+	@echo "====================================="
+	@echo "Targets:"
+	@echo "  all         - Build all examples"
+	@echo "  migration-c89 - Build C89 version"
+	@echo "  migration-c11 - Build C11 version"
+	@echo "  compatibility - Build compatibility layer"
+	@echo "  clean       - Remove build artifacts"
+	@echo "  test        - Run all examples"
+	@echo "  compare     - Compare C89 vs C11 output"
+

package/augment-extensions/coding-standards/c/examples/legacy/README.md

@@ -0,0 +1,255 @@
+# Legacy Code Maintenance Examples
+
+This directory contains examples for maintaining and modernizing legacy C code.
+
+## Examples
+
+### 1. c89-to-c11-migration.c
+Demonstrates migration from C89 to C11:
+- Variable declaration improvements
+- Designated initializers
+- Static assertions
+- Flexible array members
+- Inline functions
+- Anonymous unions/structs
+
+**Key Concepts:**
+- Compile with both standards to verify compatibility
+- Use conditional compilation for gradual migration
+- Leverage C11 features for cleaner code
+- Maintain backward compatibility when needed
+
+### 2. compatibility-layer.c
+Cross-platform and cross-standard compatibility:
+- Compiler detection
+- Platform detection
+- C standard detection
+- Feature compatibility macros
+- Safe string functions
+- Platform-specific abstractions
+
+**Key Concepts:**
+- Abstract platform differences
+- Provide fallbacks for missing features
+- Use feature detection over version checks
+- Create consistent API across platforms
+
+## Building
+
+```bash
+# Build all examples
+make
+
+# Build specific versions
+make migration-c89    # C89 version
+make migration-c11    # C11 version
+make compatibility    # Compatibility layer
+
+# Clean
+make clean
+
+# Run tests
+make test
+
+# Compare C89 vs C11 output
+make compare
+```
+
+## Migration Strategy
+
+### Phase 1: Assessment
+1. Identify C standard currently used
+2. Check compiler compatibility
+3. Review platform dependencies
+4. List deprecated features
+
+### Phase 2: Preparation
+1. Add compatibility layer
+2. Create test suite
+3. Document platform-specific code
+4. Set up build for multiple standards
+
+### Phase 3: Gradual Migration
+1. Start with isolated modules
+2. Use conditional compilation
+3. Test thoroughly at each step
+4. Update documentation
+
+### Phase 4: Modernization
+1. Adopt C11 features
+2. Remove workarounds
+3. Improve type safety
+4. Enhance error handling
+
+## C89 to C11 Feature Comparison
+
+### Variable Declarations
+
+**C89:**
+```c
+void func(void) {
+    int i;
+    int sum = 0;
+    
+    for (i = 0; i < 10; i++) {
+        sum += i;
+    }
+}
+```
+
+**C11:**
+```c
+void func(void) {
+    int sum = 0;
+    
+    for (int i = 0; i < 10; i++) {
+        sum += i;
+    }
+}
+```
+
+### Designated Initializers
+
+**C89:**
+```c
+struct Point p = {10, 20, 30};  /* Must be in order */
+```
+
+**C11:**
+```c
+struct Point p = {.x = 10, .z = 30, .y = 20};  /* Any order */
+```
+
+### Static Assertions
+
+**C89:**
+```c
+/* Runtime check only */
+if (sizeof(int) != 4) {
+    abort();
+}
+```
+
+**C11:**
+```c
+/* Compile-time check */
+_Static_assert(sizeof(int) == 4, "int must be 4 bytes");
+```
+
+### Inline Functions
+
+**C89:**
+```c
+#define MAX(a, b) ((a) > (b) ? (a) : (b))  /* Macro */
+```
+
+**C11:**
+```c
+static inline int max(int a, int b) {  /* Type-safe */
+    return a > b ? a : b;
+}
+```
+
+## Compatibility Patterns
+
+### 1. Feature Detection
+
+```c
+#if __STDC_VERSION__ >= 201112L
+    /* C11 code */
+#elif __STDC_VERSION__ >= 199901L
+    /* C99 code */
+#else
+    /* C89 code */
+#endif
+```
+
+### 2. Compiler-Specific Features
+
+```c
+#if defined(__GNUC__)
+    #define INLINE __inline__
+#elif defined(_MSC_VER)
+    #define INLINE __inline
+#else
+    #define INLINE
+#endif
+```
+
+### 3. Platform Abstraction
+
+```c
+#ifdef _WIN32
+    #include <windows.h>
+    #define sleep_ms(ms) Sleep(ms)
+#else
+    #include <unistd.h>
+    #define sleep_ms(ms) usleep((ms) * 1000)
+#endif
+```
+
+## Best Practices
+
+1. **Maintain Compatibility**
+   - Support multiple C standards
+   - Test on all target platforms
+   - Provide fallbacks for missing features
+   - Document requirements
+
+2. **Gradual Migration**
+   - Migrate one module at a time
+   - Keep old and new code working
+   - Use feature flags
+   - Extensive testing
+
+3. **Documentation**
+   - Document platform differences
+   - Note compiler requirements
+   - Explain workarounds
+   - Provide migration guide
+
+4. **Testing**
+   - Test on all platforms
+   - Test with different compilers
+   - Test different C standards
+   - Regression testing
+
+## Common Pitfalls
+
+1. **Assuming C99/C11 Features**
+   ```c
+   // WRONG - Not available in C89
+   for (int i = 0; i < 10; i++) { }
+   
+   // CORRECT - Compatible with C89
+   int i;
+   for (i = 0; i < 10; i++) { }
+   ```
+
+2. **Platform-Specific Code**
+   ```c
+   // WRONG - Windows-only
+   Sleep(1000);
+   
+   // CORRECT - Abstracted
+   compat_sleep_ms(1000);
+   ```
+
+3. **Compiler Extensions**
+   ```c
+   // WRONG - GCC-specific
+   int array[n];  /* VLA */
+   
+   // CORRECT - Standard C
+   int *array = malloc(n * sizeof(int));
+   ```
+
+## References
+
+- ISO/IEC 9899:1990 (C89/C90)
+- ISO/IEC 9899:1999 (C99)
+- ISO/IEC 9899:2011 (C11)
+- "C Programming: A Modern Approach" by K. N. King
+- GCC Compatibility: https://gcc.gnu.org/
+- MSVC Compatibility: https://docs.microsoft.com/en-us/cpp/
+