写一个能引起iowait偏高的linux内核 kernel的模块，基于linux内核5.0以上版本

为了模拟一个能引起IO wait偏高的内核模块，我们可以编写一个简单的模拟磁盘IO的程序。具体步骤如下：

1. 创建一个新的内核模块文件，例如 iowait_module.c
2. 在模块中定义一个字符设备驱动程序，用于模拟磁盘IO操作。可以使用内核提供的块设备接口来实现这个驱动程序。
3. 在设备驱动程序中，实现一个简单的读取函数，该函数会在设备上读取一个块，并且返回读取的块数。
4. 在模块初始化函数中注册该字符设备驱动程序，并且分配一些内存作为块设备的缓冲区。
5. 在模块中实现一个简单的定时器，该定时器会周期性地调用设备的读取函数，并且将读取的结果打印到内核日志中。
6. 编译内核模块，将其插入内核中，运行模块。

这样，每当定时器触发时，设备驱动程序会执行一次IO操作，从而增加系统的IO wait时间。

示例代码如下：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/timer.h>

#define DEVICE_NAME "iowait_device"
#define BLOCK_SIZE 512

static struct timer_list iowait_timer;
static struct request_queue *queue;
static struct gendisk *disk;
static char *buffer;

static int iowait_open(struct inode *inode, struct file *file)
{
    return 0;
}

static int iowait_release(struct inode *inode, struct file *file)
{
    return 0;
}

static ssize_t iowait_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    int blocks = count / BLOCK_SIZE;
    if (*ppos + count > PAGE_SIZE)
        return -EINVAL;
    if (blocks <= 0)
        return -EINVAL;
    memcpy(buf, buffer + *ppos, count);
    *ppos += count;
    return blocks;
}

static const struct file_operations iowait_fops = {
    .owner = THIS_MODULE,
    .read = iowait_read,
    .open = iowait_open,
    .release = iowait_release,
};

static void iowait_timer_func(unsigned long arg)
{
    struct request *req;
    int blocks;

    req = blk_get_request(queue, READ);
    if (!req) {
        printk(KERN_WARNING "iowait: cannot get request\n");
        return;
    }

    blk_start_request(req);

    blocks = blk_rq_cur_sectors(req);
    if (blocks <= 0)
        goto out;

    blk_rq_map_kern(req, buffer, blocks * BLOCK_SIZE, __GFP_WAIT);

    blk_execute_rq(req->q, NULL, req, 0);

    blk_rq_unmap_user(buffer, req, blocks * BLOCK_SIZE, __GFP_WAIT);

out:
    blk_put_request(req);
}

static int __init iowait_init(void)
{
    int err;

    buffer = vmalloc(PAGE_SIZE);
    if (!buffer) {
        err = -ENOMEM;
        goto fail;
    }

    queue = blk_alloc_queue(GFP_KERNEL);
    if (!queue) {
        err = -ENOMEM;
        goto fail_queue;
    }

    disk = alloc_disk(1);
    if (!disk) {
        err = -ENOMEM;
        goto fail_disk;
    }

    disk->major = 0;
    disk->first_minor = 0;
    disk->fops = &iowait_fops;
    sprintf(disk->disk_name, DEVICE_NAME);
    set_capacity(disk, PAGE_SIZE / BLOCK_SIZE);

    add_disk(disk);
    blk_queue_make_request(queue, iowait_timer_func);

    init_timer(&iowait_timer);
    iowait_timer.function = iowait_timer_func;
    iowait_timer.expires = jiffies + HZ / 10; // 100ms
    iowait_timer.data = 0;

    add_timer(&iowait_timer);

    printk(KERN_INFO "iowait: module loaded\n");

    return 0;

fail_disk:
    blk_cleanup_queue(queue);
fail_queue:
    vfree(buffer);
fail:
    return err;
}

static void __exit iowait_exit(void)
{
    del_timer_sync(&iowait_timer);
    blk_cleanup_queue(queue);
    put_disk(disk);
    vfree(buffer);
    printk(KERN_INFO "iowait: module unloaded\n");
}

module_init(iowait_init);
module_exit(iowait_exit);

MODULE_LICENSE("Dual BSD/GPL");

注意：这个模块仅仅是一个示例，不应该在生产环境中使用。在生产环境中，应该避免编写会导致IO wait偏高的内核模块。