Si vamos al grano...

Un sistema operativo es algo que implementa la multitarea (generalmente) y gestiona la distribución de recursos entre estas tareas y en general. Es necesario asegurarse de que las tareas no puedan dañarse entre sí y que funcionen en diferentes áreas de la memoria y funcionen con dispositivos a la vez, al menos eso es. También debe brindar la capacidad de transmitir mensajes de una tarea a otra.

Además, el sistema operativo, si hay memoria a largo plazo, debe proporcionar acceso a ella: es decir, proporcionar todas las funciones para trabajar con el sistema de archivos. Este es el mínimo.

En casi todas partes, el primer código de arranque debe escribirse en lenguaje ensamblador; existen muchas reglas sobre dónde debe estar, cómo debe verse, qué debe hacer y qué tamaño no debe exceder.

Para una PC, debe escribir un gestor de arranque en ASMA, que será llamado por el BIOS y que debería, sin exceder los cuatro cientos de bytes, hacer algo e iniciar el sistema operativo principal: transferir el control al código principal, que en el futuro próximo se puede escribir en C.

Para ARM, debe crear una tabla de interrupciones en ACMA (reinicio, varios errores, IRQ, interrupciones FIQ, etc.) y transferir el control al código principal. Sin embargo, en muchos entornos de desarrollo dicho código está disponible para casi cualquier controlador.

Es decir, para esto necesitas:

1. Conozca el lenguaje ensamblador de la plataforma de destino.
2. Conocer la arquitectura del procesador y todo tipo de comandos y registros de servicios para configurarlo para que funcione en modo deseado. En una PC, esta es una transición al modo protegido, por ejemplo, o al modo de 64 bits... En ARM, esto es configurar la sincronización del núcleo y los periféricos.
3. Sepa exactamente cómo se iniciará el sistema operativo, dónde y cómo debe insertar su código.
4. Conozca el lenguaje C: es difícil escribir código grande en Asma sin experiencia, mantenerlo será aún más difícil. Por lo tanto, es necesario escribir el kernel en C.
5. Conocer los principios de funcionamiento del SO. Bueno, hay muchos libros en ruso sobre este tema, aunque no sé si todos son buenos.
6. Ten mucha, mucha paciencia y perseverancia. Habrá errores y será necesario encontrarlos y corregirlos. También necesitarás leer mucho.
7. Ten muchísimo tiempo.

Próximo. Digamos que escribiste algo. Necesitamos probar esto. O necesita un dispositivo físico en el que se realizarán los experimentos (placa de depuración, segunda computadora) o un emulador para ello. El segundo suele ser más fácil y rápido de usar. Para PC, por ejemplo, VMWare.

También hay muchos artículos sobre este tema en Internet, si buscas bien. También hay muchos ejemplos de sistemas operativos ya preparados con códigos fuente.

Incluso puedes, si realmente lo deseas, mirar el código fuente del antiguo kernel de los sistemas NT (Windows), tanto por separado (que fue publicado por Microsoft, con comentarios y varios tipos de materiales de referencia), como junto con el antiguo SO (filtrado).

Guía para crear un kernel para un sistema x86. Parte 1. Sólo el núcleo

Escribamos un kernel simple que se pueda iniciar usando el gestor de arranque GRUB en un sistema x86. Este kernel mostrará un mensaje en la pantalla y esperará.

¿Cómo arranca un sistema x86?

Antes de comenzar a escribir el kernel, comprendamos cómo arranca el sistema y transfiere el control al kernel.

La mayoría de los registros del procesador ya contienen ciertos valores al inicio. El registro que apunta a la dirección de las instrucciones (Instruction Pointer, EIP) almacena la dirección de memoria donde se encuentra la instrucción ejecutada por el procesador. El EIP predeterminado es 0xFFFFFFFF0. Por lo tanto, los procesadores x86 a nivel de hardware comienzan a funcionar en la dirección 0xFFFFFFF0. En realidad, estos son los últimos 16 bytes del espacio de direcciones de 32 bits. Esta dirección se llama vector de reinicio.

Ahora el mapa de memoria del chipset garantiza que 0xFFFFFFF0 pertenezca a una parte específica del BIOS, no a la RAM. en esto hora del BIOS se copia a la RAM para más acceso rápido. La dirección 0xFFFFFFF0 solo contendrá una instrucción para saltar a la dirección en la memoria donde está almacenada una copia del BIOS.

Así es como comienza a ejecutarse el código de la BIOS. El BIOS primero busca un dispositivo desde el que pueda arrancar, en un orden preestablecido. Se encuentra un número mágico que determina si el dispositivo es de arranque (los bytes 511 y 512 del primer sector deben ser iguales a 0xAA55).

Cuando el BIOS encuentra dispositivo de arranque, copia el contenido del primer sector del dispositivo en la RAM, comenzando desde la dirección física 0x7c00; luego va a la dirección y ejecuta el código descargado. Este código se llama gestor de arranque.

El gestor de arranque carga el kernel en una dirección física. 0x100000. Esta dirección se utiliza como dirección inicial en todos los núcleos grandes en sistemas x86.

Todos los procesadores x86 comienzan en un modo simple de 16 bits llamado modo real. El gestor de arranque GRUB cambia el modo a 32 bits modo protegido, estableciendo el bit bajo del registro CR0 en 1 . Por tanto, el kernel se carga en modo protegido de 32 bits.

Tenga en cuenta que en el caso del kernel de Linux, GRUB ve los protocolos Descargas de Linux y carga el kernel en modo real. El kernel cambia automáticamente al modo protegido.

¿Qué necesitamos?

• computadora x86;
• Linux;
• ld (enlazador GNU);

Establecer el punto de entrada en ensamblador

No importa cuánto quieras limitarte solo a C, tendrás que escribir algo en ensamblador. Escribiremos en él un pequeño archivo que servirá como punto de partida para nuestro kernel. Todo lo que hará será llamar a una función externa escrita en C y detener el flujo del programa.

¿Cómo podemos asegurarnos de que este código sea el punto de partida?

Usaremos un script de vinculación que vincula archivos objeto para crear el archivo ejecutable final. En este script indicaremos explícitamente que queremos cargar datos en la dirección 0x100000.

Aquí está el código ensamblador:

;;kernel.asm bits 32 ;directiva nasm - sección de 32 bits .text inicio global extern kmain ;kmain se define en el archivo c inicio: cli ;el bloque interrumpe mov esp, stack_space ;establece la llamada al puntero de la pila kmain hlt ;detiene la sección de CPU .bss resb 8192; 8 KB para pila stack_space:

La primera instrucción, bits 32, no es una instrucción ensambladora x86. Esta es una directiva para el ensamblador NASM que especifica la generación de código para un procesador que opera en modo de 32 bits. En nuestro caso esto no es necesario, pero en general es útil.

La sección con el código comienza en la segunda línea.

global es otra directiva NASM que hace que los símbolos código fuente global. De esta manera el enlazador sabe dónde está el símbolo de inicio: nuestro punto de entrada.

kmain es una función que se definirá en el archivo kernel.c. extern significa que la función está declarada en otro lugar.

Luego viene la función start, que llama a la función kmain y detiene el procesador con la instrucción hlt. Es por eso que deshabilitamos las interrupciones por adelantado usando la instrucción cli.

Idealmente, necesitamos asignar algo de memoria y señalarla con un puntero de pila (especialmente). Sin embargo, parece que GRUB ya lo ha hecho por nosotros. Sin embargo, seguirá asignando algo de espacio en la sección BSS y moverá el puntero de la pila al principio. Usamos la instrucción resb, que reserva el número especificado de bytes. Inmediatamente antes de llamar a kmain, el puntero de la pila (esp) se establece en la ubicación correcta con la instrucción mov.

Núcleo en C

En kernel.asm hicimos una llamada a la función kmain(). Por lo tanto, nuestro código “C” debería comenzar la ejecución con kmai():

/* * kernel.c */ void kmain(void) ( const char *str = "mi primer kernel"; char *vidptr = (char*)0xb8000; //la memoria de video comienza aquí. unsigned int i = 0; unsigned int j = 0; /* este bucle borra la pantalla * hay 25 líneas cada una de 80 columnas cada elemento ocupa 2 bytes */ while(j;< 80 * 25 * 2) { /* blank character */ vidptr[j] = " "; /* attribute-byte - light grey on black screen */ vidptr = 0x07; j = j + 2; } j = 0; /* this loop writes the string to video memory */ while(str[j] != "\0") { /* the character"s ascii */ vidptr[i] = str[j]; /* attribute-byte: give character black bg and light grey fg */ vidptr = 0x07; ++j; i = i + 2; } return; }

Todo lo que nuestro kernel hará será borrar la pantalla y mostrar la línea "mi primer kernel".

Primero creamos un puntero vidptr que apunta a la dirección. 0xb8000. En modo protegido, la “memoria de video” comienza desde esta dirección. Para mostrar texto en pantalla reservamos 25 líneas de 80 caracteres ASCII, empezando por 0xb8000.

Cada carácter no se muestra en los 8 bits habituales, sino en 16. El primer byte almacena el carácter en sí y el segundo, el byte de atributo. Describe el formato del carácter, como su color.

Para mostrar el carácter s verde sobre fondo negro, escribimos este carácter en el primer byte y el valor 0x02 en el segundo. 0 significa fondo negro, 2 - verde texto.

Aquí está la carta de colores:

0 - Negro, 1 - Azul, 2 - Verde, 3 - Cian, 4 - Rojo, 5 - Magenta, 6 - Marrón, 7 - Gris claro, 8 - Gris oscuro, 9 - Azul claro, 10/a - Verde claro, 11/b - Cian claro, 12/c - Rojo claro, 13/d - Magenta claro, 14/e - Marrón claro, 15/f - Blanco.

En nuestro kernel usaremos texto gris claro sobre fondo negro, por lo que nuestro atributo byte tendrá el valor 0x07.

En el primer ciclo, el programa imprime un símbolo en blanco en toda la zona de 80x25. Esto borrará la pantalla. En el siguiente ciclo, los caracteres de la cadena terminada en nulo "mi primer núcleo" con un byte de atributo igual a 0x07 se escriben en la "memoria de video". Esto imprimirá la cadena en la pantalla.

pieza de conexión

Necesitamos ensamblar kernel.asm en un archivo objeto usando NASM; luego use GCC para compilar kernel.c en otro archivo objeto. Luego deben adjuntarse al kernel de arranque ejecutable.

Para hacer esto, usaremos un script vinculante que se pasa a ld como argumento.

/* * link.ld */ OUTPUT_FORMAT(elf32-i386) ENTRY(start) SECCIONES ( . = 0x100000; .text: ( *(.text) ) .data: ( *(.data) ) .bss: ( *( .bss) ) )

primero preguntaremos formato de salida como formato ejecutable y vinculable de 32 bits (ELF). ELF es un formato de archivo binario estándar para sistemas Unix x86. ENTRADA toma un argumento que especifica el nombre del símbolo que es el punto de entrada. SECCIONES- esta es la parte más importante. Define el marcado de nuestro archivo ejecutable. Determinamos cómo se deben conectar los diferentes tramos y dónde colocarlos.

Entre paréntesis después de SECCIONES, el punto (.) muestra el contador de posición, cuyo valor predeterminado es 0x0. Se puede cambiar, que es lo que estamos haciendo.

Veamos la siguiente línea: .text: ( *(.text) ) . Un asterisco (*) es personaje especial, que coincide con cualquier nombre de archivo. La expresión *(.text) significa todas las secciones .text de todos los archivos de entrada.

Por lo tanto, el vinculador une todas las secciones de código de los archivos objeto en una sección del archivo ejecutable en la dirección del contador de posición (0x100000). Después de esto, el valor del contador será igual a 0x100000 + el tamaño de la sección resultante.

Lo mismo ocurre con otras secciones.

Grub y arranque múltiple

Ahora todos los archivos están listos para crear el kernel. Pero queda un paso más.

Existe un estándar para cargar núcleos x86 usando un gestor de arranque llamado Especificación de arranque múltiple. GRUB sólo arrancará nuestro kernel si cumple estas especificaciones.

A continuación, el núcleo debería contener un encabezado en sus primeros 8 kilobytes. Además, este encabezado debe contener 3 campos, que son de 4 bytes:

• mágico campo: contiene el número mágico 0x1BADB002 para identificar el núcleo.
• campo banderas: no lo necesitamos, pongámoslo a cero.
• campo suma de control: si lo sumas con los dos anteriores, deberías obtener cero.

Nuestro kernel.asm se verá así:

;;kernel.asm ;directiva nasm - 32 bits bits 32 sección .text ;alineación de especificación de arranque múltiple 4 dd 0x1BADB002 ;magic dd 0x00 ;flags dd - (0x1BADB002 + 0x00) ;suma de comprobación. m+f+c debe ser cero inicio global extern kmain ;kmain se define en el inicio del archivo c: cli ;el bloque interrumpe mov esp, stack_space ;establece la llamada al puntero de la pila kmain hlt ;detiene la sección de la CPU .bss resb 8192 ;8 KB para la pila espacio_pila:

Construyendo el núcleo

Ahora crearemos archivos objeto a partir de kernel.asm y kernel.c y los vincularemos usando nuestro script.

Nasm -f elf32 kernel.asm -o kasm.o

Esta línea ejecutará el ensamblador para crear el archivo objeto kasm.o en formato ELF-32.

Gcc -m32 -c kernel.c -o kc.o

La opción "-c" garantiza que no se produzcan enlaces ocultos después de la compilación.

Ld -m elf_i386 -T link.ld -o kernel kasm.o kc.o

Esto ejecutará el vinculador con nuestro script y creará archivo ejecutable llamado núcleo.

Configurar grub e iniciar el kernel

GRUB requiere que el nombre del kernel cumpla con el patrón kernel- . Entonces cambie el nombre del kernel. Llamé al mío kernel-701.

Ahora ponlo en el directorio. /bota. Para hacer esto necesitará derechos de superusuario.

En el archivo de configuración de GRUB grub.cfg, agregue lo siguiente:

Título myKernel root (hd0,0) kernel /boot/kernel-701 ro

No olvide eliminar la directiva de menú oculto si está presente.

Reinicie su computadora y verá una lista de kernels, incluido el suyo. Selecciónalo y verás:

¡Este es tu núcleo! Agreguemos un sistema de entrada/salida.

PD

• Para cualquier truco del kernel, es mejor utilizar una máquina virtual.
• Para ejecutar el kernel en comida2 la configuración debería verse así: entrada de menú "kernel 7001" ( set root="hd0,msdos1" multiboot /boot/kernel-7001 ro )
• si desea utilizar el emulador qemu, utilice: qemu-system-i386 -kernel kernel

Leyendo a Habr durante los últimos dos años, he visto solo unos pocos intentos de desarrollar un sistema operativo (específicamente: por parte de los usuarios y (pospuesto indefinidamente) y (no abandonado, pero por ahora parece más una descripción del funcionamiento del modo protegido de procesadores compatibles con x86, que sin duda también es necesario saber para escribir un sistema operativo para x86 y una descripción del sistema terminado (aunque no desde cero, aunque no tiene nada de malo, tal vez incluso lo contrario)); . Por alguna razón, creo que casi todos los programadores de sistemas (y algunas aplicaciones) han pensado al menos una vez en escribir sus propios programas. Sistema operativo. En este sentido, 3 sistemas operativos de la gran comunidad de este recurso parece una cantidad ridícula. Al parecer, la mayoría de los que piensan en su propio sistema operativo no van más allá de la idea, una pequeña parte se detiene después de escribir el gestor de arranque, unas pocas escriben partes del kernel y sólo los irremediablemente testarudos crean algo que recuerda vagamente a un sistema operativo. (si se compara con algo como Windows/Linux). Hay muchas razones para esto, pero la principal en mi opinión es que la gente abandona el desarrollo (algunos incluso antes de comenzar) debido a la pequeña cantidad de descripciones del proceso de escritura y depuración de un sistema operativo, lo cual es bastante diferente de lo que sucede. durante el desarrollo del software de la aplicación.

Con esta breve nota me gustaría demostrar que si empiezas correctamente, no hay nada particularmente difícil en desarrollar tu propio sistema operativo. Debajo del corte hay una guía breve y bastante general para escribir un sistema operativo desde cero.

Cómo No hay necesidad empezar

No tome el siguiente texto como una crítica explícita a los artículos o guías de nadie sobre cómo escribir un sistema operativo. Es solo que con demasiada frecuencia en artículos de este tipo con titulares ruidosos se hace hincapié en la implementación de una pieza de trabajo mínima y se presenta como un prototipo del núcleo. De hecho, debería pensar en la estructura del kernel y la interacción de partes del sistema operativo en su conjunto, y considerar ese prototipo como una aplicación estándar de "¡Hola mundo!" en el mundo del software de aplicaciones. Como ligera justificación de estos comentarios, cabe decir que debajo hay una subsección “¡Hola mundo!”, a la que en este caso se le presta exactamente tanta atención como es necesaria, y nada más.

No es necesario escribir un gestor de arranque. gente inteligente ideó la especificación Multiboot, la implementó y describió en detalle qué es y cómo usarla. No quiero repetirme, solo diré que funciona, hace la vida más fácil y hay que usarlo. Por cierto, es mejor leer la especificación completa, es pequeña e incluso contiene ejemplos.

No es necesario escribir el sistema operativo completamente en ensamblador. Esto no es tan malo, sino todo lo contrario: los programas rápidos y pequeños siempre serán muy apreciados. Lo que pasa es que, como este lenguaje requiere mucho más esfuerzo para desarrollarse, el uso del ensamblador sólo conducirá a una disminución del entusiasmo y, como resultado, a arrojar las fuentes del sistema operativo a un segundo plano.

No es necesario cargar una fuente personalizada en la memoria de video y mostrar nada en ruso. Esto no tiene sentido. Es mucho más fácil y universal usar el inglés, y dejar cambiar la fuente para más tarde, descargándola desde disco duro a través del controlador del sistema de archivos (al mismo tiempo, habrá un incentivo adicional para hacer algo más que simplemente iniciar).

Preparación

Para empezar, como siempre, conviene familiarizarse con la teoría general para tener una idea del alcance del próximo trabajo. Buenas fuentes sobre el tema que nos ocupa son los libros de E. Tanenbaum, que ya se han mencionado en otros artículos sobre cómo escribir un sistema operativo en Habré. También hay artículos que describen sistemas existentes, y hay varias guías/correos/artículos/ejemplos/sitios con énfasis en el desarrollo de sistemas operativos, cuyos enlaces a algunos de ellos se encuentran al final del artículo.

Después del programa educativo inicial, es necesario decidir las cuestiones principales:

• arquitectura de destino: x86 (modo real/protegido/largo), PowerPC, ARM, ...
• Arquitectura kernel/OS: monolito, monolito modular, microkernel, exokernel, varios híbridos
• lenguaje y su compilador: C, C++, ...
• Formato de archivo kernel: elf, a.out, coff, binario, ...
• entorno de desarrollo (sí, esto también juega un papel importante): IDE, vim, emacs, ...

A continuación, deberás profundizar tus conocimientos según el elegido y en las siguientes áreas:

• memoria de video y trabajar con ella: la salida como prueba de funcionamiento es necesaria desde el principio
• HAL (capa de abstracción de hardware): incluso si hay soporte para varias arquitecturas de hardware y no hay planes para separar adecuadamente las partes del nivel más bajo del kernel de la implementación de cosas tan abstractas como procesos, semáforos, etc. no ser superfluo
• Gestión de memoria: física y virtual.
• gestión de ejecución: procesos e hilos, su planificación
• gestión de dispositivos - controladores
• sistemas de archivos virtuales: para proporcionar una interfaz única para el contenido de varios sistemas de archivos
• API (interfaz de programación de aplicaciones): cómo accederán exactamente las aplicaciones al kernel
• IPC (Comunicación entre procesos): tarde o temprano los procesos tendrán que comunicarse

Herramientas

Teniendo en cuenta el lenguaje elegido y las herramientas de desarrollo, se debe seleccionar un conjunto de utilidades y sus configuraciones que en el futuro, al escribir scripts, harán que sea lo más fácil y rápido posible construir, preparar una imagen y ejecutar una máquina virtual con un proyecto. Echemos un vistazo más de cerca a cada uno de estos puntos:

• Cualquiera es adecuado para el montaje. medios estándar, como make, cmake,... Aquí se pueden utilizar scripts para el vinculador y utilidades (específicamente escritas) para agregar un encabezado de arranque múltiple, sumas de verificación o para cualquier otro propósito.
• Cuando preparamos una imagen nos referimos a montarla y copiar archivos. En consecuencia, se debe seleccionar el formato del archivo de imagen de modo que sea compatible tanto con la utilidad de montaje/copia como con la máquina virtual. Naturalmente, nadie prohíbe realizar las acciones a partir de este punto ni como parte final del montaje ni como preparación para el lanzamiento del emulador. Todo depende de los medios específicos y de las opciones elegidas para su uso.
• Iniciar una máquina virtual no es difícil, pero debe recordar desmontar primero la imagen (desmontar en este punto, ya que no tiene sentido realizar esta operación antes de iniciar la máquina virtual). También sería útil tener un script para iniciar el emulador en modo de depuración (si está disponible).

Si se han completado todos los pasos anteriores, debe escribir un programa mínimo que se iniciará como un núcleo e imprimirá algo en la pantalla. Si se descubren inconvenientes o deficiencias en los medios elegidos, es necesario eliminarlos (las deficiencias) o, en el peor de los casos, darlos por sentados.

En este paso, debe verificar tantas capacidades como sea posible de las herramientas de desarrollo que planea usar en el futuro. Por ejemplo, cargar módulos en GRUB o usar máquina virtual disco físico/partición/unidad flash en lugar de una imagen.

Una vez exitosa esta etapa, comienza el verdadero desarrollo.

Proporcionar soporte en tiempo de ejecución

Dado que se propone escribir en lenguajes de alto nivel, se debe tener cuidado de brindar soporte para algunas de las características del lenguaje que generalmente implementan los autores del paquete compilador. Por ejemplo, para C++, estos incluyen:

• función para asignar dinámicamente un bloque de datos en la pila
• trabajando con montón
• función de copia de bloque de datos (memcpy)
• La función es el punto de entrada al programa.
• llamadas a constructores y destructores de objetos globales
• una serie de funciones para trabajar con excepciones
• stub para funciones virtuales puras no realizadas

Al escribir "¡Hola mundo!" Es posible que la ausencia de estas funciones no se haga sentir, pero a medida que se agrega código, el vinculador comenzará a quejarse de dependencias no satisfechas.

Naturalmente, también deberíamos mencionar la biblioteca estándar. No es necesaria una implementación completa, pero vale la pena implementar un subconjunto central de la funcionalidad. Entonces escribir código será mucho más familiar y rápido.

Depuración

No mire lo que se dice sobre la depuración hacia el final del artículo. De hecho, este es un tema muy serio y difícil en el desarrollo de sistemas operativos, ya que las herramientas convencionales no son aplicables aquí (con algunas excepciones).

Podemos recomendar lo siguiente:

• No hace falta decirlo, salida de depuración.
• afirmar con salida inmediata al "depurador" (ver el siguiente párrafo)
• algo parecido a un depurador de consola
• comprueba si el emulador te permite conectar un depurador, tablas de símbolos u otra cosa

Sin un depurador integrado en el kernel, la búsqueda de errores tiene muchas posibilidades de convertirse en una pesadilla. Así que simplemente no hay forma de evitar escribirlo en alguna etapa de su desarrollo. Y como esto es inevitable, es mejor empezar a escribirlo con antelación y así facilitar mucho el desarrollo y ahorrar bastante tiempo. Es importante poder implementar un depurador de manera independiente del kernel para que la depuración tenga un impacto mínimo en el funcionamiento normal del sistema. A continuación se muestran algunos tipos de comandos que pueden resultar útiles:

• parte de las operaciones de depuración estándar: puntos de interrupción, pila de llamadas, impresión de valores, impresión de volcado, ...
• varios comandos de salida información útil, como la cola de ejecución del programador o varias estadísticas (no es tan inútil como podría parecer al principio)
• Comandos para comprobar la coherencia del estado de varias estructuras: listas de memoria libre/utilizada, montón o cola de mensajes.

Desarrollo

A continuación, debe escribir y depurar los elementos principales del sistema operativo, que en este momento debe proporcionarlo trabajo estable, y en el futuro: fácil ampliación y flexibilidad. Además de los administradores de memoria/proceso/(cualquier otra cosa), la interfaz del controlador y sistemas de archivos. Su diseño debe abordarse con especial cuidado, teniendo en cuenta la variedad de tipos de dispositivos/FS. Con el tiempo, por supuesto, se pueden cambiar, pero este es un proceso muy doloroso y propenso a errores (y depurar el kernel no es una tarea fácil), así que recuerde: piense en estas interfaces al menos diez veces antes de comenzar a implementarlas. a ellos.

SDK similares

A medida que el proyecto se desarrolle, se le deben agregar nuevos controladores y programas. Lo más probable es que ya en el segundo controlador (posiblemente de cierto tipo)/programa se noten algunas características comunes (estructura de directorios, archivos de control de ensamblaje, especificación de dependencias entre módulos, código repetido en los controladores de solicitudes principales o del sistema (por ejemplo, si los propios controladores comprueban su compatibilidad con el dispositivo )). Si es así, entonces esto es una señal de la necesidad de desarrollar plantillas para varios tipos programas para su sistema operativo.

No es necesaria documentación que describa el proceso de redacción de tal o cual tipo de programa. Pero vale la pena hacer un espacio en blanco a partir de elementos estándar. Esto no sólo hará que sea más fácil agregar programas (lo que se puede hacer copiando programas existentes y luego cambiándolos, pero esto llevará más tiempo), sino que también hará que sea más fácil actualizarlos cuando cambien las interfaces, los formatos o cualquier otra cosa. Está claro que, idealmente, tales cambios no deberían ocurrir, pero como el desarrollo de sistemas operativos es algo atípico, hay muchos lugares para tomar decisiones potencialmente equivocadas. Pero entender la falacia decisiones tomadas como siempre, llegará algún tiempo después de su implementación.

Próximos pasos

En resumen: lea sobre sistemas operativos (y, en primer lugar, sobre su diseño), desarrolle su sistema (el ritmo no es realmente importante, lo principal es no detenerse por completo y volver al proyecto de vez en cuando con nuevos fuerzas e ideas) y Es natural corregir errores en él (para encontrarlos a veces es necesario iniciar el sistema y "jugar" con él). Con el tiempo, el proceso de desarrollo será cada vez más sencillo, los errores ocurrirán con menos frecuencia y usted será incluido en la lista de "irremediablemente testarudos", esos pocos que, a pesar de lo absurdo de la idea de desarrollar su propio sistema operativo, todavía lo hice.

Lo que necesitas saber para escribir un sistema operativo

Crear un sistema operativo es una de las tareas más difíciles en programación porque requiere conocimientos amplios y complejos sobre cómo funciona una computadora. ¿Cuáles exactamente? Averigüemos a continuación.

¿Qué es el sistema operativo?

El sistema operativo (SO) es software, que trabaja con el hardware de la computadora y sus recursos y es un puente entre el hardware y el software de la computadora.

Las computadoras de primera generación no tenían sistemas operativos. Los programas de las primeras computadoras incluían códigos para el funcionamiento directo del sistema, comunicación con dispositivos periféricos y cálculos para los cuales se escribió este programa. Debido a esta situación, incluso los programas que tenían una lógica simple eran difíciles de implementar en el software.

A medida que las computadoras se volvieron más diversas y complejas, escribir programas que funcionaran como sistema operativo y aplicación se volvió simplemente inconveniente. Por lo tanto, para que los programas fueran más fáciles de escribir, los propietarios de computadoras comenzaron a desarrollar software. Así aparecieron los sistemas operativos.

El sistema operativo proporciona todo lo necesario para que se ejecuten los programas de usuario. Su aparición significó que los programas ya no necesitaban controlar todo el volumen de trabajo en la computadora (este es un excelente ejemplo de encapsulación). Ahora los programas debían funcionar específicamente con el sistema operativo, y el propio sistema se encargaba de los recursos y del trabajo con los periféricos (teclado, impresora).

Breve historia de los sistemas operativos.

lenguaje c

Como se mencionó anteriormente, existen varios lenguajes de programación de alto nivel para escribir un sistema operativo. Sin embargo, el más popular de ellos es C.

Puedes empezar a aprender este idioma desde aquí. Este recurso le presentará conceptos básicos y le preparará para tareas más avanzadas.

“Aprenda C de la manera difícil” es el título de otro libro. Además de la teoría habitual, contiene muchas soluciones prácticas. Este tutorial cubrirá todos los aspectos del idioma.

O puedes elegir uno de estos libros:

• "El lenguaje de programación C" de Kernighan y Ritchie;
• "Guía absoluta para principiantes en programación en C" de Parry y Miller.

desarrollo del sistema operativo

Después de dominar todo lo que necesita saber sobre informática, lenguaje ensamblador y C, debe leer al menos uno o dos libros sobre el desarrollo real de sistemas operativos. Aquí hay algunos recursos para esto:

"Linux desde cero". El proceso de montaje del quirófano se analiza aquí. sistemas linux(El libro de texto ha sido traducido a muchos idiomas, incluido el ruso). Aquí, como en otros libros de texto, se le proporcionará todo lo necesario. conocimientos basicos. Confiando en ellos, puede intentar crear un sistema operativo. Hacer parte del software El sistema operativo es más profesional, hay adiciones al libro de texto: "

Autor jugador vulf hizo una pregunta en la sección Otros lenguajes y tecnologías

¿Cómo crear tu propio sistema operativo? y obtuve la mejor respuesta

Respuesta de Alexander Bagrov[gurú]
La idea es loable.
En primer lugar, necesita conocer el sistema de comando de la máquina para la cual desea escribir un sistema operativo.
El sistema de comando se refleja directamente en el lenguaje ensamblador.
Por lo tanto, en primer lugar, debe crear su propio lenguaje ensamblador y escribir un programa para él (ensamblador) que traduzca símbolos alfanuméricos al lenguaje de máquina.
código.
Si está interesado, puede ver qué requisitos debe tener un sistema operativo nuevo (ideal).
Algunas de estas características se enumeran aquí:
.ru/D_OS/OS-PolyM.html#IdealOS
Es necesario estudiar materiales de sitios de desarrolladores de microprocesadores. Por ejemplo, Intel y AMD.
Puede que le resulte útil el curso en vídeo sobre sistemas operativos, que se presenta aquí:
.ru/D_OS/OS_General.html
PD: No escuches a los pesimistas. Basado en la ideología de un gallo persiguiendo a una gallina:
"No me pondré al día, al menos calentaré".
Fuente: Sitio web "¡Utilice su PC correctamente!"

Responder de 2 respuestas[gurú]

¡Hola! Aquí tienes una selección de temas con respuestas a tu pregunta: ¿Cómo crear tu propio sistema operativo?

Responder de Vadim Khprlamov[novato]
Por supuesto) Aquí solo hay puertas) Pregúntele a Microsoft)

Responder de Irina Starodubtseva[novato]
tomar todos los sistemas operativos y juntarlos en uno

Responder de Alexander Tuntsov[gurú]
Familiarícese con el sistema operativo Linux, aprenda a programar y listo

Responder de ~En llamas~[gurú]
Aprenda programación al más alto nivel, reúna a una multitud de los mismos genios de la informática y luego podrá hacerlo.

Responder de Rasul Magomedov[gurú]
Comienza creando fondos de pantalla divertidos

Responder de Capitán Google[gurú]
No escuches “10 años para aprender lo básico”; Torvalds escribió la primera versión de Linux a la edad de 22 años y consiguió una computadora a los 12. Como comprenderás, no solo estudió lo básico.
Empiece por estudiar lo que ya existe: por un lado, "Sistemas operativos modernos" de Tannenbaum, por otro lado, construir Linux desde cero, por el tercero, aprender ensamblador, C, C++. Puedes hacer todo sobre todo en 3-4 años. Después de eso, puedes empezar a desarrollar tu sistema... si aún quieres.

Responder de Yoanya Semenov[gurú]
¿Sabes lo que hizo Gates? prueba lo mismo, dicen que sale rentable..
Cuando sus padres lo castigaron, él, al no tener nada mejor que hacer, comenzó a saltar sobre el teclado y luego lo vendió, llamando a lo que consiguió "ventanas".
PD y si es real escribe primero " Hola Mundo"en C++ e inmediatamente comprenderás que la idea es paranoica

Responder de Kostafey[gurú]
¿Por qué? ¿Qué es lo que insatisface fundamentalmente a los existentes? ¿Realmente no existe ninguno que satisfaga al menos parcialmente los requisitos de su sistema operativo? ¿Quizás sea mejor unirse al equipo de desarrollo? Habrá 100500 veces más sentido.
Y luego, abandonarás esta idea por otro 0,(0)1% de su implementación.

Responder de Evgeny Lomega[gurú]
E. Tanenbaum "Sistemas operativos: desarrollo e implementación"
Buena suerte
PD: Desafortunadamente, es poco probable que tenga éxito como lo tuvo Bill Gates. Su madre es una banquera genial, ¿la tuya?

Responder de corteza de cangrejo[gurú]
Puedes escribir un sistema operativo simple tú mismo, pero nunca podrá competir con un sistema operativo como Windows, MAC OS o Linux, en el que cientos o miles de programadores han trabajado durante al menos diez años. Además, el sistema operativo es sólo la base. Es necesario que los desarrolladores de hardware escriban sus propios controladores para este sistema operativo, los desarrolladores programas de aplicacion editores, reproductores, navegadores, juegos, el diablo en el mortero escribieron para ello... Y sin esto, el sistema operativo seguirá siendo una base inútil para una casa que nadie construirá.

Responder de Vadim Stajánov[activo]
Sería mejor si fuera a estudiar filología. Y luego gritaba “¡Caja registradora gratis!”

Responder de =Serge=[gurú]
¡Hurra! Finalmente, la pregunta 58 en el sitio sobre cómo crear "su propio" sistema operativo))
Aquí están las preguntas sobre "escribir su propio sistema operativo": solo hay 34))
Leer...92 preguntas*10 respuestas = aproximadamente 920 respuestas))
Al mismo tiempo, probablemente comprenderá lo que significa "papel tapiz no aburrido").

Responder de irreproducible[gurú]
¿Otro Denis Popov con otro BolgenOS?

Responder de Iván Tatarchuk[novato]
inicie el bloc de notas, descargue el compilador toadscript y comience a saltar sobre el teclado
compila en 60 minutos y listo
tu oska está lista

Responder de Mila la oveja[novato]
¿SO? ¿Cuál exactamente? Chester original del sistema operativo (personaje original (traducido))
Necesita imágenes de sí misma en dibujos animados o películas.
1. Piensa qué tipo de dibujos animados/película quieres para el sistema operativo.
2. Considere el estilo de dibujos animados/película
3. ¿Quién será tu personaje (hada, pony, mago, robot, etc.)
4. Descríbelo mentalmente y luego en papel.
5. Crea un diseño
6. Piensa en un nombre y una biografía.
7. ¡Dibuja un personaje!
8. Ahora pongámonos manos a la obra con Paint Tooth Sai

Wi-Fi