linux内核rwlock读写锁测试

OS版本：openEuler 22.03 LTS

架构：x86_64

描述：启动两个内核线程，一个线程用于修改全局静态变量 s_count ，一个用于读取全局静态变量。

源码如下：

// rwlock_test.c

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sizes.h>
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/rwlock.h>


static struct task_struct *write_task = NULL;
static struct task_struct *read_task = NULL;

static rwlock_t lock;

static int s_count = 0;

char *write_thread = "write-thread";
char *read_thread = "read-thread";


int thread_write(void *data)
{
    while(!kthread_should_stop()) {
        msleep(200);
		write_lock(&lock);
        printk(KERN_INFO "%s is running! s_count = %d\n", (char *)data, s_count);
		s_count++;
		write_unlock(&lock);
    }
    return 0;
}

int thread_read(void *data)
{
	while (!kthread_should_stop()) {
		msleep(200);
		read_lock(&lock);
		printk(KERN_INFO "%s is running! s_count = %d\n", (char *)data, s_count);
		read_unlock(&lock);
	}
	return 0;
}

static int __init rwlock_test_init(void)
{
	rwlock_init(&lock);
    write_task = kthread_create(thread_write, write_thread, write_thread);
    if (!IS_ERR(write_task)) {
    	printk(KERN_INFO "create write_thread success\n");
		wake_up_process(write_task);
    }

	read_task = kthread_create(thread_read, read_thread, read_thread);
	if (!IS_ERR(read_task)) {
		printk(KERN_INFO "create read_thread success\n");
		wake_up_process(read_task);
	}
    return 0;
}

static void __exit rwlock_test_exit(void)
{
    kthread_stop(write_task);
	kthread_stop(read_task);
    printk(KERN_INFO "rwlock_test is stop!\n");
    return;
}

module_init(rwlock_test_init);
module_exit(rwlock_test_exit);
MODULE_LICENSE("GPL");

Makefile如下：

obj-m+=rwlock_test.o
CONFIG_MODULE_SIG=n
all:
	make -C /lib/modules/$(shell uname -r)/build/ M=$(PWD) modules
clean:
	make -C /lib/modules/$(shell uname -r)/build/ M=$(PWD) clean

加载rwlock_test.ko内核模块后的运行结果：

卸载rwlock_test.ko内核模块后输出：