Sistema operativo tipo UNIX: escribiendo el kernel en C. ¡Escribamos el kernel! Creando el kernel del sistema operativo más simple

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 este momento, el BIOS se copia a sí mismo en la RAM para un acceso más 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 busca un número mágico para determinar si el dispositivo es de arranque (los bytes 511 y 512 del primer sector deben ser iguales a 0xAA55).

Cuando el BIOS encuentra un dispositivo de arranque, copia el contenido del primer sector del dispositivo en la RAM, comenzando en 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 de arranque de Linux y arranca 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 del código fuente sean globales. 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 con los 8 bits habituales, sino con 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 escribiremos este carácter en el primer byte y el valor 0x02 en el segundo. 0 significa fondo negro, 2 significa color de texto verde.

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) ) . El asterisco (*) es un carácter 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á un 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:

Un artículo sobre cómo crear tú mismo un núcleo semántico para que tu tienda online esté en las primeras posiciones de los resultados de los buscadores. El proceso de selección de palabras clave no es tan sencillo. Requerirá cuidado y una cantidad relativamente grande de tiempo. Pero si está listo para seguir adelante y hacer crecer su negocio, este artículo es para usted.Habla en detalle sobre los métodos para recopilar palabras clave, así como sobre qué herramientas pueden ayudarle con esto.

La respuesta es banal: para que los motores de búsqueda "amen" el sitio. Y para que cuando los usuarios soliciten palabras clave específicas, se devuelva su recurso.

¡Y la formación de un núcleo semántico es el primer paso, pero muy importante y seguro, hacia la meta!

El siguiente paso es crear una especie de esqueleto, lo que significa distribuir "claves" seleccionadas en determinadas páginas del sitio. Y sólo después de esto debería pasar a un nuevo nivel: escribir e implementar artículos y etiquetas.

Tenga en cuenta que la red presenta varias opciones para definir el concepto de núcleo semántico (en lo sucesivo, SK).

En general, son similares y si resumimos todo, podemos formar lo siguiente: un conjunto de palabras clave (así como frases y formularios que las acompañan) para la promoción de un sitio web. Estas palabras caracterizan con precisión el enfoque del sitio, reflejan los intereses de los usuarios y corresponden a las actividades de la empresa.

Nuestro artículo proporciona un ejemplo de cómo formar un lenguaje estratégico para una tienda online de ropa de cama. Todo el proceso se divide en cinco etapas sucesivas.

1) Recopilar consultas básicas

En este caso, estamos hablando de todas las frases que corresponderán al rumbo de las actividades de la tienda. Por eso, es muy importante pensar con la mayor precisión posible aquellas frases que mejor caracterizan los productos presentados en el catálogo.

Por supuesto, esto a veces puede resultar difícil de hacer. Pero la columna derecha de Wordstat.Yandex vendrá al rescate: indica las frases que los usuarios ingresan con mayor frecuencia cuando usan la frase que ha elegido.

Para obtener los resultados, ingrese la frase que necesita en la línea de servicio y haga clic en el botón "Seleccionar".

Para no copiar todas las solicitudes manualmente, recomendamos utilizar la extensión Wordstat Helper, creada específicamente para los navegadores Mozilla Firefox y Google Chrome. Esta adición simplificará enormemente el trabajo con la selección de palabras. Cómo funciona: vea la captura de pantalla a continuación.

Guarde las palabras seleccionadas en un documento separado. Luego haz una lluvia de ideas y agrega las frases que se te ocurran.

2) Cómo ampliar el SY: tres opciones

La primera etapa es relativamente simple. Aunque requerirá atención de tu parte. Pero el segundo es la actividad cerebral activa. Después de todo, cada frase seleccionada individualmente es la base de un futuro grupo de consultas de búsqueda por las que avanzará.

Para crear un grupo de este tipo, debe utilizar:

• sinónimos;
• parafraseando.

Para evitar la “descarga” en esta etapa, utilice aplicaciones o servicios especiales. Cómo hacer esto se describe en detalle a continuación.

Cómo ampliar sus palabras clave con el Planificador de palabras clave de Google

vamos a la temática capítulo (se llama Keyphrase Planner) y escribe aquellas frases que caracterizan con mayor precisión el grupo de consultas que te interesan. No toque otros parámetros y haga clic en el botón “Obtener…”.

Después de eso, simplemente descargue los resultados.

Cómo expandir SA usando Serpstat (ej. Prodvigator)

También puedes utilizar otro servicio similar que realiza análisis de la competencia. Después de todo, sus competidores son el mejor lugar para obtener las palabras clave que necesita.

Servicio Serpstat (ej. Prodvigator) le permite determinar con precisión qué consultas clave sus competidores se han convertido en líderes en los motores de búsqueda. Aunque existen otros servicios, tú decides cuál utilizar.

Para seleccionar consultas de búsqueda, necesita:

• ingrese una solicitud;
• indique la región de promoción que le interesa;
• haga clic en el botón "Buscar";
• y cuando esté completo seleccione la opción “Consultas de búsqueda”.

Después de eso, haga clic en el botón "Exportar tabla".

Cómo ampliar la sintaxis usando Key Collector/Slovoeb

¿Tienes una tienda grande con una gran cantidad de productos? En tal situación necesitarás un servicio. Coleccionista de llaves.

Sin embargo, si recién está comenzando a aprender la ciencia de seleccionar palabras clave y formar un núcleo semántico, le recomendamos que preste atención a otro servicio, con un nombre disonante. cabrón de palabras . Su ventaja es que es completamente gratis.

Descargue la aplicación, vaya a la configuración de Yandex.Direct e ingrese el nombre de usuario/contraseña de su buzón de Yandex.

Después de esto:

• abrir un nuevo proyecto;
• haga clic en la pestaña Datos;
• allí haz clic en la opción Agregar frases;
• indique la región de promoción que le interesa;
• ingrese las consultas que se generaron anteriormente.

Después de esto, comience a recopilar FL de Wordstat.Yandex. Para hacer esto:

• ir a la sección “Recopilación de datos”;
• luego, debe seleccionar la sección "Recopilación por lotes de palabras de la columna de la izquierda";
• Aparecerá una nueva ventana en su pantalla;
• en él, haga lo que se indica en la captura de pantalla a continuación;

Tenga en cuenta que Key Collector es una herramienta excelente para proyectos grandes y voluminosos y con su ayuda es fácil organizar la recopilación de datos estadísticos sobre servicios que analizan el "trabajo" de los sitios de la competencia. Por ejemplo, dichos servicios incluyen los siguientes: SEMrush, SpyWords, Serpstat (por ejemplo, Prodvigator) y muchos otros.

3) Eliminar las “llaves” innecesarias

Entonces, se ha formado la base. El volumen de “llaves” recopiladas es más que sustancial. Pero si las analizas (en este caso, simplemente léelas atentamente), descubrirás que no todas las palabras recopiladas se corresponden exactamente con la temática de tu tienda. Por lo tanto, los usuarios "no objetivo" los utilizarán para acceder al sitio.

Es necesario eliminar esas palabras.

Aquí hay otro ejemplo. Entonces, en el sitio usted vende ropa de cama, pero su surtido no incluye simplemente la tela con la que se puede coser dicha ropa. Por lo tanto, es necesario eliminar todo lo que toque las telas.

Por cierto, será necesario generar manualmente una lista completa de dichas palabras. Ninguna cantidad de “automatización” ayudará aquí. Naturalmente, llevará bastante tiempo y, para no perderse nada, recomendamos realizar una sesión de lluvia de ideas completa.

Observemos los siguientes tipos y tipos de palabras que serán irrelevantes para las tiendas online:

• nombre y mención de tiendas competidoras;
• ciudades y regiones en las que no opera y donde no entrega mercancías;
• todas las palabras y frases que contengan “gratis”, “antiguo” o “usado”, “descargar”, etc.;
• el nombre de una marca que no está representada en su tienda;
• “claves” que contienen errores;
• palabras repetidas.

Ahora te diremos cómo eliminar todas las palabras que no necesitas.

crear una lista

Abra el servicio Slovoeb, seleccione la sección "Datos" y luego vaya a la pestaña "Palabras de parada" y "escriba" las palabras seleccionadas manualmente en ella. Curiosamente, puedes escribir palabras manualmente o simplemente cargar un archivo con ellas (si has preparado uno).

De esta forma, podrás eliminar rápidamente de tu lista las palabras vacías que no se correspondan con la temática y características de la tienda.

filtro rápido

Ha recibido una especie de SYA en blanco. Analízalo cuidadosamente y comienza a eliminar palabras innecesarias manualmente. El mismo servicio Slovoeb ayudará a optimizar la solución a este problema. Aquí está la secuencia de acciones que debe realizar:

• tome la primera palabra innecesaria de su lista, por ejemplo, que sea la ciudad de Kiev;
• ingréselo en la búsqueda (número 1 en la pantalla);
• marcar las líneas apropiadas;
• haciendo clic derecho sobre ellos, elimínelos;
• presione Enter en el campo de búsqueda para volver a la lista original.

Repita estos pasos tantas veces como sea necesario hasta que haya revisado la mayor lista posible de palabras.

4) Solicitudes grupales

Para comprender cómo distribuir palabras en páginas específicas, debe agrupar todas las consultas que haya seleccionado. Para ello es necesario formar los llamados clusters semánticos.

Este concepto significa un grupo de "claves" similares en tema y significado, que se formaliza en forma de una estructura de varios niveles. Digamos que el grupo de primer nivel es la consulta de búsqueda "ropa de cama". Pero los grupos de segundo nivel serán las consultas de búsqueda "mantas", "cuadros" y similares.

En la mayoría de los casos, los grupos se identifican mediante una lluvia de ideas. Pero es importante tener un buen conocimiento del surtido, las características de su producto, pero también tener en cuenta cómo se construye la estructura de la competencia.

Lo siguiente a lo que debe prestar especial atención es que en el último nivel del clúster solo deben existir aquellas consultas que correspondan exactamente a la necesidad única de los clientes potenciales. Es decir, un tipo específico de bienes.

En este caso, el mismo servicio de Slovoeb y la opción de filtro rápido descrita anteriormente volverán a ayudarle. Le ayudará a ordenar las consultas de búsqueda en categorías específicas.

Para realizar esta clasificación es necesario seguir unos sencillos pasos. Primero, en la barra de búsqueda del servicio, ingresa la palabra clave que se utilizará en el nombre:

• categorías;
• página de destino, etc.

Por ejemplo, podría ser una marca de ropa de cama. En los resultados marca las frases que más te convengan y cópialas.

Aquellas frases que no necesitas, simplemente selecciona con el botón derecho del ratón y elimina.

En el lado derecho del menú de servicio, cree un nuevo grupo y asígnele el nombre adecuado. Por ejemplo, el nombre de la marca.

Para transferir las frases que ha seleccionado a esta parte de la pestaña, debe seleccionar la línea Datos y hacer clic en la inscripción Agregar frases. Para obtener más detalles, consulte la captura de pantalla.

Al presionar Enter en la columna de búsqueda, volverá a la lista original de palabras. Siga el procedimiento descrito con todas las demás solicitudes.

El sistema mostrará todas las frases seleccionadas en orden alfabético, lo que facilita el trabajo con ellas: podrá determinar fácilmente qué se puede eliminar exactamente. O agrupar palabras en un grupo específico.

Añadamos que la agrupación manual también requiere una cantidad de tiempo suficiente. Especialmente si hablamos de demasiadas frases clave. Por lo tanto, recomendamos utilizar programas pagos automatizados. Estos incluyen:

• Coleccionista de llaves;
• Rush-Análisis;
• Just-Magic y otros.

También hay un script Devaka.ru completamente gratuito. Por cierto, tenga en cuenta que a menudo es necesario combinar algunos tipos de consultas.

Ya que no tiene sentido acumular una gran cantidad de categorías en el sitio, diferenciándose sólo en nombres como "Ropa de cama hermosa" y "Ropa de cama de moda".

Para determinar la importancia de cada frase clave individual para una categoría en particular, simplemente transfiéralas al planificador de Google, como se muestra en la captura de pantalla.

De esta manera, puede determinar qué tan popular es una consulta de búsqueda en particular. Todos ellos se pueden dividir en tres categorías, según el uso específico:

• frecuencia alta;
• baja frecuencia;
• frecuencia media;
• e incluso micro-baja frecuencia.

Sin embargo, es importante entender que no existen números exactos que indiquen si una solicitud pertenece a un grupo específico. Aquí debe centrarse en el tema tanto del sitio en sí como de la solicitud. En un caso particular, una solicitud con una frecuencia de hasta 800 por mes puede considerarse de baja frecuencia. En otra situación, una solicitud con una frecuencia de hasta 150 se considerará de alta frecuencia.

Las consultas más frecuentes de todas las seleccionadas se incluirán posteriormente en las etiquetas. Pero se recomienda utilizar los de menor frecuencia para optimizar páginas de tienda específicas para ellos. Dado que habrá poca competencia entre dichas consultas, basta con completar dichas subsecciones con descripciones de texto de alta calidad para que las páginas aparezcan en los primeros puestos de los resultados de búsqueda.

Todas las acciones anteriores te permitirán crear una estructura clara que tendrá:

• todas las categorías necesarias e importantes: para visualizar el "esqueleto" de su tienda, utilice un servicio adicional Xmente;
• páginas de destino;
• páginas que proporcionan información importante para el usuario, por ejemplo, con información de contacto, una descripción de las condiciones de entrega, etc.

Cómo ampliar el núcleo semántico: un método alternativo

Con el desarrollo del sitio y la ampliación de la tienda, la SA aumentará. Para ello, es necesario realizar un seguimiento y recopilar frases clave dentro de cada grupo. Esto simplifica y acelera significativamente el proceso de ampliación del lenguaje estratégico.

Para recopilar solicitudes similares y proporcionar sugerencias, utilice servicios adicionales, que incluyen:

• Serpstat (ej. Prodvigator);
• Ubersugerir;
• Herramienta para palabras clave;
• y otros.

La siguiente captura de pantalla muestra cómo utilizar el servicio Promotor.

Qué hacer después de completar nuestras instrucciones

Entonces, para crear un FL de forma independiente para una tienda en línea, debe realizar una serie de acciones secuenciales.

Todo comienza con la selección de palabras clave que sólo podrán utilizarse en la búsqueda de sus productos y que posteriormente se convertirán en el principal grupo de consultas. A continuación, utilice las herramientas de los motores de búsqueda para ampliar el núcleo semántico. También se recomienda analizar los sitios de la competencia para este fin.

Los próximos pasos serán:

• análisis de todas las consultas de búsqueda seleccionadas;
• eliminar solicitudes que no se ajusten al propósito de su tienda;
• solicitudes de agrupación;
• formación de la estructura del sitio;
• Seguimiento constante de las consultas de búsqueda y ampliación de los sinónimos.

El método de selección de FL para una tienda en línea presentado en este artículo está lejos de ser el único correcto y correcto. Hay otros. Pero intentamos presentarle la forma más conveniente.

Naturalmente, para la promoción también son importantes indicadores como la calidad de las descripciones del texto, los artículos, las etiquetas y la estructura de la tienda. Pero hablaremos de esto en un artículo aparte.

Para no perderse artículos nuevos y útiles, ¡asegúrese de suscribirse a nuestro boletín!

¿Aún no has completado la formación? Regístrate ahora mismo y en 4 días tendrás tu propia web.

Si no puedes hacerlo tú mismo, ¡lo haremos por ti!

Desarrollar un kernel no se considera, con razón, una tarea fácil, pero cualquiera puede escribir un kernel simple. Para experimentar la magia del hackeo del kernel, sólo necesita seguir algunas convenciones y dominar el lenguaje ensamblador. En este artículo le mostraremos cómo hacer esto.

Esta es una traducción de dos artículos de Arjun Sreedharan:

¡Hola Mundo! Escribamos un kernel que arranque a través de GRUB en sistemas compatibles con x86. Nuestro primer kernel mostrará un mensaje en la pantalla y se detendrá allí.

Cómo arrancan las máquinas x86

Antes de pensar en cómo escribir un kernel, veamos cómo arranca una computadora y transfiere el control al kernel. La mayoría de los registros del procesador x86 tienen valores específicos después del arranque. El registro del puntero de instrucción (EIP) contiene la dirección de la instrucción que ejecutará el procesador. Su valor codificado es 0xFFFFFFF0. Es decir, el procesador x86 siempre iniciará la ejecución desde la dirección física 0xFFFFFFF0. Estos son los últimos 16 bytes del espacio de direcciones de 32 bits. Esta dirección se llama vector de reinicio.

La tarjeta de memoria contenida en el chipset indica que la dirección 0xFFFFFFF0 se refiere a una parte específica del BIOS y no a la RAM. Sin embargo, el BIOS se copia a sí mismo en la RAM para un acceso más rápido; este proceso se llama "sombreado", que crea una instantánea. Entonces, la dirección 0xFFFFFFF0 solo contendrá una instrucción para saltar a la ubicación en la memoria donde el BIOS se ha copiado.

Entonces, el BIOS comienza a ejecutarse. Primero, busca dispositivos desde los que pueda arrancar en el orden especificado en la configuración. Comprueba los medios en busca de un "número mágico" que distinga los discos de arranque de los normales: si los bytes 511 y 512 en el primer sector son 0xAA55, entonces el disco es de arranque.

Una vez que el BIOS encuentra el dispositivo de arranque, copiará el contenido del primer sector en la RAM, comenzando en la dirección 0x7C00, y luego moverá la ejecución a esa dirección y comenzará a ejecutar el código que acaba de cargar. Este código se llama gestor de arranque.

El gestor de arranque carga el kernel en la dirección física 0x100000. Esto es lo que utilizan los kernels x86 más populares.

Todos los procesadores compatibles con x86 comienzan en un modo primitivo de 16 bits llamado "modo real". El gestor de arranque GRUB cambia el procesador al modo protegido de 32 bits configurando el bit inferior del registro CR0 en uno. Por lo tanto, el kernel comienza a cargarse en modo protegido de 32 bits.

Tenga en cuenta que GRUB, en el caso de los kernels de Linux, selecciona el protocolo de arranque apropiado y carga el kernel en modo real. Los kernels de Linux cambian automáticamente al modo protegido.

¿Qué necesitamos?

• Computadora compatible con x86 (obviamente)
• linux
• ensamblador NASM,
• ld (enlazador GNU),
• COMIDA.

Puede encontrar el código fuente de lo que deberíamos obtener aquí.

Punto de entrada del lenguaje ensamblador

Por supuesto, nos gustaría escribir todo en C, pero no podremos evitar por completo el uso del ensamblador. Escribiremos un pequeño archivo en ensamblador x86 que se convertirá en el punto de partida de nuestro kernel. Todo lo que hará el código ensamblador será llamar a una función externa que escribiremos en C y luego detener la ejecución del programa.

¿Cómo podemos hacer que el código ensamblador sea el punto de partida de nuestro núcleo? Usamos un script de vinculación que vincula archivos objeto y crea el archivo ejecutable del kernel final (explicaré más a continuación). En este script indicaremos directamente que queremos que nuestro binario se descargue en la dirección 0x100000. Esta es la dirección, como ya escribí, en la que el gestor de arranque espera ver el punto de entrada al kernel.

Aquí está el código ensamblador.

núcleo.asm

bits 32 sección. texto inicio global kmain externo comenzar : mov esp, espacio_pila llamar a kmain sección. bs resb 8192 espacio_pila:

La primera instrucción de 32 bits no es un ensamblador x86, sino una directiva NASM que le indica que genere código para que el procesador se ejecute en modo de 32 bits. Esto no es necesario para nuestro ejemplo, pero es una buena práctica indicarlo explícitamente.

La segunda línea comienza la sección de texto, también conocida como sección de código. Todo nuestro código irá aquí.

global es otra directiva NASM, declara que los símbolos en nuestro código son globales. Esto permitirá al vinculador encontrar el símbolo de inicio, que sirve como nuestro punto de entrada.

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

Luego viene la función de inicio, que llama a kmain y detiene el procesador con la instrucción hlt. Las interrupciones pueden activar el procesador después de hlt, por lo que primero deshabilitamos las interrupciones con la instrucción cli (borrar interrupciones).

Idealmente, deberíamos asignar cierta cantidad de memoria para la pila y apuntarle el puntero de la pila (especialmente). GRUB parece hacer esto por nosotros de todos modos, y en este punto el puntero de la pila ya está configurado. Sin embargo, por si acaso, asignemos algo de memoria en la sección BSS y apuntemos el puntero de la pila a su comienzo. Usamos la instrucción resb: reserva la memoria especificada en bytes. Luego se deja una marca que indica el borde del fragmento de memoria reservado. Justo antes de llamar a kmain, la instrucción mov dirige el puntero de pila (esp) a esta área.

Núcleo en C

En el archivo kernel.asm llamamos a la función kmain(). Entonces, en código C, la ejecución comenzará desde allí.

núcleo.c

vacío kmain(vacío) const char * str = "mi primer núcleo"; char * vidptr = (char * ) 0xb8000 ; int sin signo yo = 0; int sin signo j = 0; mientras(j< 80 * 25 * 2 ) { vidptr[j] = " "; vidptr[j+1] = 0x07; j = j + 2 ; j = 0; mientras (cadena [j]! = "\0") ( vidptr[i] = cadena[j]; vidptr[i+1] = 0x07; yo = yo + 2 ; devolver ;

Todo lo que nuestro kernel hará será borrar la pantalla e imprimir la línea my first kernel.

Primero, creamos un puntero vidptr que apunta a la dirección 0xb8000. En modo protegido, este es el comienzo de la memoria de video. La memoria de la pantalla de texto es simplemente parte del espacio de direcciones. Se asigna una sección de memoria para E/S de pantalla, que comienza en la dirección 0xb8000; en ella se colocan 25 líneas de 80 caracteres ASCII.

Cada carácter en la memoria de texto está representado por 16 bits (2 bytes), en lugar de los 8 bits (1 byte) a los que estamos acostumbrados. El primer byte es el código ASCII del carácter y el segundo byte es el byte de atributo. Esta es una definición del formato de carácter, incluido su color.

Para generar el carácter s verde sobre negro, debemos colocar s en el primer byte de la memoria de video y el valor 0x02 en el segundo byte. 0 aquí significa fondo negro y 2 significa color verde. Usaremos un color gris claro, su código es 0x07.

En el primer ciclo while, el programa llena las 25 líneas de 80 caracteres con caracteres vacíos con el atributo 0x07. Esto borrará la pantalla.

En el segundo bucle while, la cadena terminada en nulo de mi primer núcleo se escribe en la memoria de vídeo y cada carácter recibe un byte de atributo de 0x07. Esto debería generar una cadena.

Disposición

Ahora debemos compilar kernel.asm en un archivo objeto usando NASM y luego usar GCC para compilar kernel.c en otro archivo objeto. Nuestra tarea es vincular estos objetos en un kernel ejecutable adecuado para cargar. Para hacer esto, necesitaremos escribir un script para el vinculador (ld), que le pasaremos como argumento.

enlace.ld

FORMATO_SALIDA (elf32 - i386) ENTRADA (inicio) SECCIONES 0x100000; Texto: (*(.texto)) Datos: (*(.datos)) Bss: (*(.bss))

Aquí primero configuramos el formato (OUTPUT_FORMAT) de nuestro archivo ejecutable en ELF (formato ejecutable y vinculable) de 32 bits, un formato binario estándar para sistemas basados ​​en Unix para la arquitectura x86.

ENTRY toma un argumento. Especifica el nombre del símbolo que servirá como punto de entrada del archivo ejecutable.

SECCIONES es la parte más importante para nosotros. Aquí definimos el diseño de nuestro archivo ejecutable. Podemos definir cómo se combinarán las diferentes secciones y dónde se ubicará cada una de ellas.

Entre las llaves que siguen a la expresión SECCIONES, el punto indica el contador de ubicación. Se inicializa automáticamente a 0x0 al comienzo del bloque SECCIONES, pero se puede cambiar asignando un nuevo valor.

Escribí anteriormente que el código del kernel debería comenzar en la dirección 0x100000. Por eso asignamos al contador de posición el valor 0x100000.

Eche un vistazo a line.text: ( *(.text) ). El asterisco aquí especifica una máscara que puede coincidir con cualquier nombre de archivo. En consecuencia, la expresión *(.text) significa todas las secciones .text de entrada en todos los archivos de entrada.

Como resultado, el vinculador fusionará todas las secciones de texto de todos los archivos objeto en la sección de texto del archivo ejecutable y lo colocará en la dirección especificada en el contador de posición. La sección de código de nuestro ejecutable comenzará en la dirección 0x100000.

Después de que el vinculador produzca una sección de texto, el valor del contador de posición será 0x1000000 más el tamaño de la sección de texto. De manera similar, las secciones de datos y bss se fusionarán y se colocarán en la dirección proporcionada por el contador de posición.

GRUB y arranque múltiple

Ahora todos nuestros archivos están listos para construir el kernel. Pero como iniciaremos el kernel usando GRUB, queda un paso más.

Existe un estándar para cargar diferentes kernels x86 utilizando un gestor de arranque. Esto se denomina "especificación de arranque múltiple". GRUB sólo cargará kernels que coincidan con él.

Según esta especificación, el kernel puede contener un encabezado (encabezado de arranque múltiple) en los primeros 8 kilobytes. Este encabezado debe contener tres campos:

• magia- contiene el número "mágico" 0x1BADB002, mediante el cual se identifica el encabezado;
• banderas- este campo no es importante para nosotros, puedes dejarlo en cero;
• suma de control- suma de comprobación, debería dar cero si se agrega a los campos mágico y de banderas.

Nuestro archivo kernel.asm ahora tendrá este aspecto.

núcleo.asm

bits 32 sección. texto ; especificación de arranque múltiple alinear 4 dd 0x1BADB002; magia dd 0x00; banderas dd-(0x1BADB002 + 0x00); suma de control inicio global kmain externo comenzar : mov esp, espacio_pila llamar a kmain sección. bs resb 8192 espacio_pila:

La instrucción dd especifica una palabra doble de 4 bytes.

Ensamblando el núcleo

Entonces, todo está listo para crear un archivo objeto a partir de kernel.asm y kernel.c y vincularlos usando nuestro script. Escribimos en la consola:

El parámetro -c indica que no es necesario vincular el archivo después de la compilación. Lo haremos nosotros mismos:

$ ld - m elf_i386 - T enlace . ld-o kernel kasm. Bueno, kc. oh

Este comando ejecutará el vinculador con nuestro script y generará un ejecutable llamado kernel.

La piratería del kernel se realiza mejor en un entorno virtual. Para ejecutar el kernel en QEMU en lugar de GRUB, use el comando qemu-system-i386 -kernel kernel.

Configurando GRUB e iniciando el kernel

GRUB requiere que el nombre del archivo del kernel siga al kernel-<версия>. Así que cambiemos el nombre del archivo; llamaré al mío kernel-701.

Ahora colocamos el kernel en el directorio /boot. Esto requerirá privilegios de superusuario.

Deberá agregar algo como esto al archivo de configuración de GRUB grub.cfg:

Escribir un kernel con soporte para teclado y pantalla

Hemos completado el trabajo en un kernel mínimo que arranca mediante GRUB, se ejecuta en modo protegido e imprime una sola línea en la pantalla. Es hora de expandirlo y agregar un controlador de teclado que lea los caracteres del teclado y los muestre en la pantalla.

Puede encontrar el código fuente completo en el repositorio del autor en GitHub.

Nos comunicaremos con los dispositivos de E/S a través de puertos de E/S. Básicamente, son sólo direcciones en el bus de E/S. Hay instrucciones especiales del procesador para operaciones de lectura y escritura.

Trabajar con puertos: lectura y salida.

puerto_lectura: mov edx, [esp + 4] en al, dx puerto_escritura: mov edx, [esp + 4] mov al, [esp + 4 + 4] fuera dx, al

Se accede a los puertos de E/S mediante las instrucciones de entrada y salida incluidas en el conjunto x86.

En read_port, el número de puerto se pasa como argumento. Cuando el compilador llama a una función, envía todos los argumentos a la pila. El argumento se copia al registro edx mediante un puntero de pila. El registro dx son los 16 bits inferiores del registro edx. La instrucción in aquí lee el número de puerto proporcionado en dx y coloca el resultado en al . El registro al son los 8 bits inferiores del registro eax. Quizás recuerdes de la universidad que los valores devueltos por las funciones se pasan a través del registro eax. Entonces read_port nos permite leer desde puertos de E/S.

La función write_port funciona de manera similar. Tomamos dos argumentos: el número de puerto y los datos que se escribirán. La instrucción out escribe datos en un puerto.

Interrumpe

Ahora, antes de volver a escribir el controlador, debemos comprender cómo sabe el procesador que uno de los dispositivos ha realizado una operación.

La solución más sencilla es sondear los dispositivos: comprobar continuamente su estado en un círculo. Esto es, por razones obvias, ineficaz y poco práctico. Aquí es donde entran en juego las interrupciones. Una interrupción es una señal enviada al procesador por un dispositivo o programa que indica que ha ocurrido un evento. Al utilizar interrupciones, podemos evitar la necesidad de sondear dispositivos y solo responderemos a eventos que nos interesen.

Un chip llamado Controlador de Interrupciones Programable (PIC) es responsable de las interrupciones en la arquitectura x86. Maneja interrupciones y rutas de hardware y las convierte en interrupciones apropiadas del sistema.

Cuando el usuario hace algo con el dispositivo, se envía un pulso llamado Solicitud de interrupción (IRQ) al chip PIC. El PIC traduce la interrupción recibida en una interrupción del sistema y envía un mensaje al procesador de que es hora de interrumpir lo que está haciendo. El manejo adicional de interrupciones es tarea del núcleo.

Sin PIC, tendríamos que sondear todos los dispositivos presentes en el sistema para ver si ocurrió algún evento que involucrara a alguno de ellos.

Veamos cómo funciona esto con un teclado. El teclado se cuelga en los puertos 0x60 y 0x64. El puerto 0x60 envía datos (cuando se presiona un botón) y el puerto 0x64 envía estado. Sin embargo, necesitamos saber cuándo leer exactamente estos puertos.

Las interrupciones son útiles aquí. Cuando se presiona el botón, el teclado envía una señal PIC a través de la línea de interrupción IRQ1. El PIC almacena el valor de compensación guardado durante su inicialización. Agrega el número de línea de entrada a este relleno para formar un vector de interrupción. Luego, el procesador busca una estructura de datos llamada Tabla de descriptores de interrupciones (IDT) para darle al controlador de interrupciones la dirección correspondiente a su número.

Luego, el código en esa dirección se ejecuta y maneja la interrupción.

Establecer IDT

estructura IDT_entry( unsigned short int offset_lowerbits; selector int corto sin firmar; carácter cero sin firmar; carácter sin firmar type_attr; unsigned short int offset_higherbits; estructura IDT_entry IDT [IDT_SIZE]; vacío idt_init(vacío) dirección_teclado larga sin firmar; dirección_idt larga sin firmar; idt_ptr largo sin firmar [2]; dirección_teclado = (largo sin firmar) manejador_teclado; IDT[0x21]. offset_lowerbits = dirección_teclado & 0xffff; IDT[0x21]. selector = 0x08; /* KERNEL_CODE_SEGMENT_OFFSET */ IDT[0x21]. cero = 0; IDT[0x21]. type_attr = 0x8e; /* INTERRUPT_GATE */ IDT[0x21]. offset_higherbits = (dirección_teclado y 0xffff0000) >> 16; write_port(0x20, 0x11); write_port(0xA0, 0x11); write_port(0x21, 0x20); write_port(0xA1, 0x28); write_port(0x21, 0x00); write_port(0xA1, 0x00); write_port(0x21, 0x01); write_port(0xA1, 0x01); write_port(0x21, 0xff); write_port(0xA1, 0xff); idt_address = (largo sin firmar) IDT; idt_ptr[0] = (tamaño de(estructura entrada_IDT) * IDT_SIZE) + ((dirección_idt& 0xffff) << 16 ) ; idt_ptr[ 1 ] = dirección_idt>> 16 ; cargar_idt(idt_ptr) ; }

IDT es una matriz de estructuras IDT_entry. Más adelante discutiremos cómo vincular una interrupción de teclado a un controlador, pero ahora veamos cómo funciona el PIC.

Los sistemas x86 modernos tienen dos chips PIC, cada uno con ocho líneas de entrada. Los llamaremos PIC1 y PIC2. PIC1 recibe IRQ0 a IRQ7 y PIC2 recibe IRQ8 a IRQ15. PIC1 usa el puerto 0x20 para comandos y 0x21 para datos, y PIC2 usa el puerto 0xA0 para comandos y 0xA1 para datos.

Ambos PIC se inicializan con palabras de ocho bits denominadas palabras de comando de inicialización (ICW).

En modo protegido, ambos PIC primero deben emitir el comando de inicialización ICW1 (0x11). Le dice al PIC que espere a que lleguen tres palabras de inicialización más al puerto de datos.

Estos comandos pasarán el PIC:

• vector de sangría (ICW2),
• ¿Cuáles son las relaciones maestro/esclavo entre los PIC (ICW3)?
• información adicional sobre el medio ambiente (ICW4).

El segundo comando de inicialización (ICW2) también se envía a la entrada de cada PIC. Asigna offset, que es el valor al que sumamos el número de línea para obtener el número de interrupción.

Cuando empiezas a leer manuales sobre promoción de sitios web, todo comienza siempre con la creación de un núcleo semántico. Para los principiantes, este primer paso es el más difícil. Además del hecho de que no está claro de inmediato qué es este núcleo semántico, tampoco está claro cuál es su propósito y cómo crearlo correctamente.

En este artículo hablaremos de cómo crear correctamente el núcleo semántico de un sitio web. También aprenderás qué es y por qué se elabora. De hecho, no hay nada complicado ni difícil en el concepto de núcleo semántico. Vamos a resolverlo.

Nadie ha respondido nunca a la pregunta de qué es un núcleo semántico con palabras tan sencillas como lo haremos ahora. Entonces, el núcleo semántico de un sitio es una lista de frases clave mediante las cuales será promocionado. ¡Todo! Todo el significado del concepto está en una frase breve y clara. Y no hay necesidad de confundir nada con términos ingeniosos.

Si profundizamos en el término, entonces la semántica es una ciencia que se ocupa del contenido semántico de las unidades léxicas. En términos simples, la semántica es el estudio del significado de algo. En SEO, el núcleo semántico permite comprender el significado de todo el sitio, de cualquier sección del mismo o de un solo artículo. Esto queda claro para el motor de búsqueda, el visitante y todos los desarrolladores que trabajarán con el sitio.

El núcleo semántico, sin exagerar, es la base de toda promoción.

Cómo utilizar el núcleo semántico y por qué es necesario

Las funciones del núcleo semántico incluyen los siguientes aspectos de la promoción de un sitio web:

• La tarea más importante del núcleo semántico es comprender la estructura del sitio y su contenido. Mirándolo, puedes imaginar qué secciones tendrá el sitio y qué artículos habrá en cada sección. Y, por lo tanto, todas las deficiencias e inconvenientes de la estructura son inmediatamente visibles y pueden eliminarse en una etapa temprana.
• La semántica define el vector de contenido. Gracias a una mejor comprensión de la estructura del sitio, podrá seleccionar las palabras clave más relevantes y efectivas.
• El núcleo semántico es el plan de contenidos del sitio para los próximos años. Cada vez que necesites escribir artículos, puedes mirar allí y ver qué contenido se planeó y en qué sección del sitio debería estar.
• Si está planificando la promoción pagada de un sitio web, por ejemplo, mediante publicidad contextual, gracias al núcleo semántico podrá calcular el costo de la promoción.

Cómo hacer un núcleo semántico

Primero debe decidir de dónde obtendrá las frases clave para el núcleo. La mejor fuente para principiantes es el servicio Yandex WordPStat, que muestra cuántas veces al mes se ingresó una determinada consulta en la búsqueda de Yandex. WordStat tiene una variedad de funciones útiles, como filtrar consultas por región o dispositivo, ver consultas similares y mucho más. Y lo más importante es que es absolutamente gratis. Lea más sobre esto.

Puede utilizar una variedad de programas pagos, pero WordStat es más adecuado para principiantes debido a su simplicidad. Además, es adecuado no sólo para Runet, donde predomina Yandex. Si está promocionando un sitio dentro de la CEI, podrá utilizarlo de forma segura y las estadísticas en Google serán aproximadamente las mismas.

La esencia principal de la creación de un núcleo semántico es la colección de frases clave que de una forma u otra se ajustan al tema del sitio. Es necesario formalizarlos y sistematizarlos de alguna manera. Las hojas de cálculo como Excel, Google Doc o similares funcionan mejor para esto.

Y para una mayor eficiencia, se pueden agregar columnas adicionales a la tabla central semántica:

• Naturalmente, debería haber una columna con la frase clave en sí.
• Por supuesto, una columna con el nombre de la sección del sitio donde se utilizará esta frase.
• Puede agregar una columna con metaetiquetas de título y descripción e inmediatamente escribir un título y una descripción para el artículo utilizando una frase clave determinada. En primer lugar, inmediatamente quedará claro sobre qué escribir un artículo y, en segundo lugar, no tendrá que devanarse los sesos y pensar en ello.
• Puede crear una columna para indicar la cantidad de caracteres de un artículo para una frase clave determinada para comprender mejor el plan de contenido.
• Si hablamos de promoción con publicidad contextual, es necesario sumar el coste de la publicidad por cada solicitud.
• Todo lo que necesita se puede anotar de forma segura en la tabla del núcleo semántico. No existe una plantilla para esto, por lo que puedes hacer lo que quieras allí y cómodamente.

Errores comunes al crear un núcleo semántico

Ahora ya sabes cómo crear correctamente el núcleo semántico de un sitio web. Finalmente veamos qué errores comunes cometen los optimizadores novatos.

• Si el núcleo prevé dividir el sitio en categorías, entonces un error común es crear niveles profundos de anidamiento. Se recomienda el segundo nivel y no más. Es decir, puedes hacer un título, una subcategoría y listo, ya no es posible dividirlo en títulos más pequeños.
• Los principiantes pueden ignorar las consultas de baja frecuencia porque creen que usarlas es inapropiado y que de todos modos no generarán mucho tráfico. Pero en realidad es al revés. El nuevo sitio requiere consultas no competitivas y de baja frecuencia.
• No se puede confiar completamente en el servicio con el que se obtendrán las frases clave. Y esto es exactamente lo que hacen los novatos. Las máquinas pueden cometer errores y elegir lo incorrecto para usted.
• No es necesario crear un artículo por una frase de palabras clave. Si encuentra las frases "vender una casa con urgencia" y "vender una casa rápidamente", entonces no tiene sentido escribir dos artículos separados para ellas.

El componente más básico del sistema operativo Linux es el kernel. Es el núcleo el que actúa como vínculo intermedio entre los programas de usuario y el hardware de la computadora. En todas las distribuciones binarias, no necesitamos preocuparnos por ensamblar y configurar el kernel; los desarrolladores de la distribución ya han hecho todo por nosotros; Pero si queremos construir nuestra distribución nosotros mismos o instalar la última versión del kernel, tendremos que compilar el kernel manualmente.

La primera opción solía ser relevante para aquellos que querían obtener el máximo rendimiento de su equipo, pero ahora, dado el rápido aumento de la potencia de la computadora, el aumento en el rendimiento al ensamblar el kernel es completamente imperceptible. Hoy en día, construir el kernel puede ser necesario para los usuarios de distribuciones no binarias como Gentoo, aquellos que desean realizar algunos cambios en el kernel, obtener la última versión del kernel y, por supuesto, aquellos que desean comprender completamente el funcionamiento de su sistema.

En este tutorial veremos cómo construir el kernel de Linux. La primera parte le dirá cómo configurar el kernel en modo automático. Por así decirlo, para aquellos que no quieren entender cómo funciona, que solo necesitan obtener el producto terminado como resultado: el núcleo ensamblado. En la segunda parte veremos los pasos principales para ajustar manualmente el kernel, este proceso es complejo y lento, pero intentaré darte los conceptos básicos para que puedas resolverlo tú mismo.

Lo primero que debe hacer es descargar las fuentes del kernel. Lo mejor es tomar las fuentes del sitio web de su distribución, si las hay, o del sitio web oficial del kernel: kernel.org. Veremos la descarga de fuentes desde kernel.org.

Antes de descargar las fuentes, debemos decidir la versión del kernel que construiremos. Hay dos versiones principales de lanzamientos: estable (estable) y lanzamientos candidatos (rc); por supuesto, también hay versiones estables con un largo período de soporte (largo plazo), pero ahora es importante comprender las dos primeras. Los estables, por regla general, no son los más nuevos, pero ya son núcleos bien probados con una cantidad mínima de errores. Los de prueba, por el contrario, son los más nuevos, pero pueden contener varios errores.

Entonces, cuando hayamos decidido la versión, vayamos a kernel.org y descarguemos las fuentes necesarias en formato tar.xz:

Este artículo utilizará la versión más reciente actualmente inestable, 4.4.rc7.

También puede obtener las fuentes del kernel de Linux utilizando la utilidad git. Primero, creemos una carpeta para las fuentes:

mkdir fuentes_del_kernel

Para descargar la última versión, escriba:

clon de git https://github.com/torvalds/linux

Desempaquetando fuentes del kernel

Ahora tenemos fuentes guardadas. Vaya a la carpeta de origen:

cd linux_fuentes

O si descargó el kernel de Linux usando un navegador, primero cree esta carpeta y copie el archivo en ella:

mkdir linux_fuentes

cp ~/Descargas/linux* ~/linux_sources

Desempaquete el archivo usando la utilidad tar:

Y vaya a la carpeta con el kernel descomprimido, tengo esto:

cd linux-4.4-rc7/

Configuración automática de la compilación del kernel de Linux

Antes de comenzar a construir el kernel de Linux, tendremos que configurarlo. Como dije, primero veremos la opción automática para configurar la compilación del kernel. Su sistema ya tiene un núcleo ensamblado, configurado por el fabricante de la distribución y completamente funcional. Si no desea lidiar con las complejidades de la configuración del kernel, simplemente puede extraer las configuraciones ya preparadas del kernel anterior y generar configuraciones para el nuevo basándose en ellas. Únicamente tendremos que especificar los valores para los nuevos parámetros. Teniendo en cuenta que no ha habido ni están previstos cambios importantes en las últimas versiones, puede responder a todos estos parámetros como sugiere el script de configuración.

Los parámetros del kernel utilizado se almacenan en un archivo en /proc/config.gz. Descomprimamos la configuración y la coloquemos en nuestra carpeta usando la utilidad zcat:

Durante el proceso, deberá responder varias preguntas. Estas son nuevas opciones que han cambiado o se han agregado al nuevo kernel y soporte para nuevo hardware, en la mayoría de los casos puede elegir la opción predeterminada. Por lo general, hay tres opciones: y - habilitar, n - no incluir, m - habilitar como módulo. La opción recomendada está escrita en letras mayúsculas; para seleccionarla simplemente presione Enter.

Te llevará unos 10 minutos hacer todo. Una vez que se completa el proceso, el kernel está listo para ser compilado. A continuación veremos cómo configurar manualmente el kernel, pero puedes pasar directamente a construir el kernel de Linux.

Ajuste manual del kernel de Linux

La configuración manual es un proceso complejo y que requiere mucho tiempo, pero le permite comprender cómo funciona su sistema, qué funciones se utilizan y crear un kernel con el conjunto mínimo requerido de funciones que se adapte a sus necesidades. Consideraremos solo los pasos principales que deben completarse para que el kernel esté ensamblado y funcionando. Tendrá que descubrir todo lo demás usted mismo basándose en la documentación del kernel. Afortunadamente, la utilidad de configuración tiene documentación extensa para cada parámetro que lo ayudará a comprender qué otras configuraciones necesita habilitar.

Empecemos. Para iniciar el menú de configuración del kernel de Linux, escriba:

Esto abrirá una utilidad con la interfaz ncurses:

Como puede ver, algunas opciones requeridas ya están incluidas para facilitarle el proceso de configuración. Comencemos con la configuración más básica. Para habilitar el parámetro presione y, para habilitarlo por módulo - m, para moverse use las teclas de flecha e Enter, puede regresar al nivel superior con el botón Salir Abra el elemento Configuración general.

Aquí configuramos los siguientes parámetros:

Versión Local- La versión local del kernel aumentará en uno con cada compilación, para que los nuevos kernels no reemplacen a los antiguos durante la instalación, establezca el valor en 1.

Agregar automáticamente información de versión a la cadena de versión- agregue la versión al nombre del archivo del kernel.

Modo de compresión del núcleo- Modo de compresión de imágenes del kernel, el lzma más eficaz.

Nombre de host predeterminado- nombre de la computadora que se muestra en el mensaje de entrada

Colas de mensajes POSIX- soporte para colas POSTIX

Soporte para paginación de memoria anónima - habilitar el soporte de intercambio

Soporte del grupo de control- soporte para un mecanismo para distribuir recursos entre grupos de procesos

Soporte de Kernel.config Y Habilite el acceso a .config a través de /proc/config.gz- habilitar la capacidad de extraer la configuración del kernel a través de /proc/config.gz

Eso es todo, vuelve a subir un nivel y enciéndelo. Habilitar la compatibilidad con módulos cargables, Esta función permite cargar módulos externos, luego abrir su menú y habilitar:

soporte para deshabilitar módulos

apagado forzado de módulos

De nuevo volvemos y abrimos. Tipo de procesador y características:

Familia de procesadores (Opteron/Athlon64/Hammer/K8)- seleccione su tipo de procesador.

Volvamos de nuevo y vayamos a la sección. Sistemas de archivos, marque todas las casillas necesarias aquí.

Asegúrate de encenderlo El sistema de archivos Extendido 3 (ext3) Y El sistema de archivos Extendido 4 (ext4)- para admitir sistemas de archivos estándar ext3 y ext4

Regresamos y vamos a Hackeo de núcleos.

Aquí incluimos Tecla mágica SysRq- soporte para funciones mágicas SysRq, no es algo esencial, pero a veces es útil.

Queda un punto más, el más difícil, porque tendrás que superarlo tú mismo. Controladores de dispositivos- debe pasar por las secciones y habilitar los controladores para su equipo. Por equipos me refiero a discos duros no estándar, ratones, dispositivos USB, cámaras web, Bluetooth, adaptadores WIFI, impresoras, etc.

Puedes ver qué equipo está conectado a tu sistema con el comando:

Una vez que haya completado todos los pasos, el kernel estará listo para compilarse, pero probablemente tendrá mucho que resolver.

Para salir presione el botón un par de veces. Salida.

Construyendo el kernel de Linux

Una vez completados todos los preparativos, se puede construir el kernel de Linux. Para iniciar el proceso de compilación, ejecute:

hacer && hacer módulos

Ahora puedes ir a tomar un café o dar un paseo, porque el proceso de montaje es largo y tardará aproximadamente media hora.

Instalación de un nuevo kernel

Cuando el kernel y los módulos estén ensamblados, se podrá instalar el nuevo kernel. Puede copiar manualmente el archivo del kernel a la carpeta del gestor de arranque:

cp arch/x86_64/boot/bzImage /boot/vmlinuz

O simplemente puede ejecutar el script de instalación, instalando inmediatamente los módulos al mismo tiempo:

sudo make install && sudo make module_install

Después de la instalación, no olvide actualizar la configuración del cargador de arranque Grub:

grub-mkconfig -o /boot/grub/grub.cfg

Y reinicie la computadora para ver el nuevo kernel en acción:

Conclusiones

Eso es todo. En este artículo, analizamos en detalle cómo construir el kernel de Linux desde el código fuente. Esto será útil para cualquiera que quiera comprender mejor su sistema y para aquellos que quieran obtener la última versión del kernel en su sistema. Si tienes alguna duda, ¡pregunta en los comentarios!