C# Open Source Managed Operating System ( Cosmos ) es un conjunto de herramientas para crear sistemas operativos basados en GUI y línea de comandos , escrito principalmente en el lenguaje de programación C# y pequeñas cantidades de un lenguaje ensamblador de alto nivel llamado X#. Cosmos es un acrónimo inverso , [1] en el sentido de que el acrónimo se eligió antes que el significado. Es un software de código abierto publicado bajo una licencia BSD .
A partir de 2022 [update], Cosmos incluye un compilador adelantado en el tiempo (AOT) llamado IL2CPU para traducir el lenguaje intermedio común (CIL) en instrucciones nativas. Cosmos compila programas creados por el usuario y bibliotecas asociadas utilizando IL2CPU para crear un ejecutable nativo de arranque que puede ejecutarse de forma independiente. La salida resultante se puede arrancar desde una unidad flash USB , un CD-ROM , a través de una red mediante el entorno de ejecución de prearranque (PXE) o dentro de una máquina virtual . Las versiones recientes también permiten la implementación en ciertos dispositivos integrados x86 a través del bus serie universal ( USB ). Si bien C# es el lenguaje principal que utilizan los desarrolladores (tanto en el backend como por los usuarios finales de Cosmos), se pueden utilizar muchos lenguajes CLI , siempre que se compilen en CIL puro sin el uso de servicios de invocación de plataforma (P/Invokes). Cosmos está destinado principalmente para su uso con .NET .
Cosmos no pretende convertirse en un sistema operativo completo, sino más bien en un conjunto de herramientas que permita a otros desarrolladores crear de forma sencilla y fácil sus propios sistemas operativos utilizando .NET. También funciona como una capa de abstracción , ocultando gran parte del funcionamiento interno del hardware al posible desarrollador.
Las versiones anteriores de Cosmos se publicaron en Milestones , siendo la última Milestone 5 (publicada en agosto de 2010). Más recientemente, el proyecto cambió a nombrar las nuevas versiones simplemente según el último número de confirmación.
Las versiones de Cosmos se dividen en dos tipos: Userkit y Devkit . El Userkit es una versión preempaquetada que se actualiza de forma irregular, a medida que se agregan características nuevas y mejoradas. Los Userkits generalmente se consideran estables, pero no incluyen cambios recientes y pueden carecer de características. Los Devkits, que se refieren al código fuente de Cosmos, suelen ser estables pero pueden tener algunos errores. Se pueden adquirir en GitHub y deben compilarse manualmente. [1] Git se utiliza para la gestión del control de código fuente.
La mayor parte del trabajo en Cosmos actualmente está orientado a mejorar la funcionalidad del depurador y la integración con Microsoft Visual Studio . El trabajo del núcleo se centra en la implementación de sistemas de archivos , la gestión de memoria y el desarrollo de una interfaz de red confiable. Limine sirve como cargador de arranque del proyecto ; en versiones anteriores del kit de herramientas, se utilizaba GRUB en su lugar. [2]
La idea de Cosmos fue creada por Chad Hower y fue desarrollada inicialmente en conjunto por Hower y Matthijs ter Woord. Con el tiempo, muchas otras personas han mantenido y mejorado Cosmos.
Cosmos cuenta con numerosas funciones para mejorar la experiencia de desarrollo de sistemas operativos y está diseñado para que el proceso sea lo más rápido y sencillo posible. No es necesario tener conocimientos de lenguaje ensamblador para utilizar Cosmos.
Una característica clave de Cosmos, que lo distingue de otros sistemas operativos de su tipo, es su estrecha integración con Microsoft Visual Studio . El código se puede escribir, compilar , depurar y ejecutar completamente a través de Visual Studio , con solo presionar unas pocas teclas. Cosmos ya no es compatible con Visual Studio 2015 , Visual Studio 2017 o Visual Studio 2019 , solo es compatible con Visual Studio 2022 .
Cosmos se puede depurar sin problemas a través de Visual Studio cuando se ejecuta sobre PXE o en una máquina virtual . Hay muchas funciones de depuración estándar , como puntos de interrupción, seguimiento y registro. Además, la depuración se puede realizar a través de cables seriales, si se ejecuta en hardware físico. Cuando se ejecuta en VMWare , Cosmos admite pasos y puntos de interrupción, incluso mientras se ejecuta un sistema operativo.
Cosmos utiliza la virtualización para acelerar el desarrollo, permitiendo a los desarrolladores probar sus sistemas operativos sin tener que reiniciar sus computadoras tan a menudo. De manera predeterminada, se utiliza VMware Player, debido a su facilidad de uso en términos de integración con el proyecto. También se admiten otros entornos de virtualización, como Bochs y Hyper-V . También se puede generar una imagen de disco ISO que se puede grabar en una unidad flash USB , CD-ROM o medio similar.
También se admite el arranque PXE, lo que permite que máquinas remotas ejecuten Cosmos a través de una conexión de red.
Para compilar .NET CIL en lenguaje ensamblador, los desarrolladores de Cosmos crearon un compilador avanzado llamado IL2CPU, diseñado para analizar CIL y generar códigos de operación x86 . (IL To CPU) es un compilador AOT escrito con un lenguaje compatible con Common Intermediate Language ( C# ). Traduce Common Intermediate Language a código de máquina .
X# es un lenguaje de programación de bajo nivel diseñado para la arquitectura de procesador x86 como parte del sistema operativo Cosmos. Su objetivo es simplificar el desarrollo del sistema operativo incorporando una sintaxis de lenguaje similar a C al lenguaje ensamblador . Inicialmente, X# se utilizó para depurar servicios en Cosmos. El compilador X# es un programa de interfaz de línea de comandos (consola) de código abierto que analiza las líneas de código en tokens, las compara con patrones y traduce los patrones coincidentes a la sintaxis de ensamblaje x86 de Intel, generalmente para el ensamblador YASM. Las primeras versiones de X# funcionaban principalmente 1:1 con el código ensamblador, pero este ya no es el caso. [ aclaración necesaria ]
La sintaxis de X# es sencilla pero más estricta en comparación con C.
X# solo admite comentarios de una sola línea en el estilo C++, comenzando con - //.
X# permite la definición de constantes nombradas declaradas fuera de las funciones. Las constantes numéricas se definen de manera similar a C++ ; por ejemplo:
constante i = 0 Para hacer referencia a ellos en otro lugar se requiere un #antes del nombre; por ejemplo: - "#i".
''). Para incluir una comilla simple en una constante de cadena, utilice una barra invertida (por ejemplo, 'I\'m so happy').las cadenas X# terminan en nulo ).$), seguido de la constante. ( $B8000).0.Las etiquetas en X# funcionan de manera similar a las etiquetas en otros lenguajes ensambladores. El gotomnemónico se utiliza para saltar a una etiqueta en lugar del jumpmnemónico convencional jmp.
CodeLabel1 : ir a CodeLabel2 : Los archivos de programa X# deben comenzar con una directiva de espacio de nombres. X# carece de una jerarquía de espacios de nombres, por lo que el espacio de nombres actual cambia con cada directiva hasta que finaliza el archivo. Las variables o constantes en diferentes espacios de nombres pueden tener el mismo nombre, ya que el espacio de nombres se antepone al nombre del miembro en la salida del ensamblado. Los espacios de nombres no pueden hacer referencia entre sí, excepto a través de operaciones de bajo nivel.
namespace FIRST // Todos los nombres de variables o constantes tendrán como prefijo FIRST y un guión bajo. Por lo tanto, el nombre completo verdadero de la variable a continuación // es FIRST_aVar. var aVar namespace SECOND // No hay problema en nombrar otra variable aVar. Su verdadero nombre es SECOND_aVar. var aVar espacio de nombres PRIMERO // Este código ahora regresa al espacio de nombres PRIMERO hasta que finalice el archivo. Todo el código ejecutivo de X# debe ubicarse en funciones definidas por la palabra clave 'function'. A diferencia de C, X# no admite ninguna declaración formal de parámetros en el encabezado de las funciones, por lo que se omiten los paréntesis convencionales después del nombre de la función. Debido a que los patrones fijos de línea se especifican en la sintaxis implementada en el analizador de código, la llave de apertura no se puede colocar en la siguiente línea, a diferencia de muchos otros lenguajes de estilo C.
función xSharpFunction { // código de función } Debido a que X# es un lenguaje de bajo nivel, no se insertan marcos de pila , por lo que, de manera predeterminada, la dirección EIP de retorno debe estar en la parte superior de la pila. Las llamadas a funciones de X# contienen argumentos entre paréntesis, a diferencia de los encabezados de función. Los argumentos que se pasan a las funciones pueden ser registros, direcciones o constantes. Estos argumentos se insertan en la pila en orden inverso. Tenga en cuenta que la pila en plataformas x86 no puede insertar ni extraer registros de un byte.
función xSharpFunction { EAX = $10 otraFunción ( EAX ); return } función otraFunción { //código de función } La returnpalabra clave devuelve la ejecución a la dirección EIP de retorno guardada en la pila.
X# puede trabajar con tres estructuras de datos de bajo nivel: los registros , la pila y la memoria , en diferentes puertos. Los registros son la base de todas las operaciones normales para X#. Un registro se puede copiar a otro escribiendo DST = SRCen lugar de movinstrucciones de carga/almacenamiento. Los registros se pueden incrementar o decrementar con la misma facilidad. Las operaciones aritméticas (sumar, restar, multiplicar, dividir) se escriben como dest op srcdonde srces una constante, variable o registro, y destes tanto un operando como la ubicación donde se almacena el resultado.
A continuación se muestran ejemplos de operaciones de asignación y aritméticas.
ESI = 12345 // asigna 12345 a ESI EDX = # constantForEDX // asigna #ConstantForEDX a EDX EAX = EBX // mueve EBX a EAX => mov eax, ebx EAX -- // decrementa EAX => dec eax EAX ++ // incrementa EAX => inc eax EAX + 2 // suma 2 a eax => add eax, 2 EAX - $ 80 // resta 0x80 de eax => sub eax, 0x80 BX * CX // multiplica BX por CX => mul cx -- la división, la multiplicación y el módulo deben conservar los registros CX / BX // divide CX por BX => div bx CX mod BX // resto de CX/BX a BX => div bx El cambio y el balanceo del registro son similares a C.
DX << 10 // desplazar a la izquierda 10 bits CX >> 8 // desplazar a la derecha 8 bits EAX <~ 6 // rotar a la izquierda 6 bits EAX ~> 4 // rotar a la derecha 4 bits Otras operaciones bit a bit son similares a las operaciones aritméticas.
DL & $ 08 // realiza AND bit a bit en DL con 0x08 y almacena el resultado en DL CX | 1 // establece el bit más bajo de CX en 1 (hazlo impar) EAX = ~ ECX // realiza NOT bit a bit en ECX y almacena el resultado en EAX EAX ^ EAX // borra EAX al realizar XOR con él mismo La manipulación de la pila en X# se realiza mediante los prefijos +y -, donde +se inserta un registro, valor, constante o todos los registros en la pila y -se extrae un valor en algún registro. Todas las constantes se insertan en la pila como palabras dobles, a menos que se indique lo contrario (no se admite la inserción de bytes individuales).
+ ESI // push esi - EDI // pop into edi + All // guardar todos los registros => pushad - All // cargar todos los registros => popad + $ 1 badboo2 // push 0x1badboo2 en la pila + $ cafe como palabra // \/ + $ babe como palabra // push 0xcafebabe + # VideoMemory // push valor de la constante VideoMemory Las variables se definen dentro de los espacios de nombres mediante la varpalabra clave. Las matrices se definen especificando el tipo y el tamaño. Las variables y las matrices se ponen a cero de forma predeterminada. Para hacer referencia al valor de una variable, utilice un punto ('.') y para hacer referencia a su dirección, utilice @.
namespace XSharpVariables var zeroVar // a la variable se le asignará cero var myVar1 = $ f000beef // a la variable se le asignará 0xf000beef var someString = ' Hello XSharp ! ' // a la variable se le asignará 'Hello XSharp!\0', var buffer byte [ 1024 ] // a la variable de tamaño 1024 bytes se le asignarán 1024 bytes cero ... EAX = . myVar1 // mueve el valor de myVar1 (0xf000beef) a EAX ESI = @ . someString // mueve la dirección de someString a ESI CL = . someString // mueve el primer carácter de someString ('H') a CL . zeroVar = EAX // asigna zeroVar al valor de EAX X# puede acceder a una dirección con un desplazamiento especificado usando corchetes:
var someString = ' Hello XSharp ! ' //la variable será asignada a 'Hello XSharp!\0' ... ESI = @ . someString // cargar la dirección de someString a ESI CL = 'B' // establecer CL a 'B' (reescribir 'H' al inicio) CH = ESI [ 1 ] // mover el segundo carácter ('E') de la cadena a CH ESI [ 4 ] = $ 00 // fin de la cadena //El valor de someString será 'Bell' (o 'Bell\0 XSharp!\0') Hay dos formas de comparar valores en X#: comparación pura y comparación if.
ifpalabra clave sin especificar miembros de comparación.ifpalabra clave.Aquí hay dos formas de escribir una función de longitud de cadena (lenta) X# ( strlen):
// Método 1: usar la función de comparación pura strlen { ESI = ESP [ 4 ] // obtener el puntero a la cadena pasada como primer argumento ECX ^ ECX // limpiar ECX Loop : AL = ESI [ ECX ] // obtener el siguiente carácter AL ?= 0 // ¿es 0? guardar en FLAGS if = return // si ZF está configurado, retorna ECX ++ // de lo contrario incrementa ECX goto Loop // bucle... //Forma 2: usar la función if strlen { ESI = ESP [ 4 ] // obtener el puntero a la cadena pasada como primer argumento ECX ^ ECX // limpiar ECX Loop : AL = ESI [ ECX ] si AL = 0 return // AL = 0? return ECX ++ goto Loop // loop.... } Hay seis operadores de comparación disponibles: < > = <= >= !=. Estos operadores se pueden utilizar tanto en comparaciones como en bucles. Tenga en cuenta que también hay un operador AND bit a bit que prueba bits:
AL ?& $ 80 // prueba AL MSB si = return // si ZF es 0, la instrucción de prueba resultó en 0 y MSB no está configurado. Un sistema operativo creado con Cosmos se desarrolla de manera similar a cualquier programa de consola .NET C# . Al comienzo del programa se incluyen referencias adicionales que dan acceso a las bibliotecas de Cosmos.
El kit de usuario de Cosmos es una parte de Cosmos diseñada para facilitar el uso de Cosmos a los desarrolladores que utilizan Microsoft Visual Studio . Cuando se instala, el kit de usuario agrega un nuevo tipo de proyecto a Visual Studio , llamado Proyecto Cosmos. Se trata de una versión modificada de una aplicación de consola, con el compilador de Cosmos y el código auxiliar de arranque ya agregados.
Una vez que el código esté completo, se puede compilar utilizando Roslyn, el compilador .NET , ya sea a través de Microsoft Visual Studio o las herramientas de línea de comandos .NET (dotnet).
Esto convierte la aplicación del código fuente original ( C# o cualquier otro) al lenguaje intermedio común (CIL), el lenguaje intermedio nativo de .NET.
El proceso de compilación invoca entonces al compilador IL2CPU , que escanea sistemáticamente todo el código CIL de la aplicación (excluyendo el código del compilador Cosmos) y lo convierte en lenguaje ensamblador para la arquitectura de procesador seleccionada. A partir de 2022 [update], solo se admite la arquitectura x86 . A continuación, Cosmos invoca al ensamblador seleccionado para convertir este código en lenguaje ensamblador en un código de operación nativo de la unidad central de procesamiento (CPU) . Por último, se activa la opción de salida deseada, ya sea iniciar una máquina virtual, iniciar un motor PXE o producir un archivo de imagen de disco ISO .
Cosmos ofrece varias opciones sobre cómo implementar el sistema operativo resultante y cómo depurar la salida.
Cosmos permite a los usuarios arrancar el sistema operativo en un entorno emulado mediante una máquina virtual . Esto permite a los desarrolladores probar el sistema en su propio ordenador sin tener que reiniciarlo, lo que ofrece la ventaja de no requerir hardware adicional ni que los desarrolladores salgan de su entorno de desarrollo integrado (IDE). VMware es el principal método de virtualización, aunque también se admiten otros, como QEMU y Hyper-V.
Esta opción escribe el sistema operativo en un archivo de imagen de disco ( imagen ISO ), que puede cargarse en algunos emuladores (como Bochs , QEMU o más comúnmente VMware ) o escribirse en una unidad flash USB y arrancarse en hardware físico.
Esta opción permite que el sistema operativo arranque en hardware físico. Los datos se envían a través de una red de área local (LAN) a la máquina cliente . Esto requiere dos computadoras: una como máquina cliente (en la que se inicia el sistema operativo) y otra como servidor (generalmente la máquina de desarrollo). También requiere una red que conecte las dos computadoras, una máquina cliente con una tarjeta de red y un sistema básico de entrada/salida ( BIOS ) que pueda arrancar con PXE. A partir de 2022 [update], ya no se admite la depuración a través de una red.
.svg/1280px-Free_and_open-source_software_logo_(2009).svg.png){kind=logo}