389 puntos de vista

Así de fácil puedes instalar drivers en Linux

Así de fácil puedes instalar drivers en Linux

Publicado el 28 de agosto, 2022 • 13:00

  • 1

Podríamos definir un driver como un traductor, un traductor que hace que el componente electrónico conectado hable el mismo idioma que el sistema operativo en el que tiene que funcionar. Al hablar el mismo idioma, el sistema operativo puede hacer uso del componente en su totalidad. Esta definición, muy sui géneris, de driver, se aplica tanto a Windows como a Linux y macOS. En este artículo os vamos a mostrar cómo instalar drivers en Linux, si es que realmente es necesario.

Y digo si es que realmente es necesario por las distribuciones Linux han evolucionado muchísimo en los últimos años. La época en la que instalar drivers en Linux era una odisea donde era necesario ser ingeniero de software y tener acceso a un gran número de foros de entusiastas de Linux acabó.

Conforme han ido pasando los años, Linux ha evolucionado muchísimo con el principal objetivo de reducir los conocimientos necesarios y así poder llegar a un mayor número de usuarios, objetivo que poco a poco está consiguiendo, aunque todavía está muy lejos de la penetración de Windows en el mercado.

Los controladores de dispositivos del kernel de Linux son, esencialmente, una biblioteca compartida de rutinas de manejo de hardware de bajo nivel, residentes en memoria y privilegiadas. Son los controladores de dispositivos de Linux los que manejan las peculiaridades de los dispositivos que administran. Una de las características básicas de es que abstrae el manejo de dispositivos.

El procedimiento para compilar y ejecutar un módulo kernel es el siguiente:

  1. Modifique el archivo MAKE reemplazando cada ocurrencia de helloWorld y kernelRead por los nombres de los módulos que desea crear.
  2. compila los módulos ejecutando make en el directorio donde residen los módulos.
  3. Ahora conviértase en superusuario escribiendo.

Tutorial del controlador de dispositivo Linux – Sugerencia para Linux

Categoría Miscelánea | July 30, 2021 14:47

El sistema operativo Linux contiene 3 secciones principales: Sistema de archivos raíz, Kernel y Bootloader.

Sistema de archivos raíz:

Esta parte del sistema operativo contiene binarios de la aplicación, bibliotecas, scripts, archivos de configuración y archivos de módulo cargables del kernel, etc.

Núcleo:

Esta parte es el corazón del sistema operativo, el kernel es responsable de manejar todas las operaciones necesarias para ejecutar el sistema operativo, como la gestión de la memoria, la gestión de procesos y las operaciones de hardware de entrada / salida, etc.

Cargador de arranque:

Esta es la primera parte que ejecuta la CPU al arrancar. Bootloader contiene el código fuente para inicializar el sistema y comenzar a ejecutar el kernel y contiene comandos para depurar y modificando el entorno del kernel, también contiene los comandos para descargar y actualizar las imágenes del kernel y del sistema en la memoria flash memoria.

Los controladores actúan como un puente entre el hardware y una aplicación de usuario, el núcleo proporciona un mecanismo llamado llamadas al sistema para comunicarse con el núcleo. En Linux, los controladores se pueden implementar de dos maneras, una es que los controladores se pueden compilar como parte del kernel y otra es que los controladores se pueden compilar como módulos y cargar en tiempo de ejecución.

Comencemos con un módulo de kernel simple hello world. Aquí está el código fuente para un módulo de kernel simple hello world.

Hola C

Makefile

Crea una carpeta llamada Hola y luego coloque el Hola C y Makefile dentro de eso. Abre el Terminal aplicación y cambie el directorio a hola. Ahora ejecuta el comando hacer y si tiene éxito, debería generar un archivo de módulo de kernel cargable llamado hola.ko.

Cuando ejecutas make si obtienes salida make: No se puede hacer nada por «todos». Luego, asegúrese de que en el Makefile haya ingresado la pestaña (sin espacios) antes de hacer -C. Si la creación tiene éxito, debería obtener el resultado como se muestra a continuación.

Ahora probemos el módulo cargándolo en el kernel. Para cargar y descargar módulos del kernel, necesitamos tener permiso de superusuario. Utilice el siguiente comando para cargar el módulo del kernel en el kernel.

Para ver el mensaje de printk, debe verificar el registro del kernel, para verificar el registro del kernel use el siguiente comando.

dmesg

Este comando generará los mensajes de registro del kernel, al final debería ver que nuestro mensaje Hola Mundo impreso.

Para descargar el módulo use el siguiente comando.

Para ver el mensaje de printk, use el comando dmesg nuevamente y en el registro del kernel puede ver nuestro mensaje Adiós mundo.

Ahora entendamos el código fuente.

Hola C

Para comenzar a escribir el controlador del kernel, puede usar cualquier editor o ide de su elección, pero lo más común es que los desarrolladores del kernel prefieran usar vi editor.

Cada módulo del kernel debe incluir el archivo de encabezado linux / module.h esto tiene las declaraciones y macros para funciones del kernel como module_init y module_exit etc. Las dos funciones más necesarias para un controlador de kernel son las funciones module_init y module_exit. La función cuyo puntero se pasa a module_init se ejecutará cuando carguemos el módulo en el kernel, y la función cuyo puntero se pasa a module_exit se llamará cuando descarguemos o eliminemos el módulo de la núcleo.

Dentro del kernel para depurar e imprimir el registro, usamos printk función que es similar a la función printf que usamos en la aplicación. Puede utilizar macros como KERN_INFO, KERN_ERR, etc. para especificar un nivel de registro.

Si estamos escribiendo un controlador para hablar con un hardware específico, entonces la función init debe tener el código para inicializar el hardware antes de comenzar a usarlo y la función de salida debe tener un código para limpiar los recursos (memoria dinámica, etc.) que usamos en el controlador antes de salir del núcleo.

Aquí, en este ejemplo, solo estamos imprimiendo mensajes de depuración en las funciones init y exit.

Makefile

Para construir el módulo del kernel, necesitamos escribir un Makefile que guiará hacer utilidad cómo compilar el módulo. La sintaxis obj-m se usa para decirle al archivo make del kernel que el controlador debe compilarse como módulo usando el archivo objeto especificado. Cuando solo ejecutas el comando hacer entonces el control llega al todos: sección del Makefile y si ejecuta el comando hacer limpia luego el control va a la limpio: sección de Makefile. Desde este Makefile estamos ejecutando make dentro del directorio fuente del kernel usando la opción -C. Asegúrese de tener el directorio fuente del kernel instalado en su sistema. Aquí en este ejemplo usamos el comando uname -r para encontrar la versión actual del kernel de Linux de su sistema.

Hemos utilizado la opción M = $ (PWD) para indicar en el archivo make del kernel que la fuente del controlador está en el directorio de trabajo actual y estamos especificando la palabra modulos para decirle al archivo makefile del kernel que solo compile módulos y no que compile el código fuente completo del kernel. En limpio: sección de Makefile le estamos diciendo al kernel makefile que limpie los archivos objeto generados para construir este módulo.

Esto debería comenzar a compilar y ejecutar su primer módulo del kernel.

Linux Hint LLC, [correo electrónico protegido]
1210 Kelly Park Cir, Morgan Hill, CA 95037

Agregar repositorio e instalar

Hay diferentes formas de agregar el repositorio a través de ñam, dnf, y apto para conseguir; describirlos a todos está más allá del alcance de este artículo. Para mantenerlo simple, este ejemplo usará apto para conseguir, pero la idea es similar para las otras opciones.

1. Elimine el repositorio existente, si existe.

o NOMBRE_DE_CONDUCTOR es el nombre probable de su conductor. También puede agregar una coincidencia de patrón a su expresión regular para filtrar más.

2. Agregue el repositorio al repolist, que debe especificarse en la guía del controlador.

o REPOLIST_OF_DRIVER debe especificarse en la documentación del conductor (por ejemplo, lista de hechizos).

3. Actualice la lista de repositorios.

4. Instale el paquete.

5. Verifique la instalación.

Ejecutarlo lscpi comando (como arriba) para verificar que el controlador se instaló correctamente.

Agregamos el repositorio y lo instalamos

Hay diferentes formas de agregar el repositorio a través de yum, dnf y apt-get. Para hacerlo simple, este ejemplo usará apt-get, pero la idea es similar para las otras opciones.

1. Eliminar el repositorio existente, si existe.

sudo apt-get purge NOMBRE_DEL_DRIVER donde NOMBRE_DEL_DRIVER es el nombre probable de su controlador. También se puede agregar coincidencia de patrones a nuestra expresión regular para filtrar aún más.

2. Agregar el repositorio a la lista, que debe especificarse en la guía del controlador.

sudo add-apt-repository REPOLIST donde REPOLIST debe especificarse a partir de la documentación del controlador (por ejemplo, epel-list).

3. Actualización de la lista de repositorios.

sudo apt-get update

4. Instalación del paquete.

sudo apt-get install NOMBRE_DEL_DRIVER

5. Comprobación de la instalación.

Ejecutamos el comando lspci (como arriba) para verificar que el controlador se instaló correctamente.

Resolver errores comunes de PC

Su PC podría estar infectada con virus, spyware u otro software malicioso. Restoro escaneará e identificará todos estos problemas en su máquina y los eliminará por completo. Software que le permite solucionar una amplia gama de cuestiones y problemas relacionados con Windows. Restoro puede reconocer fácil y rápidamente cualquier error de Windows (incluida la temida pantalla azul de la muerte) y tomar las medidas adecuadas para resolver estos problemas. La aplicación también detectará archivos y aplicaciones que fallan con frecuencia y le permitirá solucionar sus problemas con un solo clic.

  • 1. Descargue e instale Reimage
  • 2. Inicie la aplicación e inicie sesión con los detalles de su cuenta
  • 3. Inicie un escaneo de su computadora para encontrar y corregir cualquier error

    Independientemente del origen del kernel, sus módulos 2.6.x originales deben ser la mayoría de ustedes. configure el aumento del árbol y monte su kernel en su sistema. Esta obligación es cambiar uno de versiones anteriores relacionadas con el kernel que eran suficientes con respecto a la computadora host definida actualmente. 2.6 Los módulos siempre han sido que vienen con archivos de objetos que se encuentran en la salida del árbol de código fuente particular granos; cada cargador de módulos más robusto, pero el requisito particular de que esos archivos de objetos que tienes que estar disponibles. Para Su primer objetivo es crear un árbol de fuentes del kernel especializado (utilizando Paquetes de red de Kernel.org o paquete de kernel preliminar del distribuidor), Configure un kernel único y restáurelo en el sistema de su empresa. Por los problemas que luego entenderemos, así es la vida En general, es un desafío si está seguro de ejecutar todo el núcleo de destino si alguien crea sus propios módulos personales. incluso si todo es realmente necesariamente no.

    Deberíaadvertir

    El laberinto de Falken

    Is this real or is it a game? What’s the difference?

    Buscar este blog

    Desarrollo de controladores de dispositivo (device drivers) en Linux

    Continúo la serie de artículos sobre programación del kernel Linux con un artículo sobre el desarrollo de controladores de dispositivos o device drivers. El controlador de ejemplo que voy a mostraros se carga en memoria como un módulo del kernel, así que conviene leer los anteriores posts sobre programación de módulos del kernel Linux y cómo usar /proc desde un módulo del kernel Linux. Para compilar el módulo me he basado en el entorno para desarrollo para kernel Linux que publiqué en un anterior artículo.
    Voy a comenzar presentando un ejemplo sencillo que seguidamente pasaré a analizar.

    El código de ejemplo hay que situarlo en el directorio

    kerneldev/src/modulo3 y lo llamaremos ramdisk.c.
    Este controlador, llamado ramdisk, en realidad no va a ser más que un pequeño buffer donde podremos almacenar hasta 255 bytes. Una especie de mini disco ram, que a pesar de ser muy simple, nos permitirá echar un primer vistazo al funcionamiento interno de los controladores.

    Sin más preámbulos, vamos directos al código.

    Puedes usar el siguiente Makefile para compilar el módulo: Una vez compilado, para probar el ejemplo, iniciamos la máquina virtual Qemu que hemos usado en los anteriores artículos y copiamos el kernel desde allí. Para poder usar un controlador de dispositivo primero hay que crearlo en el directorio /dev de linux con la instrucción mknod. En nuestro caso, vamos a asignar como major number del dispositivo el 231, y será de tipo carácter, así que se crea el descriptor con el siguiente comando: El módulo se carga en memoria de la forma habitual con insmod en la máquina virtual. Podemos usar el dispositivo como cualquier otro dispositivo de caracteres y escribir en él con echo o leer con cat. Por supuesto, también podemos usar las llamadas al sistema open(), close(), read(), write(), etc. (por ejemplo a través de libc).

    Tras comprobar que todo está en orden y funcionando analicemos el código del ejemplo. No volveré a explicar la parte relacionada con la carga y descarga del módulo, que es similar a los ejemplos que ya presenté en los anteriores artículos. Lo primero que hay que hacer es registrar el dispositivo para que el kernel tenga conocimiento de él y de cuáles son las funciones a las que hay que invocar para realizar operaciones (de lectura, escritura, etc.) sobre él. Esto se hace en la siguiente línea: El primer parámetro es el número mayor asociado al dispositivo (en este caso 231), seguido del nombre del driver. El tercer parámetro es un puntero a una estructura de datos de tipo file_operations, que hemos definido de la siguiente manera: Como se puede observar, esta estructura le indica al kernel qué funciones van a gestionar las llamadas del kernel open, read, write, close, ioctl y lseek. Por ejemplo, cuando se realice una llamada open() sobre el dispositivo, el kernel ejecutará la función do_open(). En este caso, la función do_open() no hace nada, ya que no estamos accediendo a un dispositivo real. En otro caso sí tendríamos que realizar algunas operaciones, como comprobar si otro proceso ya tiene abierto el dispositivo (en caso de que sea de acceso exclusivo), etc. La estructura file_operations completa tiene la siguiente definición (aunque, como en nuestro caso, no todos los campos de la estructura ha de rellenarse): En este código se han implementado las funciones do_read(), do_write() y do_llseek(). No entraré en demasiados detalles ya que estas funciones están bien comentadas sobre el propio código y son bastante autoexplicativas. Sólo comentaré los parámetros de la función do_read() y do_write() que pueden ser un poco confusos. *filp es un puntero a una estructura de datos que mantiene información sobre el fichero (por ahora no entraré en más detalle). El puntero *buf apunta al inicio del buffer donde debemos escribir los bytes a devolver para que sean recuperados desde el espacio de usuario (usaremos copy_to_user() para poner ahí los bytes leídos). count es el número de bytes solicitados y *f_pos es un puntero al primer carácter que debe leerse (offset), y además debemos actualizarlo según vayamos transfiriendo bytes al espacio de usuario. Vemos que en el caso de do_write() los parámetros son los mismos. Las diferencias son que ahora *buf contiene los bytes que han de ser escritos al dispositivo y *f_pos apunta a la posición del fichero donde debemos empezar a escribir. En este caso usamos la función copy_from_user() para transferir datos del espacio de usuario hacia el espacio del kernel.

    Huelga decir que para codificar estas funciones hay que tener un buen conocimiento del hardware y acceso a su documentación técnica para poder hacer una correcta implementación. Si en el futuro el tiempo (no el climatológico) me lo permite, os presentaré un ejemplo más realista en el que trataremos de llevar a cabo un driver para una pieza de hardware concreta. Hasta entonces os invito a «jugar» con este ejemplo, a mejorarlo y a ampliarlo.

    Los conductores son se utiliza para ayudar a los dispositivos de hardware a interactuar con el sistema operativo. … En Linux, incluso los dispositivos de hardware se tratan como archivos ordinarios, lo que facilita que el software interactúe con los controladores de dispositivos. Cuando se conecta un dispositivo al sistema, se crea un archivo de dispositivo en el directorio /dev.

    Un controlador de dispositivo es un programa que permite que el sistema operativo se comunique con hardware de computadora específico.

    Muchas partes de una computadora necesitan controladores, y algunos ejemplos comunes son:

    • Impresoras de computadora.
    • Tarjetas gráficas.
    • módems.
    • Tarjetas de red.
    • Tarjetas de sonido.

    CUDA se ha desarrollado específicamente para las GPU NVIDIA. Por lo tanto, CUDA no puede funcionar en GPU AMD. Las GPU de AMD no podrán ejecutar archivos CUDA Binary (.cubin), ya que estos archivos se crean específicamente para la Arquitectura de GPU de NVIDIA que está utilizando.

    CUDA es una cadena de herramientas de desarrollo para crear programas que se pueden ejecutar en las GPU nVidia, así como una API para controlar dichos programas desde la CPU. Los beneficios de la programación de la GPU frente a la programación de la CPU es que para algunos problemas altamente paralelizables, puede obtener aceleraciones masivas (aproximadamente dos órdenes de magnitud más rápido).

    0 0 votes
    Calificación del artículo
  • Ссылка на основную публикацию
    0
    Would love your thoughts, please comment.x
    ()
    x
    Adblock
    detector