【Linux内核及内核编程】Linux下的C编程特点

// 正确示例：下划线命名
int get_file_size(const char *filename);

// 错误示例：驼峰命名（Linux内核禁止）
int getFileSize(const char *filename); 

// K&R风格示例
if (condition) {
    do_something();
    if (nested_condition) {
        do_nested();
    }
}

/*
 * copy_from_user - copy data from user space to kernel space
 * @to: destination in kernel space
 * @from: source in user space
 * @n: number of bytes to copy
 * Returns: the number of bytes that could not be copied, 0 on success
 */
unsigned long copy_from_user(void *to, const void __user *from, unsigned long n);

// 传统宏的缺陷（可能重复计算参数）
#define MAX(a,b) ((a) > (b) ? (a) : (b))

// GNU C语句表达式（支持局部变量）
#define MAX(a,b) ({ \
    typeof(a) _a = (a); \
    typeof(b) _b = (b); \
    _a > _b ? _a : _b; \
})

#define DEBUG(fmt, ...) printk(KERN_DEBUG fmt, ##__VA_ARGS__)

// 使用时支持任意数量参数
DEBUG("PID %d, value %d", pid, value);

int ret = -EINVAL;
goto out;  // 传统goto用法

// GNU C标签变量（非传统goto，用于表达式）
int result = ({
    int x = 10;
    if (x > 5)
        goto label;  // 标签在语句表达式内部
    x * 2;
label:
    x * 3;
});

// 传统柔性数组（C99）
struct buffer {
    int len;
    char data[];  // 柔性数组成员
};

// GNU C零长度数组（早期写法）
struct buffer {
    int len;
    char data[0];  // 零长度数组
};

// 错误示例：宏包含多条语句时出错
#define SAFE_FREE(p) free(p); (p) = NULL
if (condition)
    SAFE_FREE(ptr);  // 等价于 free(); (p)=NULL; 导致语法错误

// 正确写法：使用do{}while(0)
#define SAFE_FREE(p) do { free(p); (p) = NULL; } while(0)
if (condition)
    SAFE_FREE(ptr);  // 正确执行两条语句

#define BLOCK_FUNC() do { \
    int temp = get_value(); \
    process(temp); \
} while(0)

// 调用后temp变量不会泄漏到外部作用域

switch (cmd) {
case CMD_RUN:
    BLOCK_FUNC();  // 宏内部的break会正确跳出switch
    break;
}

int open_device(struct device *dev) {
    if (alloc_res1(dev))
        goto err1;
    if (alloc_res2(dev))
        goto err2;
    if (alloc_res3(dev))
        goto err3;
    return 0;

err3:
    free_res2(dev);
err2:
    free_res1(dev);
err1:
    return -ERROR;
}

ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
    ssize_t ret;
    /*
     * We don't allow the kernel to read from user space when pagefaults are
     * disabled, as that can lead to deadlocks.
     */
    might_sleep();
    if (!file->f_op->read)
        return -EINVAL;
    if (unlikely(!access_ok(buf, count)))
        return -EFAULT;
    ret = file->f_op->read(file, buf, count, pos);
    /*
     * A read error should not change the file position, so we restore it
     * only when ret is an error.
     */
    if (unlikely(ret >= 0)) {
        /*
         * update the position even if we didn't read all we wanted to
         * (short read is normal, like EOF)
         */
        update_pos(file, pos, ret);
    } else {
        /*
         * do_no_page() in do_fault() can increment the read-ahead window,
         * so we must not update the position in case of errors.
         */
        if (ret == -ERESTARTSYS || ret == -ERESTARTNOINTR ||
            ret == -ERESTARTNOHAND || ret == -ERESTART_RESTARTBLOCK) {
            ret = -EINTR;
        }
        /*
         * Restore the original position if we failed.
         */
        update_pos(file, pos, 0);
    }
    return ret;
}