Ir al contenido
wsn

Recursos para aprender ensamblador - Sistema de arranque casero.

Recommended Posts


assembly_language_for_IA_32_fig8t.jpg

 

Hola!
 
Este es un hilo sobre código de arranque de un PC hecho en ensamblador y disponible en la red, para el aprendizaje de modo autodidacta.
 
Mis intenciones con este tema.


Mis intenciones son que quiero compartir con ustedes unos enlaces, donde he encontrado información sobre un tema que desde hace un tiempo me llama la atención, concretamente un sistema de arranque simple con un micro kernel casero y siempre gracias a los compañeros de la red que comparten la información necesaria para aprender algo tan complicado como es el ensamblador.
 
Yo veo algunas ventajas entre el ensamblador y los ordenadores antiguos y es que los PC antiguos tienen puertos muy asequibles que los equipos mas modernos han ido suprimiendo en pro de puertos mas sofisticados y difíciles de controlar, además programando ensamblador  y con lo mínimo necesario, puede hacer de un cacharro antiguo y limitado, una máquina potente de verdad. :emo:
 
Si alguna vez has querido seguir los "primeros pasos" que dio Linus Torvals cuando creó el kernel Linux, este podría ser un buen camino.

 

Herramientas recomendadas.

 

 

Herramientas recomendadas.

  • Nasm - Recomendado para lenguaje ensamblador, por que es libre, tiene mucha documentación y trabaja con muchas tipos de archivos, hay mas alternativas a Nasm y posiblemente algún otro es mejor, pero este está muy extendido y por eso se recomienda.
  • GCC - Recomendado para lenguaje C, por que es libre, tienen una documentación extensa, y por que es sexy =)
  • Qemu  - Recomendado para emular un sistema con el que hacer nuestras pruebas.
  • Un editor de texto - Cualquiera vale.
  • Ganas - Eso depende de cada uno.

 

Instalación de las herramientas.

 

Con este comando instalamos lo necesario para empezar a compilar.

Creo que otras herramientas ya se encuentran disponibles por defecto en el sistema, como dd o ld.

Aunque no estoy seguro de si es así, que vienen por defecto o se instalan con build-essential.

sudo aptitude install nasm build-essential

Con este comando lo podemos instalar Qemu para hacer nuestras pruebas al momento.

apt-get install qemu qemu-kvm libvirt-bin

El editor de texto, a elección de cada uno, yo uso Gedit.

 

 

Algunos comandos de ejemplo para compilar ensamblador y enlazar archivos.

 

 

Para sistemas de 64bits un ejemplo de compilación generico.

$ nasm -f elf64 -o ArchivoCompilado.o ArchivoFuente.asm

Para sistemas de 32bits un ejemplo de compilación generico.

$ nasm -f elf -o ArchivoCompilado.o Archivofuente.asm

Para compilar un sector de arranque, lo compilaremos como un archivo de tipo binario plano.

nasm ArchivoFuente.asm -f bin -o Arranque.bin

El archivo *.bin generado despues de la compilación convertimos en imagen de disco.

dd if=Arranque.bin of=arranque.img count=1 seek=0

Y si además tenemos un archivo kernel a parte del arranque...

Podemos usar el mismo comando anterior pero cambiaremos algún parámetros del programa "dd".

El parámetro seek es el equivalente al sector del disco, la diferencia con el comando anterior es que usa el sector 0 del disco duro,

lógico sabiendo que es el arranque.

dd if=kernel.bin of=arranque.img bs=512 count=1 seek=1

Listando las arquitecturas y formatos soportados por Nasm.

$ nasm -hf

Para enlazar un archivo binario de tipo ELF.

$ ld -o ArchivoBinario Archivo.o

 

 

Enlaces hacia recursos y enseñanza de ensamblador enfocados en arranques de sistemas.


http://www.brokenthorn.com/Resources/OSDevIndex.html
 
https://appusajeev.wordpress.com/2011/01/27/writing-a-16-bit-real-mode-os-nasm/
 
Enlace a un proyecto bastante completo, con muchos comentarios de la mayoría de lineas de código.
http://www.osdever.net/bkerndev/bkerndev.zip
 
Aunque está compilado en el lado oscuro de M$, tiene una imagen precompilada para ver que es lo que hace y que no es gran cosa, pero los comentarios del código valen muy bien para ver por donde van los tiros en lo que concierne a la configuración de IRQ's, pantalla, teclado, timer y alguna cosa mas, modificar los comandos de compilación para usarlos en GNU no debería ser complicado.
 
Además, funciona con Grub, así se logra el tener posibilidades de arranque de mas de un sistema si es lo que se desea.
 
Para probar la imagen precompilada he usado QEmu con la linea -> qemu-system-i386 -fda dev_kernel_grub.img
 
En este caso ha hecho falta el parámetro "-fda" para que la imagen fuera cargada a modo de disco de 3,5 en vez de imagen de disco duro.
 
Enlace al tutorial explicativo acerca de este proyecto de Brandon F.
http://www.osdever.net/tutorials/view/brans-kernel-development-tutorial
 
Listado de recursos y tutoriales (en ingles) mas que interesantes del mismo sitio web.
http://www.osdever.net/tutorials/
 
Un compendio de información relativa al tema tratado.
http://wiki.osdev.org/Main_Page
 
Código de ayuda masticado.
http://sourceforge.net/projects/clicker/
http://clicker.cvs.sourceforge.net/viewvc/clicker/c32-lxsdk/kernel/src/sosflppy/
http://clicker.cvs.sourceforge.net/viewvc/clicker/c32-lxsdk/kernel/src/sosflppy/boot.asm?view=markup
http://sourceforge.net/projects/asmadian/?source=recommended
 
Foro de ayuda Nasm.
http://forum.nasm.us/
 
Mas recursos de la mano de Anthony LineBerry.
http://ominos.sourceforge.net/index.php
http://sourceforge.net/p/ominos/code/HEAD/tree/branches/Anthony/ominos/

Lista de "algunos" de los términos mas utilizados en estos menesteres.


Explicación resumida de algunos de los términos relativos al tema tratado.

  • ; - El punto y coma es usado para los comentarios en este caso Nasm.
  • BIOS - Basic Input/Output System, en castellano sistema básico de entrada/salida, físicamente es un circuito integrado alojado en la placa base, el bios comprueba que el hardware está presente, además tiene algunas funciones internas que pueden ser llamadas usando interrupciones.
  • Código fuente - El código del programa escrito por un programador antes de su compilación, la extensión no es importante en este caso.
  • Codigo objeto - El código del objeto resultante después de  haber compilado el código fuente, normalmente usan extensión *.o
  • Enlazador o linker -  Es un programa que usa los objetos previamente compilados, gestiona recursos necesarios como las bibliotecas, quita los recursos innecesarios y al final enlaza el código objeto con las bibliotecas y termina generando el fichero ejecutable o biblioteca.
  • Pila o stack - Es una lista o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO.
  • LIFO - Significa, ultimo en entrar y primero en salir y su función es la de almacenar y recuperar datos de pilas.
  • Interrupción - Se usan como ordenes internas para llamar a funciones o procedimientos del sistema enfocado en el manejo de hardware.
  • Hexadecimal - Sistema de numeración base16 muy usado en lo relativo al tema tratado.
  • Decimal - Sistema de numeración base10, el que hemos aprendido en las escuelas.
  • $ - Apunte directo hacia el inicio de una instrucción.
  • $$ - Apunte directo hacia el inicio de un programa.
  • bit - Puede ser un 1 o 0, la unidad mas pequeña usada en computación.
  • byte - Equivalente a un conjunto de 8 bit.
  • db - Pseudo instrucción usada para declarar un byte.
  • dw - Pseudo instrucción usada para declarar una palabra (Word), de  2 bytes, generalmente de un sistema x86.
  • dd - Pseudo instrucción usada para declarar una palabra doble, de 4 bytes, generalmente de un sistema x86.
  • ax - Acumulador
  • bx - Registro base
  • cx - Registro contador.
  • dx - Registro de datos
  • ds - Registro del segmento de datos.
  • es - Registro del segmento extra.
  • ss - Registro del segmento de pila.
  • cs - Registro del segmento de código.
  • si - Registro índice fuente.
  • bp - registro de apuntadores base.
  • di - Registro índice destino.
  • ip - Registro de apuntadores de la siguiente instrucción
  • sp - Registro de apuntador de la pila.
  • f - registro de banderas.

Instrucciones lógicas:

  • xor - Usado para realizar una disyunción lógica bit por bit entre dos operandos.
  • test - Usado para realizar una conjunción bit por bit enfocado a las banderas y al contrario que "and" que coloca el resultado en el operando de destino.
  • and - Usado para realizar una conjugación de operandos, bit por bit.
  • neg - Usado para generar el complemento de 2 del operador destino para almacenarlo en el mismo operando.
  • not - Usado para guardar el mismo operando destino.
  • or - Usado para la disyunción inclusiva y lógica de dos operandos, bit por bit.

 

Mas sobre este tema en:

 

http://www.osdever.net

https://es.wikipedia.org/wiki/Lenguaje_ensamblador#Uso_del_t.C3.A9rmino

Las reglas mas básicas del juego (para un arranque).


Las principales y mas básicas reglas a tener en cuenta.

  • La imagen de disco generada al final del proceso, debe ser de 512bytes, ni mas ni menos!
  • Se debe iniciar con la firma del gestor de arranque, '7C 00', uno de los números mágicos.
  • Se debe terminar con la firma del gestor de arranque, '55 AA ', uno de los números mágicos.

Entendiendo una estructura básica en un arranque de 16bit.

Este código de arranque solo es explicativo para entender las lineas constantes de un arranque de 16bit.
Realmente no hace nada de nada, no lo uses.

[BITS 16]      ;Esta etiqueta le dice al compilador que debe generar código para un sistema de 16bit.
[ORG 0x7C00]   ;ORG le dice al compilador donde empieza el código de arranque una vez cargado en memoria.

...
...             ;Aquí en blanco va la funcionalidad del sistema de arranque, es decir todo.
...             ;Las definiciones, los registros, las asignaciones, los saltos de memoria, etc.
...

times 510-($-$$) db 0  ;Esta es la instrucción que llena de ceros el espacio restante del primer sector-
                       ;es lo que no se ha utilizado hasta completar los primeros 512 bytes.
dw 0xAA55              ;Esta linea marca el final del arranque, otro de los números mágicos.

 


Añadiendo un bucle sin fin, igualmente para 16bit.

 

[BITS 16]    ;Esta etiqueta le dice al compilador que debe generar código para un sistema de 16bit.
[ORG 0x7C00] ;ORG le dice al compilador donde empieza el código de arranque una vez cargado en memoria.

main:        ;Esta es la etiqueta main, registrando el inicio del código de arranque. 
jmp $        ;jmp es un salto a una dirección, en este caso a $, que retorna a la etiqueta main.
             ;Así es como tenemos nuestro primer bucle, una función que no tiene fin.
             ;Ni otro sentido que no sea el de aprender.

times 510-($-$) db 0 ;Esta es la instrucción que llena de ceros el espacio restante del primer sector-
                     ;es lo que no se ha utilizado hasta completar los primeros 512 bytes.
dw 0xAA55            ;Esta linea marca el final del arranque, otro de los números mágicos.

 


Mi proyecto de andar por casa.


Mi proyecto es un portátil con las siguientes especificaciones.
 
Toshiba CDS 4000, Intel MMX @ 233 Mhz con 32 Mb de ram + disco duro de 30 Gb.
1 puerto COM.
1 Puerto LPT.
1 Puerto USB.
1 Puerto VGA
1 Puerto Irda.
2 Pcmcia.
1 Audio In + out + micro.
1 Puerto mixto de raton y teclado PS2.
1 Disquetera 3'5
1 CdRom
 
Si, es un cacharro viejo, con esa ram poco se puede hacer si le metiera Linux y menos aun con Windows, pero lo bueno que tiene es que funciona con 12 voltios, :idea:
 
Aprovechar los puertos mas asequibles como el puerto serie y paralelo es bastante fácil con muy poca electrónica y enviar un 1 o 0 lógico a una dirección de un puerto usando ensamblador también es fácil, con eso se puede automatizar muchas cosas sin volverse loco en el intento.
 
Al mismo tiempo la idea es ahorrar la instalación y consumos de un sistema operativo innecesario en su gran mayoría para hacer una labor tan simple como es por ejemplo el control de un sistema mas o menos complejo del típico riego por goteo,  sistema de alarma o lo que se nos pueda ocurrir, pero con eficiencia y velocidad, donde el ensamblador siempre es el rey del mambo.
 
Se que hay algunos proyectos de código abierto que ya tienen la rueda inventada, sistemas basados en Linux que ocupan un diskette o sistemas operativos hechos completamente en ensamblador como ColibriOS y similares, yo prefiero trastear y tratar de aprender algo.
 
Si alguien conoce recursos con enlaces relativos a este tema, se agradece mucho cualquier comentario.

 

Vídeos sobre ensamblador - Parte1:

 

 

Estos vídeos están enfocados a la explotación de software, pero son igualmente validos para entender conceptos mas o menos básicos sobre la programación en este lenguaje.

 

https://www.youtube.com/watch?v=zZu_KHqrsh4

https://www.youtube.com/watch?v=7HoxYLQOgvk

https://www.youtube.com/watch?v=duRAZxGGGkA

https://www.youtube.com/watch?v=rAWQBp61JBU

https://www.youtube.com/watch?v=ECVB4xxdWjA

 

 

Vídeos sobre ensamblador - Parte2:

 


En fin, espero que esto le sea de utilidad a alguien, un saludo!

Editado por wsn

Compartir este post


Enlace al post
Compartir en otros sitios

Gracias amigo por poner aqui tan buena info, es increible.

 

Gracias a ti @@portaro, por pasarte por aquí y comentar. :ok:

 

Esta muy bien la información , y que tengáis mucho ánimo con ensamblador, esto es programar a lo grande. Una pregunta ¿que compiladores tenemos disponible para gnu Linux?

 

Gracias por comentar @@pacoeloyo. :ok:

 

Yo uso Nasm, pero también están Yasm y Gas, supongo que habrán muchas mas herramientas, aunque no he mirado mucho mas allá de Nasm, por el momento.

 

Por otro lado, acabo de hacer un script bash para automatizar el proceso de compilación y ensamblado de la imagen de disco, por si a alguien le sirve, por aquí lo dejo.

 

Compilar.sh

#!/bin/bash
# Ayudante para la compilación del archivo boot.asm y kernel.asm, especialmente programado para vagos, =D

ARCHIVO1=boot.asm
ARCHIVO2=kernel.asm
ARCHIVO3=boot.bin
ARCHIVO4=arranque.img
ARCHIVO5=kernel.bin

function titulo(){
	echo -e "\e[1;33m ۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞\e[0m"
	echo -e "\e[1;32m 	     Ayudante para vagos.\e[0m"
	echo -e "\e[1;33m ۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞\e[0m"
}

function snasm(){
	if [ -x /usr/bin/nasm ] || [ -x /usr/sbin/nasm ]; 
		then
		echo -e "\e[1;32m Comprobando la existencia de Nasm...  OK.\e[0m"
	else
		echo -e "\e[1;31m ERROR - El compilador 'Nasm' no está instalado, puedes instalarlo con 'sudo aptitude install nasm'.\e[0m"
		sleep 6
		exit 1;
	fi
}

function compilar(){
	echo -ne -e "\e[1;32m Se inicia la compilación de '$ARCHIVO1' y '$ARCHIVO2'...\r\e[0m"
	echo -ne '\n'
   	nasm boot.asm -f bin -o boot.bin
	sleep 2
	echo -ne -e "\e[1;32m $ARCHIVO1 compilado!\r\e[0m"
	echo -ne '\n'
	sleep 1
		nasm kernel.asm -f bin -o kernel.bin
	sleep 2
	echo -ne -e "\e[1;32m $ARCHIVO2 compilado!\r\e[0m"
	echo -ne '\n'
}

function montar(){
		dd if=boot.bin of=arranque.img count=1 seek=0
	echo -ne -e "\e[1;32m $ARCHIVO3 montado en $ARCHIVO4\r\e[0m"
	echo -ne '\n'
		dd if=kernel.bin of=arranque.img bs=512 count=1 seek=1
	echo -ne -e "\e[1;32m $ARCHIVO5 montado en $ARCHIVO4\r\e[0m"
	echo -ne '\n'
}

function comprobar(){
   if [ -f $ARCHIVO3 ];
   then
		rm boot.img
		echo -ne -e "\e[1;32m Eliminamos el archivo $ARCHIVO3...\r\e[0m"
		echo -ne '\n'
		sleep 1
		compilar
   else
		compilar		  		
	fi
}

function comprobardd(){
   if [ -f $ARCHIVO3  ] || [ -f $ARCHIVO5 ]; 
		then
		montar
		sleep 2
		limpieza
	else
		echo -e "\e[1;31m ERROR - No se encontro los archivos $ARCHIVO3 y $ARCHIVO5 para su ensamblado.\e[0m"
		sleep 5
		exit 1;
	fi
}

function limpieza(){
	 if [ -f $ARCHIVO3  ] || [ -f $ARCHIVO5 ]; 
		then
		rm $ARCHIVO3
		rm $ARCHIVO5
		echo -e "\e[1;32m Limpieza de archivos compilados... OK\e[0m"
	else
		echo -e "\e[1;31m ERROR - No se encontro los archivos $ARCHIVO3 y $ARCHIVO5 para su limpieza.\e[0m"
		sleep 5
		exit 1;
	fi
}

# Esta funcion a continuación no es necesaria para nada, es solo para practicar un poco de bash, que buena falta me hace! =)
function bp(){
		echo -ne -e "\e[1;32m (10%)\r\e[0m"
		sleep 0.1
		echo -ne -e "\e[1;32m (20%)\r\e[0m"
		sleep 0.1
		echo -ne -e "\e[1;32m (30%)\r\e[0m"
		sleep 0.1
		echo -ne -e "\e[1;32m (40%)\r\e[0m"
		sleep 0.1
		echo -ne -e "\e[1;32m (50%)\r\e[0m"
		sleep 0.1
		echo -ne -e "\e[1;32m (60%)\r\e[0m"
		sleep 0.1
		echo -ne -e "\e[1;32m (70%)\r\e[0m"
		sleep 0.1
   	echo -ne -e "\e[1;32m (80%)\r\e[0m"
		sleep 0.1
   	echo -ne -e "\e[1;32m (90%)\r\e[0m"
		sleep 0.1
   	echo -ne -e "\e[1;32m (100%)\r\e[0m"
		sleep 0.1
		echo -ne -e "\e[1;32m Completo!\r\e[0m"
		sleep 2 # Dos segundos para cerrar.
   	echo -ne '\n'	
		echo -ne -e "\e[1;32m Presiona una tecla para continuar!\r\e[0m"
}
while :
 do
	clear
	titulo
	echo "  [1] Compilar y ensamblar imagen."
	echo "  [2] Cargar imagen en QEmu."
	echo "  [3] Cerrar/Salir"
	echo -e "\e[1;33m ۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞۞\e[0m" 
	echo
	echo -n " Escoge una opción [1-3]: "
	read uioy
	case $uioy in
      1)  snasm; comprobar; comprobardd; bp; read ;;
      2) qemu-system-i386 arranque.img; read ;;
      3) exit 0 ;;
      *) echo " Solo tienes tres opciones!";
         echo " Presiona una tecla para continuar" ; read ;;
 esac
done
	exit    

El código que he probado en ensamblador es el correspondiente a los siguientes dos spoilers, en este caso para la arquitectura I386.

 

boot.asm

BITS 16
ORG 0x7C00 ;Constante
mov [DriveNum] , dl
mov esi , MsgHello
call print

mov ah, 2
mov al, 1
mov dl , [DriveNum]
mov ch , 0
mov dh , 0
mov cl , 2
mov bx , 0x1000

int 0x13
cmp ah , 0
JNE err
mov esi,Debug_MsgOK

mov esi,MsgPassingControl
call print
JMP 0x1000 ;; Jump To Stage 2

;;CODE END

;;ROUTINES START
err:
mov esi,MsgErr
call esi
call hang



asciToDigit:
 and eax,0b11001111
 ret

digitToAsci:
 xor eax,0b00110000
 ret

hang:
 JMP $

strlen:
mov ebx,eax
strlen_inc:
cmp byte [ebx],0			
JE strlen_done
inc ebx
JMP strlen_inc
strlen_done:
sub ebx,eax
mov eax,ebx
ret

strreverse: ;;eax source - ebx - strlen - edi - dest
xor edx, edx
sub edi,1
mov esi,eax
add eax , ebx
strreverse_loop:
cmp esi,eax
JG strreverse_done
mov dl , byte [eax]
mov byte [edi] , dl
inc edi
dec eax
JMP strreverse_loop
strreverse_done:
ret

asciToInt:
xor eax,eax
xor esi,esi
mov edi , 10
asciToInt_inc:
cmp esi,ebx
JE asciToInt_Done				
inc esi
mov dl , byte [ecx]
and dl,0b11001111
add al , dl
mul edi
inc ecx
JMP asciToInt_inc
asciToInt_Done:
idiv edi
ret

print:
 mov al , [si] ;Letter
 inc esi ;; Increment Pointer
 cmp al , 0
 JE print_done

 mov ah , 0x0E ;Output Mode
 mov bh , 0    ;Page
 mov bl , 0x07 ;Colour
 int 0x10   ;Interrupt
 JMP print
 print_done:
 ret
;;ROUTINES END

;;DECLARATIONS START

DriveNum dd 0
MsgHello db "Fase uno del arranque (Boot)",0xA,13,0
Debug_MsgOK db "OK",0xA,13,0
Debug_MsgNO db "NO",0xA,13,0
MsgErr db "Err",0xA,13,0
MsgPassingControl db "Pasando el control a la fase dos del arranque (kernel)",0xA,13,0
MsgDriveReady db " Disco preparado . . .",0xA,13,0
Temp db 0,0,0,0,0,0,0,0,0,0,0
TIMES 510 - ( $ - $$ ) db 0 ; Constante
DW 0xAA55  ; Constante

kernel.asm

BITS 16
ORG 0x1000
start:
mov esi , MsgHello
call print
JMP $

print:
mov AL , [si] ;Letter
inc esi ;; Increment Pointer
cmp AL , 0
JE done

mov AH , 0x0E ;Output Mode
mov BH , 0    ;Page
mov BL , 0x07 ;Colour
int 0x10   ;Interrupt
JMP print
done:
ret
MsgHello db "Kernel cargado.",0xA,13,0

En QEmu funciona muy bien este código que he probado, pero en V.Box no carga, creo que por que el tamaño de la imagen de disco no encaja con el estándar, en este caso el de 1440k, supongo que me habrá faltado algún parámetro al ensamblar los archivos *.bin de la fuente del boot y el kernel cuando he usado el comando "dd" para hacer la imagen de disco.

Pero me he llevado una alegría al ver que funciona correctamente, a partir de aquí todo será coser y cantar (llorar) :jojojo:

Fuente del boot y el kernel en http://forum.nasm.us/index.php?topic=2186.0

Editado por wsn

Compartir este post


Enlace al post
Compartir en otros sitios

Muy interesante @@wsn ¿Has pensado en montar un repositorio Git del proyecto? se que lo quieres hacer tu pero así estaría accesible a todo el mundo, a mi esto se me escapa por mucho pero siempre quise hacer algo así para la Raspberry Pi o similares, un sistema básico que tuviera un gran rendimiento.

Compartir este post


Enlace al post
Compartir en otros sitios

Muy interesante @@wsn ¿Has pensado en montar un repositorio Git del proyecto? se que lo quieres hacer tu pero así estaría accesible a todo el mundo, a mi esto se me escapa por mucho pero siempre quise hacer algo así para la Raspberry Pi o similares, un sistema básico que tuviera un gran rendimiento.

 

Gracias por comentar @@mijailbellum. :ok:

 

A mi igual que a ti este tema se me escapa por mucho también, pero nada impide trastear y aprender.

 

Contestando tu pregunta, solo pondría este proyecto en Git si yo tuviera capacidad de desarrollo suficiente para saber que no me quedaría estancado con el primer problema que se me presentara, además de que  yo no soy el autor de todo ese código de ensamblador y C. :happy:

 

Extendiéndome un poco sobre esto.

 

 

Mi único merito en este caso es que solo hice el script en bash y he editado algún que otro string del código fuente, eso sin tener casi idea de bash y gracias a lo que la gente publica en la red sobre este lenguaje de scripting, además me ha parecido que bash es de muy buena ayuda para ciertas tareas.

 

Mi intención sobre este tema es estudiar algo básico del arranque de un sistema... ( básico no es igual a fácil en este caso ), probarlo, experimentar, familiarizarme con lo que veo que es constante en distintos códigos de distintos autores, así como tratar de comprender como interactúa la relación entre asm y C en la capa mas cercana al hardware.

 

Creo que sobre este tema no conviene re-inventar la rueda, solo entender como funciona y ya de paso compartir con ustedes lo que me parece mas relevante de lo que he encontrado por la red, por si alguien se anima a experimentar que no se vuelva loco buscando algo que funcione para hacer su primer hola mundo ensamblador.

 

Y si consigo el objetivo, aprender como funciona un boot y un micro kernel para una simple aplicación embebida y quizás añadirle algunas cosas mas, pues mejor que mejor.

 

Por otra parte, para Raspberry ya hay algunos proyectos enfocados en el minimalismo, supongo que todo depende de cuan básico se necesita que sea el sistema a costa de perder funcionalidades.

 

El la mía estoy usando una distro bastante aligerada pero con todas las funcionalidades propias de un servidor, siempre se podrá desinstalar servicios no usados para hacerlo aun mas liviano hasta el punto de tener una RPi autista :D

http://gnulinuxvagos.es/topic/5373-dietpi-un-sistema-operativo-aligerado/

 

 

Un saludo.

Editado por wsn

Compartir este post


Enlace al post
Compartir en otros sitios

Podrías tener el Git igualmente así tendrías subido el script y todo lo que hagas estaría disponible para todo el mundo, el día que te estanques, te canses o lo que sea, ahí tienes eso por si alguien quiere retomar tu trabajo o tu mismo, también te serviría de respaldo, usando un git público a lo GitHub o Gitlab es bastante fácil el asunto.

Compartir este post


Enlace al post
Compartir en otros sitios

Podrías tener el Git igualmente así tendrías subido el script y todo lo que hagas estaría disponible para todo el mundo, el día que te estanques, te canses o lo que sea, ahí tienes eso por si alguien quiere retomar tu trabajo o tu mismo, también te serviría de respaldo, usando un git público a lo GitHub o Gitlab es bastante fácil el asunto.

 

Pues sobre eso, una vez registre una cuenta en Git por ver como era la región de usuario y las posibilidades que daba, pero sinceramente 

nunca he subido nada.

 

No voy a descartar tu idea, te voy a hacer caso y en cuanto tenga algo interesante lo subiré, así de paso aprendo a usar Git, que nunca viene mal aprender cosas nuevas.

 

Gracias por comentar @@mijailbellum :ok:

Compartir este post


Enlace al post
Compartir en otros sitios

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Invitado
Responder en este tema...

×   Has incluido contenido con formato.   Eliminar formato

  Sólo se permiten 75 emoticonos como máximo.

×   Tu enlace ha sido insertado automáticamente.   Deshacer y mostrar como enlace

×   Su contenido anterior ha sido restaurado.   Limpiar editor

×   No puedes pegar imágenes directamente. Súbelas a algún hosting de imágenes y pega la dirección URL


×
×
  • Crear Nuevo...