¿Cómo implemento un controlador de controlador de sistema de archivos en Linux? [cerrado]

Supongamos que he inventado un nuevo sistema de archivos y ahora quiero crear un controlador de sistema de archivos para él.

¿Cómo implementaría este controlador del sistema de archivos? ¿Se hace esto usando un módulo del núcleo?

¿Y cómo puede el controlador del sistema de archivos acceder al disco duro? ¿Debe el controlador del sistema de archivos contener código para acceder al disco duro o Linux contiene un controlador de dispositivo para acceder al disco duro que utilizan todos los controladores del sistema de archivos?

Sí, los sistemas de archivos en Linux se pueden implementar como módulos del núcleo. Pero también existe la interfaz FUSE (Sistema de archivos en USErspace), que puede permitir que un proceso regular de espacio de usuario actúe como un controlador del sistema de archivos. Si está creando prototipos de un nuevo sistema de archivos, implementarlo primero usando la interfaz FUSE podría facilitar las pruebas y el desarrollo. Una vez que tenga los elementos internos del sistema de archivos resueltos en forma FUSE, puede comenzar a implementar una versión del módulo de kernel con rendimiento optimizado.

Aquí hay información básica sobre la implementación de un sistema de archivos dentro del espacio del kernel. Es bastante antiguo (¡de 1996!), Pero eso al menos debería darte una idea básica sobre el tipo de cosas que deberás hacer.

Si elige ir a la ruta FUSE, aquí está libfuse, la implementación de referencia del lado del espacio de usuario de la interfaz FUSE.

Controlador del sistema de archivos como módulo del núcleo

Básicamente, la función de inicialización de su módulo de controlador de sistema de archivos solo necesita llamar a una register_filesystem()función, y darle como parámetro una estructura que incluya un puntero de función que identifique la función en su controlador de sistema de archivos que se usará como el primer paso para identificar su sistema de archivos escribir y montarlo. Nada más sucede en esa etapa.

Cuando se monta un sistema de archivos, y se especifica el tipo de sistema de archivos para que coincida con su controlador, o se realiza la autodetección del tipo de sistema de archivos, la capa del Sistema de archivos virtual (VFS para abreviar) del núcleo llamará a esa función. Básicamente dice: "Aquí hay un puntero a una representación a nivel de núcleo de un dispositivo de bloque Linux estándar. Mírelo, vea si es algo que pueda manejar y luego dígame qué puede hacer con él".

En ese momento, se supone que su controlador debe leer lo que sea necesario para verificar que es el controlador correcto para el sistema de archivos, y luego devolver una estructura que incluya punteros para funciones adicionales que su controlador puede realizar con ese sistema de archivos en particular. O si el controlador del sistema de archivos no reconoce los datos en el disco, se supone que devuelve un resultado de error apropiado, y luego VFS informará una falla al espacio de usuario o, si se realiza la detección automática del tipo de sistema de archivos, preguntará a otro sistema de archivos conductor para probar.

Los otros controladores en el núcleo proporcionarán la interfaz de dispositivo de bloque estándar, por lo que el controlador del sistema de archivos no tendrá que implementar soporte de hardware. Básicamente, el controlador del sistema de archivos puede leer y escribir bloques de disco utilizando funciones estándar de nivel de núcleo con el puntero del dispositivo que se le asigna.

La capa VFS espera que el controlador del sistema de archivos ponga a disposición de la capa VFS una serie de funciones estándar; algunos de estos son obligatorios para que la capa VFS haga algo significativo con el sistema de archivos, otros son opcionales y puede devolver un NULL en lugar de un puntero a dicha función opcional.

Sí, un controlador de kernel puede administrar un sistema de archivos.

La mejor solución para simular un prototipo de un sistema de archivos es usar FUSE. Y después puede pensar en transformarlo en un controlador de kernel.

Wikipedia => https://en.wikipedia.org/wiki/Filesystem_in_Userspace

Fuente => https://github.com/libfuse/libfuse

un tutorial => https://developer.ibm.com/articles/l-fuse/

Sí, esto normalmente se haría utilizando un controlador de kernel que puede cargarse como un módulo de kernel o compilarse en el kernel.

Puede consultar controladores de sistemas de archivos similares y cómo funcionan aquí .

Es probable que estos controladores usen funciones internas del núcleo para acceder a los dispositivos de almacenamiento como bloques de bytes, pero también puede usar dispositivos de bloque como los expuestos en las carpetas de dispositivos de caracteres y dispositivos de bloque .

Puede usar fusible para crear un sistema de archivos de aterrizaje de usuario o escribir un módulo de kernel. Es más fácil hacerlo con fusible, ya que tiene una selección de idiomas y no bloqueará el núcleo (y, por lo tanto, todo el sistema).

Los módulos del kernel pueden ser más rápidos, pero la primera regla de optimización es: no lo haga hasta que haya probado el código de trabajo. El segundo es así: no lo hagas hasta que tengas evidencia de que es demasiado lento. Y el tercero: no lo guarde a menos que tenga evidencia de que lo hace más rápido / más pequeño.

Y sí, el kernel ya tiene controladores para el hardware, no los vuelve a implementar.