AI 助理
备案控制台
开发者社区 人工智能 文章 正文

linux 高级字符设备驱动 ioctl操作介绍 例程分析实现【转】

2015-08-05 1367
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 转自：http://my.oschina.net/u/274829/blog/285014 1，ioctl介绍 ioctl控制设备读写数据以及关闭等。 用户空间函数原型：int ioctl(int fd,unsinged long cmd,...)   fd-文件描述符 cmd-对设备的发出的控制命令 ...表示这是一个可选的参数，存在与否依赖于cmd，如cmd为修改波特率，那么....就表示波特率的值。

转自：http://my.oschina.net/u/274829/blog/285014

1，ioctl介绍

ioctl控制设备读写数据以及关闭等。

用户空间函数原型：int ioctl(int fd,unsinged long cmd,...)

 

  • fd-文件描述符

  • cmd-对设备的发出的控制命令

  • ...表示这是一个可选的参数，存在与否依赖于cmd，如cmd为修改波特率，那么....就表示波特率的值。如果cmd表示关闭，则不需要参数

     

     

     

     

内核函数原型

file_operations结构体里面long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);

 

ioctl命令段分为：类型，序号，传递方向，参数大小

  • Type 类型：表明哪个设备的命令，在参考了ioctl-number.txt之后选出，8位宽

  • Number 序号：表明设备命令中的第几个，8位宽

  • Direction 传送方向：可能的值是

    _IOC_NONE(没数据传输)

    _IOC_READ(从设备读)

    _IOC_WRITE

  • Size 用户参数大小:（13/14位宽，视处理器而定）

内核提供了一些宏来帮助定义命令：

  • _IO(type, nr )    type为命令类型  如int， nr为序号

    没有参数的命令

  • _IOR(type, nr, datatype)  

        从驱动中读数据，datatype 读的数据参数的类型

  • _IOW(type, nr, datatype)

        写数据到驱动

  • _IOWR(type,nr, datatype)

        读写数据

定义命令例子  #define MEM_IOC_MAGIC 'm'   //定义幻数，因为命令类型type是8位的所以找个字符代替

#define MEM_IOCSET

_IOW(MEM_IOC_MAGIC,0,int)   //命令 去写 一个 int型的数据

#define MEM_IOCGQSET

_IOR(MEM_IOC_MAGIC, 1, int)

 

2，ioctl命令使用时注意事项

用户使用int ioctl(int fd,unsinged long cmd,...)时，...就是要传递的参数

再通过long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long arg);中的arg传递,如果arg是一个整形，可以直接使用，如果是指针，我们必须确保这个用户地址是有效的，因此，使用之前需要进行正解的检查。

内部有检查的，不需要检测的：

Copy_from_user

Copy_to_user

Get_user

Put_user

需要检测的：

__get_user

__put_user

使用int access_ok(int type, const void *addr, unsigned long size)检测

Type 是VERIFY_READ 或者VERIFY_WRITE用来表明是读用户内存还是写用户内存。

Addr参数是要操作的用户内存地址，size是操作的长度。如果ioctl需要从用户空间读一个整数，那么size参数就等于sizeof(int)

内核读，写入用户空间，所以用户空间使用VERIFY_WRITE写验证用户内存是否可用。

Access_ok返回一个布尔值：1，是成功（存取没问题），失败，ioctr返回-EFAULT 

 

3，ioctl实现例程

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
 
#include "memdev.h"
 
static  int  mem_major = MEMDEV_MAJOR;
 
module_param(mem_major,  int , S_IRUGO);
 
struct  mem_dev *mem_devp;  /*设备结构体指针*/
 
struct  cdev cdev; 
 
/*文件打开函数*/
int  mem_open( struct  inode *inode,  struct  file *filp)
{
     struct  mem_dev *dev;
     
     /*获取次设备号*/
     int  num = MINOR(inode->i_rdev);
 
     if  (num >= MEMDEV_NR_DEVS) 
             return  -ENODEV;
     dev = &mem_devp[num];
     
     /*将设备描述结构指针赋值给文件私有数据指针*/
     filp->private_data = dev;
     
     return  0; 
}
 
/*文件释放函数*/
int  mem_release( struct  inode *inode,  struct  file *filp)
{
   return  0;
}
 
/*IO操作*/
int  memdev_ioctl( struct  inode *inode,  struct  file *filp, unsigned  int  cmd, unsigned  long  arg)
{
 
     int  err = 0;
     int  ret = 0;
     int  ioarg = 0;
     
     /* 检测命令的有效性 */
     if  (_IOC_TYPE(cmd) != MEMDEV_IOC_MAGIC) 
         return  -EINVAL;
     if  (_IOC_NR(cmd) > MEMDEV_IOC_MAXNR) 
         return  -EINVAL;
 
     /* 根据命令类型，检测参数空间是否可以访问 */
     if  (_IOC_DIR(cmd) & _IOC_READ)
         err = !access_ok(VERIFY_WRITE, ( void  *)arg, _IOC_SIZE(cmd));
     else  if  (_IOC_DIR(cmd) & _IOC_WRITE)
         err = !access_ok(VERIFY_READ, ( void  *)arg, _IOC_SIZE(cmd));
     if  (err) 
         return  -EFAULT;
 
     /* 根据命令，执行相应的操作 */
     switch (cmd) {
 
       /* 打印当前设备信息 */
       case  MEMDEV_IOCPRINT:
           printk( "<--- CMD MEMDEV_IOCPRINT Done--->\n\n" );
         break ;
       
       /* 获取参数 */
       case  MEMDEV_IOCGETDATA: 
         ioarg = 1101;
         ret = __put_user(ioarg, ( int  *)arg);
         break ;
       
       /* 设置参数 */
       case  MEMDEV_IOCSETDATA: 
         ret = __get_user(ioarg, ( int  *)arg);
         printk( "<--- In Kernel MEMDEV_IOCSETDATA ioarg = %d --->\n\n" ,ioarg);
         break ;
 
       default :  
         return  -EINVAL;
     }
     return  ret;
 
}
 
/*文件操作结构体*/
static  const  struct  file_operations mem_fops =
{
   .owner = THIS_MODULE,
   .open = mem_open,
   .release = mem_release,
   .ioctl = memdev_ioctl,
};
 
/*设备驱动模块加载函数*/
static  int  memdev_init( void )
{
   int  result;
   int  i;
 
   dev_t devno = MKDEV(mem_major, 0);
 
   /* 静态申请设备号*/
   if  (mem_major)
     result = register_chrdev_region(devno, 2,  "memdev" );
   else   /* 动态分配设备号 */
   {
     result = alloc_chrdev_region(&devno, 0, 2,  "memdev" );
     mem_major = MAJOR(devno);
   }  
   
   if  (result < 0)
     return  result;
 
   /*初始化cdev结构*/
   cdev_init(&cdev, &mem_fops);
   cdev.owner = THIS_MODULE;
   cdev.ops = &mem_fops;
   
   /* 注册字符设备 */
   cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
    
   /* 为设备描述结构分配内存*/
   mem_devp = kmalloc(MEMDEV_NR_DEVS *  sizeof ( struct  mem_dev), GFP_KERNEL);
   if  (!mem_devp)     /*申请失败*/
   {
     result =  - ENOMEM;
     goto  fail_malloc;
   }
   memset (mem_devp, 0,  sizeof ( struct  mem_dev));
   
   /*为设备分配内存*/
   for  (i=0; i < MEMDEV_NR_DEVS; i++) 
   {
         mem_devp[i].size = MEMDEV_SIZE;
         mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
         memset (mem_devp[i].data, 0, MEMDEV_SIZE);
   }
     
   return  0;
 
   fail_malloc: 
   unregister_chrdev_region(devno, 1);
   
   return  result;
}
 
/*模块卸载函数*/
static  void  memdev_exit( void )
{
   cdev_del(&cdev);    /*注销设备*/
   kfree(mem_devp);      /*释放设备结构体内存*/
   unregister_chrdev_region(MKDEV(mem_major, 0), 2);  /*释放设备号*/
}
 
MODULE_AUTHOR( "David Xie" );
MODULE_LICENSE( "GPL" );
 
module_init(memdev_init);
module_exit(memdev_exit);

 

.h

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#ifndef _MEMDEV_H_
#define _MEMDEV_H_
 
#include <linux/ioctl.h>
 
#ifndef MEMDEV_MAJOR
#define MEMDEV_MAJOR 190   /*预设的mem的主设备号*/
#endif
 
#ifndef MEMDEV_NR_DEVS
#define MEMDEV_NR_DEVS 2    /*设备数*/
#endif
 
#ifndef MEMDEV_SIZE
#define MEMDEV_SIZE 4096
#endif
 
/*mem设备描述结构体*/
struct  mem_dev                                     
{                                                        
   char  *data;                      
   unsigned  long  size;       
};
 
/* 定义幻数 */
#define MEMDEV_IOC_MAGIC  'k'
 
/* 定义命令 */
#define MEMDEV_IOCPRINT   _IO(MEMDEV_IOC_MAGIC, 1)
#define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC, 2, int)
#define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC, 3, int)
 
#define MEMDEV_IOC_MAXNR 3
 
#endif /* _MEMDEV_H_ */

 

Makefile

?
1
2
3
4
5
6
7
8
9
10
11
12
13
ifneq ($(KERNELRELEASE),)
 
obj-m := memdev.o
 
else
     
KDIR := /forlinux/linux-3.0.1
all:
     make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
clean:
     rm -f *.ko *.o *.mod.o *.mod.c *.symvers  modul*
 
endif

 

测试程序

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
 
#include "memdev.h"  /* 包含命令定义 */
 
int  main()
{
     int  fd = 0;
     int  cmd;
     int  arg = 0;
     char  Buf[4096];
     
     
     /*打开设备文件*/
     fd = open( "/dev/memdev0" ,O_RDWR);
     if  (fd < 0)
     {
         printf ( "Open Dev Mem0 Error!\n" );
         return  -1;
     }
     
     /* 调用命令MEMDEV_IOCPRINT */
     printf ( "<--- Call MEMDEV_IOCPRINT --->\n" );
     cmd = MEMDEV_IOCPRINT;
     if  (ioctl(fd, cmd, &arg) < 0)
         {
             printf ( "Call cmd MEMDEV_IOCPRINT fail\n" );
             return  -1;
     }
     
     
     /* 调用命令MEMDEV_IOCSETDATA */
     printf ( "<--- Call MEMDEV_IOCSETDATA --->\n" );
     cmd = MEMDEV_IOCSETDATA;
     arg = 2007;
     if  (ioctl(fd, cmd, &arg) < 0)
         {
             printf ( "Call cmd MEMDEV_IOCSETDATA fail\n" );
             return  -1;
     }
 
     
     /* 调用命令MEMDEV_IOCGETDATA */
     printf ( "<--- Call MEMDEV_IOCGETDATA --->\n" );
     cmd = MEMDEV_IOCGETDATA;
     if  (ioctl(fd, cmd, &arg) < 0)
         {
             printf ( "Call cmd MEMDEV_IOCGETDATA fail\n" );
             return  -1;
     }
     printf ( "<--- In User Space MEMDEV_IOCGETDATA Get Data is %d --->\n\n" ,arg); 
     
     close(fd);
     return  0; 
}

1，ioctl介绍

ioctl控制设备读写数据以及关闭等。

用户空间函数原型：int ioctl(int fd,unsinged long cmd,...)

 

  • fd-文件描述符

  • cmd-对设备的发出的控制命令

  • ...表示这是一个可选的参数，存在与否依赖于cmd，如cmd为修改波特率，那么....就表示波特率的值。如果cmd表示关闭，则不需要参数

     

     

     

     

内核函数原型

file_operations结构体里面long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);

 

ioctl命令段分为：类型，序号，传递方向，参数大小

  • Type 类型：表明哪个设备的命令，在参考了ioctl-number.txt之后选出，8位宽

  • Number 序号：表明设备命令中的第几个，8位宽

  • Direction 传送方向：可能的值是

    _IOC_NONE(没数据传输)

    _IOC_READ(从设备读)

    _IOC_WRITE

  • Size 用户参数大小:（13/14位宽，视处理器而定）

内核提供了一些宏来帮助定义命令：

  • _IO(type, nr )    type为命令类型  如int， nr为序号

    没有参数的命令

  • _IOR(type, nr, datatype)  

        从驱动中读数据，datatype 读的数据参数的类型

  • _IOW(type, nr, datatype)

        写数据到驱动

  • _IOWR(type,nr, datatype)

        读写数据

定义命令例子  #define MEM_IOC_MAGIC 'm'   //定义幻数，因为命令类型type是8位的所以找个字符代替

#define MEM_IOCSET

_IOW(MEM_IOC_MAGIC,0,int)   //命令 去写 一个 int型的数据

#define MEM_IOCGQSET

_IOR(MEM_IOC_MAGIC, 1, int)

 

2，ioctl命令使用时注意事项

用户使用int ioctl(int fd,unsinged long cmd,...)时，...就是要传递的参数

再通过long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long arg);中的arg传递,如果arg是一个整形，可以直接使用，如果是指针，我们必须确保这个用户地址是有效的，因此，使用之前需要进行正解的检查。

内部有检查的，不需要检测的：

Copy_from_user

Copy_to_user

Get_user

Put_user

需要检测的：

__get_user

__put_user

使用int access_ok(int type, const void *addr, unsigned long size)检测

Type 是VERIFY_READ 或者VERIFY_WRITE用来表明是读用户内存还是写用户内存。

Addr参数是要操作的用户内存地址，size是操作的长度。如果ioctl需要从用户空间读一个整数，那么size参数就等于sizeof(int)

内核读，写入用户空间，所以用户空间使用VERIFY_WRITE写验证用户内存是否可用。

Access_ok返回一个布尔值：1，是成功（存取没问题），失败，ioctr返回-EFAULT 

 

3，ioctl实现例程

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
 
#include "memdev.h"
 
static  int  mem_major = MEMDEV_MAJOR;
 
module_param(mem_major,  int , S_IRUGO);
 
struct  mem_dev *mem_devp;  /*设备结构体指针*/
 
struct  cdev cdev; 
 
/*文件打开函数*/
int  mem_open( struct  inode *inode,  struct  file *filp)
{
     struct  mem_dev *dev;
     
     /*获取次设备号*/
     int  num = MINOR(inode->i_rdev);
 
     if  (num >= MEMDEV_NR_DEVS) 
             return  -ENODEV;
     dev = &mem_devp[num];
     
     /*将设备描述结构指针赋值给文件私有数据指针*/
     filp->private_data = dev;
     
     return  0; 
}
 
/*文件释放函数*/
int  mem_release( struct  inode *inode,  struct  file *filp)
{
   return  0;
}
 
/*IO操作*/
int  memdev_ioctl( struct  inode *inode,  struct  file *filp, unsigned  int  cmd, unsigned  long  arg)
{
 
     int  err = 0;
     int  ret = 0;
     int  ioarg = 0;
     
     /* 检测命令的有效性 */
     if  (_IOC_TYPE(cmd) != MEMDEV_IOC_MAGIC) 
         return  -EINVAL;
     if  (_IOC_NR(cmd) > MEMDEV_IOC_MAXNR) 
         return  -EINVAL;
 
     /* 根据命令类型，检测参数空间是否可以访问 */
     if  (_IOC_DIR(cmd) & _IOC_READ)
         err = !access_ok(VERIFY_WRITE, ( void  *)arg, _IOC_SIZE(cmd));
     else  if  (_IOC_DIR(cmd) & _IOC_WRITE)
         err = !access_ok(VERIFY_READ, ( void  *)arg, _IOC_SIZE(cmd));
     if  (err) 
         return  -EFAULT;
 
     /* 根据命令，执行相应的操作 */
     switch (cmd) {
 
       /* 打印当前设备信息 */
       case  MEMDEV_IOCPRINT:
           printk( "<--- CMD MEMDEV_IOCPRINT Done--->\n\n" );
         break ;
       
       /* 获取参数 */
       case  MEMDEV_IOCGETDATA: 
         ioarg = 1101;
         ret = __put_user(ioarg, ( int  *)arg);
         break ;
       
       /* 设置参数 */
       case  MEMDEV_IOCSETDATA: 
         ret = __get_user(ioarg, ( int  *)arg);
         printk( "<--- In Kernel MEMDEV_IOCSETDATA ioarg = %d --->\n\n" ,ioarg);
         break ;
 
       default :  
         return  -EINVAL;
     }
     return  ret;
 
}
 
/*文件操作结构体*/
static  const  struct  file_operations mem_fops =
{
   .owner = THIS_MODULE,
   .open = mem_open,
   .release = mem_release,
   .ioctl = memdev_ioctl,
};
 
/*设备驱动模块加载函数*/
static  int  memdev_init( void )
{
   int  result;
   int  i;
 
   dev_t devno = MKDEV(mem_major, 0);
 
   /* 静态申请设备号*/
   if  (mem_major)
     result = register_chrdev_region(devno, 2,  "memdev" );
   else   /* 动态分配设备号 */
   {
     result = alloc_chrdev_region(&devno, 0, 2,  "memdev" );
     mem_major = MAJOR(devno);
   }  
   
   if  (result < 0)
     return  result;
 
   /*初始化cdev结构*/
   cdev_init(&cdev, &mem_fops);
   cdev.owner = THIS_MODULE;
   cdev.ops = &mem_fops;
   
   /* 注册字符设备 */
   cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
    
   /* 为设备描述结构分配内存*/
   mem_devp = kmalloc(MEMDEV_NR_DEVS *  sizeof ( struct  mem_dev), GFP_KERNEL);
   if  (!mem_devp)     /*申请失败*/
   {
     result =  - ENOMEM;
     goto  fail_malloc;
   }
   memset (mem_devp, 0,  sizeof ( struct  mem_dev));
   
   /*为设备分配内存*/
   for  (i=0; i < MEMDEV_NR_DEVS; i++) 
   {
         mem_devp[i].size = MEMDEV_SIZE;
         mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
         memset (mem_devp[i].data, 0, MEMDEV_SIZE);
   }
     
   return  0;
 
   fail_malloc: 
   unregister_chrdev_region(devno, 1);
   
   return  result;
}
 
/*模块卸载函数*/
static  void  memdev_exit( void )
{
   cdev_del(&cdev);    /*注销设备*/
   kfree(mem_devp);      /*释放设备结构体内存*/
   unregister_chrdev_region(MKDEV(mem_major, 0), 2);  /*释放设备号*/
}
 
MODULE_AUTHOR( "David Xie" );
MODULE_LICENSE( "GPL" );
 
module_init(memdev_init);
module_exit(memdev_exit);

 

.h

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#ifndef _MEMDEV_H_
#define _MEMDEV_H_
 
#include <linux/ioctl.h>
 
#ifndef MEMDEV_MAJOR
#define MEMDEV_MAJOR 190   /*预设的mem的主设备号*/
#endif
 
#ifndef MEMDEV_NR_DEVS
#define MEMDEV_NR_DEVS 2    /*设备数*/
#endif
 
#ifndef MEMDEV_SIZE
#define MEMDEV_SIZE 4096
#endif
 
/*mem设备描述结构体*/
struct  mem_dev                                     
{                                                        
   char  *data;                      
   unsigned  long  size;       
};
 
/* 定义幻数 */
#define MEMDEV_IOC_MAGIC  'k'
 
/* 定义命令 */
#define MEMDEV_IOCPRINT   _IO(MEMDEV_IOC_MAGIC, 1)
#define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC, 2, int)
#define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC, 3, int)
 
#define MEMDEV_IOC_MAXNR 3
 
#endif /* _MEMDEV_H_ */

 

Makefile

?
1
2
3
4
5
6
7
8
9
10
11
12
13
ifneq ($(KERNELRELEASE),)
 
obj-m := memdev.o
 
else
     
KDIR := /forlinux/linux-3.0.1
all:
     make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
clean:
     rm -f *.ko *.o *.mod.o *.mod.c *.symvers  modul*
 
endif

 

测试程序

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
 
#include "memdev.h"  /* 包含命令定义 */
 
int  main()
{
     int  fd = 0;
     int  cmd;
     int  arg = 0;
     char  Buf[4096];
     
     
     /*打开设备文件*/
     fd = open( "/dev/memdev0" ,O_RDWR);
     if  (fd < 0)
     {
         printf ( "Open Dev Mem0 Error!\n" );
         return  -1;
     }
     
     /* 调用命令MEMDEV_IOCPRINT */
     printf ( "<--- Call MEMDEV_IOCPRINT --->\n" );
     cmd = MEMDEV_IOCPRINT;
     if  (ioctl(fd, cmd, &arg) < 0)
         {
             printf ( "Call cmd MEMDEV_IOCPRINT fail\n" );
             return  -1;
     }
     
     
     /* 调用命令MEMDEV_IOCSETDATA */
     printf ( "<--- Call MEMDEV_IOCSETDATA --->\n" );
     cmd = MEMDEV_IOCSETDATA;
     arg = 2007;
     if  (ioctl(fd, cmd, &arg) < 0)
         {
             printf ( "Call cmd MEMDEV_IOCSETDATA fail\n" );
             return  -1;
     }
 
     
     /* 调用命令MEMDEV_IOCGETDATA */
     printf ( "<--- Call MEMDEV_IOCGETDATA --->\n" );
     cmd = MEMDEV_IOCGETDATA;
     if  (ioctl(fd, cmd, &arg) < 0)
         {
             printf ( "Call cmd MEMDEV_IOCGETDATA fail\n" );
             return  -1;
     }
     printf ( "<--- In User Space MEMDEV_IOCGETDATA Get Data is %d --->\n\n" ,arg); 
     
     close(fd);
     return  0; 
}
【作者】 张昺华
【新浪微博】 张昺华--sky
【twitter】 @sky2030_
【facebook】 张昺华 zhangbinghua
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.
文章标签：
服务网格
Linux
机器学习/深度学习
关键词：
Linux分析
Linux字符
Linux驱动
Linux设备
Linux操作
sky-heaven
目录
相关文章
蓝易云
|
9天前
|
存储 运维 监控
Linux--深入理与解linux文件系统与日志文件分析
深入理解 Linux 文件系统和日志文件分析，对于系统管理员和运维工程师来说至关重要。文件系统管理涉及到文件的组织、存储和检索，而日志文件则记录了系统和应用的运行状态，是排查故障和维护系统的重要依据。通过掌握文件系统和日志文件的管理和分析技能，可以有效提升系统的稳定性和安全性。
蓝易云
27 7
Liuqz2009
|
5月前
|
Linux 调度
Linux 内核源代码情景分析（一）（下）
Linux 内核源代码情景分析（一）
Liuqz2009
103 1
运维有小邓
|
12天前
|
监控 安全 Linux
启用Linux防火墙日志记录和分析功能
为iptables启用日志记录对于监控进出流量至关重要
运维有小邓
36 1
dasein58
|
2月前
|
Linux 开发工具 Perl
在Linux中，有一个文件，如何删除包含“www“字样的字符？
在Linux中，如果你想删除一个文件中包含特定字样（如“www”）的所有字符或行，你可以使用多种文本处理工具来实现。以下是一些常见的方法：
dasein58
44 5
游客kwe6k52lwpmug
|
2月前
|
缓存 算法 Linux
Linux内核中的调度策略优化分析####
本文深入探讨了Linux操作系统内核中调度策略的工作原理，分析了不同调度算法（如CFS、实时调度）在多核处理器环境下的性能表现，并提出了针对高并发场景下调度策略的优化建议。通过对比测试数据，展示了调度策略调整对于系统响应时间及吞吐量的影响，为系统管理员和开发者提供了性能调优的参考方向。 ####
游客kwe6k52lwpmug
44 0
yuanzhengme
|
3月前
|
Linux 开发工具 Perl
Linux命令替换目录下所有文件里有"\n"的字符为""如何操作？
【10月更文挑战第20天】Linux命令替换目录下所有文件里有"\n"的字符为""如何操作？
yuanzhengme
53 4
Liuqz2009
|
5月前
|
存储 IDE Unix
Linux 内核源代码情景分析（四）（上）
Linux 内核源代码情景分析（四）
Liuqz2009
42 1
Linux 内核源代码情景分析（四）（上）
Liuqz2009
|
5月前
|
存储 Linux 块存储
Linux 内核源代码情景分析（三）（下）
Linux 内核源代码情景分析（三）
Liuqz2009
46 4
Liuqz2009
|
5月前
|
Linux C语言
深度探索Linux操作系统 —— 编译过程分析
深度探索Linux操作系统 —— 编译过程分析
Liuqz2009
43 2
Liuqz2009
|
5月前
|
存储 Unix Linux
Linux 内核源代码情景分析（四）（下）
Linux 内核源代码情景分析（四）
Liuqz2009
33 2

热门文章

最新文章

  • 1
    MySQL数据库下载安装教程（Windows&Linux）
  • 2
    动态链接的魔法：Linux下动态链接库机制探讨
  • 3
    Linux缓存管理：如何安全地清理系统缓存
  • 4
    （已解决）Linux环境—bash: wget: command not found； Docker pull报错Error response from daemon: Get https://registry-1.docker.io/v2/: net/http: request canceled
  • 5
    轻松管理Linux服务器的5个优秀管理面板
  • 6
    Linux 各发行版安装 ping 命令指南
  • 7
    Linux netstat 命令详解
  • 8
    深入理解Linux内核的内存管理机制
  • 9
    Linux操作系统的演变与未来趋势###
  • 10
    嵌入式Linux系统编程 — 5.3 times、clock函数获取进程时间
  • 1
    Linux系统的文本处理
    98
  • 2
    Linux对MySQL语法校验
    97
  • 3
    Linux为新创建的磁盘分区添加文件系统
    74
  • 4
    如何计算 Linux 上文件中的空行数？
    88
  • 5
    服务器Linux系统配置mysql数据库主从自动备份
    228
  • 6
    Linux文件系统
    64
  • 7
    Linux内核基础知识
    90
  • 8
    Linux网络编程 网络基础知识
    76
  • 9
    Linux系统编程之文件编程常用API回顾和文件编程一般步骤
    89
  • 10
    linux静态库，动态库总结
    69

    • 相关课程

    更多
  • Linux MySQL服务器搭建与应用
  • Linux Web服务器Nginx搭建与配置
  • 计算机基础与Linux入门
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 相关实验场景

    更多
  • Linux指令入门-文件与权限
  • Linux系统的文本处理
  • Linux指令入门-系统管理
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • Alibaba Cloud Linux操作系统的安装及使用
  • Alibaba Cloud Linux操作系统Shell程序

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月