#include <linux/module.h> // 包含内核编程最常用的函数声明，如printk
#include <linux/kernel.h> // 包含模块编程相关的宏定义，如：MODULE_LICENSE
 
/*
init初始化函数在模块被插入进内核时调用，主要作用为驱动功能做好预备工作被称为模块的入口函数
  
__init的作用 : 
  1. 一个宏，展开后为：__attribute__ ((__section__ (".init.text"))) 实际是gcc的一个特殊链接标记
  2. 指示链接器将该函数放置在 .init.text区段
  3. 在模块插入时方便内核从ko文件指定位置读取入口函数的指令到特定内存位置
*/
int __init hello_init(void)
{
	// 具体初始化逻辑
    printk("hello module init.\n");
	return 0;
}

/*
module_init 宏
1. 用法：module_init(模块入口函数名) 
2. 动态加载模块，对应函数被调用
3. 静态加载模块，内核启动过程中对应函数被调用
4. 对于静态加载的模块其本质是定义一个全局函数指针，并将其赋值为指定函数，链接时将地址放到特殊区段（.initcall段），方便系统初始化统一调用。
5. 对于动态加载的模块，由于内核模块的默认入口函数名是init_module,用该宏可以给对应模块入口函数起别名
*/
module_init(hello_init);
 
/*
exit退出函数在模块从内核中被移除时调用，主要作用做些init函数的反操作被称为模块的出口函数
  
__exit的作用：
  1. 一个宏，展开后为：__attribute__ ((__section__ (".exit.text"))) 实际也是gcc的一个特殊链接标记
  2. 指示链接器将该函数放置在 .exit.text区段
  3. 在模块插入时方便内核从ko文件指定位置读取出口函数的指令到另一个特定内存位置
*/
void __exit hello_exit(void)
{
	// 具体反初始化逻辑
    printk("hello module exit.\n");
}
 
/*
module_exit宏
  1. 用法：module_exit(模块出口函数名)
  2. 动态加载的模块在卸载时，对应函数被调用
  3. 静态加载的模块可以认为在系统退出时，对应函数被调用，实际上对应函数被忽略
  4. 对于静态加载的模块其本质是定义一个全局函数指针，并将其赋值为指定函数，链接时将地址放到特殊区段（.exitcall段），方便系统必要时统一调用，实际上该宏在静态加载时没有意义，因为静态编译的驱动无法卸载。
  5. 对于动态加载的模块，由于内核模块的默认出口函数名是cleanup_module,用该宏可以给对应模块出口函数起别名
*/
module_exit(hello_exit);

/*
MODULE_LICENSE(字符串常量);
字符串常量内容为源码的许可证协议 可以是"GPL" "GPL v2"  "GPL and additional rights"  "Dual BSD/GPL"  "Dual MIT/GPL" "Dual MPL/GPL"等, "GPL"最常用
其本质也是一个宏，宏体也是一个特殊链接标记，指示链接器在ko文件指定位置说明本模块源码遵循的许可证
在模块插入到内核时，内核会检查新模块的许可证是不是也遵循GPL协议，如果发现不遵循GPL，则在插入模块时打印抱怨信息：
	myhello：module license 'unspecified' taints kernel
	Disabling lock debugging due to kernel taint
也会导致新模块没法使用一些内核其它模块提供的高级功能
*/
MODULE_LICENSE("GPL");

typedef u32 dev_t;
// 生成设备号
#define MKDEV(ma,minor) (((ma) << 20) | (mi))
// 获取主设备号
#define MAJOR(dev)	((unsigned int) ((dev) >> MINORBITS))
// 获取次设备号
#define MINOR(dev)	((unsigned int) ((dev) & MINORMASK))

// 静态注册设备号
int register_chrdev_region(dev_t dev, unsigned count, const char *name);
// 动态申请设备号
int alloc_chrdev_region(dev_t *dev, unsigned minor, unsigned count, const char *name);
// 注销设备号
void unregister_chrdev_region(dev_t dev, unsigned count);

// 申请内存并置零。
void *kzalloc(size_t size, gfp_t flags);
// 内存释放
void kfree(const void *p)

// 初始化字符设备描述符
void cdev_init(struct cdev *cdev, const struct file_operations *ops);
// 新增字符设备描述符
int cdev_add(struct cdev *cdev, dev_t dev, unsigned count);
// 删除字符设备描述符
void cdev_del(struct cdev *cdev);

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>

#define GLOBALMEM_SIZE 0x1000
#define GLOBALMEM_MAJOR 230
#define GLOBALMEM_MINOR 0
#define DEVICE_NUM 10

// 为避免多个设备命令污染，Linux推荐使用_IO _IOR _IOW _IOWR来定义ioctl的命令
// 已经定义的设备类型可以见内核文档Documentation/ioctl/ioctl-number.txt
// 内核预定义的控制命令不会被设备驱动处理，这些定义在include/uapi/asm-generic/ioctls.h
#define GLOBALMEM_MAGIC 'g'
#define MEM_CLEAR _IO(GLOBALMEM_MAGIC, 0)

static int globalmem_major = GLOBALMEM_MAJOR;
module_param(globalmem_major, int, S_IRUGO);

typedef struct globalmem_dev
{
    // 设备号
    dev_t id;
    // 字符设备
    struct cdev cd;
    // 模拟的设备内存
    unsigned char mem[GLOBALMEM_SIZE];
} globalmem_dev_t;

globalmem_dev_t *globalmem_devp;

// 设备驱动的打开函数
static int globalmem_open(struct inode *inode, struct file *filp)
{
    globalmem_dev_t *dev = container_of(inode->i_cdev, globalmem_dev_t, cd);
    filp->private_data = dev;
    return 0;
}

// 设备驱动的释放函数
static int globalmem_release(struct inode *, struct file *)
{
    return 0;
}

// 设备驱动的I/O控制函数
static long globalmem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    globalmem_dev_t *dev = filp->private_data;

    switch (cmd)
    {
    case MEM_CLEAR:
        memset(dev->mem, 0, GLOBALMEM_SIZE);
        printk(KERN_INFO "globalmem is set to zero\n");
        break;

    default:
        return -EINVAL;
    }

    return 0;
}

// 设备驱动的读操作。*ppos是要读的位置相对于内存开头的偏移，如果大于或等于GLOBALMEM_SIZE，则会返回0（EOF）
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;
    globalmem_dev_t *dev = filp->private_data;

    if (p >= GLOBALMEM_SIZE)
        return 0;
    if (count > GLOBALMEM_SIZE - p)
        count = GLOBALMEM_SIZE - p;

    if (copy_to_user(buf, dev->mem + p, count))
    {
        ret = -EFAULT;
    }
    else
    {
        *ppos += count;
        ret = count;
        printk(KERN_INFO "read %u bytes(s) from %lu\n", count, p);
    }

    return ret;
}
// 驱动设备的写操作
static ssize_t globalmem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;
    globalmem_dev_t *dev = filp->private_data;

    if (p > GLOBALMEM_SIZE)
        return 0;
    if (count > GLOBALMEM_SIZE - p)
        count = GLOBALMEM_SIZE - p;

    if (copy_from_user(dev->mem + p, buf, count))
        ret = -EFAULT;
    else
    {
        *ppos += count;
        ret = count;
        printk(KERN_INFO "written %u bytes(s) from %lu\n", count, p);
    }

    return ret;
}

// 设备驱动的定位操作。
static loff_t globalmem_llseek_impl(struct file *filp, loff_t offset, int orig)
{
    loff_t ret = 0;
    loff_t f_pos = 0;

    switch (orig)
    {
    case 1: /* 从内存当前位置开始seek */
        f_pos = filp->f_pos;
    case 0: /* 从内存开头位置seek */
        if ((f_pos + offset) < 0)
        {
            ret = -EINVAL;
            break;
        }
        if ((f_pos + offset) > GLOBALMEM_SIZE)
        {
            ret = -EINVAL;
            break;
        }
        filp->f_pos = f_pos;
        ret = filp->f_pos;
        break;

    default:
        ret = -EINVAL;
        break;
    }

    return ret;
}

// 设备驱动的文件操作结构体
static const struct file_operations globalmem_fops = {
    .owner = THIS_MODULE,
    .llseek = globalmem_llseek_impl,
    .read = globalmem_read,
    .write = globalmem_write,
    .unlocked_ioctl = globalmem_ioctl,
    .open = globalmem_open,
    .release = globalmem_release,
};

// cdev的初始化和添加
static void globalmem_setup_cdev(globalmem_dev_t *dev)
{
    int err;
    cdev_init(&dev->cd, &globalmem_fops);
    dev->cd.owner = THIS_MODULE;
    err = cdev_add(&dev->cd, dev->id, 1);
    if (err)
        printk(KERN_NOTICE "Error %d adding globalmem", err);
}

// 设备驱动的初始化函数
static int __init globalmem_init(void)
{
    int ret;
    int i;

    // 设备号的申请
    dev_t id = MKDEV(globalmem_major, GLOBALMEM_MINOR);
    if (globalmem_major)
        // 1. 静态申请设备号
        ret = register_chrdev_region(id, DEVICE_NUM, "globalmemND");
    else
    {
        // 2. 动态申请设备号
        ret = alloc_chrdev_region(&id, 0, DEVICE_NUM, "globalmemND");
        globalmem_major = MAJOR(id);
    }
    if (ret < 0)
        return ret;

    // 从内核中申请一份globalmem_dev的内存并清零
    globalmem_devp = kzalloc(sizeof(globalmem_dev_t) * DEVICE_NUM, GFP_KERNEL);
    if (!globalmem_devp)
    {
        ret = -ENOMEM;
        goto fail_malloc;
    }

    for (i = 0; i < DEVICE_NUM; ++i)
    {
        (globalmem_devp + i)->id = MKDEV(globalmem_major, i);
        globalmem_setup_cdev(globalmem_devp + i);
    }
    return 0;

fail_malloc:
    unregister_chrdev_region(id, DEVICE_NUM);
    return ret;
}
// 导出设备驱动的初始化函数
module_init(globalmem_init);

// 设备驱动的退出函数
static void __exit globalmem_exit(void)
{
    int i;
    for (i = 0; i < DEVICE_NUM; ++i)
        cdev_del(&(globalmem_devp + i)->cd);
    kfree(globalmem_devp);
    unregister_chrdev_region(globalmem_devp->id, DEVICE_NUM);
}
// 导出设备驱动的退出函数
module_exit(globalmem_exit);

// 作者版权声明
MODULE_AUTHOR("johnny <johnny@gmail.com>");
MODULE_LICENSE("GPL v2");

// 异步通知数据结构
struct fasync_struct;
// 处理标志变更
int fasync_helper(int fd, struct file *filp, int mode, struct fasync_struct **fa);
// 释放信号函数
void kill_fasync(struct fasync_struct **fa, int sig, int band);

typedef irqreturn_t (*irq_handler_t)(int, void *);
typedef int irqreturn_t;
// 申请irq
int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev);
// 申请irq。区别是devm_开头的API申请的是内核“managed”的资源，一般不需要在出错处理和remove（）接口里再显式的释放。
int devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler, unsigned long irqflags, const char *devname, void *dev_id);
// 释放irq
void free_irq(unsigned int irq,void *dev_id);
// 屏蔽使能中断源
void disable_irq(int irq);
void disable_irq_nosync(int irq);
void enable_irq(int irq);

// 忙等待
void ndelay(unsigned long nsecs);
void udelay(unsigned long usecs);
void mdelay(unsigned long msecs);
// 睡眠
void msleep(unsigned int millisecs);
unsigned long msleep_interruptible(unsigned int millisecs);
void ssleep(unsigned int seconds);
// 睡着延时
schedule_timeout

malloc
free

// 依赖底层__get_free_pages（）来实现，分配标志的前缀GFP正好是这个底层函数的缩写。
// 最常用的分配标志是GFP_KERNEL，其含义是在内核空间的进程中申请内存。
// 使用GFP_KERNEL标志申请内存时，若暂时不能满足，则进程会睡眠等待页，即会引起阻塞，因此不能在中断上下文或持有自旋锁的时候使用GFP_KERNE申请内存。
// 使用GFP_ATOMIC标志申请内存时，若不存在空闲页，则不等待，直接返回。
void *kmalloc(size_t size, int flags);
kfree
// 一般只为存在于软件中（没有对应的硬件意义）的较大的顺序缓冲区分配内存
void *vmalloc(unsigned long size);
void vfree(void * addr);

// 创建slab缓存
struct kmem_cache *kmem_cache_create(const char *name, size_t size,size_t align, unsigned long flags,void (*ctor)(void*, struct kmem_cache *, unsigned long),void (*dtor)(void*, struct kmem_cache *, unsigned long));
// 分配和释放slab缓存
void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags);
void kmem_cache_free(struct kmem_cache *cachep, void *objp);
// 回收slab缓存
int kmem_cache_destroy(struct kmem_cache *cachep);

// 创建内存池
mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn,mempool_free_t *free_fn, void *pool_data);
typedef void *(mempool_alloc_t)(int gfp_mask, void *pool_data); // 标准对象分配的函数指针
typedef void (mempool_free_t)(void *element, void *pool_data); // 标准对象回收的函数指针
// 内存池中分配和回收对象
void *mempool_alloc(mempool_t *pool, int gfp_mask);
void mempool_free(void *element, mempool_t *pool);
// 回收内存池
void mempool_destroy(mempool_t *pool);

// 读写字节端口（8位宽）
unsigned inb(unsigned port);
void outb(unsigned char byte, unsigned port);
// 读写字端口（16位宽）
unsigned inw(unsigned port);
void outw(unsigned short word, unsigned port);
// 读写长字端口（32位宽）
unsigned inl(unsigned port);
void outl(unsigned longword, unsigned port);
// 读写一串字节
void insb(unsigned port, void *addr, unsigned long count);
void outsb(unsigned port, void *addr, unsigned long count);
// 读写一串字
void insw(unsigned port, void *addr, unsigned long count);
void outsw(unsigned port, void *addr, unsigned long count);
// 读写一串长字
void insl(unsigned port, void *addr, unsigned long count);
void outsl(unsigned port, void *addr, unsigned long count);

// 返回一个特殊的虚拟地址，该地址可用来存取特定的物理地址范围，这个虚拟地址位于vmalloc映射区域。
// 通过devm_ioremap进行的映射通常不需要在驱动退出和出错处理的时候进行iounmap
void *ioremap(unsigned long offset, unsigned long size);
void __iomem *devm_ioremap(struct device *dev, resource_size_t offset,unsigned long size);
// 释放ioremap映射的地址
void iounmap(void * addr);

// 读寄存器
#define readb(c) ({ u8 __v = readb_relaxed(c); __iormb(); __v; })
#define readw(c) ({ u16__v = readw_relaxed(c); __iormb(); __v; })
#define readl(c) ({ u32 __v = readl_relaxed(c); __iormb(); __v; })
// 写寄存器
#define writeb(v,c) ({ __iowmb(); writeb_relaxed(v,c); })
#define writew(v,c) ({ __iowmb(); writew_relaxed(v,c); })
#define writel(v,c) ({ __iowmb(); writel_relaxed(v,c); })

// 申请I/O端口
// 变体devm_request_region
struct resource *request_region(unsigned long first, unsigned long n, const char *name);
// 归还I/O端口
void release_region(unsigned long start, unsigned long n);

// 申请I/O内存
// 变体devm_request_mem_region
struct resource *request_mem_region(unsigned long start, unsigned long len, char *name);
// 归还I/O内存
void release_mem_region(unsigned long start, unsigned long len);

// 驱动中mmap原型
int(*mmap)(struct file *, struct vm_area_struct*);

// 创建页表项
int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr,unsigned long pfn, unsigned long size, pgprot_t prot);

struct map_desc
{
    unsigned long virtual; /* 虚拟地址 */
    unsigned long pfn;     /* __phys_to_pfn(phy_addr) */
    unsigned long length;  /* 大小 */
    unsigned int type;     /* 类型 */
};
// 然后通过函数iotable_init(struct map_desc&, size_t)建立映射。

unsigned long virt_to_bus(volatile void *address);
void *bus_to_virt(unsigned long address);

int dma_set_mask(struct device *dev, u64 mask);

// 申请Cache一致的DMA缓冲区
void * dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *handle,gfp_t gfp);
// 释放Cache一致的DMA缓冲区
void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,dma_addr_t handle);

// 申请写合并的DMA缓冲区
void * dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t*handle, gfp_t gfp);
#define dma_free_writecombine(dev,size,cpu_addr,handle) \
    dma_free_coherent(dev,size,cpu_addr,handle)

// PCI设备申请DMA缓冲区
void * pci_alloc_consistent(struct pci_dev *pdev, size_t size, dma_addr_t *dma_addrp);
void pci_free_consistent(struct pci_dev *pdev, size_t size, void *cpu_addr,dma_addr_t dma_addr);

// DMA映射。第4个参数为DMA的方向，可能的值包括DMA_TO_DEVICE、DMA_FROM_DEVICE、DMA_BIDIRECTIONAL和DMA_NONE
dma_addr_t dma_map_single(struct device *dev, void *buffer, size_t size,enum dma_data_direction direction);
// DMA反映射
void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,enum dma_data_direction direction);

// 获得DMA缓冲区的拥有权
void dma_sync_single_for_cpu(struct device *dev, dma_handle_t bus_addr,size_t size, enum dma_data_direction direction);
// 将其所有权返还给设备
void dma_sync_single_for_device(struct device *dev, dma_handle_t bus_addr,size_t size, enum dma_data_direction direction);

// 映射SG
int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,enum dma_data_direction direction);
// 去除映射SG
void dma_unmap_sg(struct device *dev, struct scatterlist *list,int nents, enum dma_data_direction direction);
// 返回scatterlist对应的缓冲区的总线地址和缓冲区的长度
dma_addr_t sg_dma_address(struct scatterlist *sg);
unsigned int sg_dma_len(struct scatterlist *sg);

// 获得DMA缓冲区的拥有权
void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,int nents, enum dma_data_direction direction);
// 将其所有权返还给设备
void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,int nents, enum dma_data_direction direction);

// 申请DMA通道
struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name);
struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,dma_filter_fn fn, void *fn_param);
// 释放DMA通道
void dma_release_channel(struct dma_chan *chan);

// DMA完成回调函数原型：void (dma_fini_callback)(void*)

// 申请DMA描述符，然后填充callback和callback_param参数
dmaengine_prep_slave_single
// 把描述符插入队列
dmaengine_submit
// 发起DMA动作
dma_async_issue_pending

struct platform_device
{
    const char *name;
    int id;
    bool id_auto;
    struct devicedev;
    u32 num_resources;
    struct resource *resource;

    const struct platform_device_id *id_entry;
    char *driver_override; /* Driver name to force a match */

    /* MFD cell pointer */
    struct mfd_cell *mfd_cell;

    /* arch specific additions */
    struct pdev_archdata archdata;
};

struct platform_driver
{
    int (*probe)(struct platform_device *);
    int (*remove)(struct platform_device *);
    void (*shutdown)(struct platform_device *);
    int (*suspend)(struct platform_device * pm_message_t state);
    int (*resume)(struct platform_device *);
    struct device_driver driver;
    const struct platform_device_id *id_table;
    bool prevent_deferred_probe;
};

struct device_driver
{
    const char *name;
    struct bus_type *bus;

    struct module *owner;
    const char *mod_name; /* used for built-in modules */

    bool suppress_bind_attrs; /* disables bind/unbind via sysfs */

    const struct of_device_id *of_match_table;
    const struct acpi_device_id *acpi_match_table;

    int (*probe)(struct device *dev);
    int (*remove)(struct device *dev);
    void (*shutdown)(struct device *dev);
    int (*suspend)(struct device *dev, pm_message_t state);
    int (*resume)(struct device *dev);
    const struct attribute_group **groups;

    const struct dev_pm_ops *pm;

    struct driver_private *p;
};

struct resource
{
    resource__size_t start;
    resource_size_t end;
    const char *name;
    unsigned long flags; // 值可以为IORESOURCE_IO、IORESOURCE_MEM、IORESOURCE_IRQ、IORE-SOURCE_DMA等
    struct resource *parent, *sibling, *child;
};

// 获取资源通用接口
struct resource *platform_get_resource(struct platform_device *, unsigned int,unsigned int);
// 获取IRQ资源封装接口，相当于platform_get_resource(dev, IORESOURCE_IRQ, num);
int platform_get_irq(struct platform_device *dev, unsigned int num);

static struct platform_device globalfifo_device = {
    .name = "globalfifo",
    .id = -1,
};

static int __init globalfifodev_init(void)
{
    int ret;

    globalfifo_pdev = platform_device_alloc("globalfifo", -1);
    if (!globalfifo_pdev)
        return -ENOMEM;

    ret = platform_device_add(globalfifo_pdev);
    if (ret)
    {
        platform_device_put(globalfifo_pdev);
        return ret;
    }
    return ret;
}
module_init(globalfifodev_init);

// 块设备操作描述符
struct block_device_operations
{
    // 打开和释放
    int (*open)(struct block_device *, fmode_t);
    void (*release)(struct gendisk *, fmode_t);

    // I/O控制
    int (*ioctl)(struct block_device *, fmode_t, unsigned, unsigned long);
    int (*compat_ioctl)(struct block_device *, fmode_t, unsigned, unsigned long);

    // 介质改变，以后会被check_events取代
    int (*media_changed)(struct gendisk *);

    // 使介质有效
    int (*revalidate_disk)(struct gendisk *);

    // 获取驱动器信息
    int (*getgeo)(struct block_device *, struct hd_geometry *);

    // 模块指针，通常指向THIS_MODULE
    struct module *owner;

    // 其他
    int (*rw_page)(struct block_device *, sector_t, struct page *, int rw);
    int (*direct_access)(struct block_device *, sector_t, void **, unsigned long *);
    unsigned int (*check_events)(struct gendisk *disk, unsigned int clearing);
    void (*unlock_native_capacity)(struct gendisk *);
    void (*swap_slot_free_notify)(struct block_device *, unsigned long);
};

// 磁盘描述符
struct gendisk
{
    // major、first_minor和minors共同表征了磁盘的主、次设备号，同一个磁盘的各个分区共享一个主设备号，而次设备号则不同
    int major;
    int first_minor;
    int minors;
    
    // 描述的块设备操作集合
    const struct block_device_operations *fops;
    // 管理这个设备的I/O请求队列的指针
    struct request_queue *queue;
    // 指向磁盘的任何私有数据，与字符设备驱动的private_data类似
    void *private_data;
    // 表示一个分区
    struct hd_struct part0;
    // 容纳分区表。与part0的关系：disk->part_tbl->part[0] = &disk->part0;
    struct disk_part_tbl __rcu *part_tbl;

    char disk_name[DISK_NAME_LEN]; /* name of major driver */
    char *(*devnode)(struct gendisk *gd, umode_t *mode);

    unsigned int events;       /* supported events */
    unsigned int async_events; /* async events, subset of all */

    int flags;
    struct device *driverfs_dev; // FIXME: remove
    struct kobject *slave_dir;

    struct timer_rand_state *random;
    atomic_t sync_io; /* RAID */
    struct disk_events *ev;
#ifdef CONFIG_BLK_DEV_INTEGRITY
    struct blk_integrity *integrity;
#endif
    int node_id;
};

// 分配gendisk
struct gendisk *alloc_disk(int minors);
// 增加gendisk
void add_disk(struct gendisk *disk);
// 释放gendisk
void del_gendisk(struct gendisk *gp);
// gendisk引用计数
struct kobject *get_disk(struct gendisk *disk);
void put_disk(struct gendisk *disk);

struct bvec_iter
{
    sector_t bi_sector;   /* device address in 512byte sectors */
    unsigned int bi_size; /* residual I/O count */
    unsigned int bi_idx; /* current index into bvl_vec */
    unsigned int bi_bvec_done; /* number of bytes completed in current bvec */
};

struct bio
{
    struct bio *bi_next; /* request queue link */
    struct block_device *bi_bdev;
    unsigned long bi_flags; /* status, command, etc */
    unsigned long bi_rw;    /* bottom bits READ/WRITE,
                             * top bits priority
                             */
    struct bvec_iter bi_iter;
    /* Number of segments in this BIO after
     * physical address coalescing is performed.
     */
    unsigned int bi_phys_segments;
    ...

    struct bio_vec *bi_io_vec; /* the actual vec list */
    struct bio_set *bi_pool;
    /*
     * We can inline a number of vecs at the end of the bio, to avoid
     * double allocations for a small number of bio_vecs. This member
     * MUST obviously be kept at the very end of the bio.
     */
    struct bio_vec bi_inline_vecs[0];
};

struct bio_vec
{
    struct page *bv_page;
    unsigned int bv_len;
    unsigned int bv_offset;
};

// 初始化请求队列
request_queue_t *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock);
// 清除请求队列
void blk_cleanup_queue(request_queue_t * q);
// 分配请求队列
request_queue_t *blk_alloc_queue(int gfp_mask);
// 对于RAMDISK这种完全随机访问的非机械设备，并不需要进行复杂的I/O调度。
// 使用如下函数来绑定请求队列和“制造请求”函数
void blk_queue_make_request(request_queue_t * q, make_request_fn * mfn);
// 提取请求
struct request * blk_peek_request(struct request_queue *q);
// 启动请求
void blk_start_request(struct request *req);
// 报告完成
void __blk_end_request_all(struct request *rq, int error);
void blk_end_request_all(struct request *rq, int error);
// 用blk_queue_make_request（）绕开I/O调度，但是在bio处理完成后应该使用bio_endio
void bio_endio(struct bio *bio, int error);

// 如果是I/O操作故障，可以调用快捷函数bio_io_error（）
#define bio_io_error(bio) bio_endio((bio), -EIO)
// 遍历一个请求的所有bio
#define __rq_for_each_bio(_bio, rq) \
    if ((rq->bio))                  \
        for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
// 遍历一个bio的所有bio_vec
#define __bio_for_each_segment(bvl, bio, iter, start) \
    for (iter = (start);                              \
         (iter).bi_size &&                            \
         ((bvl = bio_iter_iovec((bio), (iter))), 1);  \
         bio_advance_iter((bio), &(iter), (bvl).bv_len))
#define bio_for_each_segment(bvl, bio, iter) \
    __bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)
// 迭代遍历一个请求所有bio中的所有segment
#define rq_for_each_segment(bvl, _rq, _iter) \
    __rq_for_each_bio(_iter.bio, _rq)        \
        bio_for_each_segment(bvl, _iter.bio, _iter.iter)

// 注册设备
// major参数是块设备要使用的主设备号，name为设备名，它会显示在/proc/devices中。
// 如果major为0，内核会自动分配一个新的主设备号，register_blkdev（）函数的返回值就是这个主设备号。
int register_blkdev(unsigned int major, const char *name);
// 注销设备
int unregister_blkdev(unsigned int major, const char *name);

int (*open)(struct block_device *bdev, fmode_t mode);
void (*release)(struct gendisk *disk, fmode_t mode);