自增人生

#include <asm/atomic.h> # 引入原子操作API

// 定义原子变量，并将其初始化为0
atomic_t v = ATOMIC_INIT(0);

// 变量的原子读写操作
int atomic_read(atomic_t* v);
void atomic_set(atomic_t* v, int i);

// 变量运算的原子操作
void atomic_add(int i, atomic_t* v);    // 加
void atomic_sub(int i, atomic_t* v);    // 减
int atomic_and(int i, atomic_t* v);     // 与
int atomic_or(int i, atomic_t* v);      // 或
int atomic_xor(int i, atomic_t* v);     // 异或
int atomic_andnot(int i, atomic_t* v);  // 与非

// 在运算的基础之上“返回原来的结果”
int atomic_fetch_add(int i, atomic_t* v);
int atomic_fetch_sub(int i, atomic_t* v);
int atomic_fetch_and(int i, atomic_t* v);
int atomic_fetch_or(int i, atomic_t* v);
int atomic_fetch_xor(int i, atomic_t* v);
int atomic_fetch_andnot(int i, atomic_t* v);

void atomic_add_return(int i, atomic_t* v); // 加，并返回新值
void atomic_sub_return(int i, atomic_t* v); // 减，并返回新值

/******************************************
 * 强烈注意：
 *  以下定义在ARM平台(或Linux5.0+)不存在
 *  尽管各大书籍和网络文章里依然这么介绍
******************************************/
void atomic_int(atomic_t* v); // 自增
void atomic_dec(atomic_t* v); // 自减

// 带测试的加减运算，如果操作后原子值为0，则返回true，反之false。
int atomic_inc_and_test(atomic_t* v);
int atomic_dec_and_test(atomic_t* v);
int atomic_sub_and_test(int i, atomic_t* v);
// 注意不是atomic_add_and_test
int atomic_add_negative(int i, atomic_t* v);

#include <linux/spinlock.h> // 引入自旋锁的头

// 定义并初始化一个锁
spinlock_t lock;
spin_lock_init(&lock);

// 获取锁状态，有两种方式
spin_lock(&lock);     // 如果锁住了,原地打转
spin_trylock(&lock);  // 如果锁住了,立即返回,不会锁死

// todo...各种临界资源访问和处理

spin_unlock(&lock);   // 解锁，为后来的访问者开绿灯

void spin_lock_irq(spinlock_t* lock);   // 禁用中断，并上锁
void spin_unlock_irq(spinlock_t* lock); // 启用中断，并解锁

// 同上，但保存/恢复状态字
void spin_lock_irqsave(spinlock_t* lock, unsigned long flags);
void spin_unlock_irqrestore(spinlock_t* lock, unsigned long flags);

void spin_lock_bh(spinlock_t* lock);    // 禁用bh，并上锁
void spin_unlock_bh(spinlock_t* lock);  // 启用bh，并解锁

// 读写锁定义
rwlock_t lock;
rwlock_init(&lock);

// 读取上锁/解锁
read_lock(&lock);
// todo...
read_unlock(&lock);

// 写入上锁/解锁
write_lock(&lock);
// todo...
write_unlock(&lock);

// 顺序锁API的定义
unsigned int read_seqbegin(const seqlock_t* sl);
unsigned int read_seqretry(const seqlock_t *sl, unsigned int start);
void write_seqlock(seqlock_t *sl);
void write_sequnlock(seqlock_t *sl);

/*-----------------以下是具体使用方法-----------------*/
#include <linux/seqlock.h>

// 顺序锁定义
seqlock_t lock;
seqlock_init(&lock);

// 顺序读的过程
unsigned int start = 0;
do {
  start = read_seqbegin(&lock);
  // todo...read
} while (read_seqretry(&lock, start));

// 写入上锁
write_seqlock(&lock);
// todo...write
write_sequnlock(&lock);

#include <linux/rcupdate.h>

void rcu_read_lock(void);
void rcu_read_unlock(void);


void synchronize_rcu(void);
void call_rcu(struct callback_head *head, rcu_callback_t func);

#include <linux/mutex.h>

// 定义一个互斥体
struct mutex mutex;
mutex_init(&mutex);

// 上锁/解锁方式
void mutex_lock(struct mutex *lock);  // 睡眠后不可被中断
int mutex_lock_interruptible(struct mutex *lock); // 睡眠后可被中断
int mutex_trylock(struct mutex *lock);  // 如果能解锁就立即返回0，否则立即返回非0
void mutex_unlock(struct mutex *lock);  // 解锁

#include <linux/completion.h>

// 定义一个completion
struct completion completion;
void init_completion(struct completion *x);
void reinit_completion(struct completion *x);

// 等待completion标志
void wait_for_completion(struct completion *);

// 唤醒一个执行单元
void complete(struct completion *);
// 唤醒所有执行单元
void complete_all(struct completion *);

#define KERN_SOH      "\001"       /* ASCII Start Of Header */

#define KERN_EMERG    KERN_SOH "0" /* 紧急事件消息,在系统崩溃前提示用的 */
#define KERN_ALERT    KERN_SOH "1" /* 用于需要立即采取动作的情况 */
#define KERN_CRIT     KERN_SOH "2" /* 临界状态，涉及严重的硬件或软件操作失败时提示 */
#define KERN_ERR      KERN_SOH "3" /* 错误报告 */
#define KERN_WARNING  KERN_SOH "4" /* 常规警告 */
#define KERN_NOTICE   KERN_SOH "5" /* 普通提示，常见与安全相关的汇报 */
#define KERN_INFO     KERN_SOH "6" /* 提示性信息，比如硬件信息 */
#define KERN_DEBUG    KERN_SOH "7" /* 调试信息 */

static int __init meme_init(void)
{
    printk(KERN_EMERG"emerg 0\n");
    printk(KERN_ALERT"alert 1\n");
    printk(KERN_CRIT"crit 2\n");
    printk(KERN_ERR"err 3\n");
    printk(KERN_WARNING"warning 4\n");
    printk(KERN_NOTICE"notice 5\n");
    printk(KERN_INFO"info 6\n");
    printk(KERN_DEBUG"debug 7\n");

    return 0;
}
module_init(meme_init);

// proc入口文件的结构体定义
struct proc_dir_entry;

// 在procfs下创建一个目录
// @name    要创建的目录名
// @parent  上级目录，NULL表示/proc
struct proc_dir_entry *proc_mkdir(const char *name, struct proc_dir_entry *parent);

// 在procfs下创建一个文件
// @name    要创建的文件名
// @mode    文件的访问权限
// @parent  所在目录，NULL表示/proc
// @proc_fops 文件操作结构，与字符设备一样的机制
struct proc_dir_entry *proc_create(const char *name, umode_t mode, struct proc_dir_entry *parent, const struct file_operations *proc_fops);

// 在procfs下删除一个文件或目录
// @name    要删除的入口名
// @parent  所在上级目录
void remove_proc_entry(const char *name, struct proc_dir_entry *parent);

/**
 * meme_proc.c
 */

#include <linux/proc_fs.h>

// 全局变量，meme的设备节点状态
int meme_cdev_state = 0;

static ssize_t meme_proc_read(struct file* filp, char __user* buf, size_t len, loff_t* off)
{
    int rc = 0;
    const char* state = NULL;

    if (*off > 0) {
        return 0;
    }

    switch (meme_cdev_state) {
        case MEME_STATE_OPENED: state = "opened"; break;
        case MEME_STATE_CLOSED: state = "closed"; break;
        case MEME_STATE_READING: state = "reading"; break;
        case MEME_STATE_WRITING: state = "writing"; break;
        default: state = "unknown"; break;
    }

    len = strlen(state);
    if ((rc = copy_to_user(buf, state, len)) < 0) {
        return rc;
    }
    buf[len++] = '\n';
    buf[len++] = '\0';
    return len;
}

// 绑定用户层read时的触发函数
const struct file_operations proc_fops = {
    .owner = THIS_MODULE,
    .read = meme_proc_read,
};

// procfs入口目录
struct proc_dir_entry* meme_proc_entry = NULL;

int __init meme_proc_init(void)
{
    // 即/proc/meme/state，用于记录设备描述符/dev/meme的文件访问状态
    struct proc_dir_entry* meme_state_file = NULL;

    // 创建meme模块的proc目录，即/proc/meme/
    meme_proc_entry = proc_mkdir("meme", NULL);
    if (meme_proc_entry == NULL) {
        return -EINVAL;
    }

    // 创建/proc/meme/state文件，且该文件为只读
    meme_state_file = proc_create("state", 0500, meme_proc_entry, &proc_fops);
    if (meme_state_file == NULL) {
        return -EINVAL;
    }

    return 0;
}

void __exit meme_proc_exit(void)
{
    // 卸载模块时，自动删除所有/proc/meme所创建的文件及目录
    remove_proc_entry("state", meme_proc_entry);
    remove_proc_entry("meme", NULL);
}

/**
 * main.c
 */

static ssize_t meme_read(struct file* filp, char __user *buf, size_t size, loff_t* off)
{
    meme_cdev_state = MEME_STATE_READING;
    ...
}

static ssize_t meme_write(struct file* filp, const char __user *buf, size_t size, loff_t* off)
{
    meme_cdev_state = MEME_STATE_WRITING;
    ...
}

static int meme_open(struct inode* inode, struct file* filp)
{
    meme_cdev_state = MEME_STATE_OPENED;
    ...
}

static int meme_close(struct inode* inode, struct file* filp)
{
    meme_cdev_state = MEME_STATE_CLOSED;
    ...
}

struct seq_operations {
    // 首次访问时触发
	void * (*start) (struct seq_file *m, loff_t *pos);
    // 结束访问时触发
	void (*stop) (struct seq_file *m, void *v);
    // 迭代访问时触发
	void * (*next) (struct seq_file *m, void *v, loff_t *pos);
    // 打印展示时触发
	int (*show) (struct seq_file *m, void *v);
};

/**
 * meme_seq_file.c
 */

#include <linux/seq_file.h>

#define MAXNUM 100

// 访问文件时首先调用的接口
static void* meme_seq_start(struct seq_file* m, loff_t* pos)
{
    int* v = NULL;
    if (*pos < MAXNUM) {
        v = kmalloc(sizeof(int), GFP_KERNEL);
        *v = *pos;
        seq_printf(m, "start: *(%p) = %d\n", v, *(int*)v);
    }

    // start函数返回NULL表示pos已到达文件末尾
    return v;
}

// 每次迭代时调用，其中v是之前一次迭代(start或next)的返回值
static void* meme_seq_next(struct seq_file* m, void* v, loff_t* pos)
{
    int num = *(int*)v;
    if (num++ >= MAXNUM) {
        // 返回NULL停止迭代
        kfree(v);
        return NULL;
    }

    // 每次迭代，v和文件游标都增加1
    *(int*)v = *pos = num;
    return v;
}

// 结束迭代时调用，如果在start中有内存分配，应该在这里进行内存清理
// 但由于next的最后一次迭代肯定返回NULL，所以这里的v地址一定为NULL
// 不需要作任何处理
static void meme_seq_stop(struct seq_file* m, void* v)
{

}

// 展示时调用，主要是将v的内容格式化并输出到用户空间
static int meme_seq_show(struct seq_file* m, void* v)
{
    seq_printf(m, "show: *(%p) = %d\n", v, *(int*)v);
    return 0;
}

// 映射seq的start、next、stop、show四个迭代器的函数
const struct seq_operations meme_seq_ops = {
    .start = meme_seq_start,
    .next = meme_seq_next,
    .stop = meme_seq_stop,
    .show = meme_seq_show,
};

static int meme_seq_open(struct inode* inode, struct file* filp)
{
    // 绑定迭代操作的4个函数到/proc/meme/info文件
    return seq_open(filp, &meme_seq_ops);
}

// /proc/meme/info的文件操作映射，除了open需要自己实现外，其他均使用内部定义好的
static const struct file_operations meme_seq_fops = {
    .owner = THIS_MODULE,
    .open = meme_seq_open,
    .read = seq_read,
    .llseek = seq_lseek,
    .release = seq_release,
};

int __init meme_seq_init(void)
{
    // 创建seq入口文件，即/proc/meme/info，并绑定seq相关文件函数
    proc_create("info", 0500, meme_proc_entry, &meme_seq_fops);
    return 0;
}

void __exit meme_seq_exit(void)
{
    // 删除/proc/meme/info文件
    remove_proc_entry("info", meme_proc_entry);
}

static void __init meme_init(void)
{
    *(int*)NULL = 123;
}
module_init(meme_init)

// 动态申请，由内核自动扫描空闲设备号给它
// @dev         设备编号
// @firstminor  次设备号的起始编号
// @count       要申请多少个连续的设备号
// @name        设备名称，将出现在/proc/devices中
int alloc_chrdev_region(dev_t *dev, unsigned firstminor, unsigned count, const char *name);

// 静态注册，必须确保该设备号是空闲的
// @first   要注册的起始设备号，主+次
int register_chrdev_region(dev_t first, unsigned count, const char *name);

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>

// 字符设备结构体，该字符设备的核心数据表示
static struct cdev cdev;

// 驱动的主设备编号，每种类型的设备都有唯一编号
static dev_t devno = 0;

// 模块加载函数：注册字符设备
static int __init meme_init(void)
{
    // 1. 向内核申请分配一个主设备号，此设备号从0开始，分配1个，名称为meme
    if (alloc_chrdev_region(&devno, 0, 1, "meme") < 0 ) {
        printk(KERN_ERR"init fail\n");
        return (-1);
    }

    // 2. 初始化cdev结构体，并与fops文件操作之间建立联系
    cdev_init(&cdev, &fops);

    // 3. 正式向内核注册一个字符设备
    cdev_add(&cdev, devno, 1);

    // 注册成功后打印出该设备的主、次设备号
    printk(KERN_ALERT"meme init: %d:%d\n", MAJOR(devno), MINOR(devno));
    return 0;
}
module_init(meme_init);


// 模块卸载函数：注销字符设备
static void __exit meme_exit(void)
{
    // 1. 向内核注销该字符设备
    cdev_del(&cdev);

    // 2. 向内核申请释放该设备号
    unregister_chrdev_region(devno, 1);

    printk("meme free\n");
}
module_exit(meme_exit);

// 杂七杂八的东西
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Philon");
MODULE_DESCRIPTION("A character device driver");

struct file_operations {
        struct module *owner;
        loff_t (*llseek) (struct file *, loff_t, int);
        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
        ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
        ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
        int (*iterate) (struct file *, struct dir_context *);
        int (*iterate_shared) (struct file *, struct dir_context *);
        __poll_t (*poll) (struct file *, struct poll_table_struct *);
        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
        long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
        int (*mmap) (struct file *, struct vm_area_struct *);
        unsigned long mmap_supported_flags;
        int (*open) (struct inode *, struct file *);
        int (*flush) (struct file *, fl_owner_t id);
        int (*release) (struct inode *, struct file *);
        int (*fsync) (struct file *, loff_t, loff_t, int datasync);
        int (*fasync) (int, struct file *, int);
        int (*lock) (struct file *, int, struct file_lock *);
        ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
        unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
        int (*check_flags)(int);
        int (*flock) (struct file *, int, struct file_lock *);
        ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
        ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
        int (*setlease)(struct file *, long, struct file_lock **, void **);
        long (*fallocate)(struct file *file, int mode, loff_t offset,
                          loff_t len);
        void (*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
        unsigned (*mmap_capabilities)(struct file *);
#endif
        ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
                        loff_t, size_t, unsigned int);
        loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
                                   struct file *file_out, loff_t pos_out,
                                   loff_t len, unsigned int remap_flags);
        int (*fadvise)(struct file *, loff_t, loff_t, int);
} __randomize_layout;

// 对应用户层read读取函数，通常用户接收设备内容，如串口收数据
static ssize_t meme_read(struct file* filp, char __user *buf, size_t size, loff_t* off)
{
    // 如果当前文件偏移量已经超出内存大小，直接返回错误
    if (*off >= meme.size) {
        return -ENOMEM;
    }

    // 如果当前可访问内存长度小于要读取的长度，仅读取可访问长度
    if ((*off + size) > meme.size) {
        size = meme.size - *off;
    }

    // 拷贝内核数据到用户空间
    if (copy_to_user(buf, filp->private_data + *off, size)) {
        return -EFAULT;
    }

    // 偏移相应的读取长度
    *off += size;
    return size;
}

// 对应用户层write写入函数，通常用于写入设备内容，如串口发数据
static ssize_t meme_write(struct file* filp, const char __user *buf, size_t size, loff_t* off)
{
    // 如果文件偏移超出内存长度，就没必要再写了
    if (*off >= meme.size) {
        return 0;
    }

    // 如果要写入的数据长度比剩余可访问的内存长度还要大，仅写入可访问的内存长度
    if (*off + size > meme.size) {
        size = meme.size - *off;
    }

    // 拷贝用户数据到内核空间
    if (copy_from_user(filp->private_data + *off, buf, size)) {
        return -EFAULT;
    }

    // 偏移相应的写入函数
    *off += size;
    return size;
}

// 对应用户层open打开函数，就是打开设备描述符
static int meme_open(struct inode* inode, struct file* filp)
{
    // 如果是第一次访问设备节点，分配内存
    if (meme.data == NULL) {
        meme.data = kmalloc(MEME_DEFAULT_DATA_SIZE, GFP_KERNEL);
    }

    filp->private_data = meme.data;
    
    return 0;
}

// 对应用户层close关闭函数，就是关闭设备文件
static int meme_close(struct inode* inode, struct file* filp)
{
    // nothing todo
    return 0;
}

// 文件操作结构体，表示内核模块与用户层的函数对应关系
static const struct file_operations fops = {
    .owner = THIS_MODULE, // 这其实是个结构体，比如THIS_MODULE->name
    .read = meme_read,
    .write = meme_write,
    .open = meme_open,
    .release = meme_close,
};