• linux-自定义进程通信方式

    背景

            我们知道linux的进程的间通信的组件有管道，消息队列，socket, 信号量，共享内存等

            但是我们如果自己实现一套进程间通信的机制的话，要怎么做？了解android 开发的可能会知道，android里面有个binder机制，简单来说，就是一个进程往binder里面写数据，另一个进程从binder里面读出数据。

         

    原理 

    在这里插入图片描述

            我们首先需要注册一个字符设备文件叫/dev/channel, 同时需要为这个设备编写驱动，此时某个进程A向设备文件写数据，同时如果该设备可读，我们就通知另一个进程B去读该进程。 我们怎么知道该设备是否可读可写呢？使用poll来管理，因为该设备驱动属于一个IO, 打开一个设备就有fd, 有了fd我们就可以使用poll来管理。

    如：

    发送方：

     接收方：

     代码：

    1.  
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15.  
    16. #ifndef CHANNEL_MAJOR
    17. #define CHANNEL_MAJOR  96
    18. #endif
    19.  
    20. #ifndef CHANNEL_NR_DEVS
    21. #define CHANNEL_NR_DEVS 2
    22. #endif
    23.  
    24. #ifndef CHANNEL_SIZE  
    25. #define CHANNEL_SIZE 4096
    26. #endif
    27.  
    28. #define ENABLE_POLL		1
    29.  
    30. struct channel {
    31.     char *data;
    32.     unsigned long size;
    33. #if ENABLE_POLL
    34.     wait_queue_head_t inq;
    35. #endif
    36. };
    37.  
    38. static int channel_major = CHANNEL_MAJOR; 
    39. module_param(channel_major, int, S_IRUGO);
    40.  
    41. struct channel *channel_devp;
    42. struct cdev cdev;
    43.  
    44. char have_data = 0;
    45.  
    46. int channel_open (struct inode *inode, struct file *filp) {
    47.     struct channel *channel; 
    48.  
    49.     int num = MINOR(inode->i_rdev);  //设备读了多少次
    50.     if (num >= CHANNEL_NR_DEVS) 
    51.         return -ENODEV;
    52.  
    53.     channel = &channel_devp[num];
    54.     filp->private_data = channel;
    55.  
    56.     return 0;
    57. }
    58.  
    59. int channel_release (struct inode *inode, struct file *filp) {
    60.     return 0;
    61. }
    62.  
    63. #if ENABLE_POLL
    64. unsigned int channel_poll (struct file *filp, struct poll_table_struct *wait) {
    65.     struct channel *channel = filp->private_data;
    66. 	unsigned int mask = 0;
    67.  
    68. 	poll_wait(filp, &channel->inq, wait);  // poll 阻塞
    69.  
    70. 	if (have_data)
    71. 		mask |= (POLLIN | POLLRDNORM);
    72.  
    73. 	return mask;
    74. }
    75. #endif
    76.  
    77.  
    78. int channel_mmap (struct file *filp, struct vm_area_struct *vma) {
    79.     struct channel *channel = filp->private_data;
    80.  
    81.     vma->vm_flags |= VM_IO;
    82.     vma->vm_flags |= (VM_DONTEXPAND | VM_DONTDUMP);
    83.  
    84. 	if (remap_pfn_range(vma, vma->vm_start, virt_to_phys(channel->data) >> PAGE_SHIFT, 
    85. 		vma->vm_end-vma->vm_start, vma->vm_page_prot)) {
    86. 		return -EAGAIN;
    87. 	}
    88. 	
    89. 	return 0;
    90. }
    91.  
    92. ssize_t channel_read (struct file *filp, char __user * buffer, size_t size, loff_t *ppos) {
    93.     unsigned long p = *ppos;
    94.     unsigned int count = size;
    95.  
    96.     int ret = 0;
    97.     struct channel *channel = filp->private_data;   // 读私有空间
    98.  
    99.     if (p >= CHANNEL_SIZE) return 0;
    100.     if (count > CHANNEL_SIZE- p) 
    101.         count = CHANNEL_SIZE- p;
    102.  
    103. #if ENABLE_POLL
    104.     while (!have_data) {
    105.         if (filp->f_flags & O_NONBLOCK) return -EAGAIN;
    106.  
    107.         wait_event_interruptible(channel->inq, have_data);
    108.     }
    109. #endif
    110.     if (copy_to_user(buffer, (void*)(channel->data + p), count)) { //拷贝到用户空间
    111.         ret = -EFAULT;
    112.     } else {
    113.         ret = strlen(buffer);
    114.         channel->size -= ret;
    115.         printk(KERN_INFO "read %d byte(s) from %ld\n", ret, p);
    116.     }
    117.  
    118.     have_data = 0;
    119.     return ret;
    120. }
    121.  
    122. ssize_t channel_write (struct file *filp , const char __user * buffer, size_t size, loff_t *ppos) {
    123.     int ret = 0;
    124. 	unsigned long p = *ppos;
    125. 	unsigned int count = size;
    126.  
    127.     struct channel *channel = filp->private_data;  // 写道文件的私有空间
    128.     if (p >= CHANNEL_SIZE) return 0;
    129.     if (count > CHANNEL_SIZE- p) 
    130.         count = CHANNEL_SIZE- p;
    131.     
    132.     if (copy_from_user(channel->data +p, buffer, count)) {  // 从user -> kernel
    133.         return -EFAULT;
    134.     } else {
    135.         *ppos += count;
    136.         ret = count;
    137.         channel->size += count;
    138.         *(channel->data+p + count) = '\0'; 
    139.  
    140.         printk(KERN_INFO "written %d byte(s) from %ld\n", count, p);
    141.     }
    142.  
    143. #if ENABLE_POLL
    144. 	have_data = 1;
    145. 	wake_up(&channel->inq);
    146. #endif
    147.  
    148. 	return ret;
    149. }
    150.  
    151. loff_t channel_llseek (struct file *filp, loff_t offset, int whence) {  //偏移
    152.     loff_t newpos;
    153.  
    154.     switch (whence)
    155.     {
    156.     case 0:
    157.         newpos = offset;
    158.         break;
    159.     case 1:
    160.         newpos = filp->f_pos + offset;
    161.         break;
    162.     case 2:
    163.         newpos = CHANNEL_SIZE - 1 + offset;
    164.         break;
    165.     default:
    166.         return -EINVAL;
    167.     }
    168.  
    169.     if (newpos < 0 || newpos > CHANNEL_SIZE) return -EINVAL;
    170.  
    171.     filp->f_pos = newpos;
    172.  
    173.     return newpos;
    174. }
    175.  
    176. static const struct file_operations channel_fops = 
    177. {
    178.     .owner = THIS_MODULE,
    179.     .llseek = channel_llseek,
    180.     .read = channel_read,
    181.     .write = channel_write,
    182.     .open = channel_open, 
    183.     .release = channel_release,
    184.     .poll = channel_poll, 
    185.     .mmap = channel_mmap,
    186. };
    187.  
    188.  
    189. static int channel_init(void) {
    190.     int reslut;
    191.     int i;
    192.  
    193.     dev_t devno = MKDEV(channel_major, 0);   // 创建一个主设备号为96，次设备号为0的设备
    194.     if (channel_major) {
    195.         reslut = register_chrdev_region(devno, CHANNEL_NR_DEVS, "channel"); // 注册设备
    196.     } else {
    197.         reslut = alloc_chrdev_region(&devno, 0, CHANNEL_NR_DEVS, "channel");
    198.     }
    199.  
    200.     if (reslut < 0) return reslut;
    201.  
    202.     cdev_init(&cdev, &channel_fops);   //初始化字符设备
    203.     cdev.owner = THIS_MODULE; 
    204.  
    205.     cdev_add(&cdev, MKDEV(channel_major, 0), CHANNEL_NR_DEVS); //添加到字符设备中
    206.  
    207.     channel_devp = kmalloc(CHANNEL_NR_DEVS *sizeof(struct channel), GFP_KERNEL); //为 我们的buffer 分配一块空间
    208.     if (!channel_devp) {
    209.         reslut = -ENOMEM;
    210.         goto fail_malloc;
    211.     }
    212.     memset(channel_devp, 0, sizeof(struct channel));
    213.  
    214.     for (i = 0; i < CHANNEL_NR_DEVS; i++) {
    215.         channel_devp[i].size = CHANNEL_SIZE;
    216.         channel_devp[i].data = kmalloc(CHANNEL_SIZE, GFP_KERNEL);
    217.         memset(channel_devp[i].data, 0, CHANNEL_SIZE);
    218. #if ENABLE_POLL
    219.         init_waitqueue_head(&(channel_devp[i].inq));
    220. #endif
    221.     }
    222.     printk(KERN_INFO "ntychannel_init");
    223.  
    224. 	return 0;
    225. fail_malloc:
    226.     unregister_chrdev_region(devno, 1);
    227.     return reslut;
    228. }
    229.  
    230. static void channel_exit(void) {
    231.     printk(KERN_INFO "channel_exit");
    232.     cdev_del(&cdev);
    233.     
    234.     int i = 0;
    235.     for (i = 0; i < CHANNEL_NR_DEVS; i++) {
    236.         kfree(channel_devp[i].data);
    237.     }
    238.     
    239.     kfree(channel_devp);
    240.  
    241.     unregister_chrdev_region(MKDEV(channel_major, 0), 2);
    242. }
    243.  
    244.  
    245. MODULE_AUTHOR("birate");
    246. MODULE_LICENSE("GPL");
    247.  
    248. module_init(channel_init);  // 设备初始化
    249. module_exit(channel_exit);  //设备退出
    250.

    编写Makefile文件:

    1. obj-m += channel.o
    2. KERNELDIR ?= /lib/modules/$(shell uname -r)/build
    3. all:
    4. 	make -C $(KERNELDIR) M=$(PWD) modules
    5. clean:
    6. 	make -C $(KERNELDIR) M=$(PWD) clean

    使用 make 命令。编译出我们需要的channel.ko文件。
    使用 insmod channel.ko， 向kernel中插入 我们的module
    使用mknod /dev/channel c 96 0, 创建一个/dev/channel 的字符设备，主设备号为96，次设备号为0；


    测试程序：

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #include 
    12.  
    13. #define BUFFER_LENGTH 128
    14.  
    15. int main () {
    16.     int fd = open("/dev/channel", O_RDWR);  
    17.     if (fd < 0) {
    18.         printf("open failed: errno : %s\n", strerror(errno));
    19.         return -1;
    20.     }
    21.  
    22.     char *buffer = (char *)malloc(BUFFER_LENGTH);
    23.     memset(buffer, 0, BUFFER_LENGTH);
    24.  
    25.     char *start = mmap(NULL, BUFFER_LENGTH, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    26.  
    27.     fd_set rds;
    28.     FD_ZERO(&rds);
    29.     FD_SET(fd, &rds);
    30.  
    31.     while(1) {
    32.         int ret = select(fd+1, &rds, NULL, NULL, NULL);
    33.         if (ret < 0) {
    34.             printf("select error\n");
    35.             exit(1);
    36.         }
    37.         if (FD_ISSET(fd, &rds)) {
    38. #if 0
    39.             strcpy(buffer, start);
    40.             printf("channel: %s\n", buffer);
    41. #else 
    42.             read(fd, buffer, BUFFER_LENGTH);
    43.             printf("channel: %s\n", buffer);
    44. #endif
    45.         }
    46.     }
    47.  
    48.     munmap(start, BUFFER_LENGTH);
    49.     free(buffer);
    50.     close(fd);
    51.  
    52.     return 0;
    53. }
    54.

             gcc -o channel_app channel_app.c ， 编译出可执行文件，在一个进程中执行channel_app， 另一个进程使用echo " " > /dev/channel 去向设备文件中写就可以

    系统调用 system_call

     

    用户空间的 ：

    1. static const struct file_operations channel_fops = 
    2. {
    3.     .owner = THIS_MODULE,
    4.     .llseek = channel_llseek,
    5.     .read = channel_read,
    6.     .write = channel_write,
    7.     .open = channel_open, 
    8.     .release = channel_release,
    9.     .poll = channel_poll, 
    10.     .mmap = channel_mmap,
    11. };

    read,write等等是如何调用到内核空间的呢？

    Oldlinux.org -- Linux plinux - Early Linux Kernel Analysis and Comments

    《Linux操作系统实现原理》网页/Book-Lite/

    linux老版本下载：Index of /Linux.old/ 

            代码以0.11版本为例

            系统调用是一个软中断，中断号是0x80，它是上层应用程序与Linux系统内核进行交互通信的唯一接口。 

    如：tools\build.c

    调用open :

     open的源码路径lib\open.c

    1. /*
    2.  *  linux/lib/open.c
    3.  *
    4.  *  (C) 1991  Linus Torvalds
    5.  */
    6.  
    7. #define __LIBRARY__
    8. #include 
    9. #include 
    10.  
    11. int open(const char * filename, int flag, ...)
    12. {
    13. 	register int res;
    14. 	va_list arg;
    15.  
    16. 	va_start(arg,flag);
    17. 	__asm__("int $0x80"
    18. 		:"=a" (res)
    19. 		:"0" (__NR_open),"b" (filename),"c" (flag),
    20. 		"d" (va_arg(arg,int)));
    21. 	if (res>=0)
    22. 		return res;
    23. 	errno = -res;
    24. 	return -1;
    25. }

    在汇编语言中调用0x80 ....进入系统调用

    在include\unistd.h中定义了

    1. #define __NR_setup	0	/* used only by init, to get system going */
    2. #define __NR_exit	1
    3. #define __NR_fork	2
    4. #define __NR_read	3
    5. #define __NR_write	4
    6. #define __NR_open	5   // open是5
    7.  
    8. ......
    9.  
    10.  _syscall0(type,name)  其中  0 表示参数个数，type 表示返回值name表示函数名称
    11.  
    12. #define _syscall0(type,name) \
    13. type name(void) \
    14. { \
    15. long __res; \
    16. __asm__ volatile ("int $0x80" \
    17. 	: "=a" (__res) \
    18. 	: "0" (__NR_##name)); \
    19. if (__res >= 0) \
    20. 	return (type) __res; \
    21. errno = -__res; \
    22. return -1; \
    23. }
    24.  
    25. #define _syscall1(type,name,atype,a) \
    26. type name(atype a) \
    27. { \
    28. long __res; \
    29. __asm__ volatile ("int $0x80" \
    30. 	: "=a" (__res) \
    31. 	: "0" (__NR_##name),"b" ((long)(a))); \
    32. if (__res >= 0) \
    33. 	return (type) __res; \
    34. errno = -__res; \
    35. return -1; \
    36. }
    37.  
    38. #define _syscall2(type,name,atype,a,btype,b) \
    39. type name(atype a,btype b) \
    40. { \
    41. long __res; \
    42. __asm__ volatile ("int $0x80" \
    43. 	: "=a" (__res) \
    44. 	: "0" (__NR_##name),"b" ((long)(a)),"c" ((long)(b))); \
    45. if (__res >= 0) \
    46. 	return (type) __res; \
    47. errno = -__res; \
    48. return -1; \
    49. }
    50.  
    51. #define _syscall3(type,name,atype,a,btype,b,ctype,c) \
    52. type name(atype a,btype b,ctype c) \
    53. { \
    54. long __res; \
    55. __asm__ volatile ("int $0x80" \
    56. 	: "=a" (__res) \
    57. 	: "0" (__NR_##name),"b" ((long)(a)),"c" ((long)(b)),"d" ((long)(c))); \
    58. if (__res>=0) \
    59. 	return (type) __res; \
    60. errno=-__res; \
    61. return -1; \
    62. }
    63.

    kernel\system_call.s

    1. _system_call:
    2. 	cmpl $nr_system_calls-1,%eax
    3. 	ja bad_sys_call
    4. 	push %ds
    5. 	push %es
    6. 	push %fs
    7. 	pushl %edx
    8. 	pushl %ecx		# push %ebx,%ecx,%edx as parameters
    9. 	pushl %ebx		# to the system call
    10. 	movl $0x10,%edx		# set up ds,es to kernel space
    11. 	mov %dx,%ds
    12. 	mov %dx,%es
    13. 	movl $0x17,%edx		# fs points to local data space
    14. 	mov %dx,%fs
    15. 	call _sys_call_table(,%eax,4)
    16. 	pushl %eax
    17. 	movl _current,%eax
    18. 	cmpl $0,state(%eax)		# state
    19. 	jne reschedule
    20. 	cmpl $0,counter(%eax)		# counter
    21. 	je reschedule

    调用了系统调用表    call _sys_call_table(,%eax,4)，%eax表示下标

    include\linux\sys.h

    1. fn_ptr sys_call_table[] = { sys_setup, sys_exit, sys_fork, sys_read,
    2. sys_write, sys_open, sys_close, sys_waitpid, sys_creat, sys_link,
    3. sys_unlink, sys_execve, sys_chdir, sys_time, sys_mknod, sys_chmod,
    4. sys_chown, sys_break, sys_stat, sys_lseek, sys_getpid, sys_mount,
    5. sys_umount, sys_setuid, sys_getuid, sys_stime, sys_ptrace, sys_alarm,
    6. sys_fstat, sys_pause, sys_utime, sys_stty, sys_gtty, sys_access,
    7. sys_nice, sys_ftime, sys_sync, sys_kill, sys_rename, sys_mkdir,
    8. sys_rmdir, sys_dup, sys_pipe, sys_times, sys_prof, sys_brk, sys_setgid,
    9. sys_getgid, sys_signal, sys_geteuid, sys_getegid, sys_acct, sys_phys,
    10. sys_lock, sys_ioctl, sys_fcntl, sys_mpx, sys_setpgid, sys_ulimit,
    11. sys_uname, sys_umask, sys_chroot, sys_ustat, sys_dup2, sys_getppid,
    12. sys_getpgrp, sys_setsid, sys_sigaction, sys_sgetmask, sys_ssetmask,
    13. sys_setreuid,sys_setregid };

    可以看出系统调用表示一个函数数组，在include\unistd.h 定义了#define __NR_open   5，这里对应函数数组的下标5 ：sys_open，调用内核函数：

    fs\open.c

    常用的几种进程通信方式的比较
    application/msword 0星 超过10%的资源 39KB
    下载
    1.  
    2. int sys_open(const char * filename,int flag,int mode)
    3. {
    4. 	struct m_inode * inode;
    5. 	struct file * f;
    6. 	int i,fd;
    7.  
    8. 	mode &= 0777 & ~current->umask;
    9. 	for(fd=0 ; fd
    10. 		if (!current->filp[fd])
    11. 			break;
    12. 	if (fd>=NR_OPEN)
    13. 		return -EINVAL;
    14. 	current->close_on_exec &= ~(1<
    15. 	f=0+file_table;
    16. 	for (i=0 ; i
    17. 		if (!f->f_count) break;
    18. 	if (i>=NR_FILE)
    19. 		return -EINVAL;
    20. 	(current->filp[fd]=f)->f_count++;
    21. 	if ((i=open_namei(filename,flag,mode,&inode))<0) {
    22. 		current->filp[fd]=NULL;
    23. 		f->f_count=0;
    24. 		return i;
    25. 	}
    26. /* ttys are somewhat special (ttyxx major==4, tty major==5) */
    27. 	if (S_ISCHR(inode->i_mode))
    28. 		if (MAJOR(inode->i_zone[0])==4) {
    29. 			if (current->leader && current->tty<0) {
    30. 				current->tty = MINOR(inode->i_zone[0]);
    31. 				tty_table[current->tty].pgrp = current->pgrp;
    32. 			}
    33. 		} else if (MAJOR(inode->i_zone[0])==5)
    34. 			if (current->tty<0) {
    35. 				iput(inode);
    36. 				current->filp[fd]=NULL;
    37. 				f->f_count=0;
    38. 				return -EPERM;
    39. 			}
    40. /* Likewise with block-devices: check for floppy_change */
    41. 	if (S_ISBLK(inode->i_mode))
    42. 		check_disk_change(inode->i_zone[0]);
    43. 	f->f_mode = inode->i_mode;
    44. 	f->f_flags = flag;
    45. 	f->f_count = 1;
    46. 	f->f_inode = inode;
    47. 	f->f_pos = 0;
    48. 	return (fd);
    49. }

    那么  ：

    1. static const struct file_operations channel_fops = 
    2. {
    3.     .owner = THIS_MODULE,
    4.     .llseek = channel_llseek,
    5.     .read = channel_read,
    6.     .write = channel_write,
    7.     .open = channel_open, 
    8.     .release = channel_release,
    9.     .poll = channel_poll, 
    10.     .mmap = channel_mmap,
    11. };

    int channel_open (struct inode *inode, struct file *filp)

    inode:文件具体数据 file:路径属性

    是通过系统调用的

    int sys_open(const char * filename,int flag,int mode)  完成的

    主次设备号

            /dev目录下执行ls -l

            设备文件项的最后修改日期前的用逗号分割的两个数，对设备文件来说就是相应的主设备号和次设备号。

            第一个字符c表示字符设备，b表示块设备

            主设备号标识设备对应的驱动程序，次设备号由内核使用，用于正确确定设备文件所指的设备。依赖于驱动程序的编写方式，我们可以通过次设备号获得一个指向内核设备的直接指针，也可将次设备号当作设备本地数组的索引

    在代码中：

    1. static int channel_init(void) {
    2.     int reslut;
    3.     int i;
    4.  
    5.     dev_t devno = MKDEV(channel_major, 0);   // 创建一个主设备号为96，次设备号为0的设备
    6.     if (channel_major) {
    7.         reslut = register_chrdev_region(devno, CHANNEL_NR_DEVS, "channel"); // 注册设备
    8.     } else {
    9.         reslut = alloc_chrdev_region(&devno, 0, CHANNEL_NR_DEVS, "channel");
    10.     }
    11.  
    12.     if (reslut < 0) return reslut;
    13.  
    14.     cdev_init(&cdev, &channel_fops);   //初始化字符设备
    15.     cdev.owner = THIS_MODULE; 
    16.  
    17.     cdev_add(&cdev, MKDEV(channel_major, 0), CHANNEL_NR_DEVS); //添加到字符设备中
    18.  
    19.     channel_devp = kmalloc(CHANNEL_NR_DEVS *sizeof(struct channel), GFP_KERNEL); //为 我们的buffer 分配一块空间
    20.     if (!channel_devp) {
    21.         reslut = -ENOMEM;
    22.         goto fail_malloc;
    23.     }
    24.     memset(channel_devp, 0, sizeof(struct channel));
    25.  
    26.     for (i = 0; i < CHANNEL_NR_DEVS; i++) {
    27.         channel_devp[i].size = CHANNEL_SIZE;
    28.         channel_devp[i].data = kmalloc(CHANNEL_SIZE, GFP_KERNEL);
    29.         memset(channel_devp[i].data, 0, CHANNEL_SIZE);
    30. #if ENABLE_POLL
    31.         init_waitqueue_head(&(channel_devp[i].inq));
    32. #endif
    33.     }
    34.     printk(KERN_INFO "ntychannel_init");
    35.  
    36. 	return 0;
    37. fail_malloc:
    38.     unregister_chrdev_region(devno, 1);
    39.     return reslut;
    40. }

    在调用过：

    1. sudo insmod channel.ko 
    2. sudo mknod /dev/channel c 96 0
    3. cd /dev
    4. ls -l | grep channel

    可以看到注册的设备 

    sudo insmod channel.ko  实质是执行channel_init 函数

            1 向内核申请注册一个设备：主次设备号 register_chrdev_region

            2 初始化一个字符设备 cdev_init

            3 加入到内核 cdev_add

            4 初始化private_date

    WM_COPYDATA消息进程通信
    rar 0星 超过10%的资源 3.52MB
    下载

    open

            将file 和private_date关联起来

    1. int channel_open (struct inode *inode, struct file *filp) {
    2.     struct channel *channel; 
    3.  
    4.     int num = MINOR(inode->i_rdev);  //设备读了多少次
    5.     if (num >= CHANNEL_NR_DEVS) 
    6.         return -ENODEV;
    7.  
    8.     channel = &channel_devp[num];
    9.     filp->private_data = channel;
    10.  
    11.     return 0;
    12. }

    rmmod与模块退出

    1. static void channel_exit(void) {
    2.     printk(KERN_INFO "channel_exit");
    3.     cdev_del(&cdev);
    4.     
    5.     int i = 0;
    6.     for (i = 0; i < CHANNEL_NR_DEVS; i++) {
    7.         kfree(channel_devp[i].data);
    8.     }
    9.     
    10.     kfree(channel_devp);
    11.  
    12.     unregister_chrdev_region(MKDEV(channel_major, 0), 2);
    13. }

    write

    通过：

    root@ok-VirtualBox:/home/ok/channel# echo "111111111" > /dev/channel

    查看日志：dmesg

    可以看到写入数据的日志 

    从用户空间的buffer ->copy to -> channel.date

    1. //filp 文件属性
    2. //buffer 用户写入数据buffer 如：123\0
    3. //size 数据大小
    4. //ppos 偏移量
    5. ssize_t channel_write (struct file *filp , const char __user * buffer, size_t size, loff_t *ppos) {
    6.     int ret = 0;
    7. 	unsigned long p = *ppos;
    8. 	unsigned int count = size;
    9.  
    10.     struct channel *channel = filp->private_data;  // 写到文件的私有空间
    11.     if (p >= CHANNEL_SIZE) return 0;
    12.     //判断容量是否可以放下所有Buffer数据，防止数组越界
    13.     if (count > CHANNEL_SIZE- p) 
    14.         count = CHANNEL_SIZE- p;
    15.     
    16.     //从用户空间的数据 copy to 内核空间， 返回0表示成功 ，执行else
    17.     if (copy_from_user(channel->data +p, buffer, count)) {  // 从user -> kernel
    18.         return -EFAULT;
    19.     } else {
    20.         //修改相关标志位
    21.         *ppos += count;
    22.         ret = count;
    23.         channel->size += count;
    24.         *(channel->data+p + count) = '\0'; 
    25.  
    26.         printk(KERN_INFO "written %d byte(s) from %ld\n", count, p);
    27.     }
    28.  
    29. #if ENABLE_POLL
    30. 	have_data = 1;
    31. 	wake_up(&channel->inq);
    32. #endif
    33.  
    34. 	return ret;
    35. }

    1 检查参数

    2 拷贝数据

    3 上下文参数调整

    read

    1.  
    2. ssize_t channel_read (struct file *filp, char __user * buffer, size_t size, loff_t *ppos) {
    3.     unsigned long p = *ppos;
    4.     unsigned int count = size;
    5.  
    6.     int ret = 0;
    7.     struct channel *channel = filp->private_data;   // 读私有空间
    8.  
    9.     if (p >= CHANNEL_SIZE) return 0;
    10.     if (count > CHANNEL_SIZE- p) 
    11.         count = CHANNEL_SIZE- p;
    12.  
    13. #if ENABLE_POLL
    14.     while (!have_data) {
    15.         if (filp->f_flags & O_NONBLOCK) return -EAGAIN;
    16.  
    17.         wait_event_interruptible(channel->inq, have_data);
    18.     }
    19. #endif
    20.     if (copy_to_user(buffer, (void*)(channel->data + p), count)) { //拷贝到用户空间
    21.         ret = -EFAULT;
    22.     } else {
    23.         ret = strlen(buffer);
    24.         channel->size -= ret;
    25.         printk(KERN_INFO "read %d byte(s) from %ld\n", ret, p);
    26.     }
    27.  
    28.     have_data = 0;
    29.     return ret;
    30. }

    poll

    在应用层使用select 时，内核层会调用poll

    1.  
    2. #if ENABLE_POLL
    3. unsigned int channel_poll (struct file *filp, struct poll_table_struct *wait) {
    4.     struct channel *channel = filp->private_data;
    5. 	unsigned int mask = 0;
    6.  
    7. 	poll_wait(filp, &channel->inq, wait);  // poll 阻塞
    8.  
    9. 	if (have_data)
    10. 		mask |= (POLLIN | POLLRDNORM);
    11.  
    12. 	return mask;
    13. }
    14. #endif

  • 相关阅读:
    Colossal-AI
    Redis的最佳实践？看完不心动，算我输！！
    i.MX 6ULL 驱动开发 三：字符设备驱动框架实现和调试
    SpringBoot自动装配原理
    【刷题篇】反转链表
    文举论金：黄金原油全面走势分析策略独家指导
    LeetCode每日一题——791. 自定义字符串排序
    Django中的ajax细节
    调用 xlwings 创建多线程时报错 pywintypes.com_error: ( ‘应用程序调用一个已为另一线程整理的接口)解决方法
    【图解设计模式】适配器模式
  • 原文地址：https://blog.csdn.net/LIJIWEI0611/article/details/126110890