linux内核顺序锁seqlock_t使用说明

顺序锁seqlock_t： 写需要获取锁，同时只能一个写。
读不需要获取锁，但是在读之前要先获取一个顺序值，读完成之后要拿这个顺序值和最新的比较，若一直则说明在读的期间没有写的操作，若不一致，则需要重新读。

使用流程：
声明

 include <linux/seqlock.h>
  seqlock_t mylock;

初始化

  seqlock_init(&mylock);

写操作加锁

   write_seqlock(&mylock);

写操作释放锁

   write_sequnlock(&mylock);

读操作之前先获取顺序值

   begin = read_seqbegin(&mylock);

读操作完成之后对比顺序值

   read_seqretry(&mylock,begin)

以下是内核模块的代码：

#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/stat.h>
#include <linux/cdev.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/mutex.h>
#include <linux/interrupt.h>
#include <linux/bug.h>			/* For BUG_ON.  */
#include <linux/cpu.h>
#include <linux/init.h> /* Needed for the macros */
#include <linux/kernel.h> /* Needed for pr_info() */
#include <linux/module.h> /* Needed by all modules */
#include <linux/delay.h>
#include <linux/smp.h>
#include <linux/kernel_stat.h>
#include <linux/sched.h>
#include <linux/percpu-defs.h>
#include <linux/wait.h>
#include <linux/gpio/driver.h>
#include <linux/atomic.h>
#include <linux/platform_device.h>
#include <linux/poll.h>
#include <linux/kfifo.h>
#include <linux/rwlock_types.h>
#include <linux/rwlock.h>
#include <linux/seqlock.h>

#define DELAY_CMD_WRITE   _IOW('A',0,unsigned int)
#define DELAY_CMD_READ   _IOW('A',1,unsigned int)

#define MY_MAX_MINORS  1
#define   DEVICE_NAME  "device name 500"

DEFINE_KFIFO(myfifo, char, 1024);

struct my_device_data {
	struct cdev cdev;
};

DECLARE_WAIT_QUEUE_HEAD(wq);

seqlock_t mylock;

static struct my_device_data devs[MY_MAX_MINORS];

static int my_open(struct inode *inode, struct file *file) {
	pr_info("my_open \n");
	return 0;
}

static ssize_t my_write(struct file *filp, const char __user *user_buffer,
		size_t size, loff_t *offset) {
	int ret;
	unsigned int len = 0;
	pr_info("write");
	ret = kfifo_from_user(&myfifo, user_buffer, size, &len);
	if (ret != 0) {
		pr_err("kfifo_from_user error");
		return 0;
	}
	if (len <= 0)
		return 0;
	*offset += len;
	wake_up(&wq);
	return len;
}

static ssize_t my_read(struct file *filp, char __user *user_buffer,
		size_t count, loff_t *offset) {
	int ret;
	unsigned int len = 0;
	pr_info("read");
	ret = kfifo_to_user(&myfifo, user_buffer, count, &len);
	if (len <= 0)
		return 0;
	*offset += len;
	return len;
}

unsigned int my_poll(struct file *flip, struct poll_table_struct *table) {
	int mask = 0;
	pr_info("my_poll \n");
	poll_wait(flip, &wq, table);
	if (kfifo_is_empty(&myfifo)) {

	} else {
		mask |= POLLIN | POLLRDNORM;
	}
	return mask;
}

int my_close(struct inode *inode, struct file *flip) {
	pr_info("my_close \n");
	return 0;
}

unsigned  begin;
 int  count=0;


static long my_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
	pr_info("cmd %d\n", cmd);
	switch (_IOC_NR(cmd)) {
	case 0: {
		write_seqlock(&mylock);
		pr_info("write start\n");
		mdelay(1000);
		pr_info("write end\n");
		write_sequnlock(&mylock);
		break;
	}
	case 1: {
		pr_info("read start\n");
		do{
			count++;
			pr_info("read %d\n",count);
			begin = read_seqbegin(&mylock);
		    mdelay(3000);
		}while(read_seqretry(&mylock,begin));
		pr_info("read end\n");
		break;
	}
	default: {
		pr_info("default: \n");
	}
	}
	return 0;
}

static const struct file_operations my_fops = { .owner = THIS_MODULE, .open =
		my_open, .read = my_read, .write = my_write, .poll = my_poll, .release =
		my_close, .unlocked_ioctl = my_ioctl,

};

static dev_t mydev;

static __init int my_init(void) {
	int i;
	int err;
	pr_info("a3 init_module\n");err = alloc_chrdev_region(&mydev, 0, MY_MAX_MINORS, DEVICE_NAME);
	if (err != 0) {
		return err;
	}

	for (i = 0; i < MY_MAX_MINORS; i++) {
		/* initialize devs[i] fields */
		cdev_init(&devs[i].cdev, &my_fops);
		cdev_add(&devs[i].cdev, MKDEV(MAJOR(mydev), i), 1);
	}
   seqlock_init(&mylock);
return 0;
}

static void __exit my_exit(void) {
		int i;
		pr_info("a3 cleanup_module\n");for (i = 0; i < MY_MAX_MINORS; i++) {
		/* release devs[i] fields */
		cdev_del(&devs[i].cdev);
		}
		unregister_chrdev_region(mydev, MY_MAX_MINORS);
}

module_init(my_init);
module_exit(my_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("81553652@qq.com");
MODULE_DESCRIPTION("andy one-key driver");
MODULE_ALIAS("one-key");

应用测试代码：

#include <stdint.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdio.h>
#include <pthread.h>
#include <poll.h>

#define DELAY_CMD_WRITE   _IOW('A',0,unsigned int)
#define DELAY_CMD_READ   _IOW('A',1,unsigned int)

static void* write01(void *ptr) {
	int fd = open("/dev/t01", O_RDWR, O_NONBLOCK);
	if (fd < 0) {
		perror("open");
		printf("error open\n");
		return NULL;
	}
	printf("write start \n");
	ioctl(fd, DELAY_CMD_WRITE, 100);
	printf("write end \n");
	close(fd);
	return NULL;
}

static void* read01(void *ptr) {
	int fd = open("/dev/t01", O_RDWR, O_NONBLOCK);
	if (fd < 0) {
		perror("open");
		printf("error open\n");
		return NULL;
	}
	printf("read start \n");
	ioctl(fd, DELAY_CMD_READ, 100);
	printf("read end \n");
	close(fd);
	return NULL;
}

/**
 * first read then  write
 */
int main() {
	pthread_t thread, thread2, thread3;
	pthread_create(&thread2, NULL, read01, NULL);
	usleep(1000*20);
	pthread_create(&thread, NULL, write01, NULL);
	pthread_join(thread, NULL);
	pthread_join(thread2, NULL);
	printf("main exit\n");
	return EXIT_SUCCESS;
}

说明： 先读后写，驱动模块中读的操作比较久，在此期间执行了写入，读完成之后对比发现顺序值不一样，所以需要再读一次.