El BIOS lleva muerto muchos años pero no es que lo haya matado el EFI ni el UEFI simplemente se volvió innecesario sustituido perfectamente por las rutinas del kernel de GNU/Linux, FreeBSD y quiero creer que el Kernel NT de Windows
¿ Que es el BIOS ?
Por muchos años el BIOS fue el verdadero sistema operativo del PC, básicamente el MS-DOS era un Shell para el BIOS y el Windows 3.X hasta el Windows ME que eran un Shell para el DOS lo que supone capa sobre capa y por lo tanto más lento, pero eso es otra historia.
El BIOS es el primer programa que carga en las PC, contiene los driver del teclado, disco duro y se encarga de inicializar el video, las funciones que un Kernel deben hacer. Si el BIOS no detectaba tu disco duro no deberías haber tenido esperanzas de que tu MS-DOS lo haría, porque el DOS realmente era un Shell para el BIOS, Todos los accesos al hardware tenían que ser procesados por el BIOS pero esto era mucho más complicado ya que el BIOS solo entiende de desplazamientos de memoria en la mayoría de los casos, así que todos los servicios que presta el BIOS se venía duplicados en el MS-DOS pero con una suerte de API que facilitaba a los programadores escribir código menos doloroso.
Por supuesto hacer uso de los servicios del MS-DOS aunque más fácil hace que el programa sea más lento ya que el MS-DOS debe traducir y pasar los parámetros al BIOS quien finalmente realizara el servicio. Algunos lenguajes de programación como Turbo Pascal en MS-DOS y PC aprovechan esto y se saltan al MS-DOS llamando directamente al BIOS para hacer el trabajo, por ejemplo la función Write y Writeln van directo sobre el BIOS mientras que Printf de C lo hace con las funciones del MS-DOS lo que hace el código C portable entre sistemas operativos, pero más lento, mientras que el turbo pascal se amarraba al PC pero más rápido, por si alguna vez se han preguntando por que el logo de FreePascal y Lazarus es un leopardo que da la impresión de ir a una alta velocidad.
¿ Si es el verdadero sistema operativo, porque está muerto ?
Porque los sistemas operativos modernos desde la época de los 32 bits traen un subsistema de BIOS incorporado en sus kernels, por ejemplo GNU/Linux no hace uso del BIOS, el BIOS se limita a lanzar el cargador LILO en su momento o el GRUB, ya que todas las operaciones de escritura en bloques lo hacen directamente al hardware brincándose al BIOS en este momento el BIOS se limita a buscar los primeros 512 byte de un disco duro en el MBR y arrancar el cargador y después es ignorado.
Quiero pensar que el Kernel de Windows el NT se ha liberado igualmente del BIOS.
¿ Como queda la definición de PC ?
La pregunta que me queda es, ahora como se define una PC, si el BIOS era el sistema operativo de una PC y es innecesario o incluso sustituible por EFI, ¿ que es una PC ? Antes era definida PC por el tipo de hardware ahora la definen así si usa Windows y en el caso de las MacBook si usa MacOS X aunque el hardware es prácticamente idéntico en este momento y sin contar que esas 2 pueden correr GNU/Linux y otros sistemas operativos.
Tengo problemas para definir que es una PC, si una PC es lo que usa Windows, ¿ que es lo que usa GNU/Linux o FreeBSD y otros *NIX ?
Creo que no hay datos suficientes para una respuesta esclarecedora a esta última pregunta.
David.
mientras que Printf de C lo hace con las funciones del MS-DOS lo que hace el código C portable entre sistemas operativos, pero más lento.
Entonces que pasa con printf en Linux o en Unix por ejemplo, también hacen uso tipo de funciones MS-DOS
Saludos.
No, ahí usa el API equivalente… por eso es portable, en lugar de escribir un compilador que escriba directo al BIOS escribe al servicio de MSDOS que se encarga de eso, lo mismo para Linux, Solaris y otros, y cada respectivo sistema operativo usando su propio servicio imprime en pantalla, de esa forma C no se preocupa del CPU del direccionamiento de memoria al usar el printf para escribir una cadena de texto, en el caso de Free Pascal, bueno Free Pascal ya no compila como turbo pascal, de hecho Free Pascal hasta donde me quede compila a código fuente C y luego compila ese código fuente en C en la plataforma en la que se encuentra.
Como tenia mis dudas, instale Free Pascal para ver como compilaba y resulta que a diferencia de otros lenguajes que compilan a código fuente C para luego compilar ese código fuente con GNU/C, Free Pascal sigue manteniéndose rápido por que compila a ensamblador y luego compila ese ensamblador, no es como hacer llamadas directamente al BIOS pero sigue siendo mejor , mas rápido y optimizado…. este es el código generado por el compilador de Free Pascal de un hola mundo a ensamblador
Código Pascal ( Lo mas básico del mundo )
bengin
writeline ('Hola Mundo');
end.
El compilador de Free Pascal en Linux escupe esto.
.file "hola.pas"# Begin asmlist al_begin
# End asmlist al_begin
# Begin asmlist al_stabs
# End asmlist al_stabs
# Begin asmlist al_procedures
.section .text
.balign 8,0x90
.globl PASCALMAIN
.type PASCALMAIN,@function
PASCALMAIN:
.globl main
.type main,@function
main:
.Lc1:
pushq %rbp
.Lc3:
.Lc4:
movq %rsp,%rbp
.Lc5:
subq $16,%rsp
movq %rbx,-8(%rbp)
call FPC_INITIALIZEUNITS
call fpc_get_output
movq %rax,%rbx
movq %rbx,%rsi
movq $_$PROGRAM$_Ld1,%rdx
movl $0,%edi
call fpc_write_text_shortstr
call FPC_IOCHECK
movq %rbx,%rdi
call fpc_writeln_end
call FPC_IOCHECK
call FPC_DO_EXIT
movq -8(%rbp),%rbx
leave
ret
.Lc2:
.Le0:
.size main, .Le0 - main
.section .text
# End asmlist al_procedures
# Begin asmlist al_globals
.section .data
.balign 8
.globl THREADVARLIST_P$PROGRAM
.type THREADVARLIST_P$PROGRAM,@object
THREADVARLIST_P$PROGRAM:
.quad 0
.Le1:
.size THREADVARLIST_P$PROGRAM, .Le1 - THREADVARLIST_P$PROGRAM
.section .data
.balign 8
.globl INITFINAL
.type INITFINAL,@object
INITFINAL:
.long 1,0
.quad INIT$_SYSTEM
.quad 0
.Le2:
.size INITFINAL, .Le2 - INITFINAL
.section .data
.balign 8
.globl FPC_THREADVARTABLES
.type FPC_THREADVARTABLES,@object
FPC_THREADVARTABLES:
.long 2
.quad THREADVARLIST_SYSTEM
.quad THREADVARLIST_P$PROGRAM
.Le3:
.size FPC_THREADVARTABLES, .Le3 - FPC_THREADVARTABLES
.section .data
.balign 8
.globl FPC_RESOURCESTRINGTABLES
.type FPC_RESOURCESTRINGTABLES,@object
FPC_RESOURCESTRINGTABLES:
.quad 0
.Le4:
.size FPC_RESOURCESTRINGTABLES, .Le4 - FPC_RESOURCESTRINGTABLES
.section .data
.balign 8
.globl FPC_WIDEINITTABLES
.type FPC_WIDEINITTABLES,@object
FPC_WIDEINITTABLES:
.long 0
.Le5:
.size FPC_WIDEINITTABLES, .Le5 - FPC_WIDEINITTABLES
.section .fpc
.balign 8
.ascii "FPC 2.6.4 [2014/03/03] for x86_64 - Linux"
.section .data
.balign 8
.globl __stklen
.type __stklen,@object
__stklen:
.quad 8388608
.section .data
.balign 8
.globl __heapsize
.type __heapsize,@object
__heapsize:
.quad 0
.section .data
.globl __fpc_valgrind
.type __fpc_valgrind,@object
__fpc_valgrind:
.byte 0
.section .data
.balign 8
.globl FPC_RESLOCATION
.type FPC_RESLOCATION,@object
FPC_RESLOCATION:
.quad 0
# End asmlist al_globals
# Begin asmlist al_const
# End asmlist al_const
# Begin asmlist al_typedconsts
.section .rodata
.balign 8
.globl _$PROGRAM$_Ld1
_$PROGRAM$_Ld1:
.ascii "\012Hola mundo\000"
# End asmlist al_typedconsts
# Begin asmlist al_rotypedconsts
# End asmlist al_rotypedconsts
# Begin asmlist al_threadvars
# End asmlist al_threadvars
# Begin asmlist al_imports
# End asmlist al_imports
# Begin asmlist al_exports
# End asmlist al_exports
# Begin asmlist al_resources
# End asmlist al_resources
# Begin asmlist al_rtti
# End asmlist al_rtti
# Begin asmlist al_dwarf_frame
.section .debug_frame
.Lc6:
.long .Lc8-.Lc7
.Lc7:
.long -1
.byte 1
.byte 0
.uleb128 1
.sleb128 -4
.byte 16
.byte 12
.uleb128 7
.uleb128 8
.byte 5
.uleb128 16
.uleb128 2
.balign 4,0
.Lc8:
.long .Lc10-.Lc9
.Lc9:
.quad .Lc6
.quad .Lc1
.quad .Lc2-.Lc1
.byte 4
.long .Lc3-.Lc1
.byte 14
.uleb128 16
.byte 4
.long .Lc4-.Lc3
.byte 5
.uleb128 6
.uleb128 4
.byte 4
.long .Lc5-.Lc4
.byte 13
.uleb128 6
.balign 4,0
.Lc10:
# End asmlist al_dwarf_frame
# Begin asmlist al_dwarf_info
# End asmlist al_dwarf_info
# Begin asmlist al_dwarf_abbrev
# End asmlist al_dwarf_abbrev
# Begin asmlist al_dwarf_line
# End asmlist al_dwarf_line
# Begin asmlist al_picdata
# End asmlist al_picdata
# Begin asmlist al_resourcestrings
# End asmlist al_resourcestrings
# Begin asmlist al_objc_data
# End asmlist al_objc_data
# Begin asmlist al_objc_pools
# End asmlist al_objc_pools
# Begin asmlist al_end
# End asmlist al_end
.section .note.GNU-stack,"",%progbits
Luego esto es compilado y linkeado sin pasar por C, brillante de Free Pascal
La verdad que después de leer tu post me surgieron varias dudas, pero lo que mas me intrigo fue eso. De verdad que no imagine que Free Pascal trabajara directamente a ensamblador.
Gracias David. Saludos.