texto mostrar font ejemplo java operating-system device-driver

mostrar - ¿Es posible codificar un controlador de dispositivo en Java?



mostrar texto en jlabel java (13)

¿Acaso has escuchado una referencia al JDDK ?

Escribir un controlador de dispositivo al 100% en Java no es posible sin el código nativo para proporcionar la interacción entre (1) los puntos de entrada y las convenciones del controlador específico del sistema operativo y (2) la instancia de JVM. La instancia de JVM podría iniciarse "en proceso" (y "en proceso" puede tener diferentes significados dependiendo del sistema operativo y de si el controlador es un controlador de modo kernel o modo de usuario), o como un usuario separado proceso mediante el cual una capa delgada de adaptación del controlador nativo puede comunicarse y sobre la cual dicha capa de adaptación del controlador puede descargar el trabajo real de la tierra del usuario.

Introducción

Escuché algo acerca de escribir controladores de dispositivos en Java (escuchado como en "con mis oídos", no desde Internet) y me preguntaba ... Siempre pensé que los controladores de dispositivos operaban a nivel de sistema operativo y, por lo tanto, deben escribirse en el mismo idioma. como el sistema operativo (por lo tanto en su mayoría CI supone)

Preguntas

  1. ¿Estoy generalmente equivocado con esta suposición? (así parece)
  2. ¿Cómo se puede utilizar un controlador en un idioma "extranjero" en el sistema operativo?
  3. ¿Cuáles son los requisitos (desde el punto de vista del lenguaje de programación) para un controlador de dispositivo de todos modos?

Gracias por leer

En primer lugar, tenga en cuenta que no soy un experto en controladores de dispositivos (aunque escribí algunos de ellos mismos en el pasado), y mucho menos un experto en Java.

Dejemos de lado el hecho de que escribir controladores de dispositivos en un lenguaje de alto nivel no es una buena idea (por el rendimiento y posiblemente muchas otras razones) por un momento, y responderemos su pregunta.

Puede escribir controladores de dispositivo en casi cualquier idioma, al menos en teoría.

Sin embargo, la mayoría de los controladores de dispositivos necesitan hacer un montón de cosas de bajo nivel, como manejar interrupciones y comunicarse con el sistema operativo utilizando las API del sistema operativo y las llamadas al sistema, lo que creo que no se puede hacer en Java.

Pero, si su dispositivo se comunica mediante, digamos, un puerto serie o USB, y si el sistema operativo no necesariamente tiene que estar al tanto del dispositivo (solo su aplicación tendrá acceso al dispositivo *), entonces puede escribir el controlador en cualquier lugar. Lenguaje que proporciona los medios necesarios para acceder al dispositivo.

Por ejemplo, es probable que no pueda escribir un controlador de tarjeta SCSI en Java, pero sí puede escribir un controlador para un dispositivo de control propietario, una lámpara de lava USB, una llave de licencia, etc.

* La pregunta obvia aquí es, por supuesto, ¿eso cuenta como conductor?

Es posible compilar el código java en las instrucciones nativas de hardware (es decir, no en el código de bytes de JVM). Ver por ejemplo GCJ . Con esto en la mano, estás mucho más cerca de ser capaz de compilar controladores de dispositivos que antes.

Aunque no sé lo práctico que es.

Hay un par de maneras en que esto se puede hacer.

Primero, el código que se ejecuta a "nivel de SO" no necesita estar escrito en el mismo idioma que el SO. Simplemente tiene que ser capaz de vincularse con el código del sistema operativo. Prácticamente todos los idiomas pueden interactuar con C, que es realmente todo lo que se necesita.

Así que en cuanto al lenguaje, técnicamente no hay problema. Las funciones de Java pueden llamar a las funciones de C, y las funciones de C pueden llamar a las funciones de Java. Y si el sistema operativo no está escrito en C (digamos, en aras del argumento de que está escrito en C ++), entonces el código de C ++ del sistema operativo puede llamar a algún código C intermedio, que se reenvía a su Java, y viceversa. C es prácticamente una lengua franca de la programación.

Una vez que un programa ha sido compilado (en código nativo), su idioma de origen ya no es relevante. El ensamblador se ve muy similar sin importar en qué idioma se escribió el código fuente antes de la compilación. Mientras use la misma convención de llamada que el sistema operativo, no hay problema.

Un problema mayor es el soporte en tiempo de ejecución. No hay muchos servicios de software disponibles en el sistema operativo. Por lo general, no hay una máquina virtual de Java, por ejemplo. (No hay ninguna razón por la que técnicamente no pueda haber, pero generalmente, pero generalmente, es seguro asumir que no está presente).

Desafortunadamente, en su representación "predeterminada", como código de bytes de Java, un programa Java requiere mucha infraestructura. Necesita la máquina virtual Java para interpretar y JIT el código de bytes, y necesita la biblioteca de clases y así sucesivamente.

Pero hay dos maneras de evitar esto:

  • Soporta Java en el kernel. Este sería un paso inusual, pero podría hacerse.
  • O compile su código fuente Java a un formato nativo. Un programa Java no tiene que ser compilado a código de bytes de Java. Podrías compilarlo en un ensamblador x86. Lo mismo ocurre con cualquier clase de bibliotecas que uses. Esos también podrían ser compilados hasta el ensamblador. Por supuesto, partes de la biblioteca de clases de Java requieren ciertas características del sistema operativo que no estarán disponibles, pero luego se podría evitar el uso de esas clases.

Así que sí, se puede hacer. Pero no es sencillo, y no está claro qué ganaría.

Por supuesto, otro problema puede ser que Java no le permita acceder a ubicaciones de memoria arbitrarias, lo que dificultaría mucho la comunicación del hardware. Pero eso también podría solucionarse, tal vez recurriendo a funciones C muy simples que simplemente devuelven las áreas de memoria relevantes como arreglos para que Java trabaje.

Los controladores de dispositivo de espacio de usuario PCIe se pueden escribir en Java puro. Consulte JVerbs para obtener detalles sobre el acceso directo al hardware basado en memoria, en el contexto de OFED. Esta es una técnica que se puede utilizar para crear sistemas de muy alto rendimiento.

Puede examinar el bus PCI para determinar las regiones de memoria para un dispositivo determinado, qué puertos tiene, etc. Las regiones de memoria se pueden asignar al proceso de la JVM.

Por supuesto, usted es responsable de implementar todo usted mismo.

No dije fácil Dije posible. ;)

Vea también Controladores de dispositivo en Espacio de usuario , que trata sobre el uso del marco UIO para crear un controlador de espacio de usuario.

Los controladores de dispositivo tienen que estar escritos en un idioma que pueda ejecutarse en el kernel, ya sea compilado en él o cargados como un módulo en tiempo de ejecución. Esto generalmente impide escribir controladores de dispositivo en Java, pero supongo que teóricamente podría implementar una JVM dentro de un controlador de dispositivo y dejar que ejecute el código Java. No es que cualquier persona sana quiera hacer eso.

En Linux hay varias implementaciones de sistemas de archivos de tierras de usuarios (es decir, no kernel) que utilizan una capa de abstracción común llamada (fusible) que permite a los programas de tierras de usuarios implementar cosas que normalmente se hacen en el kernel.

No es imposible, pero posiblemente sea difícil y posiblemente no tenga mucho sentido.

Es posible, porque Java es un lenguaje de programación normal, siempre que tenga alguna forma de acceder a los datos, no hay problema. Normalmente, en un sistema operativo moderno, el kernel tiene una capa que permite el acceso directo al hardware de alguna manera. También existen controladores en el espacio de usuario, al menos la parte de espacio de usuario no debería ser un problema para implementar en Java.

Es posible que no tenga demasiado sentido, ya que el kernel tiene que iniciar una JVM para ejecutar el controlador. También las implementaciones de JVM normalmente consumen mucha memoria.

También puede utilizar el código Java compilado para ejecutarse de forma nativa en la plataforma (no con la ayuda de una JVM). Esto generalmente no es tan eficiente, pero podría ser adecuado para un controlador de dispositivo.

La pregunta es, ¿tiene sentido implementar el controlador en Java? O dicho de otra manera: ¿Cuál es el beneficio que espera, si usa Java para implementar el controlador en lugar de otra alternativa? Si puede responder a esta pregunta, debe encontrar una manera de hacerlo posible.

Al final, la sugerencia para JNode , un proyecto que intenta implementar un sistema operativo completo basado únicamente en Java.

Para la motivación, recuerde que hay muchos lenguajes rápidos que son mejores que C para la programación; Puede que no sean tan rápidos como C, pero son idiomas seguros: si comete un error, no obtiene un comportamiento indefinido. Y el "comportamiento indefinido" incluye la ejecución de código arbitrario suministrado por algún atacante que formatea su HD. Muchos lenguajes funcionales se compilan generalmente a código nativo.

Los controladores de dispositivos contienen la mayoría de los errores en un kernel del sistema operativo. Sé que para Linux (Linus Torvalds y otros lo siguen diciendo) y escuché eso para Windows. Mientras que para un disco o un controlador Ethernet necesita un rendimiento excelente, y mientras que en los controladores de Linux de hoy en día son el cuello de botella para los discos 10G Ethernet o SSD, la mayoría de los controladores no necesitan tanta velocidad; todas las computadoras esperan a la misma velocidad.

Es por eso que hay varios proyectos para permitir que los controladores de escritura se ejecuten fuera del kernel, incluso si eso causa una desaceleración; cuando puedas hacer eso, puedes usar el idioma que quieras; en ese momento, solo necesitará los enlaces de Java para la biblioteca de control de hardware que utiliza: si estuviera escribiendo el controlador en C, todavía tendría una biblioteca con enlaces de C.

Para los controladores en modo kernel propiamente dichos, hay dos problemas que aún no he visto mencionados:

  • Recolección de basura, y eso es un requisito difícil. Necesitas escribir un recolector de basura en el kernel; algunos algoritmos de GC se basan en la memoria virtual, y usted no puede usarlos. Además, probablemente deba escanear toda la memoria del sistema operativo para encontrar las raíces del GC. Por último, solo confiaría en un algoritmo que garantice GC (suave) en tiempo real, lo que aumentaría aún más la sobrecarga. Al leer el documento que se mencionó sobre los controladores de dispositivos Java en la parte superior de Linux, simplemente se dan por vencidos y requieren que los programadores liberen manualmente la memoria. Tratan de argumentar que esto no comprometerá la seguridad, pero no creo que su argumento sea convincente; ni siquiera está claro si entienden que la recolección de basura es necesaria para un lenguaje seguro.

  • Reflexión y carga de clases. Una implementación completa de Java, incluso cuando se ejecuta código nativo, debe poder cargar código nuevo. Esta es una biblioteca que puede evitar, pero si tiene un intérprete o un compilador JIT en el kernel (y no hay una razón real que lo haga técnicamente imposible).

  • Actuación. El documento sobre una JVM en Linux es muy malo, y sus números de rendimiento no son convincentes; de hecho, prueban un controlador de red USB 1.1 y luego muestran que el rendimiento no es tan malo. Sin embargo, dado suficiente esfuerzo seguramente se puede hacer algo mejor.

Dos últimas cosas:

  • Me gustaría mencionar Singularity, que es un sistema operativo completo escrito en una variante de C #, con solo una Capa de abstracción de hardware en un idioma nativo.
  • Acerca de picoJava, es una mala idea usarlo a menos que su sistema sea realmente de memoria limitada, como una tarjeta inteligente. Cliff Click ya explicó por qué: ofrece un mejor rendimiento para escribir un buen JIT, y hoy en día incluso los teléfonos inteligentes pueden admitirlo.

Tienes una vista demasiado estrecha de los controladores de dispositivo.

He escrito dichos controladores de dispositivo encima de MOST en una aplicación automotriz. Un uso más generalizado podría ser controladores para dispositivos USB si Java alguna vez obtiene una biblioteca USB decente.

En estos casos, existe un protocolo genérico de bajo nivel que se maneja en código nativo, y el controlador Java maneja las características específicas del dispositivo (formatos de datos, máquinas de estado, ...).

Windows Driver Foundation (WDF) es una API de Microsoft que permite la escritura de controladores de dispositivo en modo User y Kernel . Esto se está haciendo hoy, y ahora es compatible con w2k y versiones posteriores (solía no tener w2k como destino compatible). No hay ninguna razón por la que no se puedan realizar llamadas a JNI para realizar algún trabajo en el JRE. . . (Suponiendo que JNI sigue siendo la forma de llamar a Java desde C / C ++ ... mi conocimiento está fechado en ese campo). Esto podría ser una forma interesante de hacer que los algoritmos de alto nivel mezclen directamente los datos de una conexión USB para obtener algo al respecto. . . ¡cosas interesantes!

¿Posible?

Sí, pero solo en circunstancias especiales. Porque puede escribir un sistema operativo en Java y C #, y luego, debería poder escribir controladores de dispositivo para él. El golpe de memoria a estos controladores y sistemas operativos sería sustancial.

¿Probable?

No es probable. Al menos no en el mundo de Windows, MacOS o incluso Linux ... Al menos no en el corto plazo. Porque lenguajes como C # y Java dependen de CLR y JVM. La forma en que funcionan estos idiomas significa que no se pueden cargar efectivamente en ring0.

Además, el impacto en el rendimiento sería bastante grande si se usaran idiomas administrados en los controladores de dispositivos.

Un controlador de dispositivo puede ser muchas cosas

De hecho, escribo controladores de dispositivos en java para vivir: controladores para dispositivos industriales , como básculas o dispositivos de pesaje, máquinas de embalaje, escáneres de códigos de barras, puentes de pesaje, impresoras de bolsas y cajas, ... Java es una opción realmente buena aquí.

Los dispositivos industriales son muy diferentes de los dispositivos de su hogar / oficina (por ejemplo, escáneres, impresoras) . Especialmente en la fabricación (por ejemplo, alimentos), las empresas optan cada vez más por un servidor centralizado que ejecuta una aplicación MES (por ejemplo, desarrollado en Java) El servidor MES necesita interactuar con los dispositivos de la línea de producción, pero también contiene lógica empresarial. Java es un lenguaje que puede hacer ambas cosas.

Donde los dispositivos de su hogar / oficina a menudo están incorporados en su computadora o conectados con un cable USB, estos dispositivos industriales generalmente usan conectores Ethernet o RS232. Entonces, en esencia, casi todos los idiomas pueden hacer el trabajo.

Todavía no hay mucha estandarización en esta área. La mayoría de los proveedores prefieren crear su propio protocolo para sus dispositivos. Después de todo, son constructores de hardware, no genios de software. El resultado es que hay una gran diversidad de protocolos. Algunos proveedores prefieren protocolos simples de texto simple, pero otros prefieren protocolos binarios complejos con códigos CRC, marcos, ... A veces les gusta apilar múltiples protocolos (por ejemplo, un algoritmo de intercambio de manos específico del proveedor en la parte superior de una capa OPC). Un lenguaje fuerte OOP tiene muchas ventajas aquí.

Por ejemplo, he visto imprimir java a una velocidad continua de 100 ms / ciclo. Esto incluye generar una etiqueta única, enviarla a la impresora, recibir una confirmación, imprimirla en papel y aplicarla al producto usando presión de aire.

En resumen, el poder de java:

  • Es útil tanto para la lógica empresarial como para la interconexión compleja.
  • Es tan confiable en comunicación con sockets como C.
  • Algunos controladores pueden beneficiarse de la potencia OOP de Java.
  • Java es lo suficientemente rápido.