Cómo escribir el kernel de un sistema operativo. Una guía para crear un sistema operativo simple tipo UNIX. Crear una unidad flash USB de arranque

Original: "Lanza tu propio sistema operativo clon UNIX de juguete"
Autor: James Molloy
Fecha de publicación: 2008
Traducción: N. Romodanov
Fecha de traducción: enero de 2012

Este conjunto de tutoriales está diseñado para mostrarle en detalle cómo programar un sistema sencillo tipo UNIX. Sistema operativo para arquitectura x86. En estos tutoriales, el lenguaje de programación elegido es C, complementado con lenguaje ensamblador cuando sea necesario. El propósito de los tutoriales es informarle sobre el diseño e implementación de soluciones utilizadas en la creación del sistema operativo OS que estamos creando, el cual es monolítico en su estructura (los controladores se cargan en modo módulo kernel, y no en modo usuario como sucede con programas), ya que dicha solución es más sencilla.

Este conjunto de guías es de carácter muy práctico. Cada sección proporciona información teórica, pero la mayor parte del manual se refiere a la implementación de ideas abstractas y mecanismos discutidos en la práctica. Es importante señalar que el núcleo se implementa como núcleo de formación. Sé que los algoritmos utilizados no son ni los más eficientes en cuanto a espacio ni los óptimos. Generalmente fueron elegidos por su sencillez y facilidad de comprensión. El propósito de esto es brindarle la mentalidad adecuada y una base sobre la cual trabajar. este núcleo Es extensible y puedes conectar fácilmente los mejores algoritmos. Si tienes algún problema con la teoría, hay muchos sitios que pueden ayudarte a resolverlo. La mayoría de las preguntas discutidas en el foro OSDev se refieren a la implementación (“¡Mi función gets no funciona! ¡Ayuda!”) y para muchos, la pregunta teórica es como un sorbo. aire fresco. Las referencias se pueden encontrar al final de esta introducción.

Preparación preliminar

Para compilar y ejecutar el código de ejemplo, supongo que sólo necesitas GCC, ld, NASM y GNU Make. NASM es un ensamblador x86 de código abierto y es la elección de muchos desarrolladores de sistemas operativos x86.

Sin embargo, no tiene sentido simplemente compilar y ejecutar los ejemplos si no los comprende. Tienes que entender lo que se está codificando, y para ello tienes que conocer muy bien el lenguaje C, especialmente cuando se trata de punteros. También debe comprender algo de lenguaje ensamblador (estos tutoriales usan la sintaxis de Intel), incluido para qué se usa el registro EBP.

Recursos

Hay muchos recursos si lo sabes. como buscarlos. En particular, le resultarán útiles los siguientes enlaces:

• ¡RTFM! Los manuales de Intel son una bendición.
• Páginas wiki y foro del sitio osdev.org.
• Hay muchos buenos tutoriales y artículos en Osdever.net y en particular los tutoriales de desarrollo del kernel de Bran, cuyo código anterior se basa en este tutorial. Yo mismo usé esos tutoriales para comenzar, y el código que contenían era tan bueno que lo hice. no cambiarlo durante varios años.
• Si no eres principiante, puedes obtener respuestas a muchas preguntas en el grupo.

Esta serie de artículos está dedicada a la programación de bajo nivel, es decir, la arquitectura de computadoras, el diseño de sistemas operativos, la programación en lenguaje ensamblador y áreas afines. Hasta ahora, dos habrausers están escribiendo - y . Para muchos estudiantes de secundaria, estudiantes y programadores profesionales Estos temas resultan bastante difíciles de enseñar. Hay mucha literatura y cursos dedicados a la programación de bajo nivel, pero es difícil obtener una imagen completa y que lo abarque todo. Es difícil, después de leer uno o dos libros sobre lenguaje ensamblador y sistemas operativos, al menos en esquema general imagina cómo funciona esto realmente sistema complejo hecho de hierro, silicio y muchos programas: una computadora.

Cada uno resuelve el problema de aprendizaje a su manera. Algunas personas leen mucha literatura, otras intentan pasar rápidamente a la práctica y descubrirla sobre la marcha, otras intentan explicar a sus amigos todo lo que están estudiando. Y decidimos combinar estos enfoques. Entonces, en este curso de artículos demostraremos paso a paso cómo escribir un sistema operativo simple. Los artículos tendrán carácter de revisión, es decir, no contendrán información teórica exhaustiva, pero siempre intentaremos proporcionar enlaces a buenos materiales teóricos y responder a todas las dudas que surjan. No tenemos un plan claro, por lo que se tomarán muchas decisiones importantes a lo largo del camino, teniendo en cuenta sus comentarios.

Podemos llevar deliberadamente el proceso de desarrollo a un callejón sin salida para permitirle a usted y a nosotros comprender completamente las consecuencias de hacerlo mal. decisión tomada y también perfeccionar algunas habilidades técnicas al respecto. Por eso no debemos percibir nuestras decisiones como las únicas correctas y creernos ciegamente. Recalcamos una vez más que esperamos que los lectores participen activamente en la discusión de los artículos, lo que debería influir en gran medida. proceso general desarrollar y escribir artículos posteriores. Idealmente, con el tiempo, me gustaría que algunos de los lectores se unieran al desarrollo del sistema.

Supondremos que el lector ya está familiarizado con los conceptos básicos de los lenguajes ensamblador y C, así como con conceptos elementales arquitectura informática. Es decir, no explicaremos qué es un registro o, digamos, RAM. Si no tiene suficientes conocimientos, siempre puede recurrir a literatura adicional. lista corta La literatura y los enlaces a sitios con buenos artículos se encuentran al final del artículo. También es recomendable saber utilizar Linux, ya que todas las instrucciones de compilación se darán específicamente para este sistema.

Y ahora, más cerca del punto. En el resto del artículo escribiremos contigo. programa clasico"Hola Mundo" Nuestro Helloworld será un poco específico. No se ejecutará desde ningún sistema operativo, sino directamente, por así decirlo, "en bare metal". Antes de comenzar a escribir el código, averigüemos exactamente cómo intentamos hacer esto. Y para ello debemos considerar el proceso de inicio de la computadora.

Entonces, toma tu computadora favorita y presiona el botón más grande de la unidad del sistema. Vemos un protector de pantalla alegre, la unidad del sistema suena alegremente con su altavoz y después de un tiempo se carga el sistema operativo. Como comprenderá, el sistema operativo está almacenado en un disco duro, y aquí surge la pregunta: ¿cómo se cargó mágicamente el sistema operativo en la RAM y comenzó a ejecutarse?

Sepa esto: el sistema que está en cualquier computadora es responsable de esto, y su nombre, no, no Windows, tírese la lengua, se llama BIOS. Su nombre significa Sistema Básico de Entrada-Salida, es decir, un sistema básico de entrada-salida. El BIOS está ubicado en un pequeño chip de la placa base y se inicia inmediatamente después de presionar botón grande EN El BIOS tiene tres tareas principales:

1. Detecta todos los dispositivos conectados (CPU, teclado, monitor, RAM, tarjeta de video, cabeza, brazos, alas, piernas y colas...) y comprobar su funcionalidad. Responsable de esto programa POST(Autoprueba de encendido: autoprueba al presionar ON). Si no se detecta hardware vital, ningún software podrá ayudar, y en este punto el altavoz del sistema chirriará algo siniestro y el sistema operativo no irá al grano en absoluto. No hablemos de cosas tristes, supongamos que tenemos una computadora en pleno funcionamiento, alegrémonos y pasemos a considerar el segundo. Funciones de BIOS:
2. Proporcionar al sistema operativo conjunto básico Funciones para trabajar con hardware. Por ejemplo, a través de las funciones del BIOS puede mostrar texto en la pantalla o leer datos desde el teclado. Por eso se llama sistema básico E/S Normalmente el sistema operativo accede a estas funciones mediante interrupciones.
3. Lanzando el cargador del sistema operativo. En este caso, como regla general, se lee el sector de arranque: el primer sector del medio de almacenamiento (disquete, disco duro, CD, unidad flash). El orden de sondeo de medios se puede configurar en BIOS SETUP. El sector de arranque contiene un programa llamado a veces cargador de arranque primario. En términos generales, el trabajo del gestor de arranque es iniciar el sistema operativo. El proceso de carga de un sistema operativo puede ser muy específico y depender en gran medida de sus características. Por lo tanto, el gestor de arranque principal lo escriben directamente los desarrolladores del sistema operativo y se escribe en el sector de arranque durante la instalación. Cuando se inicia el gestor de arranque, el procesador está en modo real.

La triste noticia es que el gestor de arranque sólo debería tener un tamaño de 512 bytes. ¿Por qué tan poco? Para hacer esto, necesitamos familiarizarnos con la estructura del disquete. Aquí hay una imagen informativa:

La imagen muestra la superficie. unidad de disco. Un disquete tiene 2 superficies. Cada superficie tiene caminos (pistas) en forma de anillo. Cada pista está dividida en pequeñas piezas en forma de arco llamadas sectores. Entonces, históricamente, un sector de disquete tiene un tamaño de 512 bytes. El BIOS lee el primer sector del disco, el sector de arranque, en el segmento de memoria cero en el desplazamiento 0x7C00, y luego el control se transfiere a esta dirección. El cargador de arranque generalmente no carga en la memoria el sistema operativo en sí, sino otro programa de arranque. almacenado en el disco, pero por alguna razón (lo más probable es que sea el tamaño) no cabe en un sector y como por ahora el papel de nuestro sistema operativo lo desempeña un banal Helloworld, nuestro principal objetivo es hacer la computadora. creer en la existencia de nuestro sistema operativo, aunque sea en un sector, y ejecutarlo.

¿Cómo está estructurado el sector de arranque? En una PC, el único requisito para el sector de arranque es que sus dos últimos bytes contengan los valores 0x55 y 0xAA - firmas sector de arranque. Así pues, ya está más o menos claro lo que tenemos que hacer. ¡Escribamos código! El código proporcionado está escrito para el ensamblador yasm.

sección. texto

uso16

organización 0x7C00 ; nuestro programa se carga en la dirección 0x7C00

comenzar:

mov hacha, cs

mov ds, hacha ; seleccione un segmento de datos



mov si, mensaje

cld ; dirección para comandos de cadena

mov ah, 0x0E ; Número de característica del BIOS

movimiento bh, 0x00 ; página de memoria de vídeo

pone_loop:

lodsb ; cargar el siguiente símbolo en al

prueba al, al ; el carácter nulo significa el final de la línea

jz puts_loop_exit

entero 0x10 ; llamar a la función BIOS

jmp pone_loop

puts_loop_exit:

jmp$; ciclo eterno



mensaje:

DB "¡Hola mundo!" , 0

finalizar:

veces 0x1FE - finalizar + iniciar db 0

base de datos 0x55, 0xAA ; firma del sector de arranque

Este breve programa requiere algunas explicaciones importantes. La línea org 0x7C00 es necesaria para que el ensamblador (es decir, el programa, no el lenguaje) calcule correctamente las direcciones de las etiquetas y variables (puts_loop, puts_loop_exit, mensaje). Entonces le informamos que el programa se cargará en la memoria en la dirección 0x7C00.
en lineas

hacha mov, cs

mov ds, hacha

el segmento de datos (ds) se establece igual al segmento de código (cs), ya que en nuestro programa tanto los datos como el código se almacenan en el mismo segmento.

A continuación, en el bucle, se muestra el mensaje "¡Hola mundo!" carácter por carácter. Para ello se utiliza la función 0x0E de la interrupción 0x10. Tiene los siguientes parámetros:
AH = 0x0E (número de función)
BH = número de página del vídeo (no te molestes todavía, indica 0)
AL = código de caracteres ASCII

En la línea "jmp$" el programa se congela. Y con razón, no hay necesidad de que ella cumpla código adicional. Sin embargo, para que la computadora vuelva a funcionar, deberá reiniciar.

En la línea "times 0x1FE-finish+start db 0", el resto del código del programa (excepto los dos últimos bytes) se rellena con ceros. Esto se hace para que después de la compilación, los dos últimos bytes del programa contengan la firma del sector de arranque.

Parece que hemos resuelto el código del programa, intentemos ahora compilar esta felicidad. Para la compilación, necesitamos, estrictamente hablando, un ensamblador, el mencionado anteriormente.

Iliá Alexandrov

Creamos nuestro propio sistema operativo en Basado en Linux

Hay cientos de distribuciones de Linux y nadie sabe cuántas más aparecerán. Decenas de empresas y miles de programadores compiten para crear el mejor proyecto de Linux y, sin embargo, cualquier usuario avanzado puede convertirse en el autor de un sistema para PC doméstico que no es inferior a los productos de los gigantes de la industria de TI.

Para durante muchos años Cuando trabajaba con Linux, utilicé una gran cantidad de distribuciones diferentes: Mandriva, Fedora, SlackWare, Debian, Ubuntu y muchas otras. Algunos proyectos me gustaron más, otros menos. Pero en todas las distribuciones tuvimos que enfrentarnos inevitablemente a graves deficiencias que dificultaron mucho el trabajo. Uno es demasiado exigente con los recursos, el otro no lo soporta todo. el equipo necesario, el tercero carece de varios programas. Fue entonces cuando recordé la famosa sabiduría oriental: si necesitas hacer algo bien, hazlo tú mismo.

Linux desde cero

No soy el único que decidió empezar a construir. propia versión Linux es un SO en el que se tomará como base la parte básica del sistema y el kernel, pero donde no habrá ni un kilobyte extra por parte del desarrollador, es decir, de ti. Gran cantidad Las distribuciones de Linux que no cumplían con los requisitos de los usuarios llevaron a Gerard Beekmans a crear una distribución que permitiría a todos construir un sistema con solo los componentes y funciones que necesitaban.

El deseo de un programador talentoso dio como resultado el proyecto Linux from Scratch (www.linuxfromscratch.org), abreviado como LFS. Este proyecto te permite diseñar tu propio sistema operativo basado en Linux desde cero, a partir de códigos fuente. La compilación de LFS se realiza en una computadora que ya tiene sistema linux instalado Sin embargo, también es adecuado un Live-CD “avanzado”, como por ejemplo Knoppix.

En este caso, el sistema Linux utilizado para la compilación puede ser cualquiera; solo se requiere la presencia de un compilador y bibliotecas del sistema. Linux From Scratch difícilmente puede llamarse una distribución en el sentido habitual de la palabra: es algo así como un software auxiliar que, junto con la parte básica del sistema operativo, le permitirá crear su propia versión única del sistema operativo.

Como sabes, Linus Torvalds desarrolló su sistema operativo bajo el lema “¡Sólo por diversión!” - es decir, sólo por placer. Hay que admitir que LFS no se encuentra muy a menudo en los servidores donde se suele utilizar este sistema; entusiastas de la informática. Instalar y trabajar con Linux desde cero le ayudará a comprender la relación entre los componentes del sistema operativo, lo que le resultará útil cuando desarrollos propios Distribución Linux, y no sólo basada en LFS. Por lo tanto, LFS está diseñado en gran medida para aquellas personas para quienes el proceso de montaje distribución propia fascinante e interesante y, créanme, hay muchas personas así.

Entonces, si está listo para dedicar un día entero (o incluso más) a diseñar un sistema, le recomiendo descargar del sitio (2) LFS-packages-6.0, LFS-book y continuar leyendo este artículo.

Particionar el disco y crear un árbol de directorios

Para una mejor comprensión del material, describiremos todo el proceso en términos generales (ver Fig. 1).

En la primera etapa, utilizando un kit de distribución o LiveCD ya instalado, se divide el disco. Se asigna una partición en el disco duro para el nuevo sistema. Después de eso, en esta partición deberá compilar estáticamente todos los programas necesarios y el kernel del sistema. A continuación, el directorio raíz se cambia a la partición del disco duro asignada para nuestro nuevo sistema operativo. Deberá repetir la compilación, pero esta vez el software debe compilarse dinámicamente (la diferencia entre compilación dinámica y estática se describirá a continuación). La última etapa incluye crear la importante biblioteca glibc y configurar el sistema operativo instalado. Como puedes ver, no tienes que hacer nada particularmente complicado.

Durante todo el proceso, su asistente principal– documentación del paquete LFS-book, cuya traducción al ruso se puede encontrar aquí: http://multilinux.sakh.com/download/lfsbook.tar.bz2. El libro describe cada paso de la creación de un sistema operativo en detalle, así que asegúrese de consultar esta guía si tiene problemas (este artículo no pretende reemplazar una documentación tan extensa).

nosotros creamos nueva sección– en mi caso esto es /dev/hda5, ya que la partición /dev/hda1 ya está ocupada por la instalada en el disco duro disco de linux Slackware. Se recomienda realizar primero una copia de seguridad del sistema para poder restaurarlo en caso de daños, aunque la probabilidad de que esto ocurra es cercana a cero. Y aquí creo que todo está claro: destacamos cantidad requerida(23 GB son suficientes) para el directorio raíz, espacio equivalente al doble de la cantidad de RAM para la partición de intercambio; si lo desea, puede crear particiones separadas para el directorio de inicio (/home) y para /boot. Sin embargo, la opción de división preferida por muchos es asignar todo al directorio raíz. espacio disponible menos el intercambio, y la creación posterior del intercambio en sí también es bastante aceptable al ensamblar LFS. En la computadora del autor, tanto Linux Slackware, que es el sistema operativo principal, como LFS usan un disco duro; sin embargo, instalar LFS en otro disco duro tampoco es difícil.

Elija el sistema de archivos a su discreción: no hubo problemas ni con Ext3 ni con ReiserFS en LFS. Pero los fanáticos de XFS tendrán que sentirse decepcionados: los intentos de hacer que Linux From Scratch funcione con este FS no tuvieron éxito.

Ahora montamos la partición asignada para el nuevo SO:

$ montar /dev/hda5 /mnt/mylin

Por conveniencia, definamos la variable MYLIN:

$ exportar MYLIN=/mnt/mylin

Genial para trabajo adicional Es mejor crear un usuario mylin separado, a quien asignaremos como propietario de la partición montada.

$ usuario agregar mylin

$ chown –R mylin $MYLIN

Necesita crear un árbol de directorios en la raíz de la nueva partición:

$cd$MYLIN

$ mkdir –p bin boot dev etc home lib mnt opt ​​​​root sbin usr/(X11R6,local) var

En los directorios usr, usr/X11R6, usr/local creamos la estructura necesaria: subdirectorios bin, etc., incluyen, lib, sbin, share, src.

Luego haremos lo mismo para los directorios /var y /opt. sistema futuro:

$ mkdir var/(caché,lib,local,bloqueo,registro,opt,ejecutar,spool)

$ mkdir opt/(bin,doc,incluir,info,lib,man)

No olvidemos que existen jerarquías más profundas, por ejemplo /usr/share/man/man1. Pero el alcance del artículo no nos permite proporcionar aquí toda la información sobre la estructura del árbol de archivos, por lo que debe utilizar el documento Estándar de jerarquía del sistema de archivos (que se puede encontrar en: http://linux-ve.net /MyLDP/file-sys/fhs-2.2-rus) , o estudie detenidamente la estructura del sistema operativo que ya tiene instalado familia linux. Después entrenando duro disco procedemos al montaje estático.

Construcción estática

¿Por qué utilizamos ensamblaje estático? Con compilación estática código fuente Se adjuntan bibliotecas al código de la aplicación, lo que implica un aumento en su tamaño, pero al mismo tiempo se mantiene la integridad. Con la compilación dinámica, la biblioteca está en archivo separado, a qué aplicaciones acceden según sea necesario. Como resultado, todos los programas funcionan con la misma versión de la biblioteca.

Pero cuando usamos el comando chroot para configurar el directorio raíz para el sistema recién ensamblado, las bibliotecas del sistema instalado "principal", ubicadas en /lib, /usr/lib y otros, ya no estarán disponibles, por lo que se compilarán dinámicamente. Los programas se negarán a funcionar y, además, no será posible garantizar la compatibilidad de las versiones.

Para evitar esto, todo lo que necesitas software Para nuestro futuro sistema, primero lo ensamblaremos estáticamente. Empecemos, tal vez, con intérprete de comandos intento. (Los fanáticos de ZSH o TCSH pueden instalar sus intérpretes favoritos después de instalar el sistema, pero en la etapa de construcción su uso no está proporcionado por el autor de LFS). Debes verificar si tienes el archivo /usr/lib/libcurses.a y si no, instalar el paquete nсursesdev. Todos los paquetes deben compilarse con indicadores de compilación estática: “--enable-static-link”, “--disable-shared” o “--static”. Cuál es el apropiado en cada caso específico se puede encontrar en la documentación de un paquete específico o en el resultado del script de configuración iniciado con el parámetro “--help”.

$ ./configure --ayuda

Para no confundir más adelante los programas compilados estáticamente con los “dinámicos”, creemos un directorio especial para ellos:

$ mkdir $MYLIN/estad

Al crear e instalar paquetes, no olvide agregar el parámetro “--prefix=$MYLIN/stat” para mover archivos a este directorio. Y finalmente, instala bash:

$ ./configure –-enable-static-link --prefix=$MYLIN/stat

$ hacer

$ hacer instalación

Recopilamos el resto siguiendo el mismo esquema. paquetes requeridos: binutils, bzip2, textutils, texinfo, tar, sh-utils, gcc, grep, gzip, gawk, diffutils, fileutils, make, patch, sed, y, de hecho, el kernel de Linux.

Sí, al compilar el kernel, no olvide que para versiones anteriores de kernel (2.2.x-2.4.x) debe usar gcc 2.95, y para versión actual 2.6.x se recomienda utilizar gcc 3.x para evitar problemas.

No olvides consultar las secciones correspondientes del libro LFS, donde se habla de este y muchos otros matices. En general, compilar un kernel en LFS no se diferencia de un procedimiento similar que se lleva a cabo cuando se utiliza una distribución instalada en el disco duro. Descomprimamos las fuentes del kernel en $MYLIN/usr/src/linux-2.6.xx y luego configúrelo ejecutando:

$ crear configuración de menú

El proceso de configuración de los parámetros del kernel se ha descrito muchas veces en Internet (6; casi no es necesario profundizar en esto); A continuación damos siguientes comandos en la carpeta con las fuentes del kernel de Linux:

$ hacer bzImagen

$ hacer módulos

Eso es todo, en $MYLIN/usr/src/linux-2.6.xx/arch/i386/boot/bzImage hay un nuevo kernel.

A continuación, cree los archivos $MYLIN/etc/passwd y $MYLIN/etc/group. En el primero, registramos por ahora un solo usuario: root con cualquier contraseña, y en el segundo, grupos de usuarios (para empezar, un grupo raíz también será suficiente).

En este punto, nuestros preparativos para el siguiente paso han terminado y pasamos a una asamblea dinámica más sutil.

Montaje dinámico

Ahora necesitamos cambiar el directorio raíz a /mnt/mylin, donde usaremos solo utilidades ensambladas estáticamente; ya no podremos recurrir a la ayuda de herramientas del sistema operativo "principal". Emitimos el comando en la consola:

$ chroot $MYLIN/usr/bin/env –i

>INICIO=/root TERM=$TERM PS1=’u:w$’

>PATH=/bin: /usr/bin: /sbin: /usr/sbin: /stat/sbin

>/stat/bin/bash --iniciar sesión

Con este comando indicamos los caminos a archivos ejecutables, tipo de terminal, intérprete y tipo de símbolo de línea de comando.

Para garantizar el funcionamiento de algunos programas, debe instalar el sistema de archivos proc en el nuevo sistema.

$ montar proc /proc -t proc

Ha llegado el momento más crucial. Construyendo la biblioteca glibc. Él es el más responsable porque la mayoría de la gente trabaja sin ella. programas necesarios no lo habrá, pero en usando linux Sin la biblioteca principal no tiene sentido. La creación de glibc suele causar muchos problemas.

Durante la compilación, especificamos el parámetro “--prefix=$MYLIN/stat”, por lo que al cambiar la raíz, todos los paquetes compilados estáticamente terminarán en el directorio /stat de la nueva partición del sistema operativo.

Entonces, descomprima el archivo glibc-2.x.x.tar.gz (por ejemplo, en el directorio /usr/src/) y vaya al directorio glibclinuxthreads. Tendremos que corregir ligeramente el código fuente debido a que en esta etapa Es imposible identificar a un usuario por su nombre en el sistema (precisamente debido a la falta de glibc y otras bibliotecas), y al hecho de que para instalar glibc se necesita un intérprete de Perl, que no tenemos.

Reemplazo del nombre usuario root en el archivo login/Makefile a su uid, es decir, 0, y la variable $PERL en el archivo malloc/Makefile debe reemplazarse con la ruta al intérprete - /usr/bin/perl - y simplemente será ignorada durante configuración.

$ /usr/src/glibc-2.x.x/configure --prefix=/usr --enable-add-ons --libexecdir=/usr/bin &&

& hacer

y hacer la instalación

$ crear datos locales/instalar-locales

$ /stat/bash --iniciar sesión

Si hizo todo correctamente, glibc se compilará, finalmente aparecerá "root" en el mensaje y podrá recompilar dinámicamente todos los programas.

Completemos la instalación del kernel:

$ hacer módulos_instalar

$ hacer instalación

Para mover el nuevo kernel al directorio /boot, ejecute otro comando:

$ hacer desinstalación

Recopilamos todos los programas instalados y algunos nuevos, ahora sin indicadores de compilación estática. Necesitaremos (en esta etapa es muy importante no olvidar compilar todo lo que se enumera a continuación) (consulte la Tabla 1).

Tabla 1. conjunto requerido paquetes para montaje

configuración automática	grep	perla
autofabricación	grof
intento	zip	información
bin86		proceso
binutils	menos	psmisco
bzip2		reiserfs-progs
difusos	libherramienta
e2fsprogs	lilo	sh-utils
		sombra
archivo	hacer	registro del sistema
archivosutils	makedev	sistemavinit
encontrarutilidades	paginas man
doblar	modutils	texinfo
papar moscas	maldiciones	utiles de texto
	netkitbase	utilidad-linux
bisonte	herramientas de red
obtener texto	parche

Después de realizar la recompilación dinámica, puede eliminar el directorio con paquetes creados estáticamente:

$ rm -rf /estad

Puede dar un suspiro de alivio y tomar café: las cosas más difíciles y rutinarias quedan atrás. Pasemos a siguiente etapa– configuración inicial de nuestro sistema.

Configuración inicial del sistema

Antes de comenzar con la configuración, observo que todos los cambios deben realizarse en los archivos del directorio del nuevo sistema operativo, y no sistema padre.

Para configurar la hora del sistema, cree un archivo /etc/sysconfig/clock que contenga solo una línea:

UTC=0

Ahora el reloj de la computadora mostrará la hora en su zona horaria, siempre que el valor de la hora en el BIOS esté configurado correctamente.

Démosle un nombre a la computadora:

echo "NOMBREHOST=mi_linux" > /etc/sysconfig/network

Ahora indicamos las particiones que debe montar el sistema al arrancar en /etc/fstab:

# opciones de tipo fs del punto de montaje del sistema de archivos volcado fsck-order

/dev/hda5/ext3 valores predeterminados 1 1

/dev/hda3 intercambio intercambio pri=1 0 0

proc /proc proc valor predeterminado 0 0

En lugar de /dev/hda3 y /dev/hda5, escriba sus particiones (raíz y swap), complemente el archivo, si es necesario, con puntos de montaje para otras particiones del disco duro y CD-ROM.

Ahora hagamos que nuestro sistema sea arrancable.

Si además de lFS utilizas otros Distribuciones de Linux, entonces ahora necesitas ingresar viejo sistema– para ello ejecutamos el comando:

$ salir

Ya en el sistema operativo principal, agregue lo siguiente al archivo /etc/lilo.conf:

#LFS

imagen=/boot/bzImagen

Etiqueta=lfs

Raíz =

Sólo lectura

Está claro que "/boot/bzImage" es la ruta al kernel del sistema que compiló y "partición" es la partición del disco donde se encuentra el directorio raíz.

Si no planea utilizar otros sistemas operativos y distribuciones de Linux, continúe directamente con la configuración de LILO en LFS.

En este caso, lilo.conf se verá así:

arranque=/dev/hda

Retraso=40

Compacto

vga=normal

Raíz=/dev/hda1

Sólo lectura

Imagen=/boot/zImage-2.6.12

Etiqueta=Linux

Hacer cambios necesarios dependiendo de su configuración. Actualizamos el gestor de arranque con el comando:

$ /sbin/lilo –v

Y, si se completaron correctamente todos los pasos anteriores, nos encontraremos en el nuevo sistema. Sin embargo, aún queda por delante una larga etapa de ajuste "fino" (se debe prestar especial atención a la seguridad del nuevo sistema, porque LFS por defecto parece bastante desprotegido, como cualquier sistema operativo recién instalado). Pero recogido con mis propias manos. versión de linux ya lo tienes.

PD

Gerard Beekmans no es el único que pensó en crear su propio Linux. Otro proyecto, BYOLinux, dirigido por Jonathan Thorpe, ha dejado de desarrollarse, aunque la documentación que escribió sigue siendo relevante hoy en día, pero no es tan detallada como el libro LFS y no está traducida al ruso. La principal diferencia entre el método de John es que la biblioteca glibc se transfiere del sistema principal al secundario sin recompilar; esto no es tan eficiente, pero evita muchos problemas durante el ensamblaje; Algunos usuarios de FreeBSD también quieren sentirse diseñadores de sistemas operativos.

Ahora bien, esto es bastante posible: en http://ezine.daemonnews.org/200302/fbsdscratch.html hay un artículo sobre Construcción de FreeBSD desde todo el código fuente, desde distribuciones hasta ports, y con un método que no es similar a la "reconstrucción" habitual del sistema, pero sí similar al método de Gerard Beekmans. Bueno, ahora tienes el tuyo propio. sistema único, creado en Linux. Si surgen problemas, busque su solución en el libro LFS, allí se describe todo en detalle. También recomiendo descargar desde el portal http://www.tldp.org manuales de linux La Guía del administrador de red, aunque no se relaciona directamente con LFS, será útil en la etapa de configuración del sistema. No olvides que cada programa también viene con varias páginas de manual e información, también diseñadas para hacer la vida más fácil a los usuarios de Linux.

1. Libro LFS en ruso – http://multilinux.sakh.com/lfs.
2. El portal oficial del proyecto LFS es http://www.linuxfromscratch.org.
3. Portal ByoLinux – http://www.byolinux.org.
4. Artículo sobre FreeBSD desde cero: http://ezine.daemonnews.org/200302/fbsdscratch.html.
5. Artículo recopilatorio núcleos de Linux– http://vikos.lrn.ru/MyLDP/kernel/kompil-2-6.html.
6. Bayrak A. Revisión de Knoppix 3.7 Edición rusa. - Revista " Administrador del sistema", N° 3, marzo de 2005 – 4-6 p. ().

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 trabajar en diferentes áreas de la memoria y, al menos, trabajar con dispositivos por turnos. También debe brindar la capacidad de transmitir mensajes de una tarea a otra.

Otro sistema operativo, si está disponible memoria a largo plazo, debe proporcionar acceso a él: es decir, proporcionar todas las funciones para trabajar con 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 núcleo 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 ( junta de desarrollo, segunda computadora), o su emulador. 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.

Si realmente lo deseas, puedes incluso mirar el código fuente del antiguo kernel de los sistemas NT (Windows), por separado (que está publicado por Microsoft, con comentarios y varios tipos de materiales de referencia), y en combinación con el antiguo sistema operativo (filtrado).

uno de las mejores maneras Ahorrar tiempo en cualquier actividad es crear un sistema para ello. Su ventaja es que al automatizar y optimizar tu trabajo, te vuelves más productivo y tienes más tiempo para otras tareas que son importantes para ti.

Un sistema es un método, procedimiento o rutina que se crea para realizar una actividad repetitiva utilizando una estrategia. Los sistemas le permiten gestionar su trabajo y su vida de forma más eficiente.

A continuación se muestran algunas áreas de la vida para las que puede crear su propio sistema:

• Sistematización.
• Sistematización.
• Sistematización de tareas para blogs.
• Sistematización de la limpieza del hogar.
• Sistematización de rutinas matutinas y nocturnas.
• Sistematización del procesamiento de correos electrónicos.
• Sistematización de tareas laborales.

Los siguientes cinco pasos le permitirán crear su propio sistema para casi cualquier actividad.

hacer inventario

Empiece por identificar las acciones que realiza habitualmente, tanto en casa como en el trabajo. Analiza tu día y mira todas las actividades que componen tu agenda diaria. Por ejemplo: preparación matutina para el trabajo o la escuela, preparar a los niños para la escuela, viajar al trabajo, responder preguntas correos electrónicos Y llamadas telefonicas, escribir informes, salir a correr por la noche, preparar la cena, escribir una publicación en un blog, promocionar su libro, etc.

Vaya a la lista de tareas específicas del elemento seleccionado y pregúntese lo siguiente:

• ¿Cómo lo haces ahora?
• ¿Sientes que lo estás haciendo de la manera más eficiente posible?
• ¿Dónde pierdes mucho tiempo?
• ¿Dónde estás perdiendo dinero?
• ¿Qué acciones te molestan más?
• ¿Qué es lo que no se está haciendo actualmente lo más rápido posible?
• ¿Qué hay que optimizar?

Según su inventario, elija una actividad para organizar.

Analiza lo que estás haciendo actualmente

Realiza las acciones que quieras organizar siguiendo el procedimiento normal (es decir, compórtate como de costumbre). Documente el proceso registrando todo lo siguiente:

• ¿Qué pasos estás tomando?
• ¿Qué herramientas utilizas?
• ¿Dónde están los obstáculos (donde se pierde tiempo, se producen retrasos constantemente, algo sale mal)?
• ¿Qué te decepciona?
• ¿Cuánto tiempo lleva completar esta actividad?
• ¿Cuánto cuesta?
• ¿Qué resultados estás obteniendo?

Después de esto, revise el documento recibido y estúdielo.

Planificar un nuevo proceso

Un sistema, como dijimos anteriormente, es un proceso que usted crea para optimizar las tareas y aumentar la eficiencia. Echa un vistazo a tu documento y a la actividad que deseas optimizar y hazte las siguientes preguntas:

• ¿Qué resultado quieres lograr al realizar esta actividad? ¿Qué objetivo estás tratando de lograr? ¿Cuál es el resultado ideal?
• ¿Son necesarios todos los pasos que estás dando? ¿Se pueden eliminar algunos de ellos?
• ¿Está realizando los pasos en la secuencia más eficiente? ¿Los resultados serían diferentes si cambiaras el orden de los pasos?
• ¿Cómo se puede hacer todo esto más rápido?
• ¿Puedes crear una lista de verificación, un gráfico, mapa mental o un guión para esta actividad?
• ¿Es posible automatizar algunos pasos o todo el proceso? ¿Existe algún programa que pueda usarse para esto?
• ¿Se pueden delegar algunos pasos o todo el proceso?
• ¿Es necesario actualizar las herramientas que utiliza?

Ahora escribe tu nuevo sistema, enumerando cada paso en detalle.

ejecutar el plan

Una vez que tenga un plan, debe ponerlo en práctica de inmediato. Es posible que primero necesite ayuda de otras personas o que necesite comprar software o actualizar herramientas.

Es hora de ejecutar el proceso y probar su funcionamiento. Hazlo y presta atención a los resultados. Hágase las siguientes preguntas:

• ¿Obtuviste los resultados que querías?
• ¿Qué funciona?
• ¿Qué no funciona?
• ¿Cuánto tiempo has ahorrado?
• ¿Cuánto cuesta todo esto? Teniendo en cuenta los resultados, ¿es eficaz el sistema?
• ¿Estás logrando tu objetivo de la manera más fácil?
• ¿Hay lagunas en el proceso?
• ¿Es posible optimizar aún más el proceso?

Realice los ajustes y cambios necesarios. Actualice su sistema hasta que obtenga los resultados que desea.

Mejorar continuamente el sistema.

Vale la pena monitorear constantemente su sistema, porque en un mundo que cambia rápidamente, puede quedar obsoleto con la misma rapidez. Pregúntese siempre si se necesitan mejoras.

• ¿El sistema funciona como debería?
• ¿Se puede reducir el coste del sistema?
• ¿Puedes hacer que el sistema sea aún más eficiente?
• ¿Puedes simplificar el sistema para obtener mejores resultados?

Montar un sistema siempre requiere una inversión de tiempo. Pero si inicialmente gastas más de lo que gastas habitualmente, terminarás ahorrándolo significativamente. Y minimice el impacto del estrés operativo.

¡Te deseamos mucha suerte!