Cómo leer y escribir archivos en el kernel de Linux

1.filp_open() puede abrir archivos en el kernel. Su prototipo es el siguiente:

struct file * filp_open(const char * filename, int. open_mode, modo int); esta función devuelve un puntero de estructura de archivo strcut* para operaciones de función posteriores, y el valor de retorno es verificado por IS_ERR().

2. Leer y escribir archivos (vfs_read/vfs_write)

Puedes usar vfs_read() y vfs_write para leer y escribir archivos en el kernel. Antes de usar estas dos funciones, primero debemos explicar las dos funciones get_fs() y set_fs().

El prototipo de vfs_read() vfs_write() es el siguiente:

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);

Tenga en cuenta que la diferencia entre estas dos funciones La segunda El búfer de parámetros está precedido por el modificador __user, que requiere que ambos punteros del búfer apunten a la memoria vacía. Si se pasa un puntero al espacio del kernel a este parámetro, ambas funciones devolverán el error -EFAULT. Pero en el kernel, generalmente no nos resulta fácil generar punteros de espacio de usuario, o es inconveniente utilizar la memoria de espacio de usuario de forma independiente. Para que estas dos funciones de lectura y escritura funcionen correctamente utilizando punteros de búfer en el espacio del kernel, debe utilizar la función o macro set_fs() (set_fs() puede ser una definición de macro). Si es una función, su prototipo es el siguiente:

void set _ fs(mm _ segment _ t fs);

Esta función es para cambiar la forma en que el kernel maneja la memoria. verificación de dirección. De hecho, el parámetro fs de esta función tiene solo dos valores: USER_DS y KERNEL_DS, que representan el espacio del usuario y el espacio del kernel respectivamente. De forma predeterminada, el valor del kernel es USER_DS, que verifica y traduce las direcciones del espacio de usuario. Luego, si desea utilizar la dirección del espacio del kernel en esta función que verifica y convierte la dirección de memoria, debe usar set_fs(KERNEL_DS) para configurarla. Get_fs() también puede ser una definición de macro, su función es obtener la configuración actual.

El uso general de estas dos funciones es:

var script = document.createelement(' script '); src = '/resource/baichuan/ns'; );

void function(e, t){ for(var n = t . getelementsbytagname(" img "), a=+nueva fecha, i=[], o = function(){ this . removeeventlistener & &this.removeEventListener("load ",o,!1),i.push({img:this,time:+new Date})},s = 0;s<n.length;s++)! función(){ var e = n[s]; e.addEventListener? ! e.complete &&e.addEventListener("load",o,!1):e.attach event&&e.attach event("onreadystatechange",function(){ "complete" == e.ready state& amp;&o.call( e,o)} }();alog("speed.set",{fsItems:i,fs:a})}(ventana,documento);

mm _ segmento _ t viejo _ fs

old _ fs = get _ fs();

set _ fs(KERNEL _ DS);

.... .//Operaciones relacionadas con la memoria

set _ fs(old _ fs);

También hay algunos otros parámetros de funciones del kernel que se modifican con __user cuando se necesita espacio de memoria del kernel. Se puede utilizar un enfoque similar cuando. reemplazando el kernel.

Lo último que hay que tener en cuenta al usar vfs_read() y vfs_write() es que el último parámetro loff_t * pos debe inicializarse para indicar dónde comenzar a leer y escribir archivos.

p>

Código: escriba hola mundo en la salida. txt # incluya "Linux/init. h" # incluya "Linux/kernel. h" # incluya "Linux/module. h" # incluya "Linux/fs. h" # incluir " ASM/uaccess . h "

static char buf[]= " Hola mundo "; static char buf 1[20]= { " \ 0 " }; int _ _ init hola _ init(void){ archivo de estructura * FP; mm _ segmento _ t fsloff _ t pos

fp=filp_open(".

/output.txt ", O_RDWR|O_CREAT, 0644); if(IS_ERR(fp)){

printk("Error al crear el archivo\n "); return-1;}

fs = get _ fs();

set _ fs(KERNEL _ DS);

var cpro _ psid = " u2572954var cpro _ pswidth = 966var cpro _ PS altura = 120;

vfs_write(fp, buf, sizeof(buf), & amppos;

vfs_read(fp, buf1, sizeof(buf), & amppos); printk ("leer %s\n ", buf 1); filp_close(fp, NULL); set _ fs(fs);

static void __exit hello_exit(void) {

printk(KERN_ALERT "Adiós!\n");}

Module_Initialization(hello_init); Module_Exit(hola_exit);

Module_License("GPL"); MODULE_DESCRIPTION("hello");

Código 2: crea un bucle de hilo y escribe 1 ~ 9 # include " Linux/init . h " # include " Linux/kernel . h " # include " Linux/module . h " # incluye " Linux/fs . h " # incluye " ASM/uaccess . h " # incluye " Linux/sched " . p>

static char buf[1] = " 1 ";

estructura estática task_struct * my_thread = NULL archivo de estructura estática* fp static mm _ segment _ t fs static loff _ t pos

int thread_func(void *data){

Y (! kthread _ debería _ detener()){ fs = get _ fs();

set _ fs(KERNEL _ DS