Embed Size (px)
Citation preview
Unidad 1 Arquitectura General del Sistema Operativo Linux
Contenido
Unidad 1 Arquitectura General del Sistema Operativo Linux .......................................... 1
Introducción................................................................................................................... 2
Historia .......................................................................................................................... 3
Características .............................................................................................................. 7
Kernel/Núcleo.............................................................................................................. 10
Dónde conseguir el núcleo ..................................................................................... 13
Configuración e instalación de un nuevo núcleo .................................................... 13
Consejos .................................................................................................................. 13
El interprete de comandos: ......................................................................................... 14
Indicador del sistema .............................................................................................. 15
El concepto de línea de comandos ......................................................................... 15
Entrada-salida estándar .......................................................................................... 16
Redirecciones .......................................................................................................... 16
Tuberías de comunicación ...................................................................................... 17
Llamadas al Sistema (Call System) ........................................................................... 17
X Window System .......................................................................................................... 20
Gestor de ventanas..................................................................................................... 21
Administradores de Escritorio, Local y Remoto ......................................................... 23
1. Entorno de escritorio ........................................................................................... 24
2. Gestores de ventanas ......................................................................................... 24
GNOME ................................................................................................................... 24
Versión actual (3.0) ................................................................................................. 26
KDE ......................................................................................................................... 26
Estructura General del Sistema Operativo ................................................................. 27
ESTRUCTURA BASICA DE LAS FUENTES DEL NUCLEO ................................. 27
Introducción
Linux es un sistema operativo, compatible Unix. Dos características
muy peculiares lo diferencian del resto de sistemas que podemos
encontrar en el mercado, la primera, es que es libre, esto significa que
no tenemos que pagar ningún tipo de licencia a ninguna casa
desarrolladora de software por el uso del mismo, la segunda, es que el sistema viene
acompañado del código fuente.
El sistema lo forman el núcleo del sistema (kernel) más un gran número de programas
/ bibliotecas que hacen posible su utilización. Muchos de estos programas y bibliotecas
han sido posibles gracias al proyecto GNU, por esto mismo, muchos llaman a Linux,
GNU/Linux, para resaltar que el sistema lo forman tanto el núcleo como gran parte del
software producido por el proyecto GNU.
Linux se distribuye bajo la GNU General PublicLicense por lo tanto, el código fuente
tiene que estar siempre accesible y cualquier modificación ó trabajo derivado tiene que
tener esta licencia.
El sistema ha sido diseñado y programado por multitud de programadores alrededor
del mundo. El núcleo del sistema sigue en continuo desarrollo bajo la coordinación de
Linus Torvalds, la persona de la que partió la idea de este proyecto, a principios de la
década de los noventa. Hoy en día, grandes compañías, como IBM, SUN, HP, Novell y
RedHat, entre otras muchas, aportan a Linux grandes ayudas tanto económicas como
de código.
Día a día, más y más programas y aplicaciones están disponibles para este sistema, y
la calidad de los mismos aumenta de versión a versión. La gran mayoría de los
mismos vienen acompañados del código fuente y se distribuyen generalmente bajo los
términos de licencia de la GNU General PublicLicense.
Más y más casas de software comercial distribuyen sus productos para Linux y la
presencia del mismo en empresas aumenta constantemente por la excelente relación
calidad-precio que se consigue con Linux.
Las arquitecturas en las que en un principio se puede utilizar Linux son Intel 386-, 486-
, Pentium, Pentium Pro, Pentium II/III/IV, IA-64, Amd 5x86, Amd64, Cyrix y Motorola
68020, IBM S/390, zSeries, DEC Alpha, ARM, MIPS, PowerPC, SPARC y
UltraSPARC. Además no es difícil encontrar nuevos proyectos portando Linux a
nuevas arquitecturas.
Historia
Linux hace su aparición a principios de la década de los noventa, era el año 1991 y por
aquel entonces un estudiante de informática de la Universidad de Helsinki, llamado
Linus Torvalds empezó, -como una afición y sin poder imaginar a lo que llegaría este
proyecto, a programar las primeras líneas de código de este sistema operativo al que
llamaria más tarde Linux.
Este comienzo estuvo inspirado en MINIX, un pequeño sistema Unix desarrollado por
Andy Tanenbaum. Las primeras discusiones sobre Linux fueron en el grupo de noticias
comp.os.minix, en estas discusiones se hablaba sobre todo del desarrollo de un
pequeño sistema Unix para usuarios de Minix que querían más.
El 3 de julio de 1991, Linus Torvalds mandó el primer mensaje sobre Linux al grupo de
noticias comp.os.minix:
Path: gmdzi!unido!mcsun!news.funet.fi!hydra!klaava!torvalds From: [email protected] (Linus Benedict Torvalds) Newsgroups: comp.os.minix Subject: Gcc-1.40 and a posix-question Keywords: gcc, posix Message-ID: <[email protected]> Date: 3 Jul 91 10:00:50 GMT Organization: University of Helsinki Lines: 28 Hello netlanders, Due to a project I'm working on (in minix), I'm interested in the posix standard definition. Could somebody please point me to a (preferably) machine-readable format of the latest posix rules? Ftp-sites would be nice. As an aside for all using gcc on minix - the new version (1.40) has been out for some weeks, and I decided to test what needed to be done to get it working on minix (1.37.1, which is the version you can get from plains is nice, but 1.40 is better :-). To my surpice, the answer
turned out to be - NOTHING! Gcc-1.40 compiles as-is on minix386 (with old gcc-1.37.1), with no need to change source files (I changed the Makefile and some paths, but that's it!). As default this results in a compiler that uses floating point insns, but if you'd rather not, changing 'toplev.c' to define DEFAULT_TARGET from 1 to 0 (this is from memory - I'm not at my minix-box) will handle that too. Don't make the libs, use the old gnulib&libc.a. I have successfully compiled 1.40 with itself, and everything works fine (I got the newest versions of gas and binutils at the same time, as I've heard of bugs with older versions of ld.c). Makefile needs some chmem's (and gcc2minix if you're still using it). Linus Torvalds [email protected] PS. Could someone please try to finger me from overseas, as I've installed a "changing .plan" (made by your's truly), and I'm not certain it works from outside? Itshouldreport a new .plan every time.
El 25 de agosto de 1991, mandó el siguiente mensaje, el cual es considerado por
muchos como el comienzo del proyecto Linux:
Path: gmdzi!unido!fauern!ira.uka.de!sol.ctr.columbia.edu!zaphod.mps.ohio-state.edu! wupost!uunet!mcsun!news.funet.fi!hydra!klaava!torvalds From: [email protected] (LinusBenedictTorvalds) Newsgroups: comp.os.minix Subject: Whatwouldyouliketoseemost in minix? Summary: small poll for my new operating system Keywords: 386, preferences Message-ID: <[email protected]> Date: 25 Aug 91 20:57:08 GMT Organization: University of Helsinki Lines: 20 Hello everybody out there using minix - I'm doing a (free) operating system (just a hobby, won't be big and professional like gnu) for 386(486) AT clones. This has been brewing since april, and is starting to get ready. I'd like any feedback on things people like/dislike in minix, as my OS resembles it somewhat (same physical layout of the file-system (due to practical reasons) among other things). I've currently ported bash(1.08) and gcc(1.40), and things seem to work. This implies that I'll get something practical within a few months, and I'd like to know what features most people would want. Any suggestions are welcome, but I won't promise I'll implement them :-) Linus ([email protected]) PS. Yes - it's free of any minix code, and it has a multi-threaded fs.
It is NOT protable (uses 386 task switching etc), and it probably never will support anything other than AT-harddisks, as that's all I have :-(.
Linus nunca anuncio la versión 0.01 de Linux (agosto/septiembre 1991), esta versión no era ni siquiera ejecutable, solamente incluía los principios del núcleo del sistema, estaba escrita en lenguaje ensamblador y asumía que uno tenía acceso a un sistema Minix para su compilación.
El 5 de octubre de 1991, Linus anuncio la primera versión "Oficial" de Linux, -versión
0.02. Con esta versión Linus pudo ejecutar Bash (GNU BourneAgain Shell) y gcc(El
compilador GNU de C) pero no mucho mas funcionaba. En este estado de desarrollo
ni se pensaba en los términos soporte, documentación , distribución .....
Este fue el mensaje mandado a comp.os.minix:
Path: gmdzi!unido!mcsun!news.funet.fi!hydra!klaava!torvalds From: [email protected] (Linus Benedict Torvalds) Newsgroups: comp.os.minix Subject: Free minix-like kernel sources for 386-AT Keywords: 386, preliminary version Message-ID: <[email protected]> Date: 5 Oct 91 05:41:06 GMT Organization: University of Helsinki Lines: 55 Do you pine for the nice days of minix-1.1, when men were men and wrote their own device drivers? Are you without a nice project and just dying to cut your teeth on a OS you can try to modify for your needs? Are you finding it frustrating when everything works on minix? No more all- nighters to get a nifty program working? Then this post might be just for you :-) As I mentioned a month(?) ago, I'm working on a free version of a minix-lookalike for AT-386 computers. It has finally reached the stage where it's even usable (though may not be depending on what you want), and I am willing to put out the sources for wider distribution. It is just version 0.02 (+1 (very small) patch already), but I've successfully run bash/gcc/gnu-make/gnu-sed/compress etc under it. Sources for this pet project of mine can be found at nic.funet.fi (128.214.6.100) in the directory /pub/OS/Linux. The directory also contains some README-file and a couple of binaries to work under linux (bash, update and gcc, what more can you ask for :-). Full kernel source is provided, as no minix code has been used. Library sources are only partially free, so that cannot be distributed currently. The system is able to compile "as-is" and has been known to work. Heh. Sources to the binaries (bash and gcc) can be found at the same place in /pub/gnu. ALERT! WARNING! NOTE! These sources still need minix-386 to be compiled (and gcc-1.40, possibly 1.37.1, haven't tested), and you need minix to
set it up if you want to run it, so it is not yet a standalone system for those of you without minix. I'm working on it. You also need to be something of a hacker to set it up (?), so for those hoping for an alternative to minix-386, please ignore me. It is currently meant for hackers interested in operating systems and 386's with access to minix. The system needs an AT-compatible harddisk (IDE is fine) and EGA/VGA. If you are still interested, please ftp the README/RELNOTES, and/or mail me for additional info. I can (well, almost) hear you asking yourselves "why?".Hurd will be out in a year (or two, or next month, who knows), and I've already got minix. This is a program for hackers by a hacker. I've enjouyed doing it, and somebody might enjoy looking at it and even modifying it for their own needs. It is still small enough to understand, use and modify, and I'm looking forward to any comments you might have. I'm also interested in hearing from anybody who has written any of the utilities/library functions for minix. If your efforts are freely distributable (under copyright or even public domain), I'd like to hear from you, so I can add them to the system. I'm using Earl Chews estdio right now (thanks for a nice and working system Earl), and similar works will be very wellcome. Your (C)'s will of course be left intact. Drop me a line if you are willing to let me use your code. Linus PS. to PHIL NELSON! I'm unable to get through to you, and keep getting "forward error - strawberry unknown domain" or something.
Después de la versión 0.03, Linux salto en la numeración hasta la 0.10, más y más
programadores a lo largo y ancho de internet empezaron a trabajar en el proyecto y
después de sucesivas revisiones, Linus incremento el número de versión hasta la 0.95
(Marzo 1992), la primera capaz de ejecutar el sistema X-windows. Más de un año
después (diciembre 1993) el núcleo del sistema estaba en la versión 0.99 y la versión
1.0.0 no llego hasta el 14 de marzo de 1994.
El 9 de Mayo 1996, Tux fue propuesto como mascota oficial de Linux.
El 9 de junio de 1996 fue lanzada la serie 2.0.x, la 2.2.x no llegó hasta el 25 de enero
de 1999 y la 2.4.x hasta el 4 de enero del 2001.
El 17 de diciembre del 2003 fue lanzada la serie 2.6.x del núcleo y el desarrollo de
Linux sigue avanzando día a día con la meta de perfeccionar y mejorar el sistema.
En el siguiente gráfico vemos una ilustración de las diferentes variantes de Unix desde
el lanzamiento de la primera en la década de los 70 y la posición de Linux en esta
historia.
Características
Las características más importantes de GNU/LINUX:
[Fuente: Infosheet-Como. Autor: IvanCasado]
Multitarea: La palabra multitarea describe la habilidad de ejecutar varios
programas al mismo tiempo. LINUX utiliza la llamada multitarea preventiva, la
cual asegura que todos los programas que se están utilizando en un momento
dado serán ejecutados, siendo el sistema operativo el encargado de ceder
tiempo de microprocesador a cada programa.
Multiusuario: Muchos usuarios usando la misma maquina al mismo tiempo.
Multiplataforma: Las plataformas en las que en un principio se puede utilizar
Linux son 386-, 486-. Pentium, Pentium Pro, Pentium II,Amiga y Atari, tambien
existen versiones para su utilización en otras plataformas, como amd64, Alpha,
ARM, MIPS, PowerPC y SPARC.
Multiprocesador: Soporte para sistemas con mas de un procesador esta
disponible para Intel, AMD y SPARC.
Funciona en modo protegido 386.
Protección de la memoria entre procesos, de manera que uno de ellos no
pueda colgar el sistema.
Carga de ejecutables por demanda: Linux sólo lee del disco aquellas partes de
un programa que están siendo usadas actualmente.
Política de copia en escritura para la compartición de páginas entre
ejecutables: esto significa que varios procesos pueden usar la misma zona de
memoria para ejecutarse. Cuando alguno intenta escribir en esa memoria, la
página (4Kb de memoria) se copia a otro lugar. Esta política de copia en
escritura tiene dos beneficios: aumenta la velocidad y reduce el uso de
memoria.
Memoria virtual usando paginación (sin intercambio de procesos completos) a
disco: A una partición en el sistema de archivos, con la posibilidad de añadir
más áreas de intercambio sobre la marcha.
La memoria se gestiona como un recurso unificado para los programas de
usuario y para el caché de disco, de tal forma que toda la memoria libre puede
ser usada para caché y ésta puede a su vez ser reducida cuando se ejecuten
grandes programas.
Librerías compartidas de carga dinámica (DLL's) y librerías estáticas.
Se realizan volcados de estado (coredumps) para posibilitar los análisis post-
mortem, permitiendo el uso de depuradores sobre los programas no sólo en
ejecución sino también tras abortar éstos por cualquier motivo.
Compatible con POSIX, System V y BSD a nivel fuente.
Emulación de iBCS2, casi completamente compatible con SCO, SVR3 y SVR4
a nivel binario.
Todo el código fuente está disponible, incluyendo el núcleo completo y todos
los drivers, las herramientas de desarrollo y todos los programas de usuario;
además todo ello se puede distribuir libremente. Hay algunos programas
comerciales que están siendo ofrecidos para Linux actualmente sin código
fuente, pero todo lo que ha sido gratuito sigue siendo gratuito.
Control de tareas POSIX.
Pseudo-terminales (pty's).
Emulación de 387 en el núcleo, de tal forma que los programas no tengan que
hacer su propia emulación matemática. Cualquier máquina que ejecute Linux
parecerá dotada de coprocesador matemático. Por supuesto, si el ordenador
ya tiene una FPU (unidad de coma flotante), esta será usada en lugar de la
emulación, pudiendo incluso compilar tu propio kernel sin la emulación
matemática y conseguir un pequeño ahorro de memoria.
Soporte para muchos teclados nacionales o adaptados y es bastante fácil
añadir nuevos dinámicamente.
Consolas virtuales múltiples: varias sesiones de login a través de la consola
entre las que se puede cambiar con las combinaciones adecuadas de teclas
(totalmente independiente del hardware de video). Se crean dinámicamente y
puedes tener hasta 64.
Soporte para varios sistemas de archivo comunes, incluyendo minix-1, Xenix y
todos los sistemas de archivo típicos de System V, y tiene un avanzado
sistema de archivos propio con una capacidad de hasta 4 Tb y nombres de
archivos de hasta 255 caracteres de longitud.
Acceso transparente a particiones MS-DOS (o a particiones OS/2 FAT)
mediante un sistema de archivos especial: no es necesario ningún comando
especial para usar la partición MS-DOS, esta parece un sistema de archivos
normal de Unix (excepto por algunas restricciones en los nombres de archivo,
permisos, y esas cosas). Las particiones comprimidas de MS-DOS 6 no son
accesibles en este momento, y no se espera que lo sean en el futuro. El
soporte para VFAT, FAT32 (WNT, Windows 95/98) se encuentra soportado
desde la version 2.0 del nucleo y el NTFS de WNT desde la version 2.2 (Este
último solo en modo lectura).
Soporte en sólo lectura de HPFS-2 del OS/2 2.1
Sistema de archivos de CD-ROM que lee todos los formatos estándar de CD-
ROM.
TCP/IP, incluyendo ssh, ftp, telnet, NFS, etc.
Appletalk.
Software cliente y servidor Netware.
Lan Manager / Windows Native (SMB), software cliente y servidor.
Diversos protocolos de red incluidos en el kernel: TCP, IPv4, IPv6, AX.25, X.25,
IPX, DDP, Netrom, etc.
Kernel/Núcleo
El kernel ó núcleo de linux se puede definir como el corazón de este sistema operativo.
Es el encargado de que el software y el hardware de tu ordenador puedan trabajar
juntos.
Las funciones más importantes del mismo, aunque no las únicas, son:
Administración de la memoria para todos los programas y procesos en
ejecución.
Administración del tiempo de procesador que los programas y procesos en
ejecución utilizan.
Es el encargado de que podamos acceder a los periféricos/elementos de
nuestra computadora de una manera cómoda.
Hasta que empezó el desarrollo de la serie 2.6 del núcleo, existieron dos tipos de
versiones del núcleo:
Versión de produccion: La version de produccion, era la version estable hasta
el momento. Esta version era el resultado final de las versiones de desarrollo o
experimentales.
Cuando el equipo de desarrollo del núcleo experimental, decidia que tenia un
núclo estable y con la suficiente calidad, se lanzaba una nueva versión de
producción ó estable. Esta versión era la que se debia utilizar para un uso
normal del sistema, ya que eran las versiones consideradas más estables y
libres de fallos en el momento de su lanzamiento.
Versión de desarrollo: Esta versión era experimental y era la que utilizaban los
desarrolladores para programar, comprobar y verificar nuevas características,
correcciones, etc. Estos núcleos solian ser inestables y no se debían usar sin
saber lo que se hacia.
Como interpretar los números de las versiones de las series por debajo de la 2.6:
Las versiones del núcleo se numeraban con 3 números, de la siguiente forma:
AA.BB.CC
AA: Indicaba la serie/versión principal del núcleo. Solo han existido la 1 y 2.
Este número cambiaba cuando la manera de funcionamiento del kernel habia
sufrido un cambio muy importante.
BB: Indicaba si la versión era de desarrollo ó de producción. Un número impar,
significaba que era de desarrollo, uno par, que era de producción.
CC: Indicaba nuevas revisiones dentro de una versión, en las que lo único que
se habia modificado eran fallos de programación.
Unos ejemplos nos ayudaran a entenderlo mejor:
ej1: versión del núcleo 2.4.0: Núcleo de la serie 2 (AA=2), versión de
producción 4 (BB=4 par), primera versión de la serie 2.4 (CC=0)
ej2: versión del núcleo 2.4.1: Núcleo de la serie 2, versión 4, en el que se han
corregido errores de programación presentes en la versión 2.4.0 (CC=1)
ej3: versión del núcleo 2.5.0: versión 0 del núcleo de desarrollo 2.5.
Con la serie 2.6 del núcleo, el sistema de numeración así como el modelo de
desarrollo han cambiado. Las versiones han pasado a numerarse con 4 dígitos y no
existen versiones de producción y desarrollo.
Las versiones del núcleo se numeran hoy en día con 4 dígitos, de la siguiente
forma: AA.BB.CC.DD.
AA: Indica la serie/versión principal del núcleo.
BB: Indica la revisión principal del núcleo. Números pares e impares no tienen
ningún significado hoy en día.
CC: Indica nuevas revisiones menores del núcleo. Cambia cuando nuevas
características y drivers son soportados.
DD: Este digito cambia cuando se corrigen fallos de programación o fallos de
seguridad dentro de una revisión.
Hoy en día se suele usar el núcleo distribuido con la distribución que el usuario utiliza.
Son las distribuciones las encargadas de distribuir núcleos estables a sus usuarios y
estos núcleos se basan en el núcleo ("vanilla") distribuido por Linus Torvalds y el
equipo de programadores del núcleo.
Dónde conseguir el núcleo
El núcleo denominado "vanilla" (sin alteraciones y suministrado por Linus Torvalds) se
puede bajar de un gran número de servidores en internet pero el sitio oficial es
http://www.kernel.org/. En este enlace tienes la lista internacional oficial de servidores
espejos, de donde es posible bajarse cualquier versión del núcleo (última y antiguas).
Cada distribución distribuye sus núcleos por los canales de actualización habituales
para cada una de ellas.
Configuración e instalación de un nuevo núcleo
Este es uno de los temas que asustan a los nuevos usuarios de Linux. Lo primero,
decir que no hay razón para asustarse, la configuración e instalación de un nuevo
núcleo en nuestro sistema es mas fácil de lo que suena. Lo segundo, es que puedes
tener un sistema estable, actualizado y que funcione sin problemas durante meses sin
tener que compilar un solo núcleo, siempre y cuando utilicen los núcleos distribuidos
con la versión de la distribución.
Es muy recomendable el utilizar los núcleos que llegan con la distribución que utilicen.
Estos núcleos tienen muy buena calidad y son muy completos y con esto se evitan el
trabajo de configurar, compilar y mantener nuevas versiones del núcleo. Si sois de los
que os gustan experimentar y aprender nuevas cosas, adelante, nadie os impide
bajaros el último núcleo y experimentar con el, esto era mucho más común hace unos
años y una tarea casi imprescindible en muchos casos.
Para los interesados en el tema existen dos documentos muy buenos que pueden
utilizar para aprender a como compilar un núcleo, FAQ/Kernelcompilation y el
KernelRebuild Guide
Consejos
Pregunta: Necesito actualizar el núcleo que utilizo, cada vez que una nueva
versión aparece?
Respuesta: No. La explicación es la siguiente:
Cuando un nuevo núcleo aparece, puede ser por las siguientes causas:
o Nuevas características se han añadido.
o Fallos de programación se han corregido
o Fallos de seguridad se han corregido.
o Nuevo hardware es soportado.
Si las características que se han añadido, no las vamos a utilizar, es evidente
que no necesitamos actualizar. Si los fallos de programación que se han
corregido, afectan a características/drivers que no utilizamos, no necesitamos
actualizar. Si no utilizamos el nuevo hardware soportado, tampoco necesitamos
actualizar.
De todas maneras es recomendable, actualizar de vez en cuando, sobre todo
cuando se corrigen fallos de seguridad o cuando los cambios en el nuevo
núcleo afectan a características/funciones/hardware que utilicemos.
Pregunta: Soy nuevo en Linux y acabo de instalar una distribución, como
compilo un nuevo núcleo?
Respuesta: Te aconsejo que esperes un poco. La distribución que acabas de
instalar (si es de las últimas) viene con un kernel de los "últimos", totalmente
funcional y que te sirve sin problemas.
Utiliza el sistema un tiempo, familiarízate con el nuevo sistema que acabas de
instalar, y cuando comprendas un poco mas como funcionan las cosas,
compila el núcleo si te apetece y sabes que estas haciendo. Un buen punto de
partida para encontrar información sobre el núcleo, lo tienes en estas páginas.
El interprete de comandos:
El intérprete de comandos es la interfaz entre el usuario y el sistema operativo. Por esta razón, se le da el nombre inglés que significa "caparazón".
Por lo tanto, la shell actúa como un intermediario entre el sistema operativo y el usuario gracias a líneas de comando que este último introduce. Su función es la de leer la línea de comandos, interpretar su significado, llevar a cabo el comando y después arrojar el resultado por medio de las salidas.
La shell es un archivo ejecutable que debe interpretar los comandos, transmitirlos al sistema y arrojar el resultado. Existenvarios shells. La máscomúnessh (llamada "Bourne shell"), bash ("Bourne again shell"), csh ("C Shell"), Tcsh ("Tenex C shell"), ksh ("Korn shell") y zsh ("Zero shell"). Generalmente, sus nombres coinciden con el nombre del ejecutable.
Cada usuario tiene una shell predeterminada, la cual se activará cuando se abra un indicador del comando. La shell predeterminada se especifica en el archivo de configuración /etc/passwd en el último campo de la línea que corresponde al usuario. Es posible cambiar de shell durante una sesión. Para esto, sólo debe ejecutar el archivo ejecutable correspondiente, por ejemplo:
/bin/bash
Indicador del sistema
La Shell se inicia al leer su configuración completa (en un archivo del directorio /etc/) y después al leer la configuración propia del usuario (en un archivo oculto cuyo nombre comienza con un punto y que se ubica en el directorio básico del usuario, es decir /home/user_name/.configuration_file). A continuación, aparece el siguiente indicador
(prompt en inglés):
equipo:/directorio/actual$ De manera predeterminada, para la mayoría de las shells, el indicador consiste en el
nombre del equipo, seguido de dos puntos (:), el directorio actual y después un
carácter que indica el tipo de usuario conectado:
"$" especifica un usuario normal "#" especifica el administrador, llamado "root"
El concepto de línea de comandos
Una línea de comandos es una cadena de caracteres formada por un comando que corresponde a un archivo ejecutable del sistema o, más bien, un comando de shell como así también argumentos opcionales (parámetros):
ls -al /home/jf/ En el comando anterior, ls es el nombre del comando, -al y home/jean-francois/ son
argumentos. Los argumentos que comienzan con - se denominan opciones. Por lo
general, para cada comando, hay una cierta cantidad de opciones que se pueden
detallar al introducir uno de los siguientes comandos:
comando --help comando -? man comando
Entrada-salida estándar
Una vez que se ejecuta un comando, se crea un proceso. Este proceso abre tres flujos:
stdin, denominado entrada estándar, en cuyo caso el proceso lee los datos de entrada. De manera predeterminada, stdin se refiere al teclado. STDIN se
identifica con el número 0. stdout, denominado salida estándar, en cuyo caso el proceso escribe los datos
de salida. De manera predeterminada, stdout se refiere a la pantalla. STDOUT se identifica con el número 1.
stderr, denominado error estándar, en cuyo caso el proceso escribe los mensajes del error. De manera predeterminada, stderr se refiere a la pantalla. STDERR se identifica con el número 2.
Por lo tanto, de manera predeterminada, cada vez que se ejecuta un programa, los datos se leen desde el teclado y el programa envía su salida y sus errores a la pantalla. Sin embargo, también es posible leer datos desde cualquier dispositivo de entrada, incluso desde un archivo, y enviar la salida a un dispositivo de visualización, un archivo, etc.
Redirecciones
Como cualquier sistema Unix, Linux posee mecanismos que permiten redirigir la entrada-salida estándar a archivos.
Por lo tanto, si se usa el carácter ">", se puede redirigir la salida estándar de un comando que se encuentra a la izquierda a un archivo que se encuentra a la derecha:
ls -al /home/jf/ > toto.txt echo "Toto" > /etc/miarchivodeconfiguración El siguiente comando equivale a una copia de los archivos:
cattoto> toto2 El propósito de la redirección ">" es el de crear un archivo nuevo. En el caso de que un
archivo ya exista con el mismo nombre, se lo debe eliminar. El siguiente comando
simplemente crea un archivo vacío:
>archivo El uso del carácter doble ">>" permite agregar la salida estándar al archivo, es decir,
permite agregar la salida después del archivo sin eliminarlo.
De manera similar, el carácter "<" indica una redirección de la entrada estándar. El siguiente comando envía el contenido del archivo toto.txt con el comando cat, cuyo
único propósito es mostrar el contenido en la salida estándar (el ejemplo no es útil, pero es instructivo):
cat< toto.txt
Por último, el uso de la redirección "<<" permite la lectura, en la entrada estándar,
hasta que se encuentre la cadena ubicada a la derecha. En el siguiente ejemplo, se lee la entrada estándar hasta que se encuentra la palabra STOP. Después, se muestra el resultado:
cat<< STOP
Tuberías de comunicación
Las tuberías (en inglés "pipes") (literalmente “tuberías”) son mecanismos de
comunicación específicos para todos los sistemas UNIX. Una tubería, simbolizada por una barra vertical (carácter "|"), permite asignar la salida estándar de un comando a la entrada estándar de otro, de la misma forma en que una tubería permite la comunicación entre la entrada estándar de un comando y la salida estándar de otro.
En el siguiente ejemplo, la salida estándar del comando ls -al se envía al programa sort, el cual debe extraer el resultado en orden alfabético.
ls -al | sort
Esto permite conectar una cierta cantidad de comandos a través de sucesivas tuberías. En el siguiente ejemplo, el comando muestra todos los archivos del directorio actual, selecciona las líneas que contienen la palabra "zip" (utilizando el comando grep) y cuenta la cantidad total de líneas:
ls -l | grep zip | wc -l
Llamadas al Sistema (CallSystem)
La llamada al Sistema es una llamada al Kernel
Es una llamada particular, dado que el kernel accede a recursos como el CPU en el
llamado KernelMode.
Que quiere decir esto? El CPU reconoce distinto las llamadas del Kernel que de
cualquier otro dispositivo.
Los famosos anillos son siempre dibujados para
comprender los modos de seguridad que protegen el
acceso a los recursos.
Pero vamos a lo nuestro.
Estamos en un programa, por ejemplo DF, que ya lo deben conocer de memoria.
Es el programa que nos permite ver el uso del disco en un Unix.
Lo cierto es que el programa DF una vez presionado enter, va a buscar a glibc.
GLIBC es la famosa libreria WRAPPER (envoltura). Que quiere decir envoltura?
Quiere decir que GLIBC y no DF se va a encargar de tratar con el KERNEL.
Otro Grafico?
No es el mejor, el mejor lo tengo en el manual de Programación de API de Linux, pero
es difícil extraer ese grafico.
Quizás no se lee bien, pero la columna izq. es USER MODE y la derecha KERNEL
MODE. Es decir.. DF se encarga de contactar GLIBC, y esta a su vez llama al la
famosa instrucción 0x80, es decir, CPU DETENTE de lo que haces (Si mal no
recuerdo 0x80 además es un conocido hacker en el uso de botnets).
Una vez interrumpido el CPU, GLIBC le guarda al cpu en %EAX (un registro dentro del
CPU) la instrucción, que luego ejecutara.
Si quieres verlo. Realmente en tu PC, basta con que corras el programa strace
Noten a MMAP, la llamada de Sistema (SystemCall), para asignar y declarar espacios
de paginación de Memoria.
Si les gusta ver en procesos reales el uso de Wrappers lo que pudieran hacer es usar
el comando LDD, para ver las dependencias de librerias
X WindowSystem
X WindowSystem (en españolsistema de ventanas X) es un software que fue
desarrollado a mediados de los años 1980 en el MIT para dotar de una interfaz gráfica
a los sistemas Unix. Este protocolo permite la interacción gráfica en red entre un
usuario y una o más computadoras haciendo transparente la red para éste.
Generalmente se refiere a la versión 11 de este protocolo, X11, el que está en uso
actualmente. X es el encargado de mostrar la información gráfica de forma totalmente
independiente del sistema operativo.
X fue diseñado primariamente para implementar clientes ligeros, donde mucha gente
usaba simultáneamente la capacidad de procesamiento de un mismo computador
trabajando en tiempo compartido. Cada persona usaba un terminal en red que tenía
capacidades limitadas para dibujar la pantalla y aceptar la entrada del usuario. Debido
a la ubicuidad del soporte para el software X en Unix, es usado en los computadores
personales incluso cuando no hay necesidad del tiempo compartido.
El sistema de ventanas X distribuye el procesamiento de aplicaciones especificando
enlaces cliente-servidor. El servidor provee servicios para acceder a la pantalla,
teclado y ratón, mientras que los clientes son las aplicaciones que utilizan estos
recursos para interacción con el usuario. De este modo mientras el servidor se ejecuta
de manera local, las aplicaciones pueden ejecutarse remotamente desde otras
máquinas, proporcionando así el concepto de transparencia de red.
Debido a este esquema cliente-servidor, se puede decir que X se comporta como un
terminal gráfico virtual.
El hecho que exista un estándar definido para X permite que se desarrollen servidores
X para distintos sistemas operativos y plataformas, lo que hace que el código sea muy
portable. Por ejemplo. permite tener clientes X ejecutándose en un potente servidor
UNIX mientras los resultados son visualizados en una PC de escritorio con cualquier
otro sistema operativo funcionando.
La comunicación entre el cliente X y el servidor se realiza por medio de un protocolo
conocido como Xprotocol, que consiste en una serie de bytes interpretados como
comandos básicos para generar ventanas, posicionarlas, o controlar eventos. Los
clientes X acceden al Xprotocol mediante el uso de una biblioteca llamada Xlib, que
evita al programador de clientes X tener que lidiar con el código binario del Xprotocol.
Sin embargo, los aspectos de decoración de ventana y manejos de ventanas no están
definidos en esta biblioteca.
X no es un gestor de ventanas, necesita de uno para controlar el manejo de ventanas.
Esto trae la ventaja de que permite al usuario instalar uno o más administradores de
ventanas de su preferencia. También trae la ventaja de que hace de X estrictamente
un sistema gráfico, de tal modo que un cliente X podría estar enviando un gráfico a
una pantalla, a una impresora o a cualquier otro hardware sin darse cuenta,
flexibilizando la salida gráfica.
Por otro lado, la desventaja que trae el hecho de no tener un único entorno gráfico es
que los programadores de clientes X que desean hacer uso de los recursos de los
entornos gráficos (botones, barras de deslizamientos, etc) deben elegir un entorno
gráfico específico para programar y contar que el usuario tenga por los menos las
bibliotecas de dicho entorno gráfico instalado. Las bibliotecas de los entornos gráficos
se conocen como "Toolkits", el estándar X provee sólo de un conjunto de herramientas
básicas llamadas Xintrisics que permiten a los programadores de los entornos gráficos
armar sus Toolkits sobre éstas.
Gestor de ventanas
Un gestor de ventanas es un Programa informático que controla la ubicación y apariencia de las ventanas bajo un sistema de ventanas en una interfaz gráfica de usuario.12
Las acciones asociadas al gestor de ventanas suelen ser, abrir, cerrar, minimizar, maximizar, mover, escalar y mantener un listado de las ventanas abiertas. Es también muy común que el gestor de ventanas integre elementos como: el decorador de ventanas, un panel, un visor de escritorios virtuales, iconos y un tapiz.
Las plataformas Windows y Mac OS X ofrecen un gestor de ventanas estandarizado por sus vendedores e integrado en el propio sistema operativo. En cambio el sistema gráfico X Window, popular en el ámbito de sistemas Unix y similares, como GNU/Linux, permite al usuario escoger entre varios gestores. Los gestores de ventanas difieren entre sí de muchas maneras, incluyendo apariencia, consumo de memoria, opciones de personalización, escritorios múltiples o virtuales y similitud con ciertos entornos de escritorio ya existentes, entre otras.
Los gestores de ventanas (también llamados administradores de ventanas) son la parte del software que se encarga de mostrar una interfaz gráfica al usuario, con la que se pueda comunicar con el sistema de forma sencilla. Muy comúnmente, son también llamados entornos gráficos o entornos de escritorio, aunque en realidad éstos (por ejemplo, KDE, Gnome, XFCE...) son un conjunto más amplio de software, entre los que se encuentran los mencionados gestores de ventanas.
En Windows sólo disponemos de un gestor de ventanas, DWM (Vista/7), mientras que en GNU/Linux podemos elegir el gestor de ventanas que más se adapte a nuestras necesidades (interfaz gráfica más atractiva, menor consumo de recursos, etc...).
Metacity es el gestor de ventanas actualmente utilizado por el proyecto Gnome. Se trata de una interfaz sencilla pero muy agradable.
Previamente, el proyecto Gnome utilizaba otros gestores de ventanas más configurables (como Sawfish o Enlightenment) pero se optó por sacrificar esas funcionalidades por una interfaz más amigable, sencilla y usable.
Se utiliza en cantidad de distribuciones, algunas de ellas tan famosas como Ubuntu o Fedora.
Mutter es el nuevo gestor de ventanas que incorporará el proyecto Gnome.
En GnomeShell puedes encontrar más información sobre esta evolución de Metacity, que tiene muy buena pinta.
KWin es el administrador de ventanas del famoso KDE, que junto a Gnome, son los dos entornos de escritorio más utilizados en la actualidad.
Un interfaz de usuario más complejo que el anterior, con muchos aspectos visuales configurables y gran cantidad de temas disponibles. Se puede encontrar en muchas distribuciones, como por ejemplo, OpenSUSE, Kubuntu o Xandros.
Administradores de Escritorio, Local y Remoto
Con la llegada de Gnome3 y Ubuntu 11.04 con Unity, es necesario aclarar dos
conceptos que son diferentes y que, en un principio, tienden a confundirse mucho:
Entorno de Escritorio y Gestor de Ventanas.
Al ejecutar un servidor X (gráfica), las aplicaciones cliente X pueden utilizarlo y crear
una GUI (interfaz gráfica). Existe un rango de GUIs muy amplio que abarca desde las
más rudimentarios (en twm), hasta las más desarrollados e interactivos (en GNOME,
KDE...). Para crear estas GUIs más avanzadas, se deben conectar dos clases
principales de aplicaciones clientes X al servidor X: un entorno de escritorio y un
gestor de ventanas.
1. Entorno de escritorio
(GNOME, KDE, XFCE, LXDE, ...)
Un entorno de escritorio lo que hace es unir diferentes clientes de X y al usarlos juntos
se crea un ambiente de usuario gráfico común y una plataforma de desarrollo. Estos
entornos de escritorio avanzados permiten a los clientes X y a las aplicaciones
ejecutadas, comunicarse entre ellas, permitiendo así que las aplicaciones realicen
tareas avanzadas, tales como operaciones de arrastrar y soltar, por ej.
2. Gestores de ventanas
(Metacity, Compiz, Mutter, Kwin, ...)
Los gestores de ventanas son programas clientes de X que son parte del entorno de
escritorio (por ej. Metacity es parte de GNOME y Kwin de KDE) o también pueden ser
independientes (por ej. mwm). Su propósito principal es controlar la forma en que se
muestran las ventanas gráficas (posición, redimensión, movimiento, apariencia...) y
sus funcionalidades (vínculos con los botones del ratón, barras de títulos,
combinaciones de teclas, comportamiento del foco, ...).
GNOME
GNOME es un entorno de escritorio e infraestructura de desarrollo para sistemas operativosUnix y derivados Unix como GNU/Linux, BSD o Solaris; compuesto enteramente de software libre.
El proyecto fue iniciado por los mexicanos Miguel de Icaza y Federico Mena y forma parte oficial del proyecto GNU. Nació como una alternativa a KDE bajo el nombre de GNU Network ObjectModelEnvironment. Actualmente además del español se
encuentra disponible en 166 idiomas.
Objetivo
El Proyecto GNOME, según sus creadores, provee un gestor de ventanas «intuitivo y atractivo» y una plataforma de desarrollo para crear aplicaciones que se integran con el escritorio. El Proyecto pone un gran énfasis en la simplicidad, usabilidad y eficiencia. Otros objetivos del proyecto son:
La libertad para crear un entorno de escritorio que siempre tendrá el código fuente disponible para reutilizarse bajo una licencia de software libre.
El aseguramiento de la accesibilidad, de modo que pueda ser utilizado por cualquiera, sin importar sus conocimientos técnicos y discapacidad física.
Hacer que esté disponible en muchos idiomas. Un ciclo regular de liberaciones y una estructura de comunidad disciplinada
Manejo básico
Cuando inicie una sesión gráfica verá el escritorio GNOME. Este escritorio cuenta con iconos para acceder rápidamente a aplicaciones y con menús que le permiten iniciar programas. También le permite usar varios espacios de trabajo, cada uno como un escritorio independiente de los demás —aunque es fácil pasar aplicaciones de un espacio de trabajo a otro, pues basta arrastrarlas con el ratón.
El botón izquierdo del ratón normalmente permite elegir una opción de un menú o activa un icono. El botón derecho tiene diversas aplicaciones de acuerdo al contexto —por ejemplo sobre los iconos permite configurarlos—, el botón del centro permite pegar el texto que se hubiera seleccionado con el ratón, si su ratón sólo tiene 2 botones, puede «emular» el botón del centro oprimiendo simultáneamente el izquierdo y el derecho. Para seleccionar un texto se pasa por encima del mismo con el puntero del ratón mientras se mantiene presionado el botón izquierdo.
El escritorio GNOME es bastante configurable: puede configurar los menús, los iconos, las tipografías, el fondo, el protector de pantalla, el tema, el administrador de ventanas, sonido, la interacción con las ventanas y muchos otros detalles de acuerdo a su gusto. Para hacer algunas de las configuraciones puede emplear opciones de los menús GNOME, el ratón —por ejemplo para administrar los iconos que hay sobre el escritorio—, el programa «Centro de control GNOME» y eventualmente los archivos de configuración de X-Window.
El gestor de ventanas empleado decorará cada ventana con botones que le permitirán cerrar, maximizar o minimizar. Las ventanas minimizadas se verán en la parte inferior del escritorio GNOME —más precisamente en el panel que no necesariamente está en la parte inferior, porque puede reubicarse de acuerdo a su gusto.
Entre los menús de GNOME existen múltiples herramientas, como la calculadora gcalctool; el editor de texto gedit; el calendario gnomecal, procesador de textos, hoja
de cálculo, reproductor multimedia y muchas otras.
Versión actual (3.0)
GNOME Shell, el entorno de escritorio introducido en GNOME 3.0.
La versión 3.0 de GNOME fue lanzada el 6 de abril del 2011. Fue anunciada en la conferencia GUADEC en Estambul en julio del 2008. El nombre código ToPaZ fue posteriormente introducido dentro del proyecto y varios bosquejos fueron creados como parte del proceso de elaboración de la nueva versión.[cita requerida] Aunque la nueva
versión trae muchos cambios, la principal novedad es la inclusión de GNOME Shell. La versión iba a ser lanzada en septiembre del 2010, pero en julio del mismo año el equipo desarrollador decidió posponer el lanzamiento para el mes de marzo, lanzando en su lugar la versión 2.32. En septiembre, la fecha fue nuevamente retrasada hasta abril de 2011.
KDE
Es un proyecto de software libre para la creación de un entorno de escritorio e infraestructura de desarrollo para diversos sistemas operativos como GNU/Linux, Mac OS X, Windows, etc.
De acuerdo con su página web, «KDE es un entorno de escritorio contemporáneo para estaciones de trabajo Unix. KDE llena la necesidad de un escritorio amigable para estaciones de trabajo Unix, similar a los escritorios de Mac OS X o Windows».4
Las aplicaciones KDE están traducidas a aproximadamente 75 idiomas3 y están construidas con los principios de facilidad de uso y de accesibilidad moderna en mente. Las aplicaciones de KDE 4 funcionan de forma completamente nativa en GNU/Linux, BSD, Solaris, Windows y Mac OS X.
La «K», originariamente, representaba la palabra «Kool»,5 pero su significado fue abandonado más tarde.
La mascota del proyecto es un pequeño dragón llamado Konqi.
KDE se basa en el principio de la personalización; todos los componentes de KDE pueden ser configurados en mayor o menor medida por el usuario. Las opciones más comunes son accesibles en su mayoría desde menús y diálogos de configuración. Los usuarios avanzados pueden optar por editar los archivos de configuración manualmente, obteniendo en algunos casos un mayor control sobre el comportamiento del sistema.
La apariencia de KDE es configurable en varios niveles. Tanto el gestor de ventanas (llamado KWin) como los controles (botones, menús, etc.) utilizan "estilos" intercambiables, que definen cada aspecto de su apariencia. Es por este motivo que KDE no mantiene una única apariencia entre versiones, sino que se opta por aquella más ampliamente aceptada en el momento de cada nuevo lanzamiento.
La intención del proyecto KDE es la de crear un entorno de escritorio que no se comporte de un modo predefinido, sino que permita al usuario adecuar el sistema a su gusto y comodidad. Esto no impide que KDE resulte fácil de usar para nuevos usuarios, detalle al que no se resta importancia.
Estructura General del Sistema Operativo
La arquitectura del sistema operativo LINUX se divide en tres niveles:
1. El nivel de usuario, donde se ejecutan todos los procesos de usuario , sin capacidad para ejecutar las instrucciones más privilegiadas del procesador.
2. El nivel del núcleo, es el privilegiado del procesador donde pueden ejecutarse todas sus instrucciones sin restricciones.
3. El nivel del hardware, correspondiente al hardware especifico conectado en el sistema.
La comunicación entre los procesos de usuario y el núcleo se realiza a través de la librería del sistema, que genera una interrupción software ( trap ) cada vez que se realiza una llamada al sistema para obtener un servicio del núcleo. Respecto a la estructura interna del núcleo , LINUX fue desarrollado sobre un sistema basado en un procesador bastante lento como el i386, lo que impuso la utilización de una arquitectura monolítica tradicional
ESTRUCTURA BASICA DE LAS FUENTES DEL NUCLEO
Los archivos que contienen el código fuente del núcleo de LINUX se puede encontrar a partir del directorio / usr / src / LINUX. Los directorios que los contienen son:
KERNEL: Sección central del núcleo, con la codificación de servicios como fork, exit, etc. Parte de este código es muy dependiente de la máquina donde se este ejecutando LINUX ; se ubica en directorios bajo el directorio arch.
NET: Implementación de los protocolos mas usuales en redes (TCP/IP, ARP...), así como el código para los sockets, etc.
FS: Este directorio contiene los archivos del Virtual File SystemSwitch y los que cuelgan de el contienen el soporte para los diferentes sistemas de ficheros soportados ( ext2, ms dos, minix, xiafs, sysv y muchos otros). El mas usado en LINUX actualmente es el ext2. Por ultimo hay que señalar que este directorio es también herencia de minix.
ARCH: Implementación del código dependiente de la maquina . Hay directorios como alpha( para el DEC Alpha ), i386 (para el Intel 80386) y otros.
MM: Contiene las fuentes para la administración de la memoria . No es un gestor de la memoria al estilo minix, el directorio queda como una reminiscencia del sistema a partir del cual fue desarrollado.
MODULES: Contiene las fuentes para la carga dinámica de módulos en el sistema ( permite modificar el núcleo en tiempo de ejecución).
INIT: Funciones para el arranque e iniciación del kernel a partir de ciertos parámetros que le son pasados .
DRIVERS: Contiene subdirectorios para el manejo de los diferentes dispositivos conectados a la máquina. Es en estos (block, char, net, sound. . . . ) donde se ubican los diferentes device drivers. Este directorio es el mas voluminoso de todos , y se estima que va a ser el de mayor crecimiento a lo largo del desarrollo de LI NUX, debido al enorme y creciente numero de dispositivos existentes en el mercado.
IPC: Fuentes para la intercomunicación de los procesos . Incluye semáforos, colas de mensajes y memoria compartida.
LIB: Implementación de algunas de las funciones estándar del lenguaje de programación C de las que se hace gran uso en la implementación del kernel.
INCLUDE: Directorio donde se almacenan los archivos de cabecera del kernel (header files). Cuelgan de él algunos directorios para las diferentes arquitecturas soportadas. Para
simplificar el acceso a la arquitectura adecuada existe un LINK simbólico llamado include / asm.
