Shulou(Shulou.com)06/01 Report--

This article mainly explains "the way to read and write files in the Linux kernel driver". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "the way to read and write files in the Linux kernel driver".

1. Open a file

Filp_open () can open the file in kernel, and its original shape is as follows:

Strcut file* filp_open (const char* filename, int open_mode, int mode)

This function returns a pointer to the strcut file* structure for use by subsequent function operations, and the return value is verified by IS_ERR ().

Parameter description

Filename: indicates the name of the file to open or create (including the path section). When opening a file in the kernel, you need to pay attention to the timing of opening. It is easy to see that the driver that needs to open the file loads and opens the file a long time ago, but the device where the file needs to be opened has not been mounted to the file system, resulting in failure.

Open_mode: the way the file is opened, its value is similar to the corresponding parameters of open in the standard library, and you can take OneCreat, Odyssey, DWR, and so on.

Mode: used when creating files. Set the read and write permissions for creating files. Set it to 0 in other cases.

two。 Read and write files

Vfs_read () and vfs_write can be used to read and write files in kernel, and you need to explain the get_fs () and set_fs () functions before using these two functions.

The prototype of the two functions vfs_read () vfs_write () is as follows:

Ssize_t vfs_read (struct file* filp, char _ user* buffer, size_t len, loff_t* pos)

Ssize_t vfs_write (struct file* filp, const char _ user* buffer, size_t len, loff_t* pos)

Note that the second parameter buffer of both functions is preceded by the _ _ user modifier, which requires that both buffer pointers should point to user-space memory. If a pointer to kernel space is passed to this parameter, both functions will return a failure-EFAULT. But in Kernel, it is generally not easy to generate user space pointers, or it is not convenient to use user space memory independently. For these two read-write functions to work correctly using buffer pointers in kernel space, you need to use the set_fs () function or macro (set_fs () may be a macro definition). If it is a function, its prototype is as follows:

Void set_fs (mm_segment_t fs)

This function is used to change the way kernel handles memory address checking. In fact, the parameter fs of this function has only two values: USER_DS,KERNEL_DS, which represents user space and kernel space, respectively. By default, the value of kernel is USER_DS, that is, the user space address is checked and changed. Then to use the kernel space address in this function that checks for memory address transformation, you need to use set_fs (KERNEL_DS) to set it. Get_fs () may also be a macro definition, and its purpose is to get the current settings. The general usage of these two functions is:

Mm_segment_t old_fs

Old_fs = get_fs ()

Set_fs (KERNEL_DS)

…… / / memory-related operations

Set_fs (old_fs)

There are other kernel functions that also have parameters modified with _ _ user, which can be used in kernel when you need to replace it with memory in kernel space.

One thing to note when using vfs_read () and vfs_write () * is that the value pointed to by the parameter loff_t * pos,pos of * needs to be initialized, indicating where to start reading and writing in the file.

3. Turn off reading and writing files

Int filp_close (struct file*filp, fl_owner_t id)

The use of this function is simple, and the second parameter generally passes a null value, or uses current- > files as an argument.

Other considerations for using the above functions:

1. In fact, members of the Linux Kernel group do not approve of reading and writing files independently in the kernel (this may affect policy and security issues). The contents of the files required by the kernel are completed by the application layer.

two。 Reading and writing files in a loadable kernel module in this way may cause the module to fail to load because the kernel may not have all the functions you need to EXPORT.

3. By analyzing the parameters of some of the above functions, we can see that the correct operation of these functions depends on the process environment, so some functions cannot be executed in code that is not part of an arbitrary process in the interrupted handle or Kernel, otherwise a crash may occur. To avoid this, you can create a kernel thread in kernel. These functions are executed in a threaded environment (the kernel thread is created with the parameter kernel_thread () function).

With the support of VFS, user-mode processes can read and write any type of file system using read and write to make two system calls, but how can we operate files without such system calls in the linux kernel? We know that read and write actually execute sys_read and sys_write after entering the kernel state, but look at the kernel source code and find that none of the functions that manipulate the files are exported (using EXPORT_SYMBOL export), that is, they cannot be used in the kernel module, so what should I do?

By looking at the source code of sys_open, we found that it mainly uses the do_filp_open () function, which is in fs/namei.c, and in the change file, the filp_open function is also a call to the do_filp_open function, and the interface and the sys_open function are very similar, with the same call parameters as sys_open, and exported using EXPORT_SYMBOL, so we guess that the function can open the file with the same function as open. Using the same lookup method, we found a set of functions that manipulate files in the kernel, as follows:

Function prototype opens file struct file * filp_open (const char * filename, int flags, int mode) reads file ssize_t vfs_read (struct file * file, char _ user * buf, size_t count, loff_t * pos) writes file ssize_t vfs_write (struct file * file, const char _ user * buf, size_t count, loff_t * pos) closes file int filp_close (struct file * filp, fl_owner_t id)

We notice that in the vfs_read and vfs_write functions, the parameter buf points to the memory address of the user space, which returns-EFALUT if we use the kernel space pointer directly. So we need to use

The set_fs () and get_fs () macros change the way kernel memory address checks are handled, so the process of reading and writing files in kernel space is as follows:

Mm_segment_t fs = get_fs (); set_fs (KERNEL_FS); / / vfs_write (); vfs_read (); set_fs (fs)

Here is an example of manipulating files in the kernel:

# include # include static char buf [] = "Hello"; static char buf1 [10]; int _ _ init hello_init (void) {struct file * fp; mm_segment_t fs; loff_t pos; printk ("hello enter\ n"); fp = filp_open ("/ home/niutao/kernel_file", O_RDWR | O_CREAT, 0644) If (IS_ERR (fp)) {printk ("create file error\ n"); return-1;} fs = get_fs (); set_fs (KERNEL_DS); pos = 0; vfs_write (fp, buf, sizeof (buf), & pos); pos = 0; vfs_read (fp, buf1, sizeof (buf), & pos); printk ("read:% s\ n", buf1) Filp_close (fp, NULL); set_fs (fs); return 0;} void _ exit hello_exit (void) {printk ("hello exit\ n");} module_init (hello_init); module_exit (hello_exit); MODULE_LICENSE ("GPL") Thank you for your reading. the above is the content of "how to read and write files in Linux kernel drivers". After the study of this article, I believe you have a deeper understanding of the way files are read and written in Linux kernel drivers, and the specific usage needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.