一个内核线程与一个用户线程共享互斥锁的案例

一个内核线程与一个用户线程共享互斥锁的案例如下：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/sched.h>

static struct task_struct *kthread;
static struct mutex my_mutex;

static int my_kthread_fn(void *data)
{
    while (!kthread_should_stop()) {
        mutex_lock(&my_mutex);
        printk(KERN_INFO "Kernel thread acquired mutex lock\n");
        msleep(1000);
        mutex_unlock(&my_mutex);
        printk(KERN_INFO "Kernel thread released mutex lock\n");
        msleep(1000);
    }

    return 0;
}

static int my_thread_fn(void *data)
{
    while (1) {
        mutex_lock(&my_mutex);
        printk(KERN_INFO "User thread acquired mutex lock\n");
        msleep(1000);
        mutex_unlock(&my_mutex);
        printk(KERN_INFO "User thread released mutex lock\n");
        msleep(1000);
    }

    return 0;
}

static int __init my_init(void)
{
    mutex_init(&my_mutex);
    kthread = kthread_create(my_kthread_fn, NULL, "my_kthread");
    wake_up_process(kthread);
    kthread_run(my_thread_fn, NULL, "my_thread");

    return 0;
}

static void __exit my_exit(void)
{
    kthread_stop(kthread);
    mutex_destroy(&my_mutex);
}

module_init(my_init);
module_exit(my_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple example Linux module.");
MODULE_VERSION("0.01");

这个例子中，我们创建了一个内核线程和一个用户线程，它们共享同一个互斥锁my_mutex。内核线程每隔1秒钟获取锁并释放锁，用户线程也每隔1秒钟获取锁并释放锁。由于内核线程和用户线程共享同一个互斥锁，因此它们之间会进行互斥访问，即同一时刻只有一个线程能够获取到锁，另一个线程需要等待。

在这个例子中，内核线程通过`mutex_lock`函数获取互斥锁，而用户线程通过`pthread_mutex_lock`函数获取互斥锁。两个函数的使用方式类似，但是内核线程使用的是Linux内核提供的互斥锁，而用户线程使用的是POSIX标准的互斥锁。当一个线程获取到锁后，另一个线程需要等待，直到锁被释放。这样就保证了内核线程和用户线程之间的互斥访问。