平时网络部分的东西碰的多些，这块一开始还真不知道怎么写，因为肯定和在用户空间下是不同的。google过后，得到以下答案。一般可以用两种方法：第一种是用系统调用。第二种方法是filp->open()等函数。下面分别来说下这两种方法。


1 利用系统调用：
sys_open,sys_write,sys_read等。
其实分析过sys_open可以知道，最后调用的也是filp->open。
sys_open ==> do_sys_open ==> filp->open
在linuxsir上的一个帖子，上面一个版主说：sys_open和进程紧密相关，往往不在内核中使用。
而其实sys_open最后也是调用了filp->open。
其实好像Linux2.6.20后面就不推荐使用sys_open,那我们这里就就后者进行详细的介绍

2 filp->open等函数。
在模块中，用户空间的open,read,write,llseek等函数都是不可以使用的。应该使用其在内核中对应的函数。可以使用filp->open配合struct file里的read/write来进行对文件的读写操作。


例子1：
 

  1. #include <linux/kernel.h>
     
  2. #include <linux/module.h>
     
  3. #include <linux/fs.h>
     
  4. #include <asm/uaccess.h>
     
  5. #include <linux/mm.h>
     

  6.  
  7. MODULE_AUTHOR("Kenthy@163.com.");
     
  8. MODULE_DESCRIPTION("Kernel study and test.");
     

  9.  

  10.  
  11. void fileread(const char * filename)
     
  12. {
     
  13.   struct file *filp;
     
  14.   struct inode *inode;
     
  15.   mm_segment_t fs;
     
  16.   off_t fsize;
     
  17.   char *buf;
     
  18.   unsigned long magic;
     
  19.   printk("<1>start....\n");
     
  20.   filp=filp_open(filename,O_RDONLY,0);
     
  21.   inode=filp->f_dentry->d_inode;  
     
  22.   
     
  23.   magic=inode->i_sb->s_magic;
     
  24.   printk("<1>file system magic:%li \n",magic);
     
  25.   printk("<1>super blocksize:%li \n",inode->i_sb->s_blocksize);
     
  26.   printk("<1>inode %li \n",inode->i_ino);
     
  27.   fsize=inode->i_size;
     
  28.   printk("<1>file size:%i \n",(int)fsize);
     
  29.   buf=(char *) kmalloc(fsize+1,GFP_ATOMIC);
     

  30.  
  31.   fs=get_fs();
     
  32.   set_fs(KERNEL_DS);
     
  33.   filp->f_op->read(filp,buf,fsize,&(filp->f_pos));
     
  34.   set_fs(fs);
     

  35.  
  36.   buf[fsize]='\0';
     
  37.   printk("<1>The File Content is:\n");
     
  38.   printk("<1>%s",buf);
     

  39.  

  40.  
  41.   filp_close(filp,NULL);
     
  42. }
     

  43.  
  44. void filewrite(char* filename, char* data)
     
  45. {
     
  46.   struct file *filp;
     
  47. mm_segment_t fs;
     
  48. filp = filp_open(filename, O_RDWR|O_APPEND, 0644);
     
  49. if(IS_ERR(filp))
     
  50.     {
     
  51.       printk("open error...\n");
     
  52.       return;
     
  53.         }   
     

  54.  
  55.   fs=get_fs();
     
  56.   set_fs(KERNEL_DS);
     
  57.   filp->f_op->write(filp, data, strlen(data),&filp->f_pos);
     
  58.   set_fs(fs);
     
  59.   filp_close(filp,NULL);
     
  60. }
     

  61.  
  62. int init_module()
     
  63. {
     
  64.   char *filename="/root/test1.c";
     

  65.  
  66.   printk("<1>Read File from Kernel.\n");
     
  67.   fileread(filename);
     
  68.   filewrite(filename, "kernel write test\n");
     
  69.   return 0;
     
  70. }
     

  71.  
  72. void cleanup_module()
     
  73. {
     
  74.   printk("<1>Good,Bye!\n");
     
  75. }
复制代码





eg2：
 

  1. #include<linux/module.h>
     
  2. #include<linux/kernel.h>
     
  3. #include<linux/init.h>
     

  4.  
  5. #include<linux/types.h>
     

  6.  
  7. #include<linux/fs.h>
     
  8. #include<linux/string.h>
     
  9. #include<asm/uaccess.h> /* get_fs(),set_fs(),get_ds() */
     

  10.  
  11. #define FILE_DIR "/root/test.txt"
     

  12.  
  13. MODULE_LICENSE("GPL");
     
  14. MODULE_AUTHOR("kenthy@163.com");
     

  15.  
  16. char *buff = "module read/write test";
     
  17. char tmp[100];
     

  18.  
  19. static struct file *filp = NULL;
     

  20.  
  21. static int __init wr_test_init(void)
     
  22. {
     
  23.     mm_segment_t old_fs;
     
  24.     ssize_t ret;
     
  25.    
     
  26.     filp = filp_open(FILE_DIR, O_RDWR | O_CREAT, 0644);
     
  27.    
     
  28.     //    if(!filp)
     

  29.  
  30.     if(IS_ERR(filp))
     
  31.         printk("open error...\n");
     
  32.    
     
  33.     old_fs = get_fs();
     
  34.     set_fs(get_ds());
     
  35.    
     
  36.     filp->f_op->write(filp, buff, strlen(buff), &filp->f_pos);
     
  37.    
     
  38.     filp->f_op->llseek(filp,0,0);
     
  39.     ret = filp->f_op->read(filp, tmp, strlen(buff), &filp->f_pos);
     
  40.    
     
  41.     set_fs(old_fs);
     
  42.    
     
  43.     if(ret > 0)
     
  44.         printk("%s\n",tmp);
     
  45.     else if(ret == 0)
     
  46.         printk("read nothing.............\n");
     
  47.     else
     
  48.         {
     
  49.             printk("read error\n");
     
  50.             return -1;
     
  51.         }
     

  52.  
  53.     return 0;
     
  54. }
     

  55.  
  56. static void __exit wr_test_exit(void)
     
  57. {
     
  58.     if(filp)
     
  59.         filp_close(filp,NULL);
     
  60. }
     

  61.  
  62. module_init(wr_test_init);
     
  63. module_exit(wr_test_exit);
复制代码





3.Makefile

 

  1. obj-m := os_attack.o
     

  2.  
  3. KDIR := /lib/modules/$(uname -r)/build/
     
  4. PWD := $(shell pwd)
     

  5.  
  6. all:module
     

  7.  
  8. module:
     
  9.         $(MAKE) -C $(KDIR) M=$(PWD) modules
     

  10.  

  11.  
  12. clean:
     
  13.         rm -rf *.ko *.mod.c *.o Module.* modules.* .*.cmd .tmp_versions
复制代码





注意：
在调用filp->f_op->read和filp->f_op->write等对文件的操作之前，应该先设置FS。
默认情况下，filp->f_op->read或者filp->f_op->write会对传进来的参数buff进行指针检查。如果不是在用户空间会拒绝访问。因为是在内核模块中，所以buff肯定不在用户空间，所以要增大其寻址范围。

拿filp->f_op->write为例来说明：
filp->f_op->write最终会调用access_ok ==> range_ok.
而range_ok会判断访问的地址是否在0 ～ addr_limit之间。如果在，则ok，继续。如果不在，则禁止访问。而内核空间传过来的buff肯定大于addr_limit。所以要set_fs(get_ds())。
这些函数在asm/uaccess.h中定义。以下是这个头文件中的部分内容：

#define MAKE_MM_SEG(s)    ((mm_segment_t) { (s) })

#define KERNEL_DS    MAKE_MM_SEG(-1UL)
#define USER_DS        MAKE_MM_SEG(PAGE_OFFSET)

#define get_ds()    (KERNEL_DS)
#define get_fs()    (current_thread_info()->addr_limit)
#define set_fs(x)    (current_thread_info()->addr_limit = (x))

#define segment_eq(a, b)    ((a).seg == (b).seg)


可以看到set_fs(get_ds())改变了addr_limit的值。这样就使得从模块中传递进去的参数也可以正常使用了。

在写测试模块的时候，要实现的功能是写进去什么，然后读出来放在tmp数组中。但写完了以后filp->f_ops已经在末尾了，这个时候读是什么也读不到的，如果想要读到数据，则应该改变filp->f-ops的值，这就要用到filp->f_op->llseek函数了。上网查了下，其中的参数需要记下笔记：


系统调用：
off_t sys_lseek(unsigned int fd, off_t offset, unsigned int origin)
offset是偏移量。
若origin是SEEK_SET(0)，则将该文件的位移量设置为距文件开始处offset 个字节。
若origin是SEEK_CUR(1)，则将该文件的位移量设置为其当前值加offset, offset可为正或负。
若origin是SEEK_END(2)，则将该文件的位移量设置为文件长度加offset, offset可为正或负。