Serena
1.0.0
Serena es un sistema operativo experimental basado en principios de diseño modernos con soporte para la concurrencia preventiva generalizada y múltiples usuarios. El núcleo está orientado a objetos y está diseñado para ser multiplataforma y prueba futura. Se ejecuta en sistemas Amiga con una CPU 68030 o mejor instalada.
Un aspecto que lo distingue del OSS tradicional basado en hilos es que se construye puramente alrededor de colas de despacho algo similares al gran despacho central de Apple. No hay soporte para crear subprocesos en el espacio del usuario ni en el espacio del núcleo. En cambio, el núcleo implementa un concepto de procesador virtual donde administra dinámicamente un grupo de procesadores virtuales. El tamaño del grupo se ajusta automáticamente en función de las necesidades de las colas de despacho y los procesadores virtuales se asignan a los procesos según sea necesario. Toda la concurrencia del espacio del núcleo y del usuario se logra mediante la creación de colas de despacho y enviando elementos de trabajo para enviar colas. Los elementos de trabajo son simplemente cierres (una función con estado asociado) desde el punto de vista del usuario.
Otro aspecto interesante es la interrupción del manejo. El código que quiere reaccionar a una interrupción puede registrar un semáforo de conteo con el controlador de interrupción para la interrupción que quiere manejar. El controlador de interrupción indicará el semáforo cada vez que ocurra la interrupción. El uso de un semáforo de conteo asegura que el código que esté interesado en la interrupción no pierda la ocurrencia de una interrupción. La ventaja de traducir las interrupciones en señales en un semáforo es que el código de manejo de interrupción se ejecuta en un contexto bien definido que es el mismo tipo de contexto en el que se ejecuta cualquier otro tipo de código. También le da al código de manejo de interrupción más flexibilidad, ya que no tiene que reaccionar inmediatamente a una interrupción. La información que ha sucedido una interrupción nunca se perdió, ya sea que el código del controlador de interrupción estuviera ocupado con otras cosas en el momento de la interrupción o no.
El núcleo es generalmente reentrante. Esto significa que los procesadores virtuales continúan siendo programados y el contexto se cambia preventivamente incluso mientras la CPU se está ejecutando dentro del núcleo. Además, un cumplido completo de contar semáforos, variables de condición y API de bloqueo están disponibles dentro del núcleo. La API de esos objetos se parece mucho a lo que encontraría en una implementación del espacio de usuario de un sistema operativo tradicional.
Serena implementa una estructura de proceso jerárquica similar a POSIX. Un proceso puede generar varios procesos infantiles y puede pasar una línea de comando y variables de entorno a sus hijos. Un proceso accede a los recursos de E/S a través de canales de E/S que son similares a los descriptores de archivos en POSIX.
Sin embargo, hay dos diferencias notables entre el modelo de proceso POSIX de estilo y el modelo Serena: primero en lugar de usar Fork () seguido de Exec () para generar un nuevo proceso, usa una sola función en Serena llamada Process_Spawn (). Esto hace que el desove sea un proceso mucho más rápido y significativamente menos propenso a errores.
En segundo lugar, un proceso infantil no hereda los descriptores de archivo de su padre de forma predeterminada. La única excepción son los descriptores de archivo 0, 1 y 2 que representan las secuencias de entrada y salida del terminal. Este modelo es mucho menos propenso a errores en comparación con el modelo POSIX donde un proceso debe tener cuidado de cerrar los descriptores de archivos que no quiere transmitir a un proceso de niños antes de generar a un niño. Hacer esto fue fácil en los primeros días de UNIX cuando las aplicaciones estaban bastante contenidas y cuando no había soporte para bibliotecas dinámicas. Hoy es lo contrario porque las aplicaciones son mucho más complejas y dependen de muchas bibliotecas de terceros.
El formato de archivo ejecutable en este momento es el formato de archivo Atari St Gemdos, que es un estrecho en relación con el formato ejecutable AOT. Este formato de archivo se reemplazará eventualmente con un formato de archivo que podrá admitir bibliotecas dinámicas. Sin embargo, por ahora es lo suficientemente bueno como para hacer el trabajo.
El kernel implementa SerenaFs, que es un sistema de archivos jerárquico con permisos e información de usuarios y grupos. Se puede montar un sistema de archivos en la parte superior de un directorio ubicado en otro sistema de archivos para expandir el espacio de nombres de archivos. Todo esto funciona de manera similar a cómo funciona en los sistemas POSIX. Un proceso que desea generar un proceso infantil puede especificar que el proceso infantil debe limitarse a un sub-árbol del espacio de nombres del sistema de archivos global.
El sistema de archivos de arranque está actualmente basado en RAM. La ROM contiene una imagen de disco que se crea con la herramienta de diskimage y que sirve como una plantilla para el disco RAM. Esta imagen de disco ROM se copia a RAM en el momento del arranque.
El espacio de usuario tiene soporte para LibC, Libsystem, LibClap y los comienzos de LibM. Libsystem es una biblioteca que implementa el lado del espacio de usuario de la interfaz del núcleo. LibClap es una biblioteca que implementa el análisis de argumentos para los programas de interfaz de línea de comandos.
El sistema operativo Serena viene con un caparazón que implementa un lenguaje de shell formalmente definido. Puede encontrar el documento de shell aquí.
Los siguientes servicios de kernel se implementan en este momento:
Los siguientes servicios de espacio de usuario están disponibles en este momento:
Los siguientes programas de espacio de usuario están disponibles en este momento:
El nivel de integridad y corrección de los diversos módulos varía bastante en este momento. Las cosas están planificadas genéricamente para mejorar con el tiempo :)
El siguiente hardware es compatible en este momento:
Establecer el proyecto para el desarrollo y la ejecución del sistema operativo es un poco involucrado. Las instrucciones a continuación son para Windows, pero deberían funcionar más o menos lo mismo en Linux y MacOS.
Lo primero que necesitará es un emulador de computadora Amiga. Estoy usando Winuae que puedes descargar desde https://www.winuae.net/download
Descargue el instalador de Winuae y ejecutarlo. Esto colocará el emulador dentro del directorio de 'archivos de programa' en su unidad de arranque.
A continuación, descargue e instale el compilador VBCC y el ensamblador necesario para construir el sistema operativo. Puede encontrar la página de inicio del proyecto está en http://www.compilers.de/vbcc.html y la página de descarga para las herramientas en http://sun.hasenbraten.de/vbcc.
La versión que estoy usando para mi desarrollo y que sé que funciona correctamente en Windows 11 es de 0.9h. Asegúrese de agregar una variable de entorno con el nombre VBCC que apunta a la carpeta VBCC en su disco y agregue la carpeta vbccbin a la variable de entorno PATH .
Tenga en cuenta que debe instalar Microsoft Visual Studio y herramientas de línea de comandos porque se necesita el compilador de Microsoft C para crear las herramientas de compilación en Windows.
Finalmente, instale GNU Make for Windows y asegúrese de que esté en la variable de entorno PATH . Una forma directa de hacerlo es ejecutando el siguiente comando del ala en una ventana de shell: winget install GnuWin32.Make .
Solo necesita ejecutar este paso una vez y antes de intentar construir el sistema operativo. El propósito de este paso es construir un par de herramientas necesarias para construir las bibliotecas de núcleo y espacio de usuario. Puede encontrar documentación para estas herramientas aquí.
Primero abra un símbolo del sistema de desarrollador en Windows Terminal y luego CD en la carpeta Serena/Tools . make y presione regresar. Esto creará todas las herramientas requeridas y las colocará dentro de una carpeta Serena/build/tools . Las herramientas se conservarán en esta ubicación incluso si hace una limpieza completa del proyecto del sistema operativo.
Abra la carpeta del proyecto Serena en el código Visual Studio y seleccione Build All desde la Run Build Task... Menú. Esto construirá el kernel, libsystem, libc, libm y shell y generará un solo archivo Serena.rom dentro de la Serena/product/Kernel/ carpeta. Este archivo ROM contiene el núcleo, las bibliotecas de espacio de usuario y el shell.
Primero necesitará crear una configuración de Amiga con al menos una CPU 68030 (es decir, Amiga 3000 o 4000) en Winuae si aún no lo ha hecho. La forma más fácil de hacerlo es ir a QuickStart y seleccionando A4000 como modelo. Luego vaya a la página de hardware/ROM y actualice el campo de texto "Archivo ROM principal" de modo que apunte al archivo Serena.rom dentro de la carpeta Serena/build/product/ en su disco. Finalmente, le dé a su Amiga virtual al menos 1 MB de RAM FAST yendo a la página de hardware/RAM y configurando la entrada "lenta" a 1 MB. Guarde esta configuración para que no tenga que recrearla la próxima vez que desee ejecutar el sistema operativo.
Cargue la configuración y luego presione el botón de inicio o simplemente haga doble clic en la configuración en la página de configuraciones para ejecutar el sistema operativo. El emulador debe abrir una pantalla que muestra un mensaje de arranque y luego una solicitud de shell. Consulte la página de shell para obtener una lista de comandos compatibles con el shell.
Distribuido bajo la licencia MIT. Consulte LICENSE.txt para obtener más información.
Dietmar Planitzer - @linkedin
Enlace del proyecto: https://github.com/dplanitzer/serena
